solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void dk_98() {}
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int lcm(int a, int b) { return (a * b) / gcd(a, b); }
long long exponential(long long a, long long b, long long mod) {
if (a == 0) {
return 0;
}
if (b == 0 or a == 1) {
return 1;
}
if (b == 1) {
return a;
}
long long res = 1;
while (b > 0) {
if (b & 1) {
res *= a;
res %= mod;
}
a *= a;
a %= mod;
b = b >> 1;
}
return res;
}
void solve() {
int n;
cin >> n;
int m;
cin >> m;
vector<int> graph[n + 1];
for (int i = 0; i < (int)(m); i++) {
int x, y;
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
for (int i = 1; i <= (int)(n); i++) {
sort(graph[i].begin(), graph[i].end());
}
bool flag = false;
int count = 0;
while (true) {
int tempcount = 0;
flag = false;
vector<int> removed;
for (int i = 1; i <= (int)(n); i++) {
if (graph[i].size() == 1) {
removed.push_back(i);
}
}
for (int i = 0; i < (int)(removed.size()); i++) {
int neg = graph[removed[i]][0];
graph[removed[i]].clear();
if (!graph[neg].empty()) {
graph[neg].erase(
lower_bound(graph[neg].begin(), graph[neg].end(), removed[i]));
}
flag = true;
}
if (flag) {
count++;
continue;
} else
break;
}
cout << count << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
dk_98();
int t = 1;
while (t--) {
solve();
}
cerr << "Time : " << 1000 * (double)clock() / (double)CLOCKS_PER_SEC
<< "ms\n";
;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int fend(int n, vector<string> v, string x) {
for (int i = 0; i < v.size(); i++) {
if (v[i] == x) return i;
}
return -1;
}
int main() {
int n;
cin >> n;
vector<string> v;
string s, d;
cin >> s >> d;
v.push_back(s);
v.push_back(d);
n--;
for (int i = 0; i < n; i++) {
string a, b;
cin >> a >> b;
if (count(v.begin(), v.end(), a) == 0 &&
count(v.begin(), v.end(), b) == 0) {
v.push_back(a);
v.push_back(b);
} else if (count(v.begin(), v.end(), b) == 0 &&
count(v.begin(), v.end(), a) != 0) {
int j = fend(n, v, a);
v[j] = b;
}
}
int f = 1;
cout << v.size() / 2 << endl;
for (auto z : v) {
if (f % 2 != 0)
cout << z << ' ';
else
cout << z << endl;
f++;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int nax = 1e5 + 200;
const double mpi = acos(-1);
const double eps = 1e-10;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << setprecision(20) << fixed;
int t;
cin >> t;
int n;
long long l;
while (t--) {
cin >> n >> l;
vector<double> a(n + 2);
a[0] = 0;
a[n + 1] = l;
for (int i = 1; i <= (int)n; ++i) {
cin >> l;
a[i] = l;
}
double acum = 0;
long long speed = 1;
vector<double> timeA(n + 2, 0);
for (int i = 1; i <= (int)n + 1; ++i) {
timeA[i] = acum + (a[i] - a[i - 1]) / speed;
++speed;
acum = timeA[i];
}
acum = 0;
speed = 1;
vector<double> timeB(n + 2, 0);
for (int i = n; i >= 0; --i) {
timeB[i] = acum + (a[i + 1] - a[i]) / speed;
++speed;
acum = timeB[i];
}
double ans = 0;
bool f = false;
for (int i = 0; i < (int)n + 2; ++i) {
if (timeA[i] == timeB[i]) {
ans = timeA[i];
f = true;
break;
}
if (timeA[i] >= timeB[i]) {
int l = i - 1;
int r = i;
long long speedB = n + 1 - i + 1;
long long speedA = i;
double al = a[l];
if (timeA[l] == timeB[r]) {
} else if (timeA[l] < timeB[r]) {
al += (timeB[r] - timeA[l]) * speedA;
timeA[l] = timeB[r];
} else {
a[r] -= (timeA[l] - timeB[r]) * speedB;
}
ans = (a[r] - al);
ans /= (speedA + speedB);
ans += timeA[l];
break;
}
}
cout << ans << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
int test(int x) {
scanf("%d", &x);
int a, b, c, d;
a = x / 1000;
b = x / 100 % 10;
c = x / 10 % 10;
d = x % 10;
return (a != b && a != c && a != d && b != d && b != c && c != d);
}
int main() {
int n;
scanf("%d", &n);
while (!test(++n))
;
printf("%d", n);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
struct Edge {
int to, val, nxt;
} edges[MAX << 1];
int head[MAX], siz[MAX], mx_son_siz[MAX], n, tot, rt;
long long minn, maxx;
inline void addedge(int u, int v, int w) {
edges[tot].to = v;
edges[tot].val = w;
edges[tot].nxt = head[u];
head[u] = tot++;
}
void getroot(int x, int fa) {
siz[x] = 1;
mx_son_siz[x] = 0;
for (int i = head[x]; i != -1; i = edges[i].nxt) {
int v = edges[i].to;
if (v == fa) continue;
getroot(v, x);
siz[x] += siz[v];
mx_son_siz[x] = max(mx_son_siz[x], siz[v]);
}
mx_son_siz[x] = max(mx_son_siz[x], n - siz[x]);
if (!rt || mx_son_siz[x] < mx_son_siz[rt]) rt = x;
}
void dfs(int x, int fa, long long sum, int w) {
siz[x] = 1;
for (int i = head[x]; i != -1; i = edges[i].nxt) {
int v = edges[i].to;
if (v == fa) continue;
dfs(v, x, sum + edges[i].val, edges[i].val);
siz[x] += siz[v];
}
if (siz[x] & 1) minn += w;
maxx += sum;
}
void init() {
for (int i = 1; i <= n; i++) head[i] = -1;
rt = tot = 0;
minn = maxx = 0ll;
}
int main() {
int T;
cin >> T;
while (T--) {
scanf("%d", &n);
n <<= 1;
init();
for (int i = 1; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
addedge(u, v, w);
addedge(v, u, w);
}
getroot(1, -1);
dfs(rt, -1, 0, 0);
printf("%I64d %I64d\n", minn, maxx);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int NN = 300030;
vector<int> adj[NN], del, ans[NN << 1];
vector<int> D;
set<int> st;
int col[NN], vst[NN];
int FF;
int ok() {
set<int> ed;
for (int v : st)
for (int u : adj[v]) ed.insert(u);
int sz = ed.size();
for (int v : st) {
if (adj[v].size() != sz) {
for (int u : st)
if (adj[u].size() == sz) {
FF = u;
break;
}
return 1;
}
}
return 0;
}
int n, m;
void sol(int SSS) {
st.clear();
for (int v : adj[SSS]) st.insert(v);
for (int v : adj[SSS]) {
int a = adj[v][0];
auto str = st.begin();
auto ed = st.lower_bound(a);
for (auto j = str; j != ed; j++) del.push_back(*j);
for (int u : del) st.erase(u);
del.clear();
for (int i = 0; i < adj[v].size() - 1; i++) {
int a = adj[v][i], b = adj[v][i + 1];
auto str = st.upper_bound(a);
auto ed = st.lower_bound(b);
for (auto j = str; j != ed; j++) del.push_back(int(*j));
for (int u : del) st.erase(u);
del.clear();
}
a = adj[v].back();
str = st.upper_bound(a);
ed = st.end();
for (auto j = str; j != ed; j++) del.push_back(*j);
for (int u : del) st.erase(u);
del.clear();
}
int c = NN;
if (ok()) {
if (SSS == 1)
sol(FF);
else {
puts("NO");
return;
}
return;
}
for (int v : st) ans[c].push_back(v), col[v] = c;
int fa = SSS;
int co = c;
int d = 0;
for (int v : adj[fa]) {
if (!col[v]) {
d = v;
break;
}
}
if (d) {
for (int v : adj[d]) vst[v] = 1;
st.clear();
D.clear();
for (int v : adj[fa]) {
if (!col[v] and vst[v]) {
D.push_back(v);
col[v] = 1;
}
}
}
while (1) {
int d = 0;
for (int v : adj[fa]) {
if (!col[v]) {
d = v;
break;
}
}
if (!d) break;
st.clear();
for (int v : adj[fa]) {
if (!col[v]) {
st.insert(v);
}
}
if (ok()) {
puts("NO");
return;
}
co--;
for (int v : st) ans[co].push_back(v), col[v] = co;
fa = d;
}
for (int v : D) col[v] = 0;
fa = SSS;
co = c;
while (1) {
int d = 0;
for (int v : adj[fa]) {
if (!col[v]) {
d = v;
break;
}
}
if (!d) break;
st.clear();
for (int v : adj[fa]) {
if (!col[v]) {
st.insert(v);
}
}
if (ok()) {
puts("NO");
return;
}
co++;
for (int v : st) ans[co].push_back(v), col[v] = co;
fa = d;
}
for (int i = 1; i <= n; i++) {
if (!col[i]) {
puts("NO");
return;
}
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", col[i]);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++)
adj[i].push_back(i), sort(adj[i].begin(), adj[i].end());
sol(1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
ifstream in("input.txt");
ofstream out("output.txt");
vector<int> v[500001];
vector<vector<int>> v2(101), g2(101);
vector<pair<int, int>> vi[100001];
set<int> s[1000007];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long dp[n + 1], dpp[n + 1];
for (int i = 0; i < n + 1; i++) dp[i] = 0;
for (int i = 0; i < n + 1; i++) dpp[i] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= sqrt(a[i]); j++) {
if (a[i] % j == 0) {
if (j <= n && j > 1) {
if (dp[j - 1] > 0) dpp[j] = (dp[j] + dp[j - 1]) % 1000000007;
}
int d = a[i] / j;
if (d <= n && j != d)
if (dp[d - 1] > 0) dpp[d] = (dp[d] + dp[d - 1]) % 1000000007;
}
}
dp[1]++;
for (int j = 1; j <= sqrt(a[i]); j++) {
if (a[i] % j == 0) {
if (j <= n && j > 1) {
if (dpp[j] > 0) {
dp[j] = dpp[j];
dpp[j] = 0;
}
}
int d = a[i] / j;
if (d <= n) {
if (dpp[d] > 0) {
dp[d] = dpp[d];
dpp[d] = 0;
}
}
}
}
dp[1] = dp[1] % 1000000007;
}
long long s = 0;
for (int i = 0; i < n + 1; i++) s = (s + dp[i]) % 1000000007;
cout << s << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int DP[4000][4], n, a[4000], b[4000], c[4000];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) scanf("%d", b + i);
for (int i = 1; i <= n; i++) scanf("%d", c + i);
DP[1][0] = a[1];
DP[1][1] = a[1];
DP[2][0] = a[1] + b[2];
DP[2][1] = a[2] + b[1];
for (int i = 3; i <= n; i++) {
DP[i][0] =
(DP[i - 1][0] > DP[i - 1][1] ? DP[i - 1][0] : DP[i - 1][1]) + b[i];
DP[i][1] = a[i] + DP[i - 1][0] + c[i - 1] - b[i - 1];
DP[i][1] = (DP[i][1] > a[i] + DP[i - 1][1] + b[i - 1] - a[i - 1]
? DP[i][1]
: a[i] + DP[i - 1][1] + b[i - 1] - a[i - 1]);
}
printf("%d\n", (DP[n][0] > DP[n][1] ? DP[n][0] : DP[n][1]));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[300005];
map<int, int> was;
long long sum[300005];
void load() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
}
void solve() {
long long ans = 0;
int l = -1, r = -1;
for (int i = 0; i < n; i++) {
sum[i] = (i == 0 ? 0 : sum[i - 1]) + (a[i] > 0 ? a[i] : 0);
if (was.find(a[i]) != was.end()) {
int pos = was[a[i]];
long long c = sum[i] - (pos == 0 ? 0 : sum[pos - 1]);
if (a[i] < 0) c += 2 * a[i];
if (l == -1 || c > ans) {
ans = c;
l = pos;
r = i;
}
} else {
was[a[i]] = i;
}
}
vector<int> b;
for (int i = 0; i < l; i++) {
b.push_back(i + 1);
}
for (int i = l + 1; i < r; i++) {
if (a[i] < 0) b.push_back(i + 1);
}
for (int i = r + 1; i < n; i++) {
b.push_back(i + 1);
}
cout << ans << " " << b.size() << endl;
for (int i = 0; i < (int)b.size(); i++) {
printf("%d ", b[i]);
}
}
int main() {
load();
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char down(char c) {
if (c >= 'A' && c <= 'Z') c += 32;
return c;
}
char up(char c) {
if (c >= 'a' && c <= 'z') c -= 32;
return c;
}
int main() {
char a[52], c, d[52];
int b, i, j, k;
while (cin >> a >> b) {
for (i = 0; i < strlen(a); i++) {
c = down(a[i]);
if (c <= 'a' - 1 + b) {
d[i] = up(c);
} else {
d[i] = down(c);
}
}
d[i] = '\0';
cout << d << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long TC, n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> TC;
while (TC--) {
cin >> n;
if (n > 2) {
cout << n - 2 << endl;
} else
cout << 0 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
long long int x, y, a, b, t, c, d;
scanf("%lld", &t);
while (t--) {
scanf("%lld %lld %lld %lld", &x, &y, &a, &b);
c = y - x;
d = a + b;
if (c % d == 0) {
printf("%lld\n", c / d);
} else {
printf("-1\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int x[200010], y[200010];
vector<int> row[200010], col[200010];
int parent[200010];
int sz[200100];
char used[200010];
void make_set(int v) {
parent[v] = v;
sz[v] = 1;
}
int find_set(int v) {
if (parent[v] == v) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (sz[a] < sz[b]) swap(a, b);
parent[b] = a;
sz[a] += sz[b];
}
}
set<int> rows[200010], cols[200010];
int r[200010], c[200010];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> q;
if (q == 0) {
cout << n + m - 1 << endl;
exit(0);
}
for (int i = 1; i <= q; i++) {
cin >> x[i] >> y[i];
row[x[i]].push_back(i);
col[y[i]].push_back(i);
r[x[i]]++;
c[y[i]]++;
make_set(i);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)row[i].size() - 1; j++) {
union_sets(row[i][j], row[i][j + 1]);
}
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j < (int)col[i].size() - 1; j++) {
union_sets(col[i][j], col[i][j + 1]);
}
}
int cnt = 0;
for (int i = 1; i <= q; i++) {
int p = find_set(i);
if (!used[p]) {
cnt++;
used[p] = true;
}
}
for (int i = 1; i <= n; i++)
if (!r[i]) cnt++;
for (int j = 1; j <= m; j++)
if (!c[j]) cnt++;
cout << cnt - 1 << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 2e5 + 10;
int main() {
map<int, long long> m;
long long k = 0;
int n;
cin >> n >> k;
vector<int> v(n);
for (auto &x : v) {
cin >> x;
m[x]++;
}
sort(v.begin(), v.end());
k--;
for (auto &p : m) {
if (p.second * n <= k) {
k -= p.second * n;
} else {
k /= p.second;
cout << p.first << ' ' << v[k] << endl;
break;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n;
long double w, a[N];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> w;
for (int i = 0; i < 2 * n; ++i) cin >> a[i];
sort(a, a + 2 * n);
cout << fixed << setprecision(10)
<< min(w, (long double)1.5 * n * min(a[0] * 2, a[n]));
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, m, a[6][3] = {{0, 1, 2}, {1, 0, 2}, {1, 2, 0},
{2, 1, 0}, {2, 0, 1}, {0, 2, 1}};
int main() {
cin >> n >> m;
i = n % 6;
cout << a[i][m];
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
const unsigned long long mod = 1llu << 58;
const unsigned long long inv = 6723469279985657373llu;
struct mod_int {
unsigned long long a0, a1, a2, a3;
mod_int(unsigned long long a0 = 0, unsigned long long a1 = 0,
unsigned long long a2 = 0, unsigned long long a3 = 0)
: a0(a0), a1(a1), a2(a2), a3(a3) {}
mod_int operator+(const mod_int& a) const {
return mod_int(a0 + a.a0, a1 + a.a1, a2 + a.a2, a3 + a.a3);
}
void operator+=(const mod_int& a) {
a0 += a.a0;
a1 += a.a1;
a2 += a.a2;
a3 += a.a3;
}
mod_int operator*(const mod_int& a) const {
return mod_int(
a0 * a.a0 - a1 * a.a3 - a3 * a.a1 - a2 * a.a2 - a2 * a.a3 - a3 * a.a2,
a1 * a.a0 + a0 * a.a1 + a3 * a.a1 + a2 * a.a2 + a1 * a.a3 - a3 * a.a3,
a2 * a.a0 + a1 * a.a1 - a3 * a.a1 + a0 * a.a2 - a2 * a.a2 - a1 * a.a3,
a3 * a.a0 + a2 * a.a1 + a3 * a.a1 + a1 * a.a2 + a2 * a.a2 + a0 * a.a3 +
a1 * a.a3);
}
void divN() {
a0 = a0 * inv >> 5;
a1 = a1 * inv >> 5;
a2 = a2 * inv >> 5;
a3 = a3 * inv >> 5;
}
void operator++() { ++a0; }
} omg[10], ww[10][10], a[N];
void DFT_init() {
omg[0] = mod_int(1);
for (int i = 1; i < 10; ++i) omg[i] = omg[i - 1] * mod_int(0, 1);
for (int i = 0; i < 10; ++i)
for (int j = 0; j < 10; ++j) ww[i][j] = omg[i * j % 10];
}
void DFT(mod_int* f) {
static mod_int g[15];
for (int i = 0; i < 10; ++i) g[i] = mod_int();
for (int i = 0; i < 10; ++i)
for (int j = 0; j < 10; ++j) g[j] += f[i] * ww[i][j];
for (int i = 0; i < 10; ++i) f[i] = g[i];
}
const int pw[] = {1, 10, 100, 1000, 10000};
void FWT(mod_int* f, int flag = 0) {
static mod_int g[15];
for (int i = 0; i < 5; ++i) {
int t = pw[i];
for (int j = 0; j < N; j += t * 10)
for (int k = 0; k < t; ++k) {
for (int l = 0; l < 10; ++l) g[l] = f[j + k + l * t];
DFT(g);
if (flag) reverse(g + 1, g + 10);
for (int l = 0; l < 10; ++l) f[j + k + l * t] = g[l];
}
}
if (flag)
for (int i = 0; i < N; ++i) f[i].divN();
}
mod_int ksm(mod_int a, int b, mod_int c = mod_int(1, 0, 0, 0)) {
for (; b; b /= 2, a = a * a)
if (b & 1) c = c * a;
return c;
}
int n;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
DFT_init();
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
++a[x];
}
FWT(a);
for (int i = 0; i < N; ++i) a[i] = ksm(a[i], n);
FWT(a, 1);
for (int i = 0; i < n; ++i) cout << (a[i].a0 & (mod - 1)) << '\n';
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x20202020;
const long long mod = 1000000007;
const double eps = 1e-9;
const double pi = 3.1415926535897932384626;
const int DX[] = {1, 0, -1, 0}, DY[] = {0, 1, 0, -1};
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int N = 101000;
long long dp[110][N];
int n, m, p, d, h, t;
long long s[N];
int a[N];
void solve(int l, int r, int opl, int opr, long long *p, long long *c) {
int md = (l + r) >> 1, pr = min(opr, md - 1), op = opl;
c[md] = 1ll << 60;
for (int i = opl; i <= pr; i++) {
long long v = p[i] + 1ll * (md - i) * a[md] - (s[md] - s[i]);
if (c[md] > v) op = i, c[md] = v;
}
if (l < md) solve(l, md - 1, opl, op, p, c);
if (md < r) solve(md + 1, r, op, opr, p, c);
}
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 2; i < (int)n + 1; i++) {
scanf("%d", &d);
s[i] = s[i - 1] + d;
}
for (int i = 1; i < (int)m + 1; i++) {
scanf("%d%d", &h, &t);
a[i] = t - s[h];
}
sort(a + 1, a + m + 1);
for (int i = 1; i < (int)m + 1; i++) s[i] = s[i - 1] + a[i];
for (int i = 1; i < (int)m + 1; i++) dp[0][i] = 1ll * i * a[i] - s[i];
for (int j = 0; j < (int)p - 1; j++) solve(1, m, 0, m - 1, dp[j], dp[j + 1]);
printf("%I64d\n", dp[p - 1][m]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long isprime(long long n) {
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
char a[n + 1][n + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cin >> a[i][j];
}
int f = 0, cn;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cn = 0;
if (j < n && a[i][j + 1] == 'o') cn++;
if (j > 1 && a[i][j - 1] == 'o') cn++;
if (i < n && a[i + 1][j] == 'o') cn++;
if (i > 1 && a[i - 1][j] == 'o') cn++;
if (cn & 1) {
f = 1;
break;
}
}
if (f == 1) break;
}
if (f == 1)
cout << "NO";
else
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool is_prime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
int solve(int n) {
if (is_prime(n)) {
return 1;
} else if (n % 2 == 0) {
return 2;
} else {
if (is_prime(n - 2)) {
return 2;
} else {
return 3;
}
}
}
int main() {
int n;
cin >> n;
cout << solve(n) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 502;
vector<int> cur_vertices;
vector<int> vertices;
vector<long long int> ans;
long long dp[N][N];
int a[N][N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> dp[i][j];
}
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
vertices.push_back(x);
}
reverse(vertices.begin(), vertices.end());
for (int i = 0; i < vertices.size(); i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
dp[j][k] = min(dp[j][k], dp[j][vertices[i]] + dp[vertices[i]][k]);
}
}
long long int su = 0;
for (int j = 0; j <= i; j++) {
for (int k = 0; k <= i; k++) {
su += dp[vertices[j]][vertices[k]];
}
}
ans.push_back(su);
}
reverse(ans.begin(), ans.end());
for (auto k : ans) cout << k << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int a, b;
cin >> a >> b;
int count = 1;
count += (a + b);
if (a == 0) {
for (int i = count; i >= 1; i--) cout << i << " ";
} else if (b == 0)
for (int i = 1; i <= count; i++) cout << i << " ";
else {
cout << 1 << " ";
for (int i = count - a + 1; i <= count; i++) cout << i << " ";
for (int i = count - a; i > 1; i--) cout << i << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 86;
struct card {
long long t, y;
card(int _t = 0, long long _y = 0) : t(_t), y(_y) {}
bool operator<(const card &a) const {
if (t != a.t) return t < a.t;
return y < a.y;
}
void read() {
char s[5];
cin >> s >> y;
t = !(s[0] == 'A');
}
} a[MAXN];
long long b[MAXN];
bool v[MAXN];
int n, m;
long long gao1() {
long long ret = 0;
for (int i = m - 1; i >= 0; --i) {
if (m - i > n) return ret;
long long cc = 0;
for (int j = 0, k = i; k < m; ++j, ++k) {
if (a[j].t) return ret;
if (a[j].y > b[k]) return ret;
cc += b[k] - a[j].y;
}
ret = max(ret, cc);
}
return ret;
}
long long gao2() {
long long ret = 0;
if (m <= n) return ret;
bool ok = true;
for (int i = 0, j = 0; i < n; ++i) {
if (a[i].t == 0) continue;
for (; j < m && b[j] <= a[i].y; ++j)
;
if (j >= m) {
ok = false;
break;
}
v[j] = true;
++j;
}
if (!ok) return ret;
for (int i = 0, j = 0; i < n; ++i) {
if (a[i].t == 1) break;
for (; j < m && (b[j] < a[i].y || v[j]); ++j)
;
if (j >= m) {
ok = false;
break;
}
++j;
}
if (!ok) return ret;
for (int i = 0; i < m; ++i)
if (!v[i]) ret += b[i];
for (int i = 0; i < n; ++i)
if (a[i].t == 0) ret -= a[i].y;
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; ++i) a[i].read();
sort(a, a + n);
for (int i = 0; i < m; ++i) cin >> b[i];
sort(b, b + m);
cout << max(gao1(), gao2()) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353;
const long long int nmax = 2 * 1e3 + 10;
vector<pair<long long int, long long int> > dir{
{0, -1}, {-1, 0}, {0, 1}, {1, 0}};
long long int mod_sub(long long int a, long long int b, long long int m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long int mod_add(long long int a, long long int b, long long int m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long int mod_mul(long long int a, long long int b, long long int m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
void sieve(vector<long long int>& arr, long long int n) {
arr[0] = -1;
arr[1] = -1;
for (long long int i = 2; (i * i) <= n; i++) {
if (arr[i] != -1) {
for (long long int j = i * i; j <= n; j += i) arr[j] = -1;
}
}
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int mod_exp(long long int a, long long int b, long long int c) {
if (a == 0) return 0;
if (b == 0) return 1;
long long int smallans;
if (b % 2 == 0) {
smallans = mod_exp(a, b / 2, c);
return mod_mul(smallans, smallans, c);
} else {
smallans = mod_exp(a, b - 1, c);
return mod_mul(a, smallans, c);
}
}
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n + 1);
for (long long int i = 1; i < n + 1; i++) {
cin >> a[i];
}
vector<long long int> dp1(n + 2);
dp1[0] = 1;
vector<long long int> dp2(n + 2);
for (long long int i = 1; i < n + 1; i++) {
if (a[i] > 0) {
dp2[a[i] - 1] = (dp1[a[i] - 1] % mod + (2 * dp2[a[i] - 1]) % mod) % mod;
}
dp1[a[i] + 1] = (dp1[a[i]] % mod + (2 * dp1[a[i] + 1]) % mod) % mod;
dp2[a[i] + 1] = (2 * dp2[a[i] + 1]) % mod;
}
long long int sum = 0;
for (long long int i = 0; i < n + 1; i++) {
sum = (sum % mod + dp1[i] % mod + dp2[i] % mod) % mod;
}
cout << ((sum - 1) % mod + mod) % mod;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long n, four = -1, seven = -1;
cin >> n;
int j = 0;
for (int i = 0; i <= n; i += 4, j++) {
if ((n - i) % 7 == 0) {
four = j;
seven = (n - i) / 7;
break;
}
}
if (four == -1 && seven == -1) {
cout << -1;
return 0;
}
for (int i = 0; i < four; i++) cout << 4;
for (int i = 0; i < seven; i++) cout << 7;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[30], num, pp[30], p2;
void search(int k, int x) {
int i;
if (x == a[k] - 1) {
p2 = 1;
return;
}
for (i = k - 1; i >= 1; i--)
if (pp[i] == 0 && a[i] != a[k] - 1 && a[i] + x < a[k]) {
pp[i] = 1;
search(k, a[i] + x);
if (p2 == 0) {
pp[i] = 0;
} else
return;
}
}
int main() {
int t, n, i, p;
{
scanf("%d", &n);
memset(pp, 0, sizeof(pp));
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (i = 2; i <= n; i++)
if (a[i] != a[i - 1]) break;
num = i;
for (i = num; i <= n; i++) {
p2 = 0;
search(i, 0);
if (p2 == 0) break;
}
p = 0;
for (i = 1; i < n; i++)
if (pp[i] == 0) p = 1;
if (p == 1)
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 999999;
int main() {
long long n, m, s, d, tmp, len;
cin >> n >> m >> s >> d;
vector<long long> a(n, 0);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
if (d < 2) {
cout << "IMPOSSIBLE";
return 0;
}
sort(a.begin(), a.end());
vector<long long> next(n);
vector<bool> norm(n, 0), what;
long long prev = -1;
for (long long i = n - 1; i > -1; i--) {
if (i == 0) {
if (a[i] - 1 >= s) {
norm[i] = 1;
}
next[i] = prev;
} else {
if (a[i] - a[i - 1] - 2 >= s) {
norm[i] = 1;
next[i] = prev;
prev = i;
} else {
next[i] = prev;
}
}
}
vector<long long> ans;
bool flag = false;
long long pr, next1;
for (long long i = 0; i < n + 1; i++) {
if (i == n) {
if (!norm[i - 1]) {
flag = true;
break;
}
what.push_back(1);
ans.push_back(2);
if (m - a[i - 1] - 1 > 0) {
what.push_back(0);
ans.push_back(m - a[i - 1] - 1);
}
} else if (!norm[i]) {
if (i == 0) {
flag = true;
break;
}
pr = i - 1;
next1 = next[pr];
pr = a[pr];
if (next1 == -1)
next1 = a[n - 1];
else
next1 = a[next1 - 1];
tmp = next1 - pr + 2;
if (tmp > d) {
flag = true;
break;
}
what.push_back(1);
ans.push_back(tmp);
if (next[i - 1] == -1) {
if (m - a[n - 1] - 1 > 0) {
what.push_back(0);
ans.push_back(m - a[n - 1] - 1);
}
i = n;
} else {
i = next[i - 1] - 1;
}
} else {
if (i == 0) {
what.push_back(0);
ans.push_back(a[0] - 1);
} else {
len = (long long)what.size();
if (!what[len - 1]) {
what.push_back(1);
ans.push_back(2);
what.push_back(0);
ans.push_back(a[i] - a[i - 1] - 2);
} else {
what.push_back(0);
ans.push_back(a[i] - a[i - 1] - 2);
}
}
}
}
if (flag) {
cout << "IMPOSSIBLE";
return 0;
}
for (long long i = 0; i < (long long)what.size(); i++) {
if (what[i]) {
cout << "JUMP " << ans[i] << endl;
} else {
cout << "RUN " << ans[i] << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int comp[212345], ptr;
int idx[212345];
map<int, int> place;
int h, m, n;
int merge(int x, int y) {
if (x == -1) {
return y;
}
return x;
}
struct segtree {
int n;
vector<int> tree;
segtree(vector<int> base) {
n = base.size();
tree.resize(2 * n);
for (int i = 0; i < n; ++i) {
tree[i + n] = base[i];
}
for (int i = n - 1; i > 0; --i) {
tree[i] = merge(tree[i + i], tree[i + i + 1]);
}
}
int qry(int l) {
int x = qry(l, n);
if (x == -1) {
return qry(0, l);
}
return x;
}
int qry(int l, int r) {
int resl = -1, resr = -1;
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l & 1) resl = merge(resl, tree[l++]);
if (r & 1) resr = merge(tree[--r], resr);
}
return merge(resl, resr);
}
void upd(int pos, int val) {
pos += n;
tree[pos] = val;
for (pos /= 2; pos > 0; pos /= 2) {
tree[pos] = merge(tree[pos + pos], tree[pos + pos + 1]);
}
}
};
vector<int> base[212345];
void dfs(int x) {
comp[x] = ptr;
idx[x] = base[ptr].size();
base[ptr].push_back(x);
int nxt = (x + m) % h;
if (comp[nxt] == -1) {
dfs(nxt);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> h >> m >> n;
int ans = 0;
memset(comp, -1, sizeof comp);
for (int i = 0; i < h; ++i) {
if (comp[i] == -1) {
dfs(i);
++ptr;
}
}
vector<segtree> segts;
for (int i = 0; i < ptr; ++i) {
segts.push_back(segtree(base[i]));
}
while (n--) {
char a;
int id, hash;
cin >> a >> id;
if (a == '+') {
cin >> hash;
int pos = segts[comp[hash]].qry(idx[hash]);
int dummy = idx[pos] - idx[hash];
if (dummy < 0) {
dummy += base[comp[hash]].size();
}
ans += dummy;
segts[comp[pos]].upd(idx[pos], -1);
place[id] = pos;
} else {
int pos = place[id];
segts[comp[pos]].upd(idx[pos], pos);
}
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
void solve(__attribute__((unused)) bool);
void precalc();
clock_t start;
int main() {
start = clock();
int t = 1;
cout.sync_with_stdio(0);
cin.tie(0);
precalc();
cout.precision(10);
cout << fixed;
int testNum = 1;
while (t--) {
solve(true);
}
cout.flush();
return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
if (!w) return 1 % mod;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
template <typename T>
T gcd(T q, T w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
template <typename T>
T lcm(T q, T w) {
return q / gcd(q, w) * w;
}
template <typename T>
void make_unique(vector<T>& a) {
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
}
template <typename T>
void relax_min(T& cur, T val) {
cur = min(cur, val);
}
template <typename T>
void relax_max(T& cur, T val) {
cur = max(cur, val);
}
void precalc() {}
const int INF = (int)1e9;
vector<int> get_dp(vector<int> a) {
vector<int> res(4, -INF);
if (a.size() == 2) {
if (a[0] != a[1]) {
res[1] = res[2] = 1;
} else if (a[0]) {
res[3] = 1;
} else {
res[0] = 0;
}
return res;
}
int mid = (int)a.size() / 2;
auto lef_dp = get_dp(vector<int>(a.begin(), a.begin() + mid));
auto rig_dp = get_dp(vector<int>(a.begin() + mid, a.end()));
for (int m1 = 0; m1 < 4; ++m1) {
for (int m2 = 0; m2 < 4; ++m2) {
int new_m = (m1 | m2);
if (lef_dp[m1] < 0 || rig_dp[m2] < 0) {
continue;
}
int new_dp_val = lef_dp[m1] + rig_dp[m2];
for (int j = 0; j < 2; ++j) {
if (new_m & (1 << j)) {
++new_dp_val;
}
}
if (new_m & 2) {
++new_dp_val;
}
relax_max(res[new_m], new_dp_val);
}
}
return res;
}
void solve(__attribute__((unused)) bool read) {
int n, k;
cin >> n >> k;
if (k == 0) {
cout << "0\n";
return;
}
vector<int> a(k);
vector<int> have(1 << n);
for (int& x : a) {
cin >> x;
--x;
have[x] = 1;
}
auto res = get_dp(have);
int mx = *max_element(res.begin(), res.end());
cout << mx + 1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
vector<int> g[maxn];
int s[maxn], a[maxn];
int n, k;
void pre(int u, int par) {
s[u] = a[u];
for (auto v : g[u])
if (v != par) {
pre(v, u);
s[u] += s[v];
}
}
int get_center(int u, int par) {
for (auto v : g[u])
if (v != par)
if (s[v] > k) return get_center(v, u);
return u;
}
vector<int> ans;
void dfs(int u, int par) {
if (a[u]) ans.push_back(u);
for (auto v : g[u])
if (v != par) dfs(v, u);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 0; i < k * 2; ++i) {
int x;
scanf("%d", &x);
a[x] = 1;
}
pre(1, 1);
int ct = get_center(1, 1);
printf("%d\n%d\n", 1, ct);
dfs(1, 1);
for (int i = 0; i < k; ++i) printf("%d %d %d\n", ans[i], ans[i + k], ct);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, n, ans, p[110000];
int main() {
scanf("%d%d%d", &a, &b, &c);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
sort(p + 1, p + 1 + n);
ans = (lower_bound(p + 1, p + 1 + n, c) - p - 1) -
(upper_bound(p + 1, p + 1 + n, b) - p) + 1;
printf("%d", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int d[2] = {1, -1};
int tp, k2, i, j, k, num;
char s[105];
void dp(int f[][55][2], int type) {
tp = f[i][j][k], k2 = k;
if (num & 1) {
if (s[i] == 'T')
tp += d[k];
else
k2 = !k;
} else {
if (s[i] == 'T')
k2 = !k;
else
tp += d[k];
}
if (type == 1)
f[i + 1][j + num][k2] = max(f[i + 1][j + num][k2], tp);
else
f[i + 1][j + num][k2] = min(f[i + 1][j + num][k2], tp);
}
int f[105][55][2], g[105][55][2];
int main() {
int n, len;
while (cin >> s) {
len = strlen(s);
cin >> n;
for (i = 0; i < 105; i++) {
for (j = 0; j < 55; j++) {
f[i][j][0] = f[i][j][1] = -0x3fffffff;
g[i][j][0] = g[i][j][1] = 0x3fffffff;
}
}
f[0][0][0] = f[0][0][1] = g[0][0][0] = g[0][0][1] = 0;
for (i = 0; i < len; i++) {
for (j = 0; j <= n; j++) {
for (k = 0; k < 2; k++) {
for (num = 0; j + num <= n; num++) {
if (f[i][j][k] > -0x3fffffff) dp(f, 1);
if (g[i][j][k] < 0x3fffffff) dp(g, 0);
}
}
}
}
cout << max(f[len][n][0],
max(f[len][n][1], max(-g[len][n][0], -g[len][n][1])))
<< endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long l = s.length(), i;
long count = 0;
for (i = 0; i < l / 2; i++)
if (s[i] != s[l - i - 1]) count++;
if (count == 1)
cout << "YES";
else if (count == 0 && l % 2)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
const int M = 1e6 + 5;
const int mod = 1e9 + 7;
const int m1 = 1e9 + 7;
const int m2 = 1e9 + 9;
const int p1 = 402653189;
const int p2 = 1610612741;
const int LN = 22;
int powermodm(int x, int n, int M) {
int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
int power(int _a, int _b) {
int _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a);
_b /= 2;
_a = (_a * _a);
}
return _r;
}
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int lcm(int a, int b) { return (max(a, b) / gcd(a, b)) * min(a, b); }
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int pw[LN], fact[N], invfact[N];
void pre() {
fact[0] = 1;
for (int i = 0; i < LN; i++) pw[i] = power(2, i);
for (int i = 1; i < N; i++) fact[i] = (i * fact[i - 1]) % mod;
for (int i = 0; i < N; i++) invfact[i] = powermodm(fact[i], mod - 2, mod);
}
int dp[(1 << 20) + 10];
int cnt[20][20];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
pre();
int i, j;
int n, m;
cin >> n >> m;
string s;
cin >> s;
for (i = 0; i < s.length() - 1; i++) {
cnt[s[i] - 'a'][s[i + 1] - 'a']++;
cnt[s[i + 1] - 'a'][s[i] - 'a']++;
}
for (i = 1; i < pw[m]; i++) {
dp[i] = 1e9;
vector<int> active;
for (j = 0; j < m; j++) {
if (pw[j] & i) active.push_back(j);
}
int sz = active.size();
for (j = 0; j < active.size(); j++) {
int idx = active[j];
int val = i - pw[idx];
int tans = 0;
for (int k = 0; k < m; k++) {
if (k == idx) continue;
if (pw[k] & val)
tans += cnt[idx][k] * sz;
else
tans -= cnt[idx][k] * sz;
}
dp[i] = min(dp[i], dp[val] + tans);
}
}
cout << dp[pw[m] - 1];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10;
struct node {
long long val, id;
bool operator<(const node& o) const {
if (val == o.val) return id < o.id;
return val < o.val;
}
};
node make_node(long long v, long long i) {
node res;
res.val = v;
res.id = i;
return res;
}
node max(node c, node b) {
if (c < b)
return b;
else
return c;
}
node tree[N * 20];
long long n, a[N];
void build(long long i, long long l, long long r) {
if (l == r) {
tree[i] = make_node(a[l], l);
return;
}
build(2 * i, l, (l + r) / 2);
build(2 * i + 1, (l + r) / 2 + 1, r);
tree[i] = max(tree[2 * i], tree[2 * i + 1]);
}
void input() {
cin >> n;
for (long long i = 0; i < n - 1; i++) {
cin >> a[i];
a[i]--;
}
build(1, 0, n - 1);
}
node get(long long i, long long l, long long r, long long L, long long R) {
if (r < L || l > R) return make_node(-1, -1);
if (L <= l && r <= R)
return tree[i];
else {
node left = get(2 * i, l, (l + r) / 2, L, R);
node right = get(2 * i + 1, (l + r) / 2 + 1, r, L, R);
return max(left, right);
}
}
void compute_end_to_begin() {
long long dp[N];
dp[n - 1] = 0;
for (long long i = n - 2; i >= 0; i--) {
node M = get(1, 0, n - 1, i + 1, a[i]);
long long am = M.val;
long long m = M.id;
dp[i] = dp[m] + (n - 1 - a[i]) + m - i;
}
long long sum = 0;
for (long long i = 0; i <= n - 2; i++) sum += dp[i];
cout << sum << endl;
}
int main() {
ios_base::sync_with_stdio(false);
input();
compute_end_to_begin();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int max_fib = 95;
long long fib[max_fib];
long long dyn1[max_fib], dyn2[max_fib];
int A[max_fib];
long long solve(long long& n) {
int cur_fib = 0;
while (fib[cur_fib + 1] <= n) {
++cur_fib;
}
int m = 0;
for (int i = cur_fib; i > 0; --i) {
if (n >= fib[i]) {
n -= fib[i];
A[m++] = i;
}
}
A[m] = 0;
dyn1[m] = 1, dyn2[m] = 0;
for (int i = m - 1; i >= 0; --i) {
dyn1[i] = dyn1[i + 1] + dyn2[i + 1];
dyn2[i] = (A[i] - A[i + 1] - 1) / 2 * dyn1[i + 1] +
(A[i] - A[i + 1]) / 2 * dyn2[i + 1];
}
return dyn1[0] + dyn2[0];
}
int main() {
fib[0] = fib[1] = 1;
for (int i = 2; i < max_fib; ++i) {
fib[i] = fib[i - 1] + fib[i - 2];
}
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
long long n;
cin >> n;
cout << solve(n) << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using LP = pair<ll, ll>;
const ll INF = (1e+18) + 100;
using speP = pair<LP, ll>;
bool query(int x, int y) {
cout << "? " << x + 1 << " " << y + 1 << endl;
char c;
cin >> c;
return c == '<';
}
void solve() {
int n;
cin >> n;
vector<pair<int, int>> v;
for (int i = 0; i < n; ++i) {
if (query(i, n + i)) {
v.push_back({i, n + i});
} else {
v.push_back({n + i, i});
}
}
vector<int> c(n, 0);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i; ++j) {
if (query(v[i].first, v[j].first)) {
c[j]++;
} else {
c[i]++;
}
}
}
int k = 0;
for (int i = 0; i < n; ++i)
if (c[i] == n - 1) k = i;
vector<int> c2(n, 0);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i; ++j) {
if (i == k || j == k) continue;
if (query(v[i].second, v[j].second)) {
c2[j]++;
} else {
c2[i]++;
}
}
}
int l = 0;
for (int i = 0; i < n; ++i)
if (c2[i] == n - 2) l = i;
for (int i = 0; i < n; ++i) {
if (i == k || i == l) continue;
for (int j = 0; j < n; ++j) {
query(v[i].second, v[j].first);
}
}
cout << "!" << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; ++i) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
const long long INF = 1ll << 60;
vector<vector<long long>> dp;
int n;
vector<long long> A;
string s;
public:
void run(istream &in, ostream &out) {
in >> n;
in >> s;
A.resize(n);
dp.assign(5, vector<long long>(n + 1, INF));
for (int i = 0; i < n; ++i) in >> A[i];
dp[0][0] = dp[1][0] = dp[2][0] = dp[3][0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 4; ++j) {
dp[j][i + 1] = s[i] != "hard"[j] ? dp[j][i]
: j == 0 ? dp[j][i] + A[i]
: min(dp[j][i] + A[i], dp[j - 1][i]);
}
}
out << min({dp[0][n], dp[1][n], dp[2][n], dp[3][n]}) << '\n';
}
};
int main() {
std::ios_base::sync_with_stdio(false);
Solution().run(std::cin, std::cout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool compare1(pair<long long, long long> a1, pair<long long, long long> a2) {
double aa = ((double)a1.first) / a1.second;
double bb = ((double)a2.first) / a2.second;
return aa > bb;
}
long long min(long long a, long long b) {
if (a > b) return b;
return a;
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long hashs(string a) {
long long k = 27;
long long value = 0;
for (long long i = 0; i < a.length(); i++) {
value = ((value * k + (a[i] - 'a' + 1))) % 10000000000007;
}
return value;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
deque<int> arr;
for (int i = 1; i <= k; i++) {
arr.push_back(i);
}
int count = 2;
vector<pair<int, int>> ans;
int mark = k + 1;
while (mark < n) {
if (n - mark == 1)
count += 1;
else
count += 2;
int pp = mark + k;
while (mark < n && mark < pp) {
ans.push_back(make_pair(mark, arr.back()));
arr.pop_back();
arr.push_front(mark++);
}
}
for (int i = 0; i < arr.size(); i++) {
ans.push_back(make_pair(n, arr[i]));
}
cout << count << "\n";
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c[100005];
int a[4], i, k, l = 0;
cin >> a[0] >> a[1] >> a[2] >> a[3];
cin >> c;
k = strlen(c);
for (i = 0; i < k; i++) {
l += a[(int)c[i] - 49];
}
cout << l;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n + (n / 2);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool comp(int a, int b) { return a > b; }
int main() {
int n, m, k, sum = 0, sum1 = 0;
;
cin >> n >> m >> k;
vector<int> vn(n);
vector<bool> vk(k + 1, false);
vector<int> vm(m);
if (n > m) {
cout << "YES" << endl;
return 0;
}
for (int i = 0; i < n; i++) {
cin >> vn[i];
}
for (int i = 0; i < m; i++) {
cin >> vm[i];
}
sort(vn.begin(), vn.end(), comp);
sort(vm.begin(), vm.end(), comp);
for (int i = 0; i < n; i++) {
if (vn[i] > vm[i]) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, arr[1000069] = {}, dp[1000069] = {}, f[1000069] = {};
int main() {
cin >> n;
int maxi = 0;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d", &x);
scanf("%d", &y);
arr[x] = y;
f[x] = 1;
maxi = max(maxi, x);
}
for (int i = 1; i < maxi + 1; i++) f[i] = f[i - 1] + f[i];
for (int i = 1; i < maxi + 1; i++) {
if (i - arr[i] - 1 >= 0)
dp[i] = dp[i - arr[i] - 1] + (f[i - 1] - f[i - arr[i] - 1]);
else
dp[i] = f[i - 1];
}
int ans = maxi + 2;
for (int i = 0; i < maxi + 1; i++) {
ans = min(ans, dp[i] + (f[maxi] - f[i]));
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t > 0) {
int n, s, si, f = 0, cnt = 1;
cin >> n;
string str;
cin >> str;
if ((str[0] == '0' && str[n - 1] == '1') ||
(str[0] == '1' && str[n - 1] == '0') ||
(str[0] == '1' && str[n - 1] == '1'))
cout << n * 2 << endl;
else {
for (int i = 0; str[i] != '\0'; i++) {
if (str[i] == '1') {
s = i;
f = 1;
break;
}
}
for (int i = 0; str[i] != '\0'; i++) {
if (str[i] == '1') {
si = i + 1;
f = 1;
}
}
int mx = max((n - s), si);
if (f == 1)
cnt = 2 * mx;
else
cnt = n;
cout << cnt << endl;
}
t--;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 505;
int main() {
int n, c[MAX], dp[MAX][MAX], t;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", c + i);
dp[i][0] = 1;
}
for (int i = 0; i < n - 1; ++i) dp[i][1] = (c[i] == c[i + 1]) ? 1 : 2;
for (int j = 2; j < n; ++j) {
for (int i = 0; i + j < n; ++i) {
t = dp[i][0] + dp[i + 1][j - 1];
for (int k = 1; k < j; ++k) {
t = min(t, dp[i][k] + dp[i + k + 1][j - k - 1]);
}
dp[i][j] = t;
if (c[i] == c[i + j]) {
dp[i][j] = min(dp[i][j], dp[i + 1][j - 2]);
}
}
}
printf("%d\n", dp[0][n - 1]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int ss;
int ff;
int rr;
int cc;
} inp;
inp in[250005];
int a[405];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
srand(time(NULL));
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
long long ans = 0;
for (int i = 1; i <= m; i++) {
cin >> in[i].ss >> in[i].ff >> in[i].cc >> in[i].rr;
}
reverse(in + 1, in + 1 + m);
int ms = 0, mf = 0, mc = 0, mr = 0;
for (int i = 1; i <= m; i++) {
int s = in[i].ss, f = in[i].ff, c = in[i].cc, r = in[i].rr;
int cur = s;
if (a[mf] - a[ms] >= a[f] - a[s] && c <= mc && r >= mr) continue;
for (int j = 0; j <= r; j++) {
long long LL = s, RR = n;
while (LL != RR) {
long long midd = (LL + RR + 1) / 2;
if (1LL * (a[midd] - a[cur]) * c <= ans)
LL = midd;
else
RR = midd - 1;
}
cur = LL;
if (cur >= f) break;
}
if (cur >= f) continue;
long long L = cur, R = 1e18;
while (L != R) {
long long mid = (L + R) / 2;
cur = s;
for (int j = 0; j <= r; j++) {
long long LL = s, RR = n;
while (LL != RR) {
long long midd = (LL + RR + 1) / 2;
if (1LL * (a[midd] - a[cur]) * c <= mid)
LL = midd;
else
RR = midd - 1;
}
cur = LL;
if (cur >= f) break;
}
if (cur >= f)
R = mid;
else
L = mid + 1;
}
ans = L;
ms = s;
mf = f;
mc = c;
mr = r;
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long INF = 5e18;
const double pi = acos(-1.0);
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
int gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
int lcm(int a, int b) { return (a * b) / gcd(a, b); }
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
double rad(double x) { return x * pi / 180.0; }
bool isleft(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
int det = (b.first - a.first) * (c.second - a.second) -
(c.first - a.first) * (b.second - a.second);
if (det >= 0) return true;
if (det < 0) return false;
return false;
}
int exp(int a, int b) {
int result = 1;
while (b > 0) {
if (b & 1) result = result * a % MOD;
b >>= 1;
a = a * a % MOD;
}
return result;
}
vector<int> calc(vector<int> &vet, int n) {
int v[200000];
for (int i = 0; i < 200000; i++) {
v[i] = INF;
}
v[0] = 0;
for (int &i : vet) {
for (int j = 199999; j - i >= 0; j--) {
if (v[j - i] != INF) {
v[j] = min(v[j - i] + 1, v[j]);
}
}
}
vector<int> ans;
for (int i = 0; i < 200000; i++) {
if (v[i] <= n) {
ans.push_back(i);
}
}
return ans;
}
int memo[75][200200];
int n, m, k;
vector<vector<int>> adj;
int dp(int pos, int sum) {
if (pos == n) {
if (sum % k == 0)
return sum;
else
return -INF;
}
int &x = memo[pos][sum];
if (x != -1) return x;
if (sum % k == 0) {
x = sum;
} else {
x = -INF;
}
for (int &i : adj[pos]) {
x = max(x, dp(pos + 1, sum + i));
}
return x;
}
void solve() {
memset(memo, -1, sizeof(memo));
cin >> n >> m >> k;
vector<int> vet(m);
vector<int> ans;
adj.clear();
for (int i = 0; i < n; i++) {
for (int &j : vet) {
cin >> j;
}
ans = calc(vet, m / 2);
vector<int> newans;
map<int, int> mapa;
for (int &i : ans) {
mapa[i % k] = max(i, mapa[i % k]);
}
for (auto &i : mapa) {
newans.push_back(i.second);
}
ans = newans;
adj.push_back(ans);
}
cout << dp(0, 0) << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, pos[200005], to = -1;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
pos[a] = i;
}
for (int i = 0; i < n; ++i) {
int b;
cin >> b;
int c = pos[b];
if (c <= to) {
cout << 0 << ' ';
} else {
cout << pos[b] - to << ' ';
to = pos[b];
}
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int yes = 0;
string name[n];
int before[n], after[n];
for (int i = 0; i < n; ++i) {
cin >> name[i];
if (name[i].size() > 10) return -1;
cin >> before[i];
cin >> after[i];
}
for (int i = 0; i < n; ++i) {
if (before[i] >= 2400 && before[i] < after[i]) yes++;
}
if (yes > 0)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 100;
int check(int n) {
for (int i = 3;; i += 2) {
if (n % i == 0) return i;
}
}
void solve() {
long long n, k;
cin >> n >> k;
long long ans = n;
if (n % 2 == 0) {
ans = ans + k * 2;
} else {
int tmp = check(ans);
ans += tmp;
ans += (k - 1) * 2;
}
cout << ans << '\n';
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 5, P = 1e9 + 7;
int n, m, a[M], sum[M];
char s[M];
long long t[M], ans, F[M], INV[M];
void Add(long long &x, long long y) {
x += y;
if (x >= P) x -= P;
if (x < 0) x += P;
}
long long FAST(long long x, long long y) {
long long res = 1;
for (; y; y >>= 1) {
if (y & 1) res = res * x % P;
x = x * x % P;
}
return res;
}
long long C(int x, int y) { return F[x] * INV[y] % P * INV[x - y] % P; }
void init() {
t[0] = F[0] = INV[0] = 1;
for (int i = 1; i <= 1e5; ++i) t[i] = t[i - 1] * 10 % P;
for (int i = 1; i <= 1e5; ++i) F[i] = F[i - 1] * i % P;
INV[100000] = FAST(F[100000], P - 2);
for (int i = 99999; i; --i) INV[i] = INV[i + 1] * (i + 1) % P;
}
int main() {
init();
scanf("%d%d%s", &n, &m, s + 1);
for (int i = 1; i <= n; ++i) {
a[i] = s[i] ^ 48;
sum[i] = sum[i - 1] + a[i];
}
if (m == 0) {
for (int i = 1; i <= n; ++i) Add(ans, 1ll * a[i] * t[n - i] % P);
printf("%lld\n", ans);
return 0;
}
if (m == 1) {
long long p = 0, q = 0;
for (int i = 1; i <= n; ++i) Add(q, 1ll * a[i] * t[n - i] % P);
for (int i = 1; i < n; ++i) {
p = (p * 10 + a[i]) % P;
Add(q, -1ll * a[i] * t[n - i] % P);
Add(ans, (p + q) % P);
}
printf("%lld\n", ans);
return 0;
}
for (int j = 0; j <= n - 1 - m; ++j)
Add(ans, 1ll * sum[n - j - 1] * t[j] % P * C(n - j - 2, m - 1) % P);
for (int i = 1; i <= n; ++i) {
int j = n - i;
if (n - j - 1 < m) continue;
Add(ans, a[i] * t[j] % P * C(n - j - 1, m) % P);
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> E[12100];
vector<double> P[12100];
double R[12100], TP[12100], PP[11000];
int n, K, w[110], cnt, L[110];
void Inverse(int b, int e) {
int i;
for (i = b; i <= (b + e) / 2; i++) {
swap(L[i], L[b + e - i]);
}
}
int Num(int a, int b) { return a * 101 + b; }
int main() {
int i, j, k, l, c1, c2, x, ti, tj;
double t, Res = 0.0;
scanf("%d%d", &n, &K);
for (i = 1; i <= n; i++) {
scanf("%d", &w[i]);
L[i] = i;
}
t = 1.0 / (n * (n + 1) / 2);
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
c1 = Num(i, j);
for (k = 1; k <= n; k++) {
for (l = k; l <= n; l++) {
ti = i, tj = j;
if (k <= i && i <= l) ti = k + l - i;
if (k <= j && j <= l) tj = k + l - j;
PP[Num(ti, tj)] += t;
}
}
for (k = 1; k <= 10200; k++) {
if (PP[k] > 1e-9) {
E[c1].push_back(k);
P[c1].push_back(PP[k]);
}
PP[k] = 0.0;
}
}
}
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
if (w[i] < w[j])
R[Num(j, i)] = 1.0;
else
R[Num(i, j)] = 1.0;
}
}
if (K > 1000) K = 1000;
while (K--) {
for (i = 1; i <= n; i++) {
for (k = i + 1; k <= n; k++) {
c1 = Num(i, k);
TP[c1] = 0.0;
for (j = 0; j < E[c1].size(); j++) {
x = E[c1][j];
TP[c1] += R[x] * P[c1][j];
}
TP[Num(k, i)] = 1.0 - TP[c1];
}
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (i != j) R[Num(i, j)] = TP[Num(i, j)];
}
for (i = 1; i < n; i++) {
for (j = i + 1; j <= n; j++) {
Res += R[Num(i, j)];
}
}
printf("%.11lf\n", Res);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 3 + 1e5;
int a[N], n;
int ok(int x) {
while (x) {
if (x % 3 == 2) return 0;
x /= 3;
}
return 1;
}
int main() {
for (int i = 1; i < N; ++i) a[i] = ok(i);
int T;
cin >> T;
while (T--) {
cin >> n;
while (!a[n]) ++n;
cout << n << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int arr[200100];
map<int, vector<int> > inds;
vector<int> ps;
int isp[5000];
int main() {
for (int i = (2), _i = (5000); i < _i; ++i) {
if (!isp[i]) {
ps.push_back(i);
for (int j = i + i; j < 5000; j += i) isp[j] = true;
}
}
cout << fixed << setprecision(12);
cin >> n >> m;
for (int i = 0, _i = (n + m); i < _i; ++i) {
cin >> arr[i];
}
for (int i = 0, _i = (n + m); i < _i; ++i) {
int t = arr[i];
for (int j = 0; ps[j] * ps[j] <= t; j++) {
while (t % ps[j] == 0) {
inds[ps[j]].push_back(i);
t /= ps[j];
}
}
if (t != 1) {
inds[t].push_back(i);
}
}
for (__typeof((inds).begin()) it = (inds).begin(), _it = (inds).end();
it != _it; ++it) {
int div = it->first;
vector<int> &v = it->second;
int c = 0, c2 = 0;
for (__typeof((v).begin()) i = (v).begin(), _i = (v).end(); i != _i; ++i) {
int a = *i;
if (a >= n) {
c2++;
} else {
c++;
}
}
int t = min(c, c2);
c = c2 = 0;
for (__typeof((v).begin()) i = (v).begin(), _i = (v).end(); i != _i; ++i) {
int a = *i;
if (a >= n) {
c2++;
if (c2 <= t) {
arr[a] /= div;
}
} else {
c++;
if (c <= t) {
arr[a] /= div;
}
}
}
}
cout << n << ' ' << m << endl;
for (int i = 0, _i = (n + m); i < _i; ++i) {
if (i == n) cout << '\n';
cout << arr[i] << ' ';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long int foo(long int num) {
num += 1;
while (num % 10 == 0) num /= 10;
return num;
}
int main() {
long int num;
set<long int> st;
cin >> num;
st.insert(num);
num = foo(num);
while (st.find(num) == st.end()) {
st.insert(num);
num = foo(num);
}
cout << st.size() << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long s = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') f *= c == '-' ? -1 : 1, c = getchar();
while (c >= '0' && c <= '9') s = s * 10 + c - '0', c = getchar();
return s * f;
}
struct edge {
int from, nxt, to;
long long val;
};
struct graph {
edge e[1000005 << 1];
int head[2000005], ind[2000005], tot;
inline void addedge(int u, int v, long long w) {
ind[v]++;
e[++tot] = (edge){u, head[u], v, w}, head[u] = tot;
}
} G;
class SCC : public graph {
stack<int> s;
int pre[2000005], low[2000005], dfn;
bool vis[2000005];
void dfs(int u) {
pre[u] = low[u] = ++dfn;
s.push(u);
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (!pre[v])
dfs(v), low[u] = min(low[u], low[v]);
else if (!scc[v])
low[u] = min(low[u], pre[v]);
}
if (low[u] == pre[u]) {
int x;
cnt++;
do x = s.top(), s.pop(), scc[x] = cnt;
while (x != u);
}
}
public:
int cnt, scc[2000005];
inline void tarjan(int n) {
for (int i = 1; i <= n; i++)
if (!pre[i]) dfs(i);
}
inline void init() {
memset(head, 0, sizeof(head));
memset(pre, 0, sizeof(pre));
memset(low, 0, sizeof(low));
memset(scc, 0, sizeof(scc));
tot = dfn = cnt = 0;
while (!s.empty()) s.pop();
}
} G1;
inline long long calc(long long x) {
long long t = sqrt(2 * x + 0.25) - 0.5;
return x + t * x - (t + 1) * (t + 2) * t / 6;
}
int n, m, s;
long long val[2000005], dis[2000005];
bool vis[2000005];
queue<int> q;
int main() {
n = read(), m = read();
for (register int i = (1); i <= (m); i++) {
int u = read(), v = read();
long long w = read();
G1.addedge(u, v, w);
}
G1.tarjan(n);
s = G1.scc[read()];
for (register int i = (1); i <= (m); i++) {
edge e = G1.e[i];
int u = G1.scc[e.from], v = G1.scc[e.to];
if (u == v)
val[u] += calc(e.val);
else
G.addedge(u, v, e.val);
}
int N = G1.cnt;
memset(dis, -1, sizeof(dis));
q.push(s), dis[s] = val[s], vis[s] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = 0;
for (int i = G.head[u]; i; i = G.e[i].nxt) {
edge e = G.e[i];
int v = e.to;
if (dis[v] < dis[u] + e.val + val[v]) {
dis[v] = dis[u] + e.val + val[v];
if (!vis[v]) q.push(v), vis[v] = 1;
}
}
}
for (register int i = (1); i <= (N); i++) dis[0] = max(dis[0], dis[i]);
cout << dis[0];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int k;
cin >> k;
int x = 0;
int j = 1;
while (x != k) {
if (j % 3 != 0 && j % 10 != 3) {
x++;
}
j++;
}
cout << j - 1 << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1e9 + 7;
int cost[7][7], a[7], b[7];
int n, m, dp[16000][5], tdp[16000][5], p5[7];
void chmin(int &x, int y) {
x = min(x, y);
}
string rep(int x) {
string res;
while(x) {
res += (char)('0' + (x % 5));
x /= 5;
}
while(res.size() < n)
res += '0';
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
p5[0] = 1;
for(int i = 1; i < 7; i++)
p5[i] = 5 * p5[i - 1];
cin >> n >> m;
for(int i = 0; i < p5[n]; i++)
for(int k = 0; k < 5; k++)
dp[i][k] = INF;
for(int i = 0; i < n; i++)
cin >> a[i];
for(int i = 0; i < m; i++)
cin >> b[i];
for(int i = 0; i < n; i++)
for(int j = 0; j < m; j++)
cin >> cost[i][j];
dp[0][0] = 0;
for(int j = 0; j < m; j++) {
for(int ms = 0; ms < p5[n]; ms++) {
tdp[ms][0] = dp[ms][0];
for(int k = 1; k < 5; k++)
tdp[ms][k] = INF;
}
for(int i = 0; i < n; i++) {
for(int ms = 0; ms < p5[n]; ms++) {
for(int used = 0; used <= b[j]; used++) {
int tot = tdp[ms][used] + cost[i][j];
int sat = (ms / p5[i]) % 5;
for(int add = 1; add + used <= b[j]; add++) {
if(sat + add > a[i])
continue;
chmin(tdp[ms + add * p5[i]][used + add], tot);
}
}
}
}
/*for(int ms = 0; ms < p5[n]; ms++) {
cout << rep(ms) << '\n';
for(int k = 0; k <= b[j]; k++)
cout << tdp[ms][k] << " ";
cout << '\n';
}*/
for(int ms = 0; ms < p5[n]; ms++)
for(int k = 1; k <= b[j]; k++)
chmin(dp[ms][0], tdp[ms][k]);
}
int ini_p = 0;
for(int i = 0; i < n; i++)
ini_p += a[i];
int ans = INF;
for(int ms = 0; ms < p5[n]; ms++) {
int su = 0;
for(int i = 0; i < n; i++)
su += (ms / p5[i]) % 5;
if(su < ini_p)
continue;
chmin(ans, dp[ms][0]);
}
if(ans == INF)
cout << "-1\n";
else
cout << ans << '\n';
} | 12 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000 * 1000 * 1000 + 7;
int p[2];
long long dp[100000 + 1][2];
int main() {
string s, e;
cin >> s >> e;
int n = s.length();
for (int i = 0; i < n; ++i) {
rotate(s.begin(), s.begin() + 1, s.end());
++p[s != e];
}
++dp[0][s != e];
int k;
cin >> k;
for (int i = 1; i <= k; ++i) {
dp[i][0] = (dp[i - 1][0] * (p[0] - 1) + dp[i - 1][1] * p[0]) % MOD;
dp[i][1] = (dp[i - 1][0] * p[1] + dp[i - 1][1] * (p[1] - 1)) % MOD;
}
cout << dp[k][0];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int k1mejor, k2mejor, k3mejor, solmejor = 1000000000;
double absolut(double x) {
if (x < 0) return -x;
return x;
}
long long int abso(long long int x) {
if (x < 0) return -x;
return x;
}
long long int n, s;
long long int c1 = 0, c2 = 0, c3 = 0;
void mejorar(long long int k1, long long int base2) {
for (long long int k2 = base2 - 200; k2 <= base2 + 200; k2++) {
long long int k3 = (s - (c1 * k1 + c2 * k2)) / c3;
if (k1 >= 0 and k2 >= k1 and k3 >= k2 and
c1 * k1 + c2 * k2 + c3 * k3 == s) {
long long int val = abso(c3 * k3 - c2 * k2) + abso(c2 * k2 - c1 * k1);
if (val < solmejor) {
k1mejor = k1;
k2mejor = k2;
k3mejor = k3;
solmejor = val;
}
}
}
}
int main() {
cin >> n >> s;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x == 3)
c1++;
else if (x == 4)
c2++;
else if (x == 5)
c3++;
}
for (long long int k1 = 0; k1 * n <= s; k1++) {
long long int ss = s - k1 * c1;
long long int inf = k1;
long long int sup = ss / (c2 + c3);
if (inf > sup) continue;
while (inf + 2 < sup) {
long long int med1 = (inf + inf + sup) / 3;
long long int med2 = (inf + sup + sup) / 3;
double k3_1 = double(ss - c2 * med1) / c3;
double k3_2 = double(ss - c2 * med2) / c3;
if (absolut(c3 * k3_1 - c2 * med1) + absolut(c2 * med1 - c1 * k1) <
absolut(c3 * k3_2 - c2 * med2) + absolut(c2 * med2 - c1 * k1)) {
sup = med2;
} else {
inf = med1;
}
}
mejorar(k1, inf);
}
if (solmejor == 1000000000)
cout << -1 << endl;
else
cout << k1mejor << " " << k2mejor << " " << k3mejor << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int ss[100];
int main() {
int n, m, h;
cin >> n >> m >> h;
int sum = 0;
for (int i = 0; i < m; i++) {
cin >> ss[i];
sum += ss[i];
}
if (sum < n) {
cout << "-1.0" << endl;
return 0;
} else if (ss[h - 1] == 1) {
cout << "0.0" << endl;
return 0;
} else if (sum == n) {
cout << "1.0" << endl;
return 0;
}
if (ss[h - 1] == 1) {
cout << "0.0" << endl;
return 0;
}
double res = 1;
for (int i = 0; i < ss[h - 1] - 1; i++) {
res *= (double)(sum - n - i);
res /= (double)(sum - i - 1);
}
res = 1.0 - res;
printf("%.6lf\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string x;
int lx;
int num, now, now2;
int ed;
int main() {
cin >> x;
num = 0;
now = 0;
now2 = 0;
lx = x.size();
int i;
for (i = 0; i < lx; i++) {
if (x[i] == '#') {
num++;
ed = i;
}
}
for (i = 0; i < ed; i++) {
if (x[i] == '(')
now++;
else
now--;
if (now < 0) {
printf("-1\n");
return 0;
}
}
for (i = lx - 1; i >= ed + 1; i--) {
if (x[i] == '(')
now2++;
else
now2--;
if (now2 > 0) {
printf("-1\n");
return 0;
}
}
if (now2 > 0) {
printf("-1\n");
return 0;
}
if (now + now2 <= 0) {
printf("-1\n");
return 0;
}
for (i = 1; i < num; i++) printf("1\n");
printf("%d\n", now + now2);
return 0;
}
| 3 |
/// You just can't beat the person who never gives up
/// ICPC next year
#include<bits/stdc++.h>
using namespace std ;
const int N = 2e5+5 ;
int t ,n ,k ,m ,s[N] ,l[N] ,r[N] ;
int main(){
scanf("%d",&t);
while(t--){
scanf("%d%d%d",&n,&k,&m);
for(int i=1;i<=m;++i){
scanf("%d",s+i);
l[i] = r[i] = 0 ;
}
sort(s+1,s+m+1);
int need = (k-1)/2 ;
int rmv = k-1 ;
bool ok = 0 ;
for(int i=1;i<=m;++i){
l[i] = s[i]-i ;
r[i] = (n-s[i]+1) - (m-i+1) ;
if((l[i]+r[i])%rmv) continue ;
if(l[i]>=need && r[i]>=need){
ok = 1 ;
break ;
}
}
puts(ok?"YES":"NO");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ans = 0;
cin >> n >> m;
if (n > m) {
ans = n - m;
} else {
while (n != m) {
if (m % 2 == 0 && m > n) {
ans++;
m /= 2;
} else {
if (n >= m) {
ans += n - m;
break;
}
m = (m + 1) / 2;
ans += 2;
}
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000000;
int INF = 2147483646;
long long INF64 = 9223372036854775807;
long double EPS = 0.0000000000001;
long double PI = 3.14159265358979310000;
int n, m;
long long a[123456], p[123456];
bool prov(long long first) {
int i, j, u, k, kk;
long long w, s = 0;
j = 0;
for (i = 0; i < n; i++) {
if (j >= m) break;
w = first;
if (p[j] < a[i]) {
k = 1;
w -= abs(a[i] - p[j]) * 2;
if (abs(p[j] - a[i]) > first) continue;
while (p[j + k] <= a[i]) k++;
while (j + k < m && abs(a[i] - p[j + k]) <= w) k++;
kk = 1;
w = (first - abs(a[i] - p[j])) / 2;
while (p[j + kk] <= a[i]) kk++;
while (j + kk < m && abs(a[i] - p[j + kk]) <= w) kk++;
j += max(k, kk);
} else
while (j < m && abs(a[i] - p[j]) <= first) j++;
if (j >= m) break;
}
if (j >= m) return 1;
return 0;
}
int main() {
cin >> n >> m;
for (int i = 0; i < int(n); i++) scanf("%I64d", &a[i]);
for (int i = 0; i < int(m); i++) scanf("%I64d", &p[i]);
long long l, r, mm;
l = 0;
r = 2000000000000000000;
while (r - l > 0) {
mm = (r + l) / 2;
if (prov(mm))
r = mm;
else
l = mm + 1;
}
cout << l;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct target {
int x, rad;
} t[10011];
struct shot {
int x, y;
} s[200011];
int n, m, ontarget, order[200011], result[10011];
void qsort(int left, int right) {
if (left >= right) return;
int i = left, j = right, px = s[(left + right) >> 1].x,
py = s[(left + right) >> 1].y;
while (i <= j) {
while (s[i].x < px || (s[i].x == px && s[i].y < py)) i++;
while (s[j].x > px || (s[j].x == px && s[j].y > py)) j--;
if (i <= j) {
if (i < j) {
swap(s[i].x, s[j].x);
swap(s[i].y, s[j].y);
swap(order[i], order[j]);
}
i++;
j--;
}
}
qsort(left, j);
qsort(i, right);
}
int find_first(int t) {
int ans = 1, left = 0, right = m;
while (left <= right) {
int mid = (left + right) >> 1;
if (s[mid].x < t)
left = mid + 1;
else {
right = mid - 1;
ans = mid;
}
}
return ans;
}
int find_last(int t) {
int ans = m, left = 0, right = m;
while (left <= right) {
int mid = (left + right) >> 1;
if (s[mid].x <= t) {
ans = mid;
left = mid + 1;
} else
right = mid - 1;
}
return ans;
}
int sqr(int x) { return x * x; }
int main() {
scanf("%d", &n);
if (n == 0) {
printf("0");
return 0;
}
for (int i = 1; i <= n; i++) scanf("%d%d", &t[i].x, &t[i].rad);
scanf("%d", &m);
if (m == 0) {
printf("0\n");
for (int i = 1; i <= n; i++) printf("-1 ");
return 0;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &s[i].x, &s[i].y);
order[i] = i;
}
order[0] = 2000000000;
order[m + 1] = 2000000000;
qsort(1, m);
for (int i = 1; i <= n; i++) {
int first = find_first(t[i].x - t[i].rad),
last = find_last(t[i].x + t[i].rad);
result[i] = 2000000000;
for (int j = first; j <= last; j++)
if (sqr(t[i].x - s[j].x) + sqr(s[j].y) <= sqr(t[i].rad))
result[i] = min(result[i], order[j]);
if (result[i] == 2000000000)
result[i] = -1;
else
ontarget++;
}
printf("%d\n", ontarget);
for (int i = 1; i <= n; i++) printf("%d ", result[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500023;
bool vis[N];
vector<int> adj[N];
void solve() {
long long int n, m;
cin >> n >> m;
map<long long int, long long int> cntA;
map<long long int, long long int> cntB;
map<long long int, long long int> cntC;
map<long long int, long long int> cntD;
map<long long int, long long int> cntE;
for (long long int i = 0; i < n; i++) {
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'A')
cntA[i]++;
else if (s[i] == 'B')
cntB[i]++;
else if (s[i] == 'C')
cntC[i]++;
else if (s[i] == 'D')
cntD[i]++;
else if (s[i] == 'E')
cntE[i]++;
}
}
long long int ans = 0;
for (int i = 0; i < m; i++) {
long long int c;
cin >> c;
long long int maxi = 0;
maxi = max(max(cntA[i], cntB[i]), cntC[i]);
maxi = max(max(maxi, cntD[i]), cntE[i]);
long long int temp = maxi * c;
ans += temp;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
int t = 0;
while (t++ < T) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
inline void rd(__int128_t &x) {
x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
}
inline void wr(__int128_t x) {
if (!x) return;
wr(x / 10);
putchar('0' + x % 10);
}
__int128_t n;
__int128_t s[600005], w[600005];
__int128_t nxt[600005], f[600005];
__int128_t t[600005 << 2];
inline void ins(__int128_t p, __int128_t L, __int128_t R, __int128_t x,
__int128_t d) {
if (L == R) {
t[p] = d;
return;
}
__int128_t mid = (L + R) >> 1;
if (x <= mid)
ins(p << 1, L, mid, x, d);
else
ins(p << 1 | 1, mid + 1, R, x, d);
t[p] = std::min(t[p << 1], t[p << 1 | 1]);
}
inline __int128_t mn(__int128_t p, __int128_t L, __int128_t R, __int128_t l,
__int128_t r) {
if (L > r || R < l) return 0x3f3f3f3f3f3f3f3f;
if (l <= L && R <= r) return t[p];
__int128_t mid = (L + R) >> 1;
return std::min(mn(p << 1, L, mid, l, r), mn(p << 1 | 1, mid + 1, R, l, r));
}
std::map<__int128_t, __int128_t> cnt;
__int128_t sum, ans;
signed main() {
rd(n);
memset(t, 0x3f, sizeof(t));
for (__int128_t i = 1, j = 0; i <= n; i++) {
char c;
scanf("%s", &c);
rd(w[i]);
s[i] = c = (c - 'a' + ans) % 26;
w[i] ^= (ans & ((1ll << 30) - 1));
ins(1, 1, n, i, w[i]);
if (i == 1) {
ans = w[i];
ans ? wr(ans) : (void)putchar('0');
puts("");
continue;
}
f[i - 1] = s[j + 1] == c ? f[j] : j;
for (__int128_t k = j; k > 0;)
if (s[k + 1] == c)
k = f[k];
else {
__int128_t val = mn(1, 1, n, i - k, i - 1);
sum -= val;
if (!--cnt[val]) cnt.erase(val);
k = nxt[k];
}
if (c == s[1]) {
sum += w[i];
cnt[w[i]]++;
}
__int128_t tmp = 0;
for (auto it = cnt.upper_bound(w[i]); it != cnt.end();) {
tmp += it->second;
sum -= 1ll * (it->first) * (it->second);
auto _it = std::next(it);
cnt.erase(it);
it = _it;
}
cnt[w[i]] += tmp;
sum += 1ll * tmp * w[i];
ans += sum + mn(1, 1, n, 1, i);
ans ? wr(ans) : (void)putchar('0');
puts("");
while (j && s[j + 1] != c) j = nxt[j];
if (i > 1 && s[j + 1] == c) j++;
nxt[i] = j;
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(long long first) {
return first ? 8 * sizeof(long long) - __builtin_clzll(first) : 0;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
class DPowerTree {
public:
int N;
vector<vector<int>> E;
vector<int> C;
vector<pair<int, long long>> Ans;
pair<int, long long> solve(int u, int p) {
if (E[u].size() == 1 && u != 0) {
return Ans[u] = {C[u], C[u]};
};
int a = 0;
long long b = 0;
for (int v : E[u]) {
if (v != p) {
auto s = solve(v, u);
a = max(a, s.first);
b += s.second;
}
}
return Ans[u] = {min(a, C[u]), b + min(0, C[u] - a)};
}
void collect(int u, int p, bool allPaths, vector<int>& Ret) {
if (allPaths && C[u] == Ans[u].first) Ret.push_back(u + 1);
int worst = -1;
int cnt = 0;
for (int v : E[u]) {
if (v != p) {
int myDiff = Ans[v].first;
if (myDiff > worst) {
worst = myDiff;
cnt = 0;
}
cnt += myDiff == worst;
}
}
for (int v : E[u]) {
if (v != p) {
collect(v, u,
Ans[v].first < worst || cnt > 1 || (worst <= C[u] && allPaths),
Ret);
}
}
}
void solve(istream& cin, ostream& cout) {
cin >> N;
C.resize(N);
cin >> C;
E.resize(N);
Ans.resize(N);
for (int i = 0; i < N - 1; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
E[u].push_back(v);
E[v].push_back(u);
}
auto s = solve(0, -1);
vector<int> X;
collect(0, -1, true, X);
sort(X.begin(), X.end());
cout << s.second << ' ' << X.size() << endl;
cout << X;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
DPowerTree solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 1100010;
struct Node {
int len, link;
map<char, int> nxt;
bool flag;
int id;
} tmp[N * 2];
Node st[N * 2];
int sz, last;
void extend(char c, int id) {
int cur = sz++;
st[cur].len = st[last].len + 1;
st[cur].flag = false;
st[cur].id = (1 << id);
int p;
for (p = last; ~p && !st[p].nxt.count(c); p = st[p].link) st[p].nxt[c] = cur;
if (p == -1)
st[cur].link = 0;
else {
int q = st[p].nxt[c];
if (st[p].len + 1 == st[q].len)
st[cur].link = q;
else {
int now = sz++;
st[now].len = st[p].len + 1;
st[now].nxt = st[q].nxt;
st[now].link = st[q].link;
st[now].flag = true;
for (; ~p && st[p].nxt[c] == q; p = st[p].link) st[p].nxt[c] = now;
st[q].link = st[cur].link = now;
}
}
last = cur;
}
char s[50005];
char pt[50005];
int dp2[N], dp[N], mark[N], idx[N * 2], Deg[N * 2];
pair<int, int> Q[10];
char T[10][50005];
int len[15];
int main() {
scanf("%s", s);
int n = strlen(s);
for (int i = 0; i <= N * 2 - 1; i++) st[i].nxt.clear();
sz = last = 0;
st[0].len = 0;
st[0].link = -1;
sz++;
int q;
cin >> q;
for (int i = 0; i <= n - 1; i++) extend(s[i] - 'a', q);
extend(26, q + 1);
for (int i = 0; i <= q - 1; i++) {
int l, r;
scanf("%s%d%d", T[i], &l, &r);
Q[i] = {l, r};
len[i] = strlen(T[i]);
for (int j = 0; j <= len[i]; j++) extend(T[i][j] - 'a', i);
extend(26, q + 1);
}
int m = 0;
for (int i = 0; i <= sz - 1; i++)
for (auto nw : st[i].nxt) Deg[nw.second]++;
tmp[m++] = st[0];
idx[0] = 0;
for (int i = 0; i <= sz - 1; i++) {
for (auto nw : tmp[i].nxt)
if (--Deg[nw.second] == 0) {
idx[nw.second] = m;
tmp[m++] = st[nw.second];
}
}
for (int i = 0; i <= sz - 1; i++) {
for (auto& nw : tmp[i].nxt)
if (~nw.second) nw.second = idx[nw.second];
tmp[i].link = idx[tmp[i].link];
}
for (int i = 0; i <= sz - 1; i++) st[i] = tmp[i];
long long ans = 0;
dp[0] = 1;
for (int i = 0; i <= sz - 1; i++)
for (auto e : st[i].nxt) dp[e.second] += dp[i];
for (int j = 0; j <= q; j++) {
memset(dp2, 0, sizeof(dp2));
for (int i = sz - 1; i >= 0; i--) {
if (!st[i].flag && st[i].id >> j & 1) dp2[i]++;
if (i) dp2[st[i].link] += dp2[i];
}
if (j < q) {
for (int i = 0; i <= sz - 1; i++)
if (dp2[i] >= Q[j].first && dp2[i] <= Q[j].second) mark[i]++;
} else
for (int i = 0; i <= sz - 1; i++)
if (dp2[i] > 0 && mark[i] == q && i) ans += dp[i];
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a1[3], a2[3], a, b, c, j, r, m, i, sum = 0;
cin >> t;
while (t--) {
cin >> a1[0] >> a1[1] >> a1[2];
cin >> a2[0] >> a2[1] >> a2[2];
sum = 0;
for (i = 2; i > 0; --i) {
if (i == 2) {
if (a2[1] > 0 and a1[i] > 0) {
if (a1[i] >= a2[1])
sum += 2 * a2[1];
else
sum += 2 * a1[i];
r = a2[1];
a2[1] -= a1[i];
a1[i] -= r;
}
if (a2[2] > 0 and a1[i] > 0) {
r = a2[2];
a2[2] -= a1[i];
a1[i] -= r;
}
if (a2[0] > 0 and a1[i] > 0) {
r = a2[0];
a2[0] -= a1[i];
a1[i] -= r;
}
} else if (i == 1) {
if (a2[1] > 0 and a1[i] > 0) {
r = a2[1];
a2[1] -= a1[i];
a1[i] -= r;
}
if (a2[0] > 0 and a1[i] > 0) {
r = a2[0];
a2[0] -= a1[i];
a1[i] -= r;
}
if (a2[2] > 0 and a1[i] > 0) {
if (a1[i] >= a2[2])
sum -= 2 * a2[2];
else
sum -= 2 * a1[i];
r = a2[2];
a2[2] -= a1[i];
a1[i] -= r;
}
}
}
cout << sum << endl;
}
}
| 1 |
#include <bits/stdc++.h>
char buf[1 << 23], *ps = buf, *pt = buf;
int read() {
register int x = 0;
register char f = 1, ch = (ps == pt && (pt = (ps = buf) +
fread(buf, 1, 1 << 23, stdin),
ps == pt)
? EOF
: *ps++);
for (; !isdigit(ch);
ch = (ps == pt &&
(pt = (ps = buf) + fread(buf, 1, 1 << 23, stdin), ps == pt)
? EOF
: *ps++))
if (ch == '-') f ^= 1;
for (; isdigit(ch);
ch = (ps == pt &&
(pt = (ps = buf) + fread(buf, 1, 1 << 23, stdin), ps == pt)
? EOF
: *ps++))
x = (x << 1) + (x << 3) + (ch ^ '0');
return f ? x : -x;
}
int read(char *s) {
int n = 0;
char ch =
(ps == pt && (pt = (ps = buf) + fread(buf, 1, 1 << 23, stdin), ps == pt)
? EOF
: *ps++);
for (; isspace(ch);
ch = (ps == pt &&
(pt = (ps = buf) + fread(buf, 1, 1 << 23, stdin), ps == pt)
? EOF
: *ps++))
;
for (; !isspace(ch);
ch = (ps == pt &&
(pt = (ps = buf) + fread(buf, 1, 1 << 23, stdin), ps == pt)
? EOF
: *ps++))
s[++n] = ch;
s[n + 1] = '\0';
return n;
}
char pbuf[1 << 23], *pp = pbuf;
struct __IO_flusher {
~__IO_flusher() { fwrite(pbuf, 1, pp - pbuf, stdout); }
} IO_flusher;
void print(int x, char ch = '\n') {
if (x == 0)
return (pp == pbuf + (1 << 23) ? fwrite(pbuf, 1, 1 << 23, stdout),
pp = pbuf : 0, *pp++ = '0'),
(pp == pbuf + (1 << 23) ? fwrite(pbuf, 1, 1 << 23, stdout),
pp = pbuf : 0, *pp++ = ch),
void(0);
int cnt = 0, num[25];
for (x < 0 ? (pp == pbuf + (1 << 23) ? fwrite(pbuf, 1, 1 << 23, stdout),
pp = pbuf : 0, *pp++ = '-'),
x = -x : 0;
x; x /= 10)
num[++cnt] = x % 10;
while (cnt)
(pp == pbuf + (1 << 23) ? fwrite(pbuf, 1, 1 << 23, stdout), pp = pbuf : 0,
*pp++ = num[cnt] ^ '0'),
--cnt;
(pp == pbuf + (1 << 23) ? fwrite(pbuf, 1, 1 << 23, stdout), pp = pbuf : 0,
*pp++ = ch);
}
const int N = 1000005, P = 998244353;
int n, nl, nr, zl[N], zr[N], f[N], s[N];
char a[N], l[N], r[N];
void z_algo(int *z, char *s, int n) {
z[1] = n;
for (register int i = 2, l = 1, r = 1; i <= n; ++i) {
z[i] = i > r ? 0 : std::min(r - i + 1, z[i - l + 1]);
while (i + z[i] <= n && s[i + z[i]] == s[z[i] + 1]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
}
int z[N << 1];
char t[N << 1];
void init(int nx, char *x, int *zx) {
for (register int i = 1; i <= nx; ++i) t[i] = x[i];
t[nx + 1] = '#';
for (register int i = 1; i <= n; ++i) t[nx + 1 + i] = a[i];
z_algo(z, t, nx + n + 1);
for (register int i = 1; i <= n; ++i) zx[i] = z[nx + 1 + i];
}
void inc(int &a, int b) { (a += b) >= P ? a -= P : 0; }
int plus(int a, int b) { return (a += b) >= P ? a - P : a; }
int minus(int a, int b) { return a < b ? a + P - b : a - b; }
int main() {
n = read(a), nl = read(l), nr = read(r);
init(nl, l, zl), init(nr, r, zr);
f[0] = 1;
if (a[1] == '0')
s[0] = 0;
else
s[0] = 1;
for (register int i = 1; i <= n; ++i) {
int L = i - nr, R = i - nl, pl = zl[R + 1] + 1, pr = zr[L + 1] + 1;
if (pl <= nl && a[R + pl] < l[pl]) --R;
if (pr <= nr && a[L + pr] > r[pr]) ++L;
L = std::max(L, 0);
if (L <= R)
f[i] = minus(s[R], L ? s[L - 1] : 0);
else
f[i] = 0;
if (a[i] == '0' && R == i - 1) inc(f[i], f[i - 1]);
if (i < n && a[i + 1] == '0')
s[i] = s[i - 1];
else
s[i] = plus(s[i - 1], f[i]);
}
print(f[n]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
if (n == 14) {
cout << R"(0 0
0 1
0 2
0 3
0 4
0 5
0 6
1 0
1 1
1 2
1 3
1 4
1 5
1 6)";
return 0;
}
int len = 2 * (n - 4) / 3;
if (len % 2 == 0) --len;
if (len < 0) len = 0;
int cnt = 0;
vector<vector<int> > v(len + 10, vector<int>(3));
auto put = [&](int x, int y) {
if (v[x + 3][y] == 1) return;
cout << x << " " << y << "\n";
assert(v[x + 3][y] == 0 && cnt < n);
v[x + 3][y] = 1;
++cnt;
};
for (int x = (0); x < (int)(len); ++x)
for (int y = (0); y < (int)(3); ++y) {
if ((x + y) % 2 == 0) put(x, y);
}
if (n >= 4) {
put(1, 0);
put(1, 2);
put(len - 2, 0);
put(len - 2, 2);
}
for (int i = (cnt); i < (int)(n); ++i) {
cout << i / 2 << " " << 4 + (i % 2) << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x7fffffffffffffff;
const int inf = 0x7fffffff;
const double eps = 1e-8;
const int N = 2e5 + 5;
clock_t start, finish;
void time_in() { start = clock(); }
void time_out() {
finish = clock();
double tim = (double)(finish - start) / CLOCKS_PER_SEC;
printf("Running time is %lf\n", tim);
}
inline long long mul(long long a, long long b) {
long long s = 0;
while (b) {
if (b & 1) s = (s + a) % 1000000007;
a = (a << 1) % 1000000007;
b >>= 1;
}
return s % 1000000007;
}
inline long long pow_mul(long long a, long long b) {
long long s = 1;
while (b) {
if (b & 1) s = mul(s, a);
a = mul(a, a);
b >>= 1;
}
return s;
}
inline long long poww(long long a, long long b) {
long long s = 1;
while (b) {
if (b & 1) s = (s * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return s % 1000000007;
}
inline int read() {
char c = getchar();
int sgn = 1, ret = 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') sgn = -1, c = getchar();
while (c >= '0' && c <= '9') ret = ret * 10 + c - 48, c = getchar();
return ret * sgn;
}
void write(int x) {
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline long long phi(long long x) {
long long ans = x;
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) {
ans -= ans / i;
while (x % i == 0) x /= i;
}
if (x > 1) ans -= ans / x;
return ans;
}
long long inv(long long down) {
return down == 1
? 1
: ((1000000007 - 1000000007 / down) * inv(1000000007 % down)) %
1000000007;
}
int st[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
int t, cas;
int n, m, k;
string s[N];
map<string, int> q;
int ans[N];
int a00[N], a01[N], a10[N], a11[N];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int cnt00, cnt01, cnt10, cnt11;
cin >> t;
while (t--) {
q.clear();
cnt00 = cnt01 = cnt11 = cnt10 = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
q[s[i]]++;
int len = s[i].size();
if (s[i][0] == '0') {
if (s[i][len - 1] == '0') {
a00[cnt00++] = i;
} else {
a01[cnt01++] = i;
}
} else {
if (s[i][len - 1] == '0') {
a10[cnt10++] = i;
} else {
a11[cnt11++] = i;
}
}
}
if (cnt01 + cnt10 == 0) {
if (cnt00 && cnt11) {
cout << -1 << "\n";
continue;
} else {
cout << 0 << "\n\n";
continue;
}
}
int tmp;
if (cnt10 > cnt01) {
if (cnt10 == cnt01 + 1)
cout << 0 << "\n\n";
else {
tmp = (cnt10 - cnt01) / 2;
int cnt = 0;
for (int i = 0; i < cnt10 && cnt < tmp; i++) {
reverse(s[a10[i]].begin(), s[a10[i]].end());
if (q[s[a10[i]]]) continue;
ans[cnt++] = a10[i];
}
if (cnt != tmp)
printf("-1\n");
else {
cout << tmp << "\n";
for (int i = 0; i < tmp; i++) {
cout << ans[i];
cout << (i == tmp - 1 ? "\n" : " ");
}
}
}
} else if (cnt01 > cnt10) {
if (cnt01 == cnt10 + 1)
cout << 0 << "\n\n";
else {
tmp = (cnt01 - cnt10) / 2;
int cnt = 0;
for (int i = 0; i < cnt01 && cnt < tmp; i++) {
reverse(s[a01[i]].begin(), s[a01[i]].end());
if (q[s[a01[i]]]) continue;
ans[cnt++] = a01[i];
}
if (cnt != tmp)
printf("-1\n");
else {
cout << tmp << "\n";
for (int i = 0; i < tmp; i++) {
cout << ans[i];
cout << (i == tmp - 1 ? "\n" : " ");
}
}
}
} else
cout << 0 << "\n\n";
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int a, b;
cin >> a >> b;
int n;
cin >> n;
double ans = INT_MAX;
cout << fixed << setprecision(10);
for (int i = 0, x, y, v; i < n; ++i) {
cin >> x >> y >> v;
int tx = a - x, ty = b - y;
double t = (tx * tx + ty * ty) * 1.0 / v / v;
ans = min(sqrt(t), ans);
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 3;
const int inf = 1e9 + 3;
const int md = 1e9 + 7;
int n, m, sm;
int ost = 0;
int bin(int a, int n) {
int res = 1;
while (n) {
if (n & 1) res *= a;
a *= a;
a %= 2;
res %= 2;
n /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
ost = n % 2;
for (int i = 1; i <= m; ++i) {
int x;
cin >> x;
sm += bin(ost, m - i) * x;
sm %= 2;
}
if (sm % 2 == 1)
cout << "odd";
else
cout << "even";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace zyt {
const int N = 1e4 + 10;
const double EPS = 1e-7;
int n, m;
struct point {
int x, y;
point(const int &_x = 0, const int &_y = 0) : x(_x), y(_y) {}
point operator+(const point &b) const { return point(x + b.x, y + b.y); }
point operator-(const point &b) const { return point(x - b.x, y - b.y); }
int operator*(const point &b) const { return x * b.y - y * b.x; }
bool operator<(const point &b) const { return x == b.x ? y < b.y : x < b.x; }
} A[N], B[N];
int dots(const point &a, const point &b) { return a.x * b.x + a.y * b.y; }
struct line {
point A, B;
line(const point &_A = point(), const point &_B = point()) : A(_A), B(_B) {}
} tri[N << 1];
int cnt;
vector<int> convex(const int f) {
static int sta[N];
int top = 0;
vector<int> v;
sort(A + 1, A + n + 1);
for (int i = 1; i <= n; i++) {
while (top > 1 &&
(A[sta[top - 1]] - A[sta[top - 2]]) * (A[i] - A[sta[top - 2]]) * f <=
0)
--top;
sta[top++] = i;
}
while (top--) v.push_back(sta[top]);
return v;
}
vector<int> cvx;
void dfs(const int l, const int r) {
if (r - l + 1 <= 3) return;
double mx = -INFINITY;
int id;
for (int i = l + 1; i < r; i++) {
double tmp = dots(A[cvx[l]] - A[cvx[i]], A[cvx[r]] - A[cvx[i]]) /
(double)((A[cvx[l]] - A[cvx[i]]) * (A[cvx[r]] - A[cvx[i]]));
if (tmp > mx) mx = tmp, id = i;
}
tri[cnt++] = line(A[cvx[l]], A[cvx[id]]);
tri[cnt++] = line(A[cvx[r]], A[cvx[id]]);
dfs(l, id), dfs(id, r);
}
bool in(const int a, const int l, const int r) {
return a >= min(l, r) && a <= max(l, r);
}
bool check(const line &L) {
double l = -INFINITY, r = INFINITY;
for (int i = 1; i <= n; i++) {
int crs = (A[i] - L.A) * (A[i] - L.B);
if (crs) {
double tmp = dots(A[i] - L.A, A[i] - L.B) / double(crs);
if (crs > 0)
l = max(l, tmp);
else
r = min(r, tmp);
}
}
for (int i = 1; i <= m; i++) {
int crs = (B[i] - L.A) * (B[i] - L.B);
if (crs) {
double tmp = dots(B[i] - L.A, B[i] - L.B) / double(crs);
if (crs < 0)
l = max(l, tmp);
else
r = min(r, tmp);
} else if (in(B[i].x, L.A.x, L.B.x) && in(B[i].y, L.A.y, L.B.y))
return false;
}
return l + 1e-10 <= r;
}
bool solve() {
vector<int> tmp;
cvx = convex(1), tmp = convex(-1);
tmp.pop_back(), reverse(tmp.begin(), tmp.end()), tmp.pop_back();
for (auto x : tmp) cvx.push_back(x);
cnt = 0;
for (int i = 0; i < cvx.size() - 1; i++)
tri[cnt++] = line(A[cvx[i]], A[cvx[i + 1]]);
tri[cnt++] = line(A[cvx[cvx.size() - 1]], A[cvx[0]]);
dfs(0, cvx.size() - 1);
for (int i = 0; i < cnt; i++)
if (check(tri[i])) return true;
return false;
}
int work() {
scanf("%d%d", &n, &m);
if (n == 1 || m == 1) {
puts("Yes");
return 0;
}
for (int i = 1; i <= n; i++) scanf("%d%d", &A[i].x, &A[i].y);
for (int i = 1; i <= m; i++) scanf("%d%d", &B[i].x, &B[i].y);
bool ans = solve();
swap(n, m), swap(A, B);
puts(ans || solve() ? "YES" : "NO");
return 0;
}
} // namespace zyt
int main() { return zyt::work(); }
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* argv[]) {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
int N;
cin >> N;
vector<int> data(N);
for (int i = 0; i < N; i++) cin >> data[i];
vector<int> num_ones_after(N);
num_ones_after.back() = data.back();
for (int i = N - 2; i >= 0; i--)
num_ones_after[i] = num_ones_after[i + 1] + data[i];
vector<int> num_zeroes_before(N);
num_zeroes_before[0] = (1 - data[0]);
for (int i = 1; i < N; i++)
num_zeroes_before[i] = num_zeroes_before[i - 1] + (1 - data[i]);
int main_res = 0;
for (int i = 0; i < N; i++)
main_res = max(main_res, num_zeroes_before[i] + num_ones_after[i]);
cout << main_res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
int n, m, k, mp[305][305];
std::vector<std::pair<int, int> > garden[90005];
int dis[305][305], dis2[305][305];
bool vis[305][305];
int dist(std::pair<int, int> a, std::pair<int, int> b) {
return abs(a.first - b.first) + abs(a.second - b.second);
}
void refresh(int lev) {
for (int i = 0; i < garden[lev].size(); ++i) {
int ux = garden[lev][i].first, uy = garden[lev][i].second;
for (int j = 0; j < garden[lev + 1].size(); ++j) {
int vx = garden[lev + 1][j].first, vy = garden[lev + 1][j].second;
dis[vx][vy] = std::min(
dis[vx][vy], dis[ux][uy] + dist(garden[lev][i], garden[lev + 1][j]));
}
}
}
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
void bfs(int lev) {
memset(dis2, 0x3f, sizeof(dis2));
static std::queue<int> qx, qy;
for (int i = 0; i < garden[lev].size(); ++i) {
int ux = garden[lev][i].first, uy = garden[lev][i].second;
dis2[ux][uy] = dis[ux][uy];
qx.push(ux);
qy.push(uy);
vis[ux][uy] = 1;
}
while (!qx.empty()) {
int ux = qx.front(), uy = qy.front();
qx.pop();
qy.pop();
vis[ux][uy] = 0;
for (int i = 0; i < 4; ++i) {
int vx = ux + dx[i], vy = uy + dy[i];
if (vx < 0 || vx >= n || vy < 0 || vy >= m) continue;
if (dis2[vx][vy] > dis2[ux][uy] + 1) {
dis2[vx][vy] = dis2[ux][uy] + 1;
if (!vis[vx][vy]) {
qx.push(vx);
qy.push(vy);
vis[vx][vy] = 1;
}
}
}
}
for (int i = 0; i < garden[lev + 1].size(); ++i) {
int ux = garden[lev + 1][i].first, uy = garden[lev + 1][i].second;
dis[ux][uy] = dis2[ux][uy];
}
}
void calc() {
for (int i = 0; i < garden[1].size(); ++i) {
int ux = garden[1][i].first, uy = garden[1][i].second;
dis[ux][uy] = dist(garden[1][i], std::pair<int, int>(0, 0));
}
for (int lev = 1; lev < k; ++lev) {
if (garden[lev].size() * garden[lev + 1].size() < n * m) {
refresh(lev);
} else {
bfs(lev);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &mp[i][j]);
garden[mp[i][j]].push_back(std::pair<int, int>(i, j));
}
}
memset(dis, 0x3f, sizeof(dis));
calc();
int res = 0x3f3f3f3f;
for (int i = 0; i < garden[k].size(); ++i) {
int ux = garden[k][i].first, uy = garden[k][i].second;
res = std::min(res, dis[ux][uy]);
}
printf("%d", res);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v[3005];
long long f[20][3005], ans;
int n, k;
void solve(int l, int r, int d) {
if (l == r) {
for (int i = (int)(0); i <= (int)(v[l].size() - 1); i++)
if (i + 1 <= k) ans = max(ans, v[l][i] + f[d][k - i - 1]);
return;
}
int mid = (l + r) / 2;
memcpy(f[d + 1], f[d], sizeof(f[d]));
for (int i = (int)(mid + 1); i <= (int)(r); i++) {
long long v1 = v[i].size(), v2 = v[i][v1 - 1];
for (int j = (int)(k - v1); j >= (int)(0); j--)
f[d + 1][j + v1] = max(f[d + 1][j + v1], f[d + 1][j] + v2);
}
solve(l, mid, d + 1);
memcpy(f[d + 1], f[d], sizeof(f[d]));
for (int i = (int)(l); i <= (int)(mid); i++) {
long long v1 = v[i].size(), v2 = v[i][v1 - 1];
for (int j = (int)(k - v1); j >= (int)(0); j--)
f[d + 1][j + v1] = max(f[d + 1][j + v1], f[d + 1][j] + v2);
}
solve(mid + 1, r, d + 1);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = (int)(1); i <= (int)(n); i++) {
int t;
scanf("%d", &t);
v[i].resize(t);
for (int j = (int)(0); j <= (int)(t - 1); j++) scanf("%lld", &v[i][j]);
for (int j = (int)(1); j <= (int)(t - 1); j++) v[i][j] += v[i][j - 1];
}
solve(1, n, 0);
cout << ans << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n, s, p;
cin >> k >> n >> s >> p;
long long temp = n / s;
if (n % s != 0) {
temp++;
}
temp *= k;
if (temp % p == 0) {
temp /= p;
} else {
temp = temp / p + 1;
}
cout << temp;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, h, k, i, c, d, ans = 0;
cin >> n >> h >> k;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
if (i == 0)
c = a[i];
else {
if (c + a[i] <= h) {
c += a[i];
continue;
}
d = c / k;
ans += d;
c = c - (d * k);
if (c + a[i] <= h) {
c += a[i];
continue;
} else {
ans++;
c = a[i];
}
}
}
if (c != 0) ans += (c / k) + !(c % k == 0);
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> dvsr;
void get(long long n) {
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
dvsr.push_back(i);
if (i != n / i) dvsr.push_back(n / i);
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
long long a, b;
cin >> a >> b;
if (a == b) {
cout << 0;
return 0;
}
if (a > b) swap(a, b);
long long df = b - a;
get(df);
set<pair<long long, long long> > s;
for (auto it : dvsr) {
if (a % it == 0 and b % it == 0) {
s.insert({(a * b) / it, 0});
} else {
long long dif = it * (b / it + 1) - b;
long long x = a + dif, y = b + dif;
s.insert({(x * y) / it, dif});
}
}
long long ans = b;
auto i1 = s.begin();
cout << i1->second;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2E5 + 10;
int n;
int a[MAX];
vector<int> g[MAX];
bool mark[MAX];
int sub, root;
int res;
vector<int> cir;
bool found;
void dfs(int u) {
mark[u] = false;
sub++;
for (auto v : g[u])
if (mark[v]) dfs(v);
}
void dfs1(int u, int p) {
mark[u] = false;
for (auto v : g[u])
if (v != p) {
if (mark[v])
dfs1(v, u);
else if (!found) {
found = true;
cir.push_back(v);
}
}
}
void dfs2(int u) {
mark[u] = false;
res++;
a[u] = root;
for (auto v : g[u])
if (mark[v]) dfs(v);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
if (a[i] != i) {
g[i].push_back(a[i]);
g[a[i]].push_back(i);
}
}
memset(mark, true, sizeof(mark));
int max_sub = 0;
for (int i = 1; i <= n; i++)
if (i == a[i]) {
sub = 0;
dfs(i);
if (max_sub < sub) {
max_sub = sub;
root = i;
}
}
for (int i = 1; i <= n; i++)
if (mark[i]) {
found = false;
dfs1(i, -1);
}
if (!cir.empty() && root == 0) root = cir.front();
memset(mark, true, sizeof(mark));
for (int i = 1; i <= n; i++)
if (i == a[i] && i != root) dfs2(i);
for (auto x : cir) {
a[x] = root;
res++;
}
printf("%d\n", res);
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct el {
int d, c;
} v[100003];
int cmp(el A, el B) { return A.d < B.d; }
int n, i, dim, ma, k, t, sol, nr;
int main() {
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> dim >> nr;
++dim;
v[i].c = nr;
v[i].d = dim;
if (dim > ma) ma = dim;
}
sort(v + 1, v + n + 1, cmp);
k = 1;
for (i = 1; i <= ma; ++i) {
if (!(sol % 4))
sol /= 4;
else
sol = sol / 4 + 1;
if (v[k].d == i) {
if (v[k].c >= sol) sol = v[k].c;
++k;
}
}
if (sol > 1)
for (; sol && (sol != 1); i++) {
if (!(sol % 4))
sol /= 4;
else
sol = sol / 4 + 1;
}
else
++i;
cout << i - 2;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
char s[100005];
long long num[105];
int f(int x) {
int ans = 0;
while (x) {
if (x & 1) ans++;
x >>= 1;
}
ans = 6 - ans;
int sum = 1;
for (int i = 0; i < ans; ++i) sum *= 3;
return sum;
}
int main() {
for (int i = 0; i < 64; ++i) num[i] = f(i);
long long sum = 1;
scanf("%s", s);
for (int i = 0; i < strlen(s); ++i) {
if (s[i] >= '0' && s[i] <= '9')
sum *= num[s[i] - '0'];
else if (s[i] >= 'A' && s[i] <= 'Z')
sum *= num[s[i] - 'A' + 10];
else if (s[i] >= 'a' && s[i] <= 'z')
sum *= num[s[i] - 'a' + 36];
else if (s[i] == '-')
sum *= num[62];
else if (s[i] == '_')
sum *= num[63];
sum = sum % mod;
}
printf("%lld\n", sum);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int t, n, m;
std::string s;
std::vector<int> sum;
int cnt[26];
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cin >> t;
while (t--) {
std::cin >> n >> m >> s;
sum.assign(n, 0);
for (int i = 0; i < m; ++i) {
int p;
std::cin >> p;
++sum[p - 1];
}
++sum[n - 1];
for (int i = n - 2; i >= 0; --i) sum[i] += sum[i + 1];
std::fill(cnt, cnt + 26, 0);
for (int i = 0; i < n; ++i) cnt[s[i] - 'a'] += sum[i];
for (int i = 0; i < 26; ++i) std::cout << cnt[i] << " \n"[i == 25];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[200010], t[200010];
string ans;
void solve() {
int n = strlen(s), x = 0;
for (int i = 0; i < n; i++) {
if (i) ans += '+';
if (i < n - 1 && rand() % 2 == 0) {
ans += (s[i]), ans += s[++i];
x += 10 * (s[i - 1] - '0') + s[i] - '0';
} else {
ans += (s[i]);
x += s[i] - '0';
}
}
ans += '\n';
sprintf(s, "%d", x);
}
int main() {
srand(time(0));
scanf("%s%s", s, t);
while (1) {
strcpy(s, t);
ans = "";
solve();
solve();
solve();
if (strlen(s) == 1) return cout << ans, 0;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int MAXN = 607;
int powMod(int x, int y, int p) {
long long ret = 1;
for (; y; y >>= 1) {
if (y & 1) ret = ret * x % p;
x = (long long)x * x % p;
}
return ret;
}
int detModPrime(int a[MAXN][MAXN], int n, int p) {
bool neg = false;
for (int i = 0; i < n; ++i) {
int j = i;
for (; j < n && a[j][i] == 0; ++j)
;
if (j == n) return 0;
if (j != i) {
neg = !neg;
for (int k = 0; k < n; ++k) swap(a[i][k], a[j][k]);
}
for (j = i + 1; j < n; ++j) {
long long co = (long long)(p - a[j][i]) * powMod(a[i][i], p - 2, p) % p;
for (int k = i; k < n; ++k) a[j][k] = (a[j][k] + co * a[i][k]) % p;
}
}
long long ret = neg ? (p - 1) : 1;
for (int i = 0; i < n; ++i) ret = ret * a[i][i] % p;
return ret;
}
vector<int> e[MAXN * 2];
int n, m, p;
int in[MAXN * 2], out[MAXN * 2], f[MAXN * 2];
int inn[MAXN * 2], mat[MAXN][MAXN];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> p;
memset(in, 0, sizeof(in)), memset(out, 0, sizeof(out));
vector<int> source, sink;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
--a, --b;
++out[a];
++in[b];
e[a].push_back(b);
}
for (int i = 0; i < n; i++) {
if (!in[i]) source.push_back(i);
if (!out[i]) sink.push_back(i);
}
for (int i = 0; i < source.size(); i++) {
for (int j = 0; j < n; j++) f[j] = 0, inn[j] = in[j];
f[source[i]] = 1;
queue<int> Q;
for (int j = 0; j < source.size(); j++) Q.push(source[j]);
while (Q.size()) {
int now = Q.front();
Q.pop();
for (typeof(e[now].begin()) it = e[now].begin(); it != e[now].end();
it++) {
f[*it] = (f[*it] + f[now]) % p;
--inn[*it];
if (!inn[*it]) Q.push(*it);
}
}
for (int j = 0; j < source.size(); j++) mat[i][j] = f[sink[j]];
}
cout << detModPrime(mat, sink.size(), p) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
template <typename T, typename U>
inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void amax(T &x, U y) {
if (x < y) x = y;
}
template <typename T>
inline void write(T x) {
int i = 20;
char buf[21];
buf[20] = '\n';
do {
buf[--i] = x % 10 + '0';
x /= 10;
} while (x);
do {
putchar(buf[i]);
} while (buf[i++] != '\n');
}
template <typename T>
inline T readInt() {
T n = 0, s = 1;
char p = getchar();
if (p == '-') s = -1;
while ((p < '0' || p > '9') && p != EOF && p != '-') p = getchar();
if (p == '-') s = -1, p = getchar();
while (p >= '0' && p <= '9') {
n = (n << 3) + (n << 1) + (p - '0');
p = getchar();
}
return n * s;
}
int main() {
int n;
cin >> n;
string s;
vector<string> st;
int purple = 0;
int green = 0;
int blue = 0;
int orange = 0;
int red = 0;
int yellow = 0;
for (int i = 0; i < n; i++) {
cin >> s;
if (s == "purple") purple++;
if (s == "green") green++;
if (s == "blue") blue++;
if (s == "orange") orange++;
if (s == "red") red++;
if (s == "yellow") yellow++;
st.push_back(s);
}
int sum = purple + orange + yellow + blue + red + green;
cout << 6 - sum << endl;
if (purple == 0) {
cout << "Power" << endl;
}
if (green == 0) {
cout << "Time" << endl;
}
if (red == 0) {
cout << "Reality" << endl;
}
if (yellow == 0) {
cout << "Mind" << endl;
}
if (blue == 0) {
cout << "Space" << endl;
}
if (orange == 0) {
cout << "Soul" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
#pragma GCC optimize("03")
#pragma GCC target("sse4")
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, q;
cin >> n >> q;
vector<int> d(n);
vector<int> a(n + 1);
for (int i = 0; i < n; i++) cin >> a[i];
long long res = 0;
for (int i = 0; i < n; i++) {
d[i] = max(0, a[i] - a[i + 1]);
res = (res + d[i]);
}
cout << (res) << '\n';
while (q--) {
int l, r;
cin >> l >> r;
l--, r--;
if (l == r) {
cout << (res) << '\n';
continue;
}
if (l) res -= d[l - 1];
res -= d[l];
res -= d[r];
if (l != r - 1) res -= d[r - 1];
swap(a[l], a[r]);
if (l) {
d[l - 1] = max(0, a[l - 1] - a[l]);
res += d[l - 1];
}
d[l] = max(0, a[l] - a[l + 1]);
res += d[l];
d[r] = max(0, a[r] - a[r + 1]);
res += d[r];
if (l != r - 1) {
d[r - 1] = max(0, a[r - 1] - a[r]);
res += d[r - 1];
}
cout << (res) << '\n';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, a1, b1, b, c, c1;
cin >> a >> a1 >> b >> b1 >> c >> c1;
cout << 3 << endl;
cout << a - b + c << " " << a1 - b1 + c1 << endl;
cout << c - a + b << " " << c1 - a1 + b1 << endl;
cout << b - c + a << " " << b1 - c1 + a1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, M, len, ans;
int f[200005];
int p[200005][22];
int mx[(1 << 23) + 5], tmd;
int two[22];
char ss[22];
int ask(int x, int y) {
int i, suf = 0, pre = 0, mx = 0;
for (i = 1; i <= len; i++) {
suf = suf + two[i - 1] * p[x][len - i + 1];
pre = pre * 2 + p[y][i];
if (suf == pre) mx = i;
}
return mx;
}
int main() {
int i, j, pre, suf, tmp;
scanf("%d", &N);
for (i = 1; i <= N; i++) {
scanf("%s", ss);
len = strlen(ss);
p[i][0] = p[i][len + 1] = 1;
for (j = 1; j <= len; j++) p[i][j] = (ss[j - 1] - '0');
}
ans = len * N;
for (i = 0; i < (1 << len + 2); i++) mx[i] = -0x7ffffff;
for (i = 1, two[0] = 1; i <= len; i++) two[i] = two[i - 1] * 2;
f[0] = 0, mx[1] = 0;
for (i = 1; i < N; i++) {
for (j = 0, pre = 0; j <= len; j++) {
pre = pre * 2 + p[i + 1][j];
f[i] = max(f[i], mx[pre] + j + tmd);
}
tmd += ask(i, i + 1), tmp = -tmd;
mx[1] = max(mx[1], f[i] + tmp);
for (j = len, suf = 0; j >= 1; j--) {
suf = suf + two[len - j] * p[i][j];
mx[suf + two[len - j + 1]] = max(mx[suf + two[len - j + 1]], f[i] + tmp);
}
}
f[N] = mx[1] + tmd;
printf("%d\n", ans - f[N]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int q, ope;
long long a[500005], x, lst, s;
int n, pr;
int main() {
cin >> q;
while (q--) {
cin >> ope;
if (ope == 1) {
cin >> x;
a[++n] = x;
while (pr + 1 <= n && double(a[pr + 1]) <= (s + a[n]) / double(pr + 1)) {
pr++;
s += a[pr];
}
}
if (ope == 2) {
printf("%.10lf\n", double(a[n]) - double(s + a[n]) / (pr + 1));
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long t, m, p, e[(1 << 20)], b[(1 << 20)], B[(1 << 20)], sz[(1 << 20)];
void FWT(long long *a, long long n) {
for (long long i = 2; i <= n; i <<= 1) {
long long len = i / 2;
for (long long j = 0; j < n; j += i)
for (long long k = j; k < j + len; k++) {
long long x = a[k], y = a[k + len];
a[k] = (x + y) % p;
a[k + len] = (x - y + p) % p;
}
}
}
void IFWT(long long *a, long long n) {
for (long long i = 2; i <= n; i <<= 1) {
long long len = i / 2;
for (long long j = 0; j < n; j += i)
for (long long k = j; k < j + len; k++) {
long long x = a[k], y = a[k + len];
a[k] = ((x + y) % p) / 2;
a[k + len] = ((x - y + p) % p) / 2;
}
}
}
long long ans[(1 << 20)];
long long modmul(long long A, long long B, long long mod) {
return (A * B - (long long)((long double)A * B / mod) * mod + mod) % mod;
}
void qpow(long long *a, long long b) {
ans[0] = 1;
FWT(a, (1 << (m)));
FWT(ans, (1 << (m)));
while (b) {
if (b & 1) {
for (long long i = 0; i < (1 << (m)); i++)
ans[i] = modmul(ans[i], a[i], p);
}
for (long long i = 0; i < (1 << (m)); i++) a[i] = modmul(a[i], a[i], p);
b >>= 1;
}
IFWT(ans, (1 << (m)));
}
signed main() {
scanf("%lld %lld %lld", &m, &t, &p);
for (long long i = 0; i < (1 << m); i++) scanf("%lld", &e[i]);
for (long long i = 0; i <= m; i++) scanf("%lld", &b[i]);
p *= (1 << m);
for (long long i = 0; i < (1 << m); i++) {
sz[i] = sz[(i >> 1)] + (i & 1);
B[i] = b[sz[i]];
}
qpow(B, t);
FWT(ans, (1 << (m)));
FWT(e, (1 << (m)));
for (long long i = 0; i < (1 << (m)); i++) ans[i] = modmul(e[i], ans[i], p);
IFWT(ans, (1 << (m)));
p /= (1 << m);
for (long long i = 0; i < (1 << m); i++) printf("%lld\n", ans[i] % p);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, i;
cin >> n;
long long ans = 0;
long long val = 8;
for (i = 1; i <= (n / 2); i++) {
ans += (i * val);
val += 8;
}
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
for (long long i = 0; i < t; ++i) {
long long a, b;
cin >> a >> b;
long long tmp = 1;
long long cnt = 0;
for (long long i = 0; i < 10000; ++i) {
tmp *= 10;
if (b >= tmp - 1) {
++cnt;
} else {
break;
}
}
cout << a * cnt << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
for (long long int z = 0; z < t; z++) {
long long int n, x;
cin >> n >> x;
long long int arr[n + 1];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
long long int ans = 1000000000;
sort(arr, arr + n);
for (long long int i = n - 1; i >= 0; i--) {
long long int m = x / arr[i];
long long int p = x - arr[i] * m;
long long int q = m;
if (p > 0) {
q += 1;
if (q == 1) q++;
}
ans = min(ans, q);
}
cout << ans << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
int main() {
long long int a, b, c, i, j, k = 1;
int s[100010];
scanf("%lld %lld", &a, &b);
if (b < (a / 2) || (a == 1 && b > 0))
printf("%d", -1);
else if (a == 1 && b == 0)
printf("%d", 1);
else {
c = a / 2;
j = b - (c - 1);
c--;
printf("%lld %lld", j, j + j);
k = j + j + 1;
while (c) {
if (k != j && k != j * 2 && (k + 1) != j * 2 && (k + 1) != j) {
printf(" %lld %lld", k, k + 1);
k = k + 2;
} else {
k = k + 2;
printf(" %lld %lld", k, k + 1);
k = k + 2;
}
c--;
}
if (a % 2 != 0) {
if (k != j && k != j * 2)
printf(" %lld", k);
else
printf(" %lld", k + 1);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int n, f[100000], prim[100000], primNum = 9592;
void initial() {
int i, j, rt;
rt = (int)sqrt(100000);
for (i = 0; i < 100000; i++) f[i] = 1;
f[0] = f[1] = 0;
for (i = 2; i <= rt; i++)
if (f[i])
for (j = i * i; j < 100000; j += i) f[j] = 0;
j = 0;
for (i = 0; i < 100000; i++)
if (f[i]) prim[j++] = i;
}
int isBigPrim(int n) {
int i, flag;
flag = 1;
for (i = 0; i < primNum; i++)
if (n % prim[i] == 0) {
flag = 0;
break;
}
return flag;
}
int main() {
initial();
int i, j, res;
while (scanf("%d", &n) == 1) {
if (isBigPrim(n)) {
printf("%d\n", n + 1);
} else {
res = n;
while (n > 1) {
for (i = 0; i < primNum && prim[i] <= n; i++)
if (n % prim[i] == 0) {
n /= prim[i];
res += n;
i--;
continue;
}
if (i == primNum) {
res += 1;
break;
}
}
printf("%d\n", res);
}
}
return 0;
}
| 2 |
Subsets and Splits