solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
int main() {
puts("3");
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct _ {
ios_base::Init i;
_() {
cin.sync_with_stdio(1);
cin.tie(0);
}
} _;
struct SAT2 {
int n, group_label;
vector<vector<int> > edge, reverse_edge;
vector<int> traversed_order, group_number;
vector<bool> vis;
SAT2() {}
SAT2(int n)
: n(n),
edge(vector<vector<int> >(n)),
reverse_edge(vector<vector<int> >(n)) {}
void add_edge(int first, int second) {
edge[first].push_back(second);
reverse_edge[second].push_back(first);
}
void pop_edge(int first) {
int second = edge[first].back();
edge[first].pop_back();
reverse_edge[second].pop_back();
}
void dfs1(int u) {
vis[u] = true;
for (auto& v : edge[u]) {
if (!vis[v]) {
dfs1(v);
}
}
traversed_order.push_back(u);
}
void dfs2(int u) {
group_number[u] = group_label;
vis[u] = true;
for (auto& v : reverse_edge[u]) {
if (!vis[v]) {
dfs2(v);
}
}
}
bool is_sat() {
vis = vector<bool>(n);
traversed_order.clear();
for (int i = (0); i < (n); ++i) {
if (!vis[i]) {
dfs1(i);
}
}
vis = vector<bool>(n);
group_number = vector<int>(n);
group_label = 0;
for (int i = (n - 1); i >= (0); --i) {
if (!vis[traversed_order[i]]) {
dfs2(traversed_order[i]);
group_label++;
}
}
for (int i = (0); i < (n / 2); ++i) {
if (group_number[i * 2] == group_number[i * 2 + 1]) {
return false;
}
}
return true;
}
};
bool is_vowel[30];
string s;
int N, M;
SAT2 sat;
bool prefix_choice_satisfiable(int prefix_length) {
for (int i = (0); i < (prefix_length); ++i) {
sat.add_edge(2 * i + (!is_vowel[s[i] - 'a']), 2 * i + is_vowel[s[i] - 'a']);
}
bool is_sat = sat.is_sat();
for (int i = (0); i < (prefix_length); ++i) {
sat.pop_edge(2 * i + !is_vowel[s[i] - 'a']);
}
return is_sat;
}
int main(int argc, char** argv) {
string alpha;
cin >> alpha;
int L = alpha.length();
for (int i = (0); i < (L); ++i) {
is_vowel[i] = (alpha[i] == 'V');
}
int min_vowel = -1;
int min_consonent = -1;
for (int i = (0); i < (L); ++i)
if (is_vowel[i]) {
min_vowel = i;
break;
}
for (int i = (0); i < (L); ++i)
if (!is_vowel[i]) {
min_consonent = i;
break;
}
cin >> N >> M;
sat = SAT2(N + N);
for (int i = (0); i < (M); ++i) {
string t1, t2;
int p1, p2;
cin >> p1 >> t1 >> p2 >> t2;
--p1, --p2;
sat.add_edge(p1 * 2 + (t1 == "V"), p2 * 2 + (t2 == "V"));
sat.add_edge(p2 * 2 + (t2 != "V"), p1 * 2 + (t1 != "V"));
}
cin >> s;
if (prefix_choice_satisfiable(N)) {
cout << s;
} else {
for (int i = (N - 1); i >= (0); --i) {
bool tried[2] = {false, false};
for (int j = (s[i] - 'a' + 1); j < (L); ++j) {
if (tried[is_vowel[j]]) continue;
tried[is_vowel[j]] = true;
s[i] = 'a' + j;
if (!prefix_choice_satisfiable(i + 1)) continue;
for (int k = (i + 1); k < (N); ++k) {
int trial[2] = {min_vowel, min_consonent};
sort(trial, trial + 2);
for (int z = (0); z < (2); ++z) {
if (trial[z] == -1) continue;
s[k] = 'a' + trial[z];
if (prefix_choice_satisfiable(k + 1)) break;
}
}
if (prefix_choice_satisfiable(N)) {
cout << s;
return 0;
}
}
}
cout << "-1";
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int n, jc[2002], f[2002], g[2002], h[2002][2002], a[2002][2002], c[2002],
d[2002];
bool b[2002], bb[2002];
int pow(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = 1LL * x * x % 998244353)
if (y & 1) res = 1LL * res * x % 998244353;
return res;
}
int main() {
scanf("%d", &n);
if (n == 1) {
putchar('0');
return 0;
}
jc[0] = 1;
for (int i = 1; i < n; ++i) jc[i] = 1LL * jc[i - 1] * i % 998244353;
f[1] = 0, f[2] = 1;
for (int i = 3; i <= n; ++i) {
f[i] = 1LL * (i - 1) * (f[i - 1] + f[i - 2]) % 998244353;
if (f[i] >= 998244353) f[i] -= 998244353;
}
for (int i = 0; i < n; ++i) g[i] = pow(f[n], i);
h[1][1] = 0, h[1][0] = 1;
for (int i = 2; i <= n; ++i) {
h[i][i] = f[i];
for (int j = i - 1; j >= 0; --j)
h[i][j] = (h[i][j + 1] + h[i - 1][j]) % 998244353;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[1][i]);
int m = a[1][i] - 1;
for (int j = a[1][i]; j; j -= j & (-j)) m -= c[j];
ans += 1LL * m * jc[n - i] % 998244353 * g[n - 1] % 998244353;
if (ans >= 998244353) ans -= 998244353;
for (int j = a[1][i]; j <= n; j += j & (-j)) ++c[j];
}
for (int i = 2; i <= n; ++i) {
for (int j = 1; j <= n; ++j) b[j] = bb[j] = 0, c[j] = d[j] = 0;
for (int j = 1; j <= n; ++j)
for (int k = j; k <= n; k += k & (-k)) ++d[k];
for (int j = 1, x = n; j <= n; ++j) {
scanf("%d", &a[i][j]);
int m = a[i][j] - 1;
for (int k = a[i][j]; k; k -= k & (-k)) m -= c[k];
if (a[i - 1][j] < a[i][j] && !b[a[i - 1][j]]) --m;
bb[a[i - 1][j]] = 1;
if (!b[a[i - 1][j]])
for (int k = a[i - 1][j]; k <= n; k += k & (-k)) --d[k];
int mm = 0;
for (int k = a[i][j] - 1; k; k -= k & (-k)) mm += d[k];
if (!b[a[i - 1][j]]) --x;
ans += (1LL * (m - mm) * h[n - j][x] + 1LL * mm * h[n - j][x - 1]) %
998244353 * g[n - i] % 998244353;
if (ans >= 998244353) ans -= 998244353;
if (!bb[a[i][j]]) --x;
b[a[i][j]] = 1;
if (!bb[a[i][j]])
for (int k = a[i][j]; k <= n; k += k & (-k)) --d[k];
for (int k = a[i][j]; k <= n; k += k & (-k)) ++c[k];
}
}
printf("%d", ans);
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long m[305][305];
long long g[305][305];
vector<long long> dijkstra(long long source) {
typedef struct pair {
long long vertex, distance;
bool operator<(const pair& ot) const {
return !(this->distance < ot.distance);
}
} PAIR;
priority_queue<PAIR> pqp;
vector<bool> visited(n + 1, false);
vector<long long> distance(n + 1, 2000000000);
pqp.push({source, 0});
distance.at(source) = 0;
while (!pqp.empty()) {
PAIR current_visiting = pqp.top();
pqp.pop();
if (visited.at(current_visiting.vertex)) continue;
visited.at(current_visiting.vertex) = true;
for (long long(i) = (1); (i) <= (n); ++(i)) {
if (visited.at(i) || i == current_visiting.vertex) continue;
if (current_visiting.distance + g[current_visiting.vertex][i] <
distance.at(i)) {
distance.at(i) =
current_visiting.distance + g[current_visiting.vertex][i];
pqp.push({i, distance.at(i)});
}
}
}
return distance;
}
void CodeForces_25C() {
typedef struct tri {
long long x, y, z;
bool operator<(const tri& ot) const { return !(this->z < ot.z); }
} TRI;
priority_queue<TRI> pqt;
cin >> n;
for (long long(i) = (1); (i) <= (n); ++(i)) {
for (long long(j) = (1); (j) <= (n); ++(j)) {
g[i][j] = 2000000000;
cin >> m[i][j];
}
}
long long k, a, b, c;
cin >> k;
for (long long(_) = (1); (_) <= (k); ++(_)) {
cin >> a >> b >> c;
for (long long(i) = (1); (i) <= (n); ++(i)) {
for (long long(j) = (1); (j) <= (n); ++(j)) {
if (m[i][a] + c + m[b][j] < m[i][j]) {
m[i][j] = m[i][a] + c + m[b][j];
}
if (m[i][b] + c + m[a][j] < m[i][j]) {
m[i][j] = m[i][b] + c + m[a][j];
}
}
}
long long s = 0;
for (long long(i) = (1); (i) <= (n - 1); ++(i))
for (long long(j) = (i + 1); (j) <= (n); ++(j)) s += m[i][j];
cout << s << " ";
}
cout << endl;
}
int main() {
CodeForces_25C();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
pair<int, int> p[n];
for (int i = 0; i < n; i++) {
cin >> p[i].first;
p[i].second = i + 1;
}
sort(p, p + n);
int t1 = n / 2 + (n % 2), t2 = n / 2;
cout << t1 << endl;
for (int i = 0; i < n; i += 2) {
cout << p[i].second << " ";
}
cout << endl;
cout << t2 << endl;
for (int i = 1; i < n; i += 2) {
cout << p[i].second << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m = INT_MIN, r, l, i, in, sum = 0, maxlen = 1, c;
float avg = INT_MIN;
cin >> n;
long long int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] > m) {
in = i;
m = arr[i];
}
}
l = in;
r = in;
m = arr[in];
for (i = 0; i < n; i++) {
if (arr[i] == m) {
c = 0;
while (arr[i] == m) {
c++;
i++;
}
i--;
if (maxlen < c) maxlen = c;
}
}
cout << maxlen;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 100;
int best[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n + 1];
for (long long i = 0; i < n; i++) {
cin >> a[i];
best[i] = 0;
}
best[n] = 0;
a[n] = 0;
int m;
cin >> m;
for (long long i = 0; i < m; i++) {
int b, c;
cin >> b >> c;
best[c] = max(best[c], b);
}
for (int i = n - 1; i >= 0; --i) best[i] = max(best[i], best[i + 1]);
int i = 0;
int ans = 0;
int possible = 1;
while (i < n) {
ans++;
int j = i;
int curr = a[i];
while (j < n && curr <= best[j - i + 1]) {
curr = max(curr, a[++j]);
}
if (i == j) {
possible = 0;
break;
}
i = j;
}
if (!possible)
cout << "-1\n";
else
cout << ans << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
scanf("%d%d", &n, &m);
int i, a[n + 2], b[m + 2], ans;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
sort(a, a + n);
sort(b, b + m);
if (b[0] <= a[n - 1] || 2 * a[0] >= b[0]) {
printf("-1\n");
return 0;
}
ans = a[n - 1] > 2 * a[0] ? a[n - 1] : 2 * a[0];
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + (s - '0');
s = getchar();
}
return x * f;
}
const int jzm = 1000000007;
inline int ABS(int x) { return x < 0 ? -x : x; }
int n, m, i, j, s, o, k;
struct it {
int v, w;
it() { v = w = 0; }
it(int V, int W) {
v = V;
w = W;
}
};
vector<it> g[200005];
int son[200005];
long long tm[200005], ans;
inline bool cmp(it a, it b) {
return tm[a.v] * 1ll * son[b.v] < tm[b.v] * 1ll * son[a.v];
}
void dfs(int x, int fa, int ed) {
son[x] = 1;
tm[x] = ed * 2ll;
for (int i = 0; i < g[x].size(); i++) {
int y = g[x][i].v;
if (y != fa) {
dfs(y, x, g[x][i].w);
son[x] += son[y];
tm[x] += tm[y];
}
}
return;
}
void dfs2(int x, int fa, int ed, long long &tim) {
tim += ed;
ans += tim;
for (int i = 0; i < g[x].size(); i++) {
if (g[x][i].v != fa) {
int y;
dfs2(y = g[x][i].v, x, g[x][i].w, tim);
}
}
tim += ed;
return;
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
s = read();
o = read();
k = read();
g[s].push_back(it(o, k));
g[o].push_back(it(s, k));
}
dfs(1, 0, 0);
for (int i = 1; i <= n; i++) {
sort(g[i].begin(), g[i].end(), cmp);
}
long long tm = 0;
dfs2(1, 0, 0, tm);
printf("%.7lf\n", (double)ans / (n - 1.0));
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005], f[1000005][7][7], n, m;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int u;
cin >> u;
a[u]++;
}
for (int i = 0; i < 1000005; i++) {
for (int j = 0; j < 7; j++) {
for (int k = 0; k < 7; k++) {
f[i][j][k] = -1e9;
}
}
}
f[1][0][a[1] % 3] = a[1] / 3;
if (a[1] >= 3 && a[1] % 3 != 2) {
f[1][0][a[1] % 3 + 3] = a[1] / 3 - 1;
}
for (int i = 2; i <= m; i++) {
for (int j = 0; j <= 5; j++) {
for (int k = 0; k <= min(5, a[i]); k++) {
for (int l = j; l <= 5; l++) {
for (int t = l - j; t <= 5; t++) {
int x = t, y = l - j, z = a[i], res = f[i - 1][t][l];
if (res < 0) {
continue;
}
res += (z - k) / 3;
z -= ((z - k) / 3) * 3;
z -= k;
if (z != y) {
continue;
}
res += y;
f[i][j][k] = max(f[i][j][k], res);
}
}
}
}
}
int maxi = 0;
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 7; j++) {
maxi = max(maxi, f[m][i][j]);
}
}
cout << maxi << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const long long INFL = 1LL << 60;
const long long INF = INFL;
long long MOD = 1000000007;
vector<long long> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};
vector<long long> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};
void BinarySay(long long x, long long y = 60) {
for (long long i = 0; i < (y); i++) cout << (x >> (y - 1 - i) & 1);
cout << endl;
}
long long get_bit(long long x) { return __builtin_popcountll(x); }
long long pow_long(long long x, long long k) {
long long res = 1;
while (k > 0) {
if (k % 2) res *= x;
x *= x;
k /= 2;
}
return res;
}
long long pow_mod(long long x, long long k) {
long long res = 1;
while (k > 0) {
if (k % 2) {
res *= x;
res %= MOD;
}
x *= x;
x %= MOD;
k /= 2;
}
return res;
}
long long inverse(long long x) { return pow_mod(x, MOD - 2); };
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long x, long long y) { return x / gcd(x, y) * y; };
long long kai_mod(long long x) {
if (x == 0) return 1;
return x * kai_mod(x - 1) % MOD;
}
vector<long long> divisor(long long n) {
vector<long long> res(0);
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (i != n / i) res.push_back(n / i);
}
}
sort(res.begin(), res.end());
return res;
}
vector<long long> MakePrimeList(long long x) {
vector<long long> res;
for (long long k = 2; k * k <= x; k++) {
if (x % k == 0) {
res.push_back(k);
while (x % k == 0) x /= k;
}
}
if (x > 1) res.push_back(x);
return res;
}
const int MAXcomb = 200010;
long long fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAXcomb; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long comb(int n, int k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * finv[k] % MOD * finv[n - k] % MOD;
}
long long sub(vector<long long> tmp, long long x) {
if (x == 2) {
long long res1 = 0, res2 = 0;
for (long long i = 0; i < (tmp.size()); i++) {
if (tmp[i] > res1) {
res2 = res1;
res1 = tmp[i];
} else if (tmp[i] > res2) {
res2 = tmp[i];
}
}
return res1 + res2;
}
for (long long i = 0; i < (x); i++) tmp.push_back(0);
sort(tmp.begin(), tmp.end());
reverse(tmp.begin(), tmp.end());
long long res = 0;
for (long long i = 0; i < (x); i++) res += tmp[i];
return res;
}
int main() {
long long N, M;
cin >> N >> M;
long long A[N][M];
for (long long i = 0; i < (N); i++)
for (long long j = 0; j < (M); j++) cin >> A[i][j];
long long ans = 0;
vector<long long> rowSum(N, 0), colSum(M, 0);
for (long long i = 0; i < (N); i++) {
for (long long j = 0; j < (M); j++) {
rowSum[i] += A[i][j];
colSum[j] += A[i][j];
}
}
ans = max(ans, sub(rowSum, 4));
ans = max(ans, sub(colSum, 4));
for (long long i = 0; i < (N); i++) {
for (long long j = 0; j < (M); j++) {
colSum[j] -= A[i][j];
}
ans = max(ans, sub(colSum, 3) + rowSum[i]);
for (long long j = 0; j < (M); j++) {
colSum[j] += A[i][j];
}
}
for (long long j = 0; j < (M); j++) {
for (long long i = 0; i < (N); i++) {
rowSum[i] -= A[i][j];
}
ans = max(ans, sub(rowSum, 3) + colSum[j]);
for (long long i = 0; i < (N); i++) {
rowSum[i] += A[i][j];
}
}
if (N < M) {
for (long long i1 = 0; i1 < (N); i1++) {
for (long long i2 = 0; i2 < (N); i2++) {
if (i1 >= i2) continue;
for (long long j = 0; j < (M); j++) {
colSum[j] -= A[i1][j];
colSum[j] -= A[i2][j];
}
ans = max(ans, sub(colSum, 2) + rowSum[i1] + rowSum[i2]);
for (long long j = 0; j < (M); j++) {
colSum[j] += A[i1][j];
colSum[j] += A[i2][j];
}
}
}
} else {
for (long long j1 = 0; j1 < (M); j1++) {
for (long long j2 = 0; j2 < (M); j2++) {
if (j1 >= j2) continue;
for (long long i = 0; i < (N); i++) {
rowSum[i] -= A[i][j1];
rowSum[i] -= A[i][j2];
}
ans = max(ans, sub(rowSum, 2) + colSum[j1] + colSum[j2]);
for (long long i = 0; i < (N); i++) {
rowSum[i] += A[i][j1];
rowSum[i] += A[i][j2];
}
}
}
}
cout << ans << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int MOD = 1000000007;
void solve() {
long long p, q;
cin >> p >> q;
if (p % q)
cout << p << "\n";
else {
long long x = 1;
bool f = false;
for (long long i = 2; i * i <= q; i++) {
if (q % i == 0) {
f = true;
long long t = p;
while (t && t % i == 0 && t % q == 0) t /= i;
if (t % q) x = max(x, t);
long long l = q / i;
t = p;
while (t && t % l == 0 && t % q == 0) t /= l;
if (t % q) x = max(x, t);
}
}
if (!f) {
while (p % q == 0) p /= q;
x = p;
}
cout << x << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000005;
long long n, a[N], root, d[N];
priority_queue<long long, vector<long long>, greater<long long>> heap;
signed main() {
ios::sync_with_stdio(false);
cin >> n;
for (long long i = 2; i <= n; i++) cin >> a[i];
root = a[2];
cout << root << endl;
for (long long i = 2; i <= n; i++) d[a[i]]++;
for (long long i = 1; i <= n; i++)
if (d[i] == 0) heap.push(i);
for (long long i = n; i >= 2; i--) {
long long p = heap.top();
heap.pop();
cout << p << " " << a[i] << endl;
d[a[i]]--;
if (d[a[i]] == 0) heap.push(a[i]);
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int a1, a2, a3, a4;
deque<char> ans;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> a1 >> a2 >> a3 >> a4;
if (a3 > min(a1, a2) || a4 > min(a1, a2) || abs(a3 - a4) > 1) {
cout << "-1";
return 0;
}
for (int i = 1; i <= a3; i++) {
ans.push_back('4');
ans.push_back('7');
}
a1 -= a3;
a2 -= a3;
a4 -= max(0, a3 - 1);
a3 = 0;
if (a1 && a4) {
ans.push_back('4');
a1--;
a4--;
}
if (a2 && a4) {
ans.push_front('7');
a2--;
a4--;
}
if (a3 || a4) {
cout << "-1";
return 0;
}
int first4 = -1, last7 = 0;
for (int i = 0; i < ans.size(); i++) {
if ((ans[i] == '4') && first4 == -1) first4 = i;
if (ans[i] == '7') last7 = i;
}
for (int i = 0; i < ans.size(); i++) {
if (i == first4) {
while (a1 > 0) {
cout << "4";
a1--;
}
}
if (i == last7) {
while (a2 > 0) {
cout << "7";
a2--;
}
}
cout << ans[i];
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
#define N 200001
set<pair<int, char>> graph[N];
void solve() {
int n, m;
cin >> n >> m;
int br1 = 0, br2 = 0;
for (int i = 0; i < m; i++) {
char c;
cin >> c;
if (c == '?') {
int k;
cin >> k;
if (k % 2 == 1) {
if (br1) {
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
}
else {
if (br2) {
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
}
continue;
}
if (c == '+') {
int x, y;
char l;
cin >> x >> y >> l;
x--, y--;
graph[x].insert({y, l});
auto it = graph[y].lower_bound({x, 'a'});
if (it != graph[y].end()) {
pair<int, char> p = *it;
if (p.first != x)
continue;
br1++;
if (p.second != l)
continue;
br2++;
}
continue;
}
int x, y;
cin >> x >> y;
x--, y--;
auto it = graph[x].lower_bound({y, 'a'});
pair<int, char> p = *it;
char res = p.second;
graph[x].erase({y, res});
it = graph[y].lower_bound({x, 'a'});
if (it != graph[y].end()) {
p = *it;
if (p.first != x)
continue;
br1--;
if (p.second != res)
continue;
br2--;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > p;
int n, a, b, ans[102];
int area(int i, int j) {
return (p[i].first * p[i].second) + (p[j].first * p[j].second);
}
bool chk(int i, int j) {
int x = p[i].first + p[j].first;
int y = max(p[i].second, p[j].second);
if (max(x, y) <= max(a, b) && min(x, y) <= min(a, b)) return 1;
x = p[i].first + p[j].second, y = max(p[i].second, p[j].first);
if (max(x, y) <= max(a, b) && min(x, y) <= min(a, b)) return 1;
x = p[i].second + p[j].second, y = max(p[i].first, p[j].first);
if (max(x, y) <= max(a, b) && min(x, y) <= min(a, b)) return 1;
x = p[i].second + p[j].first, y = max(p[i].first, p[j].second);
if (max(x, y) <= max(a, b) && min(x, y) <= min(a, b)) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> a >> b;
int x, y;
for (int i = 0; i < n; i++) {
cin >> x >> y;
p.push_back({x, y});
}
for (int i = 0; i < n; i++) {
ans[i] = 0;
for (int j = i + 1; j < n; j++) {
if (chk(i, j)) {
if (ans[i] < area(i, j)) ans[i] = area(i, j);
}
}
}
for (int i = 1; i < n; i++) {
ans[0] = max(ans[0], ans[i]);
}
cout << ans[0];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[2000005];
map<int, int> mp;
int getcnt(int l, int r) {
map<int, int>::iterator it1, it2;
int sb;
it1 = mp.lower_bound(l);
if (it1 != mp.begin()) {
it1--;
sb = it1->second;
} else {
sb = -1;
}
it2 = mp.upper_bound(r);
it2--;
return it2->second - sb;
}
int main() {
int n, i;
int t, l;
cin >> n >> l >> t;
int fl = (2 * t) / l;
int extra = 2 * t - fl * l;
double ans = 0;
mp[0] = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i + n] = a[i] + l;
mp[a[i]]++;
mp[a[i] + l]++;
}
map<int, int>::iterator it;
for (i = 0, it = mp.begin(); it != mp.end(); it++, i++) {
it->second = i;
}
int p1 = 1, p2 = 1;
for (i = 1; i <= n; i++) {
ans += 0.5 * fl * (n - 1);
while (a[p1] <= a[i] + extra) {
p1++;
}
ans += 0.25 * (p1 - i - 1);
while (a[p2] < l + a[i] - extra) {
p2++;
}
ans += 0.25 * (i + n - p2);
}
printf("%.10lf\n", ans / 2);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
inline void Rd(int &res) {
char c;
res = 0;
while (c = getchar(), c < '0')
;
do {
res = (res << 1) + (res << 3) + (c ^ 48);
} while (c = getchar(), c >= '0');
}
const int M = 200005;
struct Node {
int to, nxt;
} Edge[M << 1];
int Head[M], tot;
int n, k;
long long ans, cnt[M];
int depth[M];
map<int, int> Mp[M];
inline void Addedge(int a, int b) {
Edge[tot] = (Node){b, Head[a]};
Head[a] = tot++;
Edge[tot] = (Node){a, Head[b]};
Head[b] = tot++;
}
void work(int fr, int to, int x) {
int sum1 = 0, sum2 = 0;
for (map<int, int>::iterator it = Mp[fr].begin(); it != Mp[fr].end(); it++)
sum1 += (it->second);
for (map<int, int>::iterator it = Mp[to].begin(); it != Mp[to].end(); it++)
sum2 += (it->second);
ans += 1LL * sum1 * cnt[to] + 1LL * sum2 * cnt[fr];
for (map<int, int>::iterator it1 = Mp[fr].begin(); it1 != Mp[fr].end(); it1++)
for (map<int, int>::iterator it2 = Mp[to].begin(); it2 != Mp[to].end();
it2++) {
int d1 = it1->first, d2 = it2->first;
int cnt1 = it1->second, cnt2 = it2->second;
int dist = d1 + d2 - 2 * depth[x];
ans += 1LL * ((dist - 1) / k + 1) * cnt1 * cnt2;
}
}
void add(int fr, int to) {
cnt[to] += cnt[fr];
for (map<int, int>::iterator it = Mp[fr].begin(); it != Mp[fr].end(); it++)
Mp[to][it->first] += (it->second);
}
void del(int x) {
map<int, int> T;
for (map<int, int>::iterator it = Mp[x].begin(); it != Mp[x].end(); it++) {
int d = it->first;
if (d - k > depth[x]) {
T[d - k] += (it->second);
cnt[x] += (it->second);
} else
T[d] += (it->second);
}
Mp[x] = T;
}
void solve(int x, int f) {
int sz = 0;
for (int i = Head[x]; ~i; i = Edge[i].nxt) {
int to = Edge[i].to;
if (to == f) continue;
sz++;
depth[to] = depth[x] + 1;
solve(to, x);
}
Mp[x][depth[x]] = 1;
if (sz) {
int fi;
for (int i = Head[x]; ~i; i = Edge[i].nxt) {
int to = Edge[i].to;
if (to == f) continue;
fi = to;
break;
}
for (int i = Head[x]; ~i; i = Edge[i].nxt) {
int to = Edge[i].to;
if (to == f || to == fi) continue;
work(to, fi, x);
add(to, fi);
}
ans += cnt[fi];
for (map<int, int>::iterator it = Mp[fi].begin(); it != Mp[fi].end();
it++) {
int dist = (it->first) - depth[x];
ans += 1LL * ((dist - 1) / k + 1) * (it->second);
}
cnt[x] += cnt[fi];
for (map<int, int>::iterator it = Mp[fi].begin(); it != Mp[fi].end(); it++)
Mp[x][it->first] += (it->second);
del(x);
}
}
int main() {
Rd(n), Rd(k);
memset(Head, -1, sizeof(Head));
for (int i = 1; i < n; i++) {
int a, b;
Rd(a), Rd(b);
Addedge(a, b);
}
depth[1] = 1;
solve(1, 0);
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
void dfs(vector<vector<int>> &g, vector<int> &vis, stack<int> &st, int u,
int &flag) {
vis[u] = 1;
for (auto v : g[u]) {
if (vis[v] == 0) {
dfs(g, vis, st, v, flag);
} else if (vis[v] == 1) {
flag = 1;
}
}
st.push(u);
vis[u] = 2;
}
int main() {
int t;
cin >> t;
while (t--) {
int flag = 0;
int n;
cin >> n;
vector<vector<int>> g(n);
vector<vector<int>> list(n);
for (int i = 0; i < n; i++) {
int k;
cin >> k;
for (int j = 0; j < k; j++) {
int temp;
cin >> temp;
list[i].push_back(temp - 1);
g[temp - 1].push_back(i);
}
}
vector<int> vis(n, 0);
stack<int> st;
for (int i = 0; i < n; i++) {
if (vis[i] == 0) dfs(g, vis, st, i, flag);
}
if (flag == 1) {
cout << -1 << endl;
continue;
}
vector<int> dp(n, 0);
while (!st.empty()) {
int top = st.top();
st.pop();
dp[top] = 1;
for (auto node : list[top]) {
if (node > top)
dp[top] = max(dp[top], dp[node] + 1);
else
dp[top] = max(dp[top], dp[node]);
}
}
cout << *max_element(dp.begin(), dp.end()) << endl;
}
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx2")
using namespace std;
const int mxN = 3e5;
int n, m, t, a[mxN], cnt[mxN];
bool vis[mxN];
int main() {
cin >> t;
for (; t > 0; --t) {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i], --a[i];
}
memset(cnt, 0, sizeof(int) * n);
for (int i = 0; i < n; ++i) {
++cnt[(a[i] + n - i - 1) % n];
}
vector<int> cand;
for (int i = 0; i < n; ++i) {
if (cnt[i] >= n / 3) {
memset(vis, 0, sizeof(int) * n);
int swp = n;
for (int j = 0; j < n; ++j) {
int p = j;
if (!vis[p]) --swp;
while (!vis[p]) {
vis[p] = true;
p = a[(p + n - i - 1) % n];
}
}
if (swp <= m) {
cand.push_back(n - i - 1);
}
}
}
cout << cand.size() << ' ';
sort(cand.begin(), cand.end());
for (auto& item : cand) cout << item << ' ';
cout << '\n';
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
uint64_t ar[300003];
uint64_t dp[2][1 << 20];
int main() {
int t, tc = 0;
uint64_t n;
cin >> n;
for (uint64_t i = 0; i < n; i++) cin >> ar[i];
dp[1][0] = 1;
uint64_t ans = 0, x = 0;
for (uint64_t i = 0; i < n; i++) {
x ^= ar[i];
ans += dp[i % 2][x];
dp[i % 2][x]++;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 1; i < n; i += 2) a[i] = -1 * a[i];
for (int i = 0; i < n; i += 2) cout << a[i + 1] << ' ' << a[i] << ' ';
cout << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e1 + 4;
vector<int> circle;
bool vis[N];
int parent[N];
ll chk[N];
int color[N];
int tim[N];
int dis[N];
int position[N];
vector<int> adj[N];
vector<int> adj1[N];
vector<int> graph[N];
bool has_cycle;
int maxdis, maxnode, Totnode, depth = 1;
bool ok;
queue<int> q;
stack<int> stk;
vector<int> solution;
int indegree[N];
int go[N];
int to[N];
ll x1, x2, x3, x4, x5, x6;
string ss;
int gn, gk;
int main() {
int t = 1;
cin >> t;
int cas = 0;
while (t--) {
int n, m, i, j, cnt = 0, cnt1 = 0, cnt2 = 0, even = 0, odd = 0, len, k, r,
l, z = 0, x = 0, y = 0, flag = 0, sum = 0, tottal = 0;
int a = 0, b = 0, c = 0, d = 0, ans = 0, rem, quot, zero = 0, fst = 0,
null = 0, snd = 0, lst = 0, rone = 0, one = 0, pos = 0, neg = 0,
mn = INT_MAX, mx = INT_MIN;
char ch;
int h1, h2, m1, m2, h;
int velo1, velo2, ac1, ac2, tim, hour, mint, sec;
int node, edge, u, v, cost;
int bst, wrst;
double nd, ad, bd, cd, dd, xd, sumd = 0.00;
string str, str1 = "", str2 = "", str3 = "", strstore1 = "", strstore2 = "";
cin >> n >> m;
vector<int> vec;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
cin >> ch;
if (ch == '1') {
if (j == 1 && i == n) {
vec.push_back(i);
vec.push_back(j);
vec.push_back(i - 1);
vec.push_back(j);
vec.push_back(i);
vec.push_back(j + 1);
vec.push_back(i - 1);
vec.push_back(j);
vec.push_back(i - 1);
vec.push_back(j + 1);
vec.push_back(i);
vec.push_back(j);
vec.push_back(i);
vec.push_back(j + 1);
vec.push_back(i);
vec.push_back(j);
vec.push_back(i - 1);
vec.push_back(j + 1);
} else if (j == 1 && i < n) {
vec.push_back(i);
vec.push_back(j + 1);
vec.push_back(i + 1);
vec.push_back(j);
vec.push_back(i);
vec.push_back(j);
vec.push_back(i);
vec.push_back(j);
vec.push_back(i);
vec.push_back(j + 1);
vec.push_back(i + 1);
vec.push_back(j + 1);
vec.push_back(i);
vec.push_back(j);
vec.push_back(i + 1);
vec.push_back(j + 1);
vec.push_back(i + 1);
vec.push_back(j);
} else if (j <= m && i == n) {
vec.push_back(i - 1);
vec.push_back(j);
vec.push_back(i);
vec.push_back(j);
vec.push_back(i);
vec.push_back(j - 1);
vec.push_back(i);
vec.push_back(j);
vec.push_back(i - 1);
vec.push_back(j);
vec.push_back(i - 1);
vec.push_back(j - 1);
vec.push_back(i);
vec.push_back(j);
vec.push_back(i);
vec.push_back(j - 1);
vec.push_back(i - 1);
vec.push_back(j - 1);
} else {
vec.push_back(i);
vec.push_back(j - 1);
vec.push_back(i);
vec.push_back(j);
vec.push_back(i + 1);
vec.push_back(j);
vec.push_back(i);
vec.push_back(j);
vec.push_back(i);
vec.push_back(j - 1);
vec.push_back(i + 1);
vec.push_back(j - 1);
vec.push_back(i);
vec.push_back(j);
vec.push_back(i + 1);
vec.push_back(j);
vec.push_back(i + 1);
vec.push_back(j - 1);
}
}
}
}
cout << vec.size() / 6 << endl;
for (i = 0; i < vec.size(); i += 6) {
for (j = i; j < i + 6; j++) {
cout << vec[j] << " ";
}
cout << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, a, b, s1 = 0, s2 = 0;
cin >> n >> m >> a >> b;
s1 = (m - (n % m));
s2 = n % m;
s1 = (s1 * a <= s2 * b) ? s1 * a : s2 * b;
cout << s1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<long long, pair<int, int> > am;
map<long long, int> ma;
int cost[1000005];
pair<int, int> qu[1000005], c, d;
set<pair<int, int> > se;
int a1, b1, a2, b2, res = 1e9;
void normalize(int& a, int& b) {
if (a > b) swap(a, b);
}
void bfs1() {
normalize(a1, b1);
int fr = 1, re = 1;
qu[1] = pair<int, int>(a1, b1);
cost[1] = 0;
se.insert(pair<int, int>(a1, b1));
ma[(long long)a1 * (long long)b1] = 0;
am[(long long)a1 * (long long)b1] = pair<int, int>(a1, b1);
while (fr <= re) {
pair<int, int> u = qu[fr];
for (int i = 2; i <= 3; i++) {
if (u.first % i == 0) {
pair<int, int> v = u;
if (i == 2)
v.first /= i;
else
v.first = v.first / 3 * 2;
if (se.find(v) == se.end()) {
qu[++re] = v;
cost[re] = cost[fr] + 1;
se.insert(v);
if (ma.find((long long)v.first * (long long)v.second) == ma.end())
ma[(long long)v.first * (long long)v.second] = cost[re],
am[(long long)v.first *
(long long)v.second] = v;
}
}
if (u.second % i == 0) {
pair<int, int> v = u;
if (i == 2)
v.second /= i;
else
v.second = v.second / 3 * 2;
normalize(v.first, v.second);
if (se.find(v) == se.end()) {
qu[++re] = v;
cost[re] = cost[fr] + 1;
se.insert(v);
if (ma.find((long long)v.first * (long long)v.second) == ma.end())
ma[(long long)v.first * (long long)v.second] = cost[re],
am[(long long)v.first *
(long long)v.second] = v;
}
}
}
fr++;
}
}
void bfs2() {
normalize(a2, b2);
int fr = 1, re = 1;
qu[1] = pair<int, int>(a2, b2);
cost[1] = 0;
se.clear();
if (ma.find((long long)a2 * (long long)b2) != ma.end()) {
res = ma[(long long)a2 * (long long)b2];
c = am[(long long)a2 * (long long)b2];
d = qu[1];
}
while (fr <= re) {
pair<int, int> u = qu[fr];
for (int i = 2; i <= 3; i++) {
if (u.first % i == 0) {
pair<int, int> v = u;
if (i == 2)
v.first /= i;
else
v.first = v.first / 3 * 2;
if (se.find(v) == se.end()) {
qu[++re] = v;
cost[re] = cost[fr] + 1;
se.insert(v);
if (ma.find((long long)v.first * (long long)v.second) != ma.end() &&
ma[(long long)v.first * (long long)v.second] + cost[re] < res) {
res = ma[(long long)v.first * (long long)v.second] + cost[re];
c = am[(long long)v.first * (long long)v.second];
d = v;
}
}
}
if (u.second % i == 0) {
pair<int, int> v = u;
if (i == 2)
v.second /= i;
else
v.second = v.second / 3 * 2;
normalize(v.first, v.second);
if (se.find(v) == se.end()) {
qu[++re] = v;
cost[re] = cost[fr] + 1;
se.insert(v);
if (ma.find((long long)v.first * (long long)v.second) != ma.end() &&
ma[(long long)v.first * (long long)v.second] + cost[re] < res) {
res = ma[(long long)v.first * (long long)v.second] + cost[re];
c = am[(long long)v.first * (long long)v.second];
d = v;
}
}
}
}
fr++;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> a1 >> b1 >> a2 >> b2;
bfs1();
bfs2();
if (res == 1e9)
cout << "-1\n";
else {
cout << res << endl;
cout << c.first << " " << c.second << endl;
cout << d.first << " " << d.second << endl;
}
return 0;
}
| 11 |
// Problem Statement: https://codeforces.com/contest/1474/problem/E/
/**
* Author: Ravi Kanth Gojur
* Code Forces: ravireddy07
* Code Chef: ravireddy115
* Github: ravireddy07
**/
#include <bits/stdc++.h>
#define ll long long int
#define ravireddy07 return
#define ii(a) scanf("%d", &a)
#define ii2(a, b) scanf("%d%d", &a, &b)
#define ii3(a, b, c) scanf("%d%d%d", &a, &b, &c)
#define ill(a) scanf("%lld", &a)
#define ill2(a, b) scanf("%lld%lld", &a, &b)
#define ill3(a, b, c) scanf("%lld%lld%lld", &a, &b, &c)
#define for1(i, a, b) for (int i = a; i < b; ++i)
#define for2(i, a, b) for (int i = b; i >= a; --i)
#define vi vector<int>
#define vii vector<vector<int>>
#define vl vector<ll>
#define vll vector<vector<ll>>
#define pii pair<int,int>
#define unmp unordered_map
#define pqi priority_queue<int>
#define pb push_back
#define sorta(a) sort(a.begin(), a.end())
#define sortd(a) sort(a.begin(), a.end(), greater<>())
#define sortr(a) sort(a.rbegin(), a.rend())
#define yes printf("YES\n")
#define no printf("NO\n")
using namespace std;
template <typename T, typename T1>
T amax(T &a, T1 b)
{
if (b > a)
a = b;
return a;
}
const int N = 100100;
int n, m;
int p[N];
int ans[N][2];
ll sqr(ll x) {
return x * x;
}
void harry() {
ii(n);
m = 0;
for (int i = 1; i <= n; i++)
p[i] = i;
ll w = 0;
int l = 1;
int r = n - 1;
int t = 0;
while (m < n - 1) {
if (t == 0) {
w += sqr(n - l);
ans[m][0] = l;
ans[m][1] = n;
m++;
swap(p[l], p[n]);
l++;
} else {
w += sqr(r - 1);
ans[m][0] = r;
ans[m][1] = 1;
m++;
swap(p[r], p[1]);
r--;
}
t ^= 1;
}
printf("%lld\n", w);
for (int i = 1; i <= n; i++)
printf("%d ", p[i]);
printf("\n");
printf("%d\n", m);
for (int i = m - 1; i >= 0; i--)
printf("%d %d\n", ans[i][0], ans[i][1]);
ravireddy07;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t;
ii(t);
while (t--)
harry();
return 0;
} | 17 |
#include <bits/stdc++.h>
using namespace std;
void start(istream& str) {}
bool* b;
string solve(istream& cin) {
int n;
cin >> n;
int* ord = new int[n];
for (int i = 0; i < n; i++) cin >> ord[i];
int m = n;
int last = 0;
string res = "";
b = new bool[n + 1];
for (int i = 0; i < n + 1; i++) {
b[i] = false;
}
for (int i = 0; i < n; i++) {
b[ord[i]] = true;
if (ord[i] == m) {
for (int j = m; b[j]; j--) {
cout << to_string(j) + " ";
m--;
}
cout << "\n";
} else {
cout << "\n";
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
bool debug = false;
if (debug) {
ifstream infile;
infile.open("input.txt");
start(infile);
while (!infile.eof()) {
cout << solve(infile) << endl;
}
infile.close();
cin.get();
} else {
start(cin);
cout << solve(cin) << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
struct LBase {
int n, basis[20];
LBase() { n = 0; }
inline void insert(int x) {
if (n == 20) return;
for (int i = 0; i < n; i++) x = min(x, x ^ basis[i]);
if (x != 0) {
basis[n++] = x;
for (int k = n - 1; k > 0 && basis[k] > basis[k - 1]; k--)
swap(basis[k], basis[k - 1]);
}
}
inline int getmax() {
int ret = 0;
for (int i = 0; i < n; i++) ret = max(ret, ret ^ basis[i]);
return ret;
}
} base[maxn << 2];
inline LBase merge(LBase a, LBase b) {
for (int i = 20 - 1; i >= 0; i--) {
if (b.basis[i]) a.insert(b.basis[i]);
}
return a;
}
int a[maxn];
int n, q;
void pushup(int rt) { base[rt] = merge(base[rt << 1], base[rt << 1 | 1]); }
void build(int rt, int l, int r) {
if (l == r) {
base[rt].insert(a[l]);
} else {
int mid = l + r >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
}
LBase query(int rt, int l, int r, int ql, int qr) {
if (ql == l && r == qr) {
return base[rt];
} else {
int mid = l + r >> 1;
if (qr <= mid)
return query(rt << 1, l, mid, ql, qr);
else if (ql > mid)
return query(rt << 1 | 1, mid + 1, r, ql, qr);
else {
return merge(query(rt << 1, l, mid, ql, mid),
query(rt << 1 | 1, mid + 1, r, mid + 1, qr));
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, 1, n);
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
int ans = query(1, 1, n, l, r).getmax();
printf("%d\n", ans);
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100010];
int minn = 0x3fffffff;
int ans = 0x3fffffff, pre = -0x3fffffff;
int main() {
int i, j, k;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", a + i);
minn = min(minn, a[i]);
}
for (i = 1; i <= n; ++i) {
if (a[i] == minn) {
ans = min(ans, i - pre);
pre = i;
}
}
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, c, a[100005], b[100005];
int i;
long long check(long long x) {
int i;
long long sum = 0;
for (i = 1; i <= n; ++i) {
if (1. * x * a[i] / b[i] > c + 1) return c + 1;
sum += 1ll * x * a[i] / b[i] + 1;
if (sum > c) return c + 1;
}
return sum;
}
int main() {
scanf("%I64d%I64d", &n, &c);
long long flag = 0;
for (i = 1; i <= n; ++i) scanf("%I64d%I64d", &a[i], &b[i]), flag += a[i];
if (!flag) {
if (c != n)
puts("0");
else
puts("-1");
exit(0);
}
long long l = 0, r = 1e18, mid = 0;
while ((l + r) >> 1 != mid) {
mid = (l + r) >> 1;
if (check(mid) < c)
l = mid;
else
r = mid;
}
long long L = 0, R = 1e18, Mid = 0;
while ((L + R) >> 1 != Mid) {
Mid = (L + R) >> 1;
if (check(Mid) > c)
R = Mid;
else
L = Mid;
}
printf("%I64d\n", max(0ll, R - l - 1));
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 6;
const int maxl = 1e6 + 6;
const int mod = 1e9 + 7;
using ll = long long;
using pii = pair<int, int>;
string s[maxn];
int nxt[maxl];
vector<int> sorted[maxn];
int dp[2][maxl];
vector<ll> h[maxn][2];
ll Pow(ll a, ll b, int p) {
ll ret = 1;
while (b) {
if (b & 1) ret = ret * a % p;
a = a * a % p;
b >>= 1;
}
return ret;
}
ll p[2][maxl], pp[2], mods[2], revp[2];
void init() {
mods[0] = 1e9 + 7, mods[1] = 1e9 + 9;
pp[0] = 29, pp[1] = 31;
for (int i = 0; i < 2; i++) {
p[i][0] = 1;
for (int j = 1; j < maxl; j++) p[i][j] = p[i][j - 1] * pp[i] % mods[i];
}
}
pii getHash(int i, int x, int delPos) {
if (delPos > x) return make_pair(h[i][0][x], h[i][1][x]);
int ret0 = ((h[i][0][x + 1] - h[i][0][delPos + 1] + mods[0]) * revp[0] +
h[i][0][delPos]) %
mods[0];
int ret1 = ((h[i][1][x + 1] - h[i][1][delPos + 1] + mods[1]) * revp[1] +
h[i][1][delPos]) %
mods[1];
return make_pair(ret0, ret1);
}
bool equal(int i, int x, int j, int y, int mid) {
return getHash(i, mid, x) == getHash(j, mid, y);
}
int getch(int i, int x, int len) {
if (x > len) return s[i][len] - 'a' + 1;
if (len + 1 < s[i].size()) return s[i][len + 1] - 'a' + 1;
return 0;
}
bool check(int i, int x, int j, int y) {
int len1 = s[i].size(), len2 = s[j].size();
if (x != len1) len1--;
if (y != len2) len2--;
int l = 0, r = min(len1, len2), len;
while (l <= r) {
int mid = l + r >> 1;
if (equal(i, x, j, y, mid)) {
len = mid;
l = mid + 1;
} else
r = mid - 1;
}
int c1 = getch(i, x, len), c2 = getch(j, y, len);
return c1 >= c2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
init();
for (int i = 0; i < n; i++) {
cin >> s[i];
int len = s[i].size();
for (int j = 0; j < 2; j++) {
revp[j] = Pow(pp[j], mods[j] - 2, mods[j]);
h[i][j].push_back(0);
for (int t = 0; t < len; t++) {
h[i][j].push_back((h[i][j][t] + (s[i][t] - 'a' + 1) * p[j][t]) %
mods[j]);
}
}
nxt[len - 1] = len;
for (int j = len - 2; j >= 0; j--) {
if (s[i][j] == s[i][j + 1])
nxt[j] = nxt[j + 1];
else
nxt[j] = j + 1;
}
vector<int> tmp;
for (int j = 0; j < len; j++) {
if (nxt[j] == len || s[i][j] > s[i][nxt[j]])
sorted[i].push_back(j);
else
tmp.push_back(j);
}
sorted[i].push_back(len);
for (int j = tmp.size() - 1; j >= 0; j--) sorted[i].push_back(tmp[j]);
}
for (int i = 0; i < sorted[0].size(); i++) dp[0][i] = 1;
for (int i = 1; i < n; i++) {
int id = i & 1;
int sum = 0, ptr = 0;
for (int j = 0; j < sorted[i].size(); j++) {
while (ptr < sorted[i - 1].size() &&
check(i, sorted[i][j], i - 1, sorted[i - 1][ptr])) {
(sum += dp[id ^ 1][ptr]) %= mod;
ptr++;
}
dp[id][j] = sum;
}
}
int ans = 0;
for (int i = 0, id = (n - 1) & 1; i < sorted[n - 1].size(); i++)
(ans += dp[id][i]) %= mod;
cout << ans << endl;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 100;
void testcase() {
long long n;
cin >> n;
vector<long long> a(n);
for (auto &x : a) cin >> x;
sort(a.begin(), a.end());
vector<long long> fa(N), fb(N);
for (auto x : a) {
fa[x] = 1;
}
for (long long i = 1; i < N - 1; i++) {
if (fa[i] == 1) {
if (fa[i - 1]) {
fa[i] = 0;
fa[i - 1]++;
} else {
fa[i] = 0;
fa[i + 1]++;
i++;
}
}
}
for (auto x : a) {
if (fb[x - 1] == 0) {
fb[x - 1] = 1;
} else if (fb[x] == 0) {
fb[x] = 1;
} else
fb[x + 1] = 1;
}
long long minf, maxf;
minf = maxf = 0;
for (long long i = 0; i < N; i++)
if (fa[i]) minf++;
for (long long i = 0; i < N; i++)
if (fb[i]) maxf++;
cout << minf << ' ' << maxf;
}
signed main() {
ios::sync_with_stdio(0), cin.tie(nullptr);
long long t = 1;
while (t--) {
testcase();
cout << '\n';
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
double eps = 0.0000001;
int p1_ = 63;
int m1_ = 1000000009;
void get_h(string &s, vector<int> &h_pref, vector<int> &pow_p,
long long p = p1_, int m = m1_) {
pow_p[0] = 1;
int n = pow_p.size();
for (int i = 1; i < n; i++) {
pow_p[i] = pow_p[i - 1] * p % m;
}
h_pref[0] = s[0] - 'a' + 1;
for (int i = 1; i < n; i++) {
h_pref[i] = (h_pref[i - 1] + (long long)pow_p[i] * (s[i] - 'a' + 1)) % m;
}
}
vector<int> h1;
vector<int> h2;
vector<int> p1;
vector<int> p2;
int n;
bool is_p(int l, int r) {
long long hsh;
if (l != 0) {
hsh = h1[r] - h1[l - 1];
} else {
hsh = h1[r];
}
if (hsh < 0) {
hsh += m1_;
}
hsh = (hsh * p1[n - 1 - r]) % m1_;
int d = r - l;
l = n - 1 - r;
r = l + d;
long long hsh2;
if (l != 0) {
hsh2 = h2[r] - h2[l - 1];
} else {
hsh2 = h2[r];
}
if (hsh2 < 0) {
hsh2 += m1_;
}
hsh2 = (hsh2 * p2[n - 1 - r]) % m1_;
return hsh == hsh2;
}
int main() {
string s;
cin >> s;
n = s.size();
h1.resize(n);
h2.resize(n);
p1.resize(n);
p2.resize(n);
get_h(s, h1, p1);
reverse(s.begin(), s.end());
get_h(s, h2, p2);
vector<vector<int>> dp(5050, vector<int>(5050));
for (int i = 0; i < n; i++) {
dp[i][i] = 1;
}
for (int l = 2; l <= n; l++) {
for (int i = 0; i <= n - l; i++) {
int j = i + l - 1;
dp[i][j] = dp[i + 1][j] + dp[i][j - 1] - dp[i + 1][j - 1] + is_p(i, j);
}
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
printf("%d\n", dp[a][b]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int bucatal, bucatac;
string s[20];
bool nuefull() {
for (int i = bucatal; i < bucatal + 3; ++i) {
for (int j = bucatac; j < bucatac + 3; ++j) {
if (s[i][j] == '.') {
return true;
}
}
}
return false;
}
int main() {
int l, c;
for (int i = 0; i < 11; ++i) {
getline(cin, s[i]);
}
cin >> l >> c;
l %= 3;
c %= 3;
if (l == 0) {
bucatal = 8;
} else if (l == 1) {
bucatal = 0;
} else {
bucatal = 4;
}
if (c == 0) {
bucatac = 8;
} else if (c == 1) {
bucatac = 0;
} else {
bucatac = 4;
}
if (nuefull()) {
for (int i = 0; i < 11; ++i) {
if (i == 3 || i == 7) {
cout << "\n";
continue;
}
for (int j = 0; j < 11; ++j) {
if (i >= bucatal && i < bucatal + 3 && j >= bucatac &&
j < bucatac + 3 && s[i][j] == '.') {
cout << '!';
} else {
cout << s[i][j];
}
}
cout << "\n";
}
} else {
for (int i = 0; i < 11; ++i) {
if (i == 3 || i == 7) {
cout << "\n";
continue;
}
for (int j = 0; j < 11; ++j) {
if (s[i][j] == '.') {
cout << '!';
} else {
cout << s[i][j];
}
}
cout << "\n";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e15;
const int mx = 2e5 + 5;
const int x_move[] = {1, -1, 0, 0, 1, 1, -1, -1};
const int y_move[] = {0, 0, 1, -1, 1, -1, 1, -1};
int main() {
int t, q, ca = 1;
int n;
long long int pa, pb, pc;
long long int ans = 0;
pa = pb = pc = inf;
long long int pra = 0, prb = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
long long int v;
char str[10];
scanf("%I64d%s", &v, str);
if (str[0] == 'R') {
if (pa != inf) {
pra = max(pra, v - pa);
ans += v - pa;
}
pa = v;
} else if (str[0] == 'B') {
if (pb != inf) {
prb = max(prb, v - pb);
ans += v - pb;
}
pb = v;
} else {
if (pb != inf) {
prb = max(prb, v - pb);
ans += v - pb;
}
if (pa != inf) {
pra = max(pra, v - pa);
ans += v - pa;
}
if (pc != inf) ans = min(ans, ans + v - pc - pra - prb);
pa = pb = pc = v;
pra = prb = 0;
}
}
printf("%I64d\n", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const long long D = 31;
const long long N = 100010;
struct constraint {
long long l, r, q;
constraint(long long _l, long long _r, long long _q) {
l = _l;
r = _r;
q = _q;
}
};
void err() {
cout << "NO" << '\n';
exit(0);
}
long long n, m;
long long a[N][D];
long long pref[N][D];
vector<constraint> e;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long l, r, q;
cin >> l >> r >> q;
e.push_back({l, r, q});
for (long long bit = 0; bit < D; bit++) {
if (q >> bit & 1) {
a[l][bit]++;
a[r + 1][bit]--;
}
}
}
for (long long i = 1; i <= n; i++) {
for (long long bit = 0; bit < D; bit++) {
a[i][bit] += a[i - 1][bit];
}
}
for (long long i = 1; i <= n; i++) {
for (long long bit = 0; bit < D; bit++) {
pref[i][bit] = (i ? pref[i - 1][bit] : 0LL) + (a[i][bit] > 0);
}
}
for (auto [l, r, q] : e) {
for (long long bit = 0; bit < D; bit++) {
if (q >> bit & 1) {
if (pref[r][bit] - pref[l - 1][bit] != r - l + 1) {
err();
}
} else {
if (pref[r][bit] - pref[l - 1][bit] == r - l + 1) {
err();
}
}
}
}
vector<long long> res(n);
for (long long i = 1; i <= n; i++) {
for (long long bit = 0; bit < D; bit++) {
if (a[i][bit] > 0) {
res[i - 1] |= (1LL << bit);
}
}
}
cout << "YES" << '\n';
for (long long it : res) {
cout << it << " ";
}
cout << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec[10500];
int main() {
int n;
cin >> n;
int x = 0;
while (x * (x + 1) / 2 <= n) x++;
cout << x << endl;
int k = 1;
for (int i = 1; i <= x; i++) {
for (int j = i + 1; j <= x; j++, k++) {
vec[i].push_back(k);
vec[j].push_back(k);
}
}
for (int i = 1; i <= x; i++) {
for (int j = 0; j < vec[i].size(); j++) printf("%d ", vec[i][j]);
printf("\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int prevAmplifyingLine, isAmplifyingLine, firstLine;
char S[1100000];
int i, L;
int main() {
prevAmplifyingLine = 0;
firstLine = 1;
while (1) {
S[0] = 0;
fgets(S, 1100000 - 2, stdin);
if (S[0] == 0) break;
isAmplifyingLine = 0;
L = strlen(S);
for (i = 0; i < L; i++)
if (S[i] != ' ') {
if (S[i] == '#') isAmplifyingLine = 1;
break;
}
if (isAmplifyingLine) {
if (!prevAmplifyingLine && !firstLine) printf("\n");
printf("%s", S);
prevAmplifyingLine = 1;
} else {
for (i = 0; i < L; i++)
if (S[i] != ' ' && S[i] != '\n') printf("%c", S[i]);
prevAmplifyingLine = 0;
}
firstLine = 0;
}
if (!prevAmplifyingLine) printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char A[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i + j) % 2 == 0)
A[i][j] = 'W';
else
A[i][j] = 'B';
cout << A[i][j];
}
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
constexpr auto INF = 9223372036854775807;
using namespace std;
auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();
mt19937 mt(seed);
int myrand(int mod) { return mt() % mod; }
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 lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
long long int power(long long int x, long long int y, long long int mod) {
long long int ans = 1;
x = x % mod;
while (y > 0) {
if (y & 1) ans = ((ans % mod) * (x % mod)) % mod;
y = y >> 1;
x = ((x % mod) * (x % mod)) % mod;
}
return ans;
}
bool isprime(long long int n) {
if (n == 2) return true;
if (n % 2 == 0 || n == 1) {
return false;
}
for (long long int j = 3; j <= sqrt(n); j += 2) {
if (n % j == 0) {
return false;
}
}
return true;
}
long long int cal(long long int k) {
k *= 2;
long long int n = -1 + sqrt(1 + 4 * k);
n /= 2;
return n;
}
string dp[30][100001];
string solve(long long int num, long long int k) {
if (k == 0) return "";
if (num == 26) return "A";
if (dp[num][k] != "") return dp[num][k];
long long int maxi = cal(k) + 1;
for (long long int i = 2; i <= maxi; i += 1) {
string ans = solve(num + 1, k - ((i - 1) * (i)) / 2);
if (ans == "A") continue;
string temp = "";
for (long long int j = 0; j < i; j += 1) {
temp.push_back('a' + (num));
}
temp += ans;
return dp[num][k] = temp;
}
return dp[num][k] = "A";
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int k;
cin >> k;
if (k == 0)
cout << "a" << '\n';
else
cout << solve(0, k);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dp[510][510];
int main() {
int n;
cin >> n;
vector<int> s(n), t;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < 510; ++i)
for (int j = 0; j < 510; ++j) dp[i][j] = 0;
for (int l = 1; l <= n; ++l) {
for (int i = 0, j = l - 1; j < n; ++i, ++j) {
if (i == j)
dp[i][j] = 1;
else {
dp[i][j] = 1 + dp[i + 1][j];
if (s[i] == s[i + 1]) {
dp[i][j] = min(dp[i][j], 1 + dp[i + 2][j]);
}
for (int k = i + 2; k <= j; ++k)
if (s[i] == s[k]) {
dp[i][j] = min(dp[i + 1][k - 1] + dp[k + 1][j], dp[i][j]);
}
}
}
}
cout << dp[0][n - 1] << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9 + 7;
const long long Inf = 1e18 + 7;
const int maxn = 2e5 + 5;
const long long mod = 998244353;
int n;
int a[maxn], t[maxn];
struct cmp {
bool operator()(const pair<int, int>& a, const pair<int, int>& b) {
return a.second < b.second;
}
};
priority_queue<pair<int, int>, vector<pair<int, int> >, cmp> q;
map<int, int> fa;
int find(int x) { return fa[x] == 0 ? x : fa[x] = find(fa[x]); }
void ba(int x, int y) {
int px = find(x), py = find(y);
if (px > py) {
fa[py] = px;
} else {
fa[px] = py;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
cin >> t[i];
q.push(pair<int, int>(a[i], t[i]));
}
long long ans = 0;
while (!q.empty()) {
pair<int, int> p = q.top();
q.pop();
ans += 1ll * (find(p.first) - p.first) * p.second;
ba(find(p.first), find(p.first) + 1);
}
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4,avx2,abm,fma,tune=native")
#pragma GCC optimize("fast-math")
using namespace std;
const char nl = '\n';
const double INF = 1e36;
const double EPS = 1e-9;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
struct pt {
double x, y;
pt(const double& _x = 0, const double& _y = 0) : x(_x), y(_y) {}
pt operator+(const pt& o) const { return pt(x + o.x, y + o.y); }
pt operator-(const pt& o) const { return pt(x - o.x, y - o.y); }
};
pt operator*(const double& c, const pt& v) { return pt(c * v.x, c * v.y); }
inline int sqr(int x) { return x * x; }
int sgn(const double& x) { return x < -EPS ? -1 : x <= EPS ? 0 : 1; }
inline double cp(const pt& a, const pt& b) { return a.x * b.y - a.y * b.x; }
inline double dp(const pt& a, const pt& b) { return a.x * b.x + a.y * b.y; }
inline double cpl(const pt& a, const pt& b) { return a.x * b.y - a.y * b.x; }
inline double dpl(const pt& a, const pt& b) { return a.x * b.x + a.y * b.y; }
inline pt line_inter(const pt& a, const pt& b, const pt& c, const pt& d) {
return a + cpl(c - a, d - c) / cpl(b - a, d - c) * (b - a);
}
struct Car {
pt v, d;
int s;
Car(int x, int y, int dx, int dy, int _s) : v(x, y), d(dx, dy), s(_s) {}
double hit(const pt& it) const {
pt len = it - (v);
return sgn(dpl(len, (d))) >= 0 ? dpl(len, len) / sqr(s) : INF;
}
};
double parallel(const Car& a, const Car& b) {
pt len = b.v - a.v;
if (sgn(cp(len, a.d)) != 0) return INF;
int da = sgn(dp(len, a.d)), db = sgn(dp(len, b.d));
if (da >= 0 && db <= 0) return dp(len, len) / (double)sqr(a.s + b.s);
if (da >= 0 && db >= 0 && a.s != b.s) return dp(len, len) / (double)sqr(a.s);
if (da <= 0 && db <= 0 && a.s != b.s) return dp(len, len) / (double)sqr(b.s);
return INF;
}
double collide(const Car& a, const Car& b) {
if (sgn(cp(a.d, b.d)) == 0) return parallel(a, b);
pt it = line_inter((a.v), (a.v + a.d), (b.v), (b.v + b.d));
return max(a.hit(it), b.hit(it));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int n;
cin >> n;
vector<Car> v;
for (int i = 0; i < n; i++) {
int x, y, dx, dy, s;
cin >> x >> y >> dx >> dy >> s;
v.emplace_back(x, y, dx, dy, s);
}
double ans = INF;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
ans = min(ans, collide(v[i], v[j]));
}
}
if (ans < INF) {
cout << sqrt(ans) << nl;
} else {
cout << "No show :(" << nl;
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(char a, char b) { return a > b; }
signed main() {
long long t;
cin >> t;
while (t--) {
long long ch[27] = {};
char ans[55] = {};
string s;
vector<long long> v;
long long n, pos, a[55];
cin >> s >> n;
long long ac = n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < s.size(); i++) {
ch[s[i] - 'a']++;
}
long long tmp = 256;
while (n) {
for (long long i = 0; i < ac; i++) {
if (a[i] == 0) {
v.push_back(i);
a[i]--;
}
}
for (long long i = 26; i >= 0; i--) {
if (ch[i] >= v.size() && i < tmp) {
tmp = i;
for (auto x : v) {
ans[x] = char(i + 'a');
for (long long j = 0; j < ac; j++) {
a[j] -= abs(j - x);
}
ch[i] = 0;
n--;
}
v.clear();
break;
}
}
}
for (long long i = 0; i < ac; i++) {
cout << ans[i];
}
cout << '\n';
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, a, ans[200005], A[200005], root = -1, f;
bool b[200005];
vector<int> v[200005];
vector<int> cyc;
void dfs(int u, int p) {
for (auto x : v[u]) {
if (b[x] && x != p) {
if (A[x] == u)
cyc.push_back(x);
else
cyc.push_back(u);
} else if (!b[x]) {
b[x] = 1;
dfs(x, u);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
if (A[i] == i) {
root = i;
f = 1;
}
v[i].push_back(A[i]);
v[A[i]].push_back(i);
ans[i] = A[i];
}
for (int i = 1; i <= n; i++) {
if (!b[i]) b[i] = 1, dfs(i, -1);
}
if (root == -1) {
root = cyc[0];
}
for (int i = 0; i < (int)cyc.size(); i++) ans[cyc[i]] = root;
int q = 0;
for (int i = 1; i <= n; i++)
if (A[i] != ans[i]) q++;
printf("%d\n", q);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int &x : v) {
cin >> x;
}
int len = ceil((int)v.size() / 2.0);
int d = 0;
for (int i = -1000; i <= 1000; i++) {
if (i == 0) continue;
int pos = 0;
for (int j = 0; j < n; j++) {
if (v[j] == 0) continue;
if (i < 0 && v[j] < 0) pos++;
if (i > 0 && v[j] > 0) pos++;
}
if (pos >= len) {
cout << i << endl;
return 0;
}
}
cout << d << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
auto And = [&](int x, int y) {
cout << "and " << x + 1 << " " << y + 1 << endl;
int ret;
cin >> ret;
return ret;
};
auto Or = [&](int x, int y) {
cout << "or " << x + 1 << " " << y + 1 << endl;
int ret;
cin >> ret;
return ret;
};
vector<int> a(n), b(n);
for (int i = 1; i < n; ++i) {
int x = And(0, i), y = Or(0, i);
b[i] = x + y;
}
int tmp = And(1, 2) + Or(1, 2);
a[1] = ((b[1] - b[2]) + tmp) / 2;
a[0] = b[1] - a[1];
for (int i = 2; i < n; ++i) a[i] = b[i] - a[0];
vector<int> ord(n);
iota(ord.begin(), ord.end(), 0);
sort(ord.begin(), ord.end(), [&](int x, int y) { return a[x] < a[y]; });
cout << "finish " << a[ord[k - 1]] << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long llINF = 1e18;
const int MAXN = 3e5 + 5;
namespace FastIO {
char buf[1 << 23], *p1 = buf, *p2 = buf;
int read() {
static int x, f;
static char ch;
x = 0, f = 1;
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
}
return x * f;
}
long long readll() {
static long long x, f;
static char ch;
x = 0, f = 1;
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
}
while (isdigit(ch)) {
x = (x << 1ll) + (x << 3ll) + (ch ^ 48);
ch =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
}
return x * f;
}
} // namespace FastIO
using FastIO::read;
using FastIO::readll;
int n, Q;
long long a[MAXN];
struct Query {
int type;
long long l, r;
} q[MAXN];
namespace SegmentTree {
struct Tree {
int l, r, len;
int cov, rev, sum;
} tree[MAXN << 2];
void update(int k) { tree[k].sum = tree[k << 1].sum + tree[k << 1 | 1].sum; }
void applyCov(int k, int v) {
tree[k].cov = v;
tree[k].rev = 0;
tree[k].sum = tree[k].len * v;
}
void applyRev(int k) {
tree[k].cov != -1 ? tree[k].cov ^= 1 : tree[k].rev ^= 1;
tree[k].sum = tree[k].len - tree[k].sum;
}
void down(int k) {
if (tree[k].cov != -1) {
applyCov(k << 1, tree[k].cov);
applyCov(k << 1 | 1, tree[k].cov);
tree[k].cov = -1;
}
if (tree[k].rev) {
applyRev(k << 1);
applyRev(k << 1 | 1);
tree[k].rev = 0;
}
}
void Build(int k, int l, int r) {
tree[k].l = l;
tree[k].r = r;
tree[k].len = r - l + 1;
tree[k].sum = tree[k].rev = 0;
tree[k].cov = -1;
if (l == r) return;
int mid = (l + r) >> 1;
Build(k << 1, l, mid);
Build(k << 1 | 1, mid + 1, r);
update(k);
}
void Modify(int k, int l, int r, int type) {
if (tree[k].l >= l && tree[k].r <= r) {
if (type == 1)
applyCov(k, 1);
else if (type == 2)
applyCov(k, 0);
else if (type == 3)
applyRev(k);
return;
}
down(k);
int mid = (tree[k].l + tree[k].r) >> 1;
if (l <= mid) Modify(k << 1, l, r, type);
if (r > mid) Modify(k << 1 | 1, l, r, type);
update(k);
}
int Query(int k) {
if (tree[k].l == tree[k].r) return tree[k].l;
down(k);
if (tree[k << 1].sum < tree[k << 1].len)
return Query(k << 1);
else
return Query(k << 1 | 1);
}
} // namespace SegmentTree
int main() {
Q = read();
a[++n] = 1;
for (int i = 1; i <= Q; i++) {
int t = read();
long long l = readll(), r = readll();
q[i] = (Query){t, l, r};
a[++n] = l;
a[++n] = r;
a[++n] = r + 1;
}
sort(a + 1, a + 1 + n);
n = unique(a + 1, a + 1 + n) - a - 1;
SegmentTree::Build(1, 1, n);
for (int i = 1; i <= Q; i++) {
int l = lower_bound(a + 1, a + 1 + n, q[i].l) - a;
int r = lower_bound(a + 1, a + 1 + n, q[i].r) - a;
SegmentTree::Modify(1, l, r, q[i].type);
printf("%lld\n", a[SegmentTree::Query(1)]);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
if (k % 2 == 0) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
if (k == 1) {
cout << 2 << " " << 1 << endl;
cout << 1 << " " << 2 << endl;
return 0;
}
int n = k + 2;
int m = n * k;
cout << 2 * n << " " << m << endl;
for (int i = 2; i <= k; i++) {
cout << 1 << " " << i << endl;
cout << n + 1 << " " << n + i << endl;
}
for (int i = 2; i <= k; i++)
for (int j = i + 1; j <= k; j++) {
if (i % 2 == 0 && j == i + 1) continue;
cout << i << " " << j << endl;
cout << n + i << " " << n + j << endl;
}
for (int i = 2; i <= k; i++) {
cout << i << " " << k + 1 << endl;
cout << i << " " << k + 2 << endl;
cout << n + i << " " << n + k + 1 << endl;
cout << n + i << " " << n + k + 2 << endl;
}
cout << k + 1 << " " << k + 2 << endl;
cout << n + k + 1 << " " << n + k + 2 << endl;
cout << 1 << " " << n + 1 << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 60;
long long n, arr[N], dp[N][2];
long long fun(long long i, long long flag) {
if (i > n) {
return 0;
}
if (dp[i][flag] != -1) {
return dp[i][flag];
}
if (flag == 1) {
return dp[i][flag] =
max(arr[i] + fun(i + 1, (long long)2), fun(i + 1, (long long)1));
} else {
return dp[i][flag] =
min(arr[i] + fun(i + 1, (long long)2), fun(i + 1, (long long)1));
}
}
long long power_mod(long long x, long long y) {
x %= 1000000007;
long long res = 1;
while (y) {
if (y & 1) {
res = (res * x) % 1000000007;
}
y /= 2;
x = (x * x) % 1000000007;
}
return res;
}
void solve() {
long long total = 0;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> arr[i];
total += arr[i];
}
memset(dp, -1, sizeof(dp));
fun((long long)1, (long long)1);
cout << total - dp[1][1] << " " << dp[1][1] << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int tc = 1;
while (tc--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string s[60];
int dp[60][60][60][60];
inline bool can(int i, int j) {
return ((s[i][0] == s[j][0]) || (s[i][1] == s[j][1]));
}
int rec(int len, int x, int y, int z) {
if (len == 3) return 1;
if (dp[len][x][y][z] != -1) return dp[len][x][y][z];
int ret = 0;
if (can(y, z)) ret |= rec(len - 1, len - 3, x, z);
if (len - 3 >= 3 && can(len - 3, z)) ret |= rec(len - 1, z, x, y);
return dp[len][x][y][z] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(dp, -1, sizeof dp);
int n;
cin >> n;
for (int i = 3; i <= n + 2; i++) cin >> s[i];
if (rec(n + 2, n, n + 1, n + 2))
cout << "YES\n";
else
cout << "NO\n";
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
const long long N = 2e5 + 1;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long power(long long a, long long b = mod - 2) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long t;
cin >> t;
;
while (t--) {
long long n, a, b, h;
cin >> n >> a >> b >> h;
string s;
cin >> s;
;
long long sum = 0;
for (char c : s)
if (c == '0')
sum += min(a, b + h);
else
sum += min(b, a + h);
cout << sum << '\n';
;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int cnt[3000] = {
4784, 8978, 12981, 16901, 20732, 24523, 28249, 31916,
35585, 39176, 42818, 46430, 49962, 53516, 57023, 60523,
64040, 67489, 70985, 74417, 77879, 81285, 84679, 88055,
91433, 94878, 98240, 101608, 104979, 108284, 111653, 115039,
118375, 121695, 124997, 128270, 131626, 134912, 138219, 141503,
144830, 148121, 151368, 154619, 157925, 161166, 164444, 167675,
170946, 174194, 177433, 180617, 183844, 187048, 190283, 193493,
196709, 199900, 203111, 206333, 209526, 212732, 215966, 219123,
222272, 225463, 228651, 231844, 235069, 238261, 241443, 244581,
247733, 250868, 253974, 257141, 260352, 263482, 266623, 269760,
272885, 276014, 279149, 282271, 285396, 288556, 291710, 294878,
297984, 301101, 304177, 307326, 310444, 313579, 316642, 319813,
322904, 326007, 329106, 332181, 335268, 338394, 341465, 344551,
347665, 350739, 353840, 356909, 360000, 363080, 366160, 369261,
372328, 375439, 378518, 381635, 384728, 387817, 390920, 393993,
397033, 400087, 403209, 406288, 409309, 412333, 415431, 418499,
421556, 424569, 427583, 430660, 433680, 436753, 439791, 442818,
445857, 448901, 451962, 454974, 457972, 461015, 464069, 467135,
470153, 473178, 476215, 479250, 482265, 485275, 488279, 491293,
494311, 497242, 500236, 503251, 506276, 509308, 512383, 515414,
518404, 521398, 524428, 527422, 530472, 533469, 536442, 539450,
542467, 545501, 548499, 551461, 554513, 557493, 560489, 563514,
566514, 569508, 572481, 575503, 578464, 581445, 584484, 587448,
590416, 593357, 596373, 599365, 602379, 605357, 608340, 611346,
614316, 617284, 620283, 623219, 626204, 629187, 632137, 635171,
638124, 641088, 644018, 646968, 649933, 652929, 655897, 658857,
661819, 664771, 667743, 670676, 673688, 676670, 679672, 682576,
685541, 688504, 691478, 694490, 697405, 700326, 703273, 706181,
709115, 712113, 715038, 717989, 720960, 723896, 726882, 729831,
732782, 735740, 738676, 741606, 744563, 747458, 750384, 753318,
756217, 759188, 762199, 765150, 768087, 771012, 773928, 776896,
779827, 782754, 785698, 788611, 791513, 794449, 797361, 800286,
803241, 806180, 809116, 812028, 814963, 817868, 820796, 823752,
826720, 829643, 832596, 835498, 838436, 841364, 844292, 847194,
850080, 853022, 855895, 858875, 861761, 864672, 867592, 870514,
873482, 876358, 879282, 882186, 885138, 888023, 890933, 893857,
896758, 899686, 902573, 905460, 908421, 911332, 914214, 917110,
920007, 922881, 925822, 928780, 931678, 934604, 937520, 940453,
943326, 946295, 949181, 952088, 955026, 957871, 960726, 963624,
966507, 969407, 972309, 975196, 978085, 980962, 983867, 986746,
989647, 992538, 995405, 998272, 1001141, 1004047, 1006935, 1009828,
1012698, 1015619, 1018497, 1021407, 1024321, 1027185, 1030064, 1032962,
1035803, 1038722, 1041665, 1044521, 1047338, 1050175, 1053074, 1055897,
1058798, 1061676, 1064500, 1067388, 1070268, 1073174, 1076029, 1078883,
1081790, 1084692, 1087554, 1090413, 1093331, 1096221, 1099056, 1101903,
1104801, 1107645, 1110568, 1113425, 1116309, 1119226, 1122066, 1124941,
1127772, 1130652, 1133559, 1136475, 1139334, 1142195, 1145026, 1147867,
1150738, 1153592, 1156490, 1159339, 1162244, 1165140, 1168043, 1170911,
1173746, 1176591, 1179444, 1182370, 1185244, 1188093, 1190925, 1193801,
1196660, 1199545, 1202432, 1205285, 1208198, 1211026, 1213868, 1216688,
1219588, 1222393, 1225259, 1228119, 1230996, 1233830, 1236682, 1239605,
1242422, 1245272, 1248112, 1250996, 1253792, 1256652, 1259537, 1262363,
1265205, 1268047, 1270890, 1273689, 1276506, 1279377, 1282286, 1285127,
1287980, 1290771, 1293580, 1296434, 1299249, 1302081, 1304899, 1307765,
1310565, 1313437, 1316314, 1319179, 1321953, 1324799, 1327680, 1330570,
1333417, 1336222, 1339091, 1341880, 1344730, 1347558, 1350402, 1353252,
1356098, 1358925, 1361746, 1364529, 1367411, 1370266, 1373089, 1375934,
1378787, 1381608, 1384448, 1387240, 1390062, 1392850, 1395709, 1398555,
1401374, 1404179, 1407069, 1409899, 1412745, 1415626, 1418381, 1421271,
1424100, 1426913, 1429775, 1432595, 1435430, 1438258, 1441129, 1443939,
1446779, 1449605, 1452383, 1455248, 1458083, 1460920, 1463729, 1466529,
1469369, 1472195, 1475031, 1477838, 1480667, 1483501, 1486323, 1489166,
1491981, 1494787, 1497648, 1500453, 1503239, 1506081, 1508873, 1511686,
1514527, 1517367, 1520184, 1523011, 1525806, 1528622, 1531402, 1534201,
1536997, 1539894, 1542683, 1545503, 1548241, 1551093, 1553884, 1556702,
1559565, 1562352, 1565117, 1567943, 1570716, 1573536, 1576359, 1579176,
1581960, 1584772, 1587542, 1590356, 1593212, 1596005, 1598783, 1601564,
1604386, 1607165, 1609974, 1612824, 1615617, 1618452, 1621217, 1624007,
1626767, 1629636, 1632421, 1635222, 1637991, 1640857, 1643718, 1646485,
1649297, 1652064, 1654854, 1657619, 1660460, 1663265, 1666081, 1668892,
1671700, 1674594, 1677356, 1680125, 1682935, 1685691, 1688539, 1691341,
1694101, 1696863, 1699639, 1702441, 1705278, 1708110, 1710912, 1713725,
1716510, 1719267, 1722095, 1724880, 1727671, 1730436, 1733217, 1736052,
1738807, 1741642, 1744421, 1747205, 1750007, 1752772, 1755537, 1758337,
1761093, 1763839, 1766647, 1769444, 1772246, 1775046, 1777876, 1780671,
1783464, 1786236, 1789019, 1791841, 1794680, 1797448, 1800274, 1803074,
1805871, 1808647, 1811416, 1814143, 1816933, 1819707, 1822528, 1825244,
1828005, 1830793, 1833548, 1836360, 1839214, 1841996, 1844792, 1847581,
1850327, 1853089, 1855856, 1858663, 1861433, 1864207, 1866991, 1869796,
1872540, 1875345, 1878117, 1880878, 1883646, 1886490, 1889297, 1892075,
1894867, 1897679, 1900521, 1903296, 1906069, 1908797, 1911589, 1914346,
1917129, 1919906, 1922737, 1925489, 1928318, 1931029, 1933873, 1936618,
1939421, 1942195, 1944975, 1947727, 1950518, 1953327, 1956076, 1958882,
1961653, 1964430, 1967231, 1969999, 1972724, 1975510, 1978238, 1981017,
1983809, 1986618, 1989438, 1992205, 1994950, 1997721, 2000489, 2003304,
2006033, 2008816, 2011607, 2014373, 2017180, 2019933, 2022702, 2025513,
2028256, 2031020, 2033803, 2036610, 2039323, 2042136, 2044905, 2047682,
2050502, 2053230, 2055971, 2058719, 2061484, 2064275, 2067035, 2069780,
2072561, 2075349, 2078104, 2080845, 2083584, 2086330, 2089097, 2091864,
2094672, 2097407, 2100185, 2102972, 2105738, 2108433, 2111259, 2113990,
2116784, 2119527, 2122304, 2125069, 2127838, 2130618, 2133419, 2136173,
2138962, 2141713, 2144481, 2147172, 2149924, 2152702, 2155442, 2158237,
2161008, 2163758, 2166537, 2169247, 2171965, 2174706, 2177470, 2180269,
2183018, 2185806, 2188547, 2191332, 2194100, 2196835, 2199596, 2202324,
2205083, 2207860, 2210669, 2213444, 2216182, 2218953, 2221739, 2224515,
2227246, 2230006, 2232708, 2235482, 2238231, 2240991, 2243756, 2246480,
2249227, 2252025, 2254788, 2257554, 2260312, 2263079, 2265828, 2268545,
2271245, 2274003, 2276736, 2279483, 2282217, 2284983, 2287747, 2290512,
2293240, 2295997, 2298702, 2301494, 2304177, 2306931, 2309704, 2312443,
2315163, 2317910, 2320691, 2323417, 2326186, 2328942, 2331676, 2334374,
2337139, 2339871, 2342642, 2345411, 2348163, 2350887, 2353608, 2356373,
2359139, 2361872, 2364678, 2367432, 2370149, 2372878, 2375651, 2378388,
2381162, 2383896, 2386653, 2389450, 2392222, 2394902, 2397618, 2400363,
2403099, 2405857, 2408603, 2411351, 2414127, 2416904, 2419627, 2422296,
2425056, 2427745, 2430503, 2433251, 2436001, 2438719, 2441528, 2444352,
2447016, 2449765, 2452482, 2455256, 2458031, 2460744, 2463429, 2466187,
2468912, 2471679, 2474403, 2477113, 2479832, 2482617, 2485399, 2488154,
2490869, 2493631, 2496331, 2499026, 2501804, 2504528, 2507234, 2509986,
2512726, 2515473, 2518175, 2520875, 2523614, 2526330, 2529122, 2531839,
2534604, 2537308, 2540008, 2542791, 2545541, 2548284, 2551055, 2553802,
2556546, 2559256, 2562021, 2564750, 2567510, 2570148, 2572929, 2575664,
2578403, 2581128, 2583836, 2586615, 2589384, 2592090, 2594819, 2597536,
2600254, 2602944, 2605706, 2608394, 2611086, 2613806, 2616565, 2619321,
2622048, 2624787, 2627470, 2630206, 2632916, 2635613, 2638344, 2641068,
2643874, 2646581, 2649274, 2651923, 2654664, 2657389, 2660089, 2662840,
2665564, 2668329, 2671039, 2673788, 2676540, 2679254, 2682014, 2684761,
2687515, 2690185, 2692884, 2695614, 2698331, 2701067, 2703798, 2706497,
2709174, 2711871, 2714585, 2717374, 2720152, 2722854, 2725559, 2728236,
2730937, 2733698, 2736447, 2739146, 2741927, 2744682, 2747379, 2750078,
2752811, 2755521, 2758290, 2761026, 2763725, 2766426, 2769153, 2771910,
2774616, 2777363, 2780032, 2782759, 2785459, 2788181, 2790935, 2793661,
2796375, 2799109, 2801844, 2804531, 2807261, 2809930, 2812655, 2815400,
2818088, 2820817, 2823539, 2826276, 2828967, 2831689, 2834417, 2837100,
2839799, 2842571, 2845296, 2847955, 2850686, 2853362, 2856131, 2858814,
2861494, 2864215, 2866912, 2869649, 2872353, 2875061, 2877770, 2880505,
2883226, 2885940, 2888661, 2891324, 2894042, 2896737, 2899482, 2902173,
2904857, 2907606, 2910319, 2913026, 2915749, 2918453, 2921165, 2923834,
2926597, 2929265, 2931966, 2934703, 2937422, 2940118, 2942867, 2945636,
2948312, 2951035, 2953764, 2956447, 2959193, 2961881, 2964616, 2967240,
2969938, 2972638, 2975367, 2978051, 2980755, 2983431, 2986123, 2988902,
2991612, 2994331, 2997075, 2999799, 3002504, 3005203, 3007900, 3010597,
3013324, 3016009, 3018743, 3021417, 3024129, 3026843, 3029542, 3032258,
3034938, 3037647, 3040326, 3043022, 3045754, 3048458, 3051170, 3053831,
3056533, 3059268, 3061963, 3064626, 3067352, 3069997, 3072755, 3075490,
3078186, 3080941, 3083637, 3086305, 3089049, 3091766, 3094461, 3097083,
3099791, 3102503, 3105214, 3107929, 3110676, 3113376, 3116121, 3118822,
3121506, 3124226, 3126914, 3129663, 3132389, 3135041, 3137800, 3140465,
3143179, 3145895, 3148595, 3151359, 3154060, 3156704, 3159381, 3162037,
3164764, 3167422, 3170165, 3172860, 3175583, 3178276, 3180981, 3183679,
3186336, 3189067, 3191741, 3194439, 3197144, 3199905, 3202633, 3205350,
3208093, 3210815, 3213514, 3216212, 3218845, 3221531, 3224234, 3226984,
3229664, 3232326, 3235040, 3237756, 3240412, 3243108, 3245793, 3248448,
3251142, 3253794, 3256465, 3259118, 3261786, 3264499, 3267184, 3269881,
3272566, 3275208, 3277990, 3280684, 3283348, 3286023, 3288733, 3291422,
3294158, 3296809, 3299511, 3302209, 3304882, 3307587, 3310219, 3312951,
3315658, 3318340, 3321024, 3323750, 3326372, 3329060, 3331730, 3334387,
3337067, 3339778, 3342472, 3345126, 3347848, 3350545, 3353226, 3355956,
3358630, 3361303, 3363969, 3366670, 3369387, 3372104, 3374796, 3377477,
3380175, 3382885, 3385555, 3388181, 3390855, 3393551, 3396270, 3398959,
3401658, 3404348, 3407022, 3409749, 3412424, 3415112, 3417799, 3420476,
3423164, 3425804, 3428513, 3431140, 3433831, 3436495, 3439209, 3441873,
3444597, 3447272, 3450005, 3452685, 3455326, 3458010, 3460716, 3463433,
3466044, 3468740, 3471402, 3474095, 3476807, 3479443, 3482094, 3484813,
3487498, 3490171, 3492860, 3495568, 3498297, 3500974, 3503652, 3506387,
3509080, 3511783, 3514444, 3517154, 3519834, 3522520, 3525176, 3527908,
3530582, 3533256, 3535969, 3538668, 3541338, 3543978, 3546667, 3549376,
3552022, 3554739, 3557385, 3560090, 3562780, 3565457, 3568117, 3570777,
3573441, 3576162, 3578838, 3581527, 3584202, 3586899, 3589608, 3592224,
3594895, 3597609, 3600284, 3602937, 3605598, 3608315, 3611057, 3613719,
3616375, 3619063, 3621779, 3624437, 3627138, 3629813, 3632494, 3635172,
3637897, 3640546, 3643225, 3645881, 3648522, 3651242, 3653950, 3656685,
3659419, 3662084, 3664727, 3667446, 3670105, 3672775, 3675493, 3678172,
3680848, 3683590, 3686168, 3688865, 3691503, 3694149, 3696775, 3699495,
3702151, 3704779, 3707476, 3710195, 3712861, 3715571, 3718229, 3720907,
3723622, 3726326, 3729014, 3731697, 3734399, 3737057, 3739687, 3742387,
3745052, 3747736, 3750447, 3753093, 3755763, 3758470, 3761125, 3763798,
3766488, 3769101, 3771838, 3774512, 3777096, 3779799, 3782494, 3785161,
3787804, 3790455, 3793100, 3795810, 3798471, 3801142, 3803841, 3806532,
3809252, 3811893, 3814570, 3817240, 3819899, 3822594, 3825303, 3827949,
3830626, 3833257, 3835966, 3838551, 3841206, 3843893, 3846531, 3849184,
3851821, 3854488, 3857123, 3859809, 3862541, 3865213, 3867908, 3870566,
3873197, 3875855, 3878498, 3881127, 3883820, 3886491, 3889196, 3891882,
3894547, 3897254, 3899883, 3902460, 3905110, 3907779, 3910369, 3913050,
3915712, 3918400, 3921049, 3923696, 3926401, 3929085, 3931738, 3934443,
3937079, 3939772, 3942498, 3945191, 3947875, 3950555, 3953194, 3955921,
3958645, 3961297, 3963906, 3966568, 3969211, 3971880, 3974536, 3977155,
3979753, 3982460, 3985072, 3987720, 3990416, 3993126, 3995735, 3998438,
4001109, 4003807, 4006464, 4009128, 4011827, 4014469, 4017140, 4019846,
4022481, 4025096, 4027765, 4030424, 4033095, 4035734, 4038441, 4041068,
4043777, 4046464, 4049121, 4051770, 4054424, 4057114, 4059771, 4062451,
4065123, 4067794, 4070475, 4073176, 4075821, 4078473, 4081177, 4083782,
4086435, 4089090, 4091774, 4094421, 4097099, 4099748, 4102417, 4105056,
4107702, 4110356, 4113050, 4115722, 4118385, 4121052, 4123728, 4126380,
4129050, 4131700, 4134353, 4137024, 4139686, 4142364, 4145061, 4147677,
4150324, 4153011, 4155686, 4158364, 4160967, 4163597, 4166236, 4168923,
4171606, 4174224, 4176870, 4179522, 4182183, 4184850, 4187489, 4190141,
4192811, 4195422, 4198063, 4200732, 4203355, 4206045, 4208687, 4211357,
4213982, 4216686, 4219357, 4221985, 4224628, 4227283, 4229915, 4232565,
4235233, 4237862, 4240503, 4243170, 4245785, 4248402, 4251066, 4253702,
4256360, 4259015, 4261661, 4264294, 4266922, 4269625, 4272264, 4274957,
4277598, 4280202, 4282798, 4285399, 4288065, 4290688, 4293351, 4296021,
4298654, 4301295, 4303982, 4306609, 4309218, 4311887, 4314529, 4317235,
4319923, 4322593, 4325294, 4327912, 4330591, 4333234, 4335879, 4338516,
4341144, 4343802, 4346451, 4349053, 4351735, 4354389, 4357049, 4359663,
4362342, 4364926, 4367588, 4370299, 4372936, 4375553, 4378193, 4380845,
4383575, 4386240, 4388879, 4391542, 4394200, 4396851, 4399521, 4402187,
4404832, 4407487, 4410086, 4412694, 4415371, 4418023, 4420721, 4423372,
4425992, 4428609, 4431243, 4433902, 4436580, 4439170, 4441823, 4444490,
4447138, 4449673, 4452307, 4454923, 4457555, 4460241, 4462894, 4465544,
4468140, 4470785, 4473457, 4476148, 4478750, 4481417, 4484076, 4486724,
4489312, 4492007, 4494652, 4497293, 4499966, 4502619, 4505253, 4507856,
4510573, 4513194, 4515919, 4518560, 4521186, 4523774, 4526427, 4529073,
4531708, 4534347, 4536968, 4539593, 4542204, 4544861, 4547523, 4550196,
4552844, 4555492, 4558141, 4560804, 4563438, 4566061, 4568706, 4571337,
4574015, 4576657, 4579285, 4581977, 4584687, 4587326, 4589993, 4592654,
4595266, 4597877, 4600572, 4603201, 4605817, 4608469, 4611140, 4613737,
4616385, 4619006, 4621593, 4624232, 4626876, 4629508, 4632187, 4634797,
4637399, 4640031, 4642678, 4645360, 4647919, 4650560, 4653231, 4655889,
4658586, 4661190, 4663804, 4666451, 4669055, 4671705, 4674351, 4676997,
4679633, 4682243, 4684949, 4687533, 4690161, 4692790, 4695463, 4698103,
4700735, 4703363, 4706007, 4708643, 4711274, 4713900, 4716608, 4719202,
4721853, 4724481, 4727184, 4729855, 4732496, 4735168, 4737851, 4740486,
4743083, 4745721, 4748367, 4750950, 4753627, 4756289, 4758913, 4761561,
4764205, 4766823, 4769430, 4772013, 4774673, 4777296, 4779967, 4782597,
4785262, 4787905, 4790546, 4793167, 4795770, 4798436, 4801064, 4803668,
4806333, 4808985, 4811623, 4814267, 4816891, 4819529, 4822161, 4824805,
4827436, 4830058, 4832685, 4835379, 4838000, 4840681, 4843322, 4845982,
4848640, 4851212, 4853838, 4856492, 4859127, 4861763, 4864388, 4867028,
4869676, 4872296, 4874854, 4877529, 4880180, 4882798, 4885427, 4888078,
4890746, 4893365, 4896011, 4898673, 4901286, 4903891, 4906512, 4909157,
4911785, 4914384, 4917033, 4919690, 4922306, 4924919, 4927573, 4930213,
4932818, 4935488, 4938140, 4940775, 4943379, 4946070, 4948680, 4951297,
4953911, 4956558, 4959210, 4961878, 4964538, 4967185, 4969806, 4972410,
4975039, 4977662, 4980311, 4982941, 4985647, 4988226, 4990898, 4993516,
4996145, 4998802, 5001443, 5004057, 5006709, 5009406, 5012065, 5014695,
5017340, 5019950, 5022572, 5025179, 5027802, 5030447, 5033047, 5035681,
5038280, 5040863, 5043508, 5046095, 5048766, 5051412, 5054025, 5056629,
5059278, 5061913, 5064512, 5067205, 5069825, 5072492, 5075114, 5077659,
5080256, 5082860, 5085500, 5088135, 5090728, 5093333, 5095989, 5098616,
5101203, 5103826, 5106459, 5109090, 5111744, 5114362, 5116967, 5119591,
5122214, 5124845, 5127515, 5130154, 5132783, 5135431, 5138076, 5140731,
5143346, 5145981, 5148606, 5151275, 5153900, 5156547, 5159150, 5161734,
5164342, 5166954, 5169574, 5172232, 5174885, 5177522, 5180106, 5182723,
5185364, 5187966, 5190596, 5193213, 5195881, 5198500, 5201126, 5203797,
5206415, 5209050, 5211713, 5214289, 5216846, 5219488, 5222091, 5224741,
5227387, 5230075, 5232642, 5235256, 5237883, 5240497, 5243171, 5245787,
5248349, 5250964, 5253604, 5256295, 5258925, 5261560, 5264198, 5266812,
5269432, 5272057, 5274678, 5277359, 5279981, 5282588, 5285176, 5287825,
5290378, 5292984, 5295576, 5298144, 5300709, 5303300, 5305965, 5308565,
5311160, 5313783, 5316423, 5319019, 5321597, 5324214, 5326785, 5329410,
5332021, 5334623, 5337228, 5339868, 5342497, 5345130, 5347796, 5350422,
5353090, 5355703, 5358368, 5360987, 5363545, 5366148, 5368777, 5371412,
5374088, 5376687, 5379310, 5381929, 5384561, 5387172, 5389785, 5392412,
5395046, 5397629, 5400260, 5402887, 5405527, 5408176, 5410794, 5413434,
5415999, 5418615, 5421235, 5423862, 5426485, 5429133, 5431730, 5434359,
5436989, 5439576, 5442164, 5444785, 5447430, 5450050, 5452630, 5455226,
5457874, 5460458, 5463064, 5465636, 5468292, 5470840, 5473438, 5476040,
5478624, 5481234, 5483862, 5486492, 5489062, 5491685, 5494277, 5496930,
5499560, 5502195, 5504849, 5507484, 5510039, 5512631, 5515229, 5517813,
5520451, 5523148, 5525740, 5528354, 5530960, 5533526, 5536136, 5538821,
5541485, 5544171, 5546787, 5549334, 5551962, 5554594, 5557156, 5559794,
5562401, 5564989, 5567668, 5570318, 5572922, 5575559, 5578173, 5580735,
5583348, 5585968, 5588600, 5591257, 5593883, 5596537, 5599126, 5601766,
5604343, 5606978, 5609544, 5612150, 5614795, 5617364, 5619974, 5622604,
5625220, 5627890, 5630520, 5633085, 5635731, 5638332, 5640958, 5643587,
5646179, 5648777, 5651328, 5653955, 5656616, 5659237, 5661891, 5664467,
5667110, 5669724, 5672315, 5674898, 5677516, 5680112, 5682698, 5685283,
5687873, 5690537, 5693138, 5695725, 5698354, 5700962, 5703597, 5706173,
5708793, 5711418, 5713948, 5716608, 5719236, 5721870, 5724432, 5727030,
5729670, 5732291, 5734927, 5737555, 5740151, 5742760, 5745303, 5747922,
5750484, 5753109, 5755700, 5758284, 5760903, 5763488, 5766103, 5768742,
5771329, 5773921, 5776526, 5779099, 5781662, 5784324, 5786983, 5789590,
5792263, 5794904, 5797482, 5800089, 5802685, 5805349, 5807963, 5810588,
5813145, 5815758, 5818375, 5820930, 5823533, 5826127, 5828742, 5831423,
5834055, 5836688, 5839332, 5841893, 5844529, 5847110, 5849741, 5852352,
5854947, 5857519, 5860154, 5862786, 5865406, 5868021, 5870662, 5873255,
5875845, 5878520, 5881140, 5883729, 5886329, 5888952, 5891561, 5894167,
5896791, 5899352, 5901946, 5904577, 5907199, 5909822, 5912399, 5914980,
5917583, 5920157, 5922796, 5925412, 5928032, 5930672, 5933314, 5935941,
5938528, 5941165, 5943777, 5946380, 5949001, 5951600, 5954206, 5956845,
5959490, 5962107, 5964740, 5967358, 5969954, 5972550, 5975142, 5977742,
5980358, 5982939, 5985529, 5988135, 5990733, 5993379, 5995955, 5998500,
6001091, 6003727, 6006283, 6008887, 6011523, 6014158, 6016757, 6019332,
6021859, 6024475, 6027082, 6029692, 6032264, 6034853, 6037496, 6040041,
6042691, 6045299, 6047914, 6050499, 6053126, 6055662, 6058265, 6060852,
6063464, 6066107, 6068704, 6071358, 6073902, 6076512, 6079117, 6081675,
6084293, 6086846, 6089462, 6092066, 6094754, 6097313, 6099890, 6102471,
6105113, 6107732, 6110282, 6112891, 6115533, 6118146, 6120762, 6123306,
6125905, 6128580, 6131219, 6133813, 6136360, 6139005, 6141600, 6144218,
6146820, 6149371, 6152008, 6154675, 6157271, 6159871, 6162461, 6164976,
6167591, 6170168, 6172803, 6175450, 6178055, 6180645, 6183213, 6185805,
6188462, 6191134, 6193761, 6196339, 6198883, 6201446, 6204006, 6206615,
6209208, 6211825, 6214485, 6217047, 6219685, 6222252, 6224827, 6227426,
6230025, 6232618, 6235254, 6237903, 6240568, 6243137, 6245745, 6248383,
6250968, 6253594, 6256157, 6258704, 6261229, 6263772, 6266353, 6268950,
6271545, 6274153, 6276725, 6279295, 6281850, 6284431, 6287079, 6289703,
6292248, 6294880, 6297458, 6300083, 6302647, 6305225, 6307854, 6310423,
6313002, 6315578, 6318146, 6320783, 6323413, 6326011, 6328577, 6331172,
6333770, 6336395, 6339009, 6341630, 6344208, 6346739, 6349347, 6351927,
6354521, 6357116, 6359727, 6362295, 6364935, 6367512, 6370124, 6372759,
6375330, 6377932, 6380538, 6383126, 6385750, 6388317, 6390928, 6393566,
6396156, 6398760, 6401309, 6403894, 6406444, 6409020, 6411621, 6414240,
6416840, 6419444, 6421985, 6424585, 6427175, 6429774, 6432352, 6434905,
6437478, 6440084, 6442694, 6445293, 6447930, 6450524, 6453111, 6455682,
6458326, 6460917, 6463538, 6466171, 6468741, 6471304, 6473882, 6476474,
6479075, 6481719, 6484300, 6486895, 6489472, 6492070, 6494656, 6497314,
6499923, 6502519, 6505097, 6507692, 6510279, 6512873, 6515451, 6518114,
6520675, 6523259, 6525868, 6528444, 6531066, 6533690, 6536273, 6538887,
6541470, 6544021, 6546672, 6549285, 6551864, 6554452, 6556996, 6559587,
6562188, 6564770, 6567411, 6569951, 6572574, 6575116, 6577700, 6580260,
6582892, 6585456, 6588087, 6590708, 6593326, 6595957, 6598515, 6601071,
6603686, 6606273, 6608834, 6611498, 6614095, 6616698, 6619295, 6621894,
6624418, 6627012, 6629605, 6632211, 6634763, 6637327, 6639847, 6642444,
6645043, 6647598, 6650124, 6652723, 6655351, 6657923, 6660525, 6663028,
6665670, 6668208, 6670804, 6673402, 6676025, 6678603, 6681238, 6683806,
6686331, 6688966, 6691555, 6694117, 6696711, 6699329, 6701946, 6704527,
6707200, 6709795, 6712367, 6714983, 6717599, 6720189, 6722794, 6725391,
6727968, 6730547, 6733134, 6735695, 6738207, 6740828, 6743394, 6745968,
6748552, 6751153, 6753724, 6756299, 6758910, 6761489, 6764062, 6766666,
6769185, 6771775, 6774395, 6776965, 6779497, 6782076, 6784634, 6787249,
6789787, 6792400, 6795031, 6797654, 6800239, 6802810, 6805406, 6807999,
6810601, 6813192, 6815770, 6818374, 6820939, 6823539, 6826057, 6828648,
6831224, 6833809, 6836379, 6838975, 6841545, 6844146, 6846743, 6849310,
6851866, 6854427, 6857053, 6859666, 6862301, 6864928, 6867491, 6870031,
6872597, 6875182, 6877737, 6880327, 6882924, 6885471, 6888050, 6890595,
6893240, 6895824, 6898361, 6900909, 6903508, 6906086, 6908592, 6911194,
6913799, 6916351, 6918938, 6921532, 6924153, 6926760, 6929345, 6932010,
6934558, 6937122, 6939699, 6942266, 6944833, 6947433, 6950048, 6952622,
6955229, 6957811, 6960447, 6963003, 6965624, 6968229, 6970814, 6973374,
6975908, 6978553, 6981142, 6983701, 6986303, 6988895, 6991452, 6994053,
6996636, 6999239, 7001827, 7004386, 7006943, 7009509, 7012092, 7014637,
7017247, 7019911, 7022468, 7025101, 7027733, 7030312, 7032873, 7035446,
7038006, 7040537, 7043119, 7045744, 7048342, 7050888, 7053483, 7056063,
7058671, 7061274, 7063885, 7066487, 7069099, 7071649, 7074208, 7076794,
7079414, 7081992, 7084585, 7087182, 7089730, 7092253, 7094829, 7097378,
7099975, 7102560, 7105136, 7107734, 7110341, 7112923, 7115505, 7118105,
7120687, 7123329, 7125909, 7128529, 7131104, 7133676, 7136261, 7138851,
7141412, 7143963, 7146532, 7149099, 7151678, 7154306, 7156895, 7159502,
7162172, 7164744, 7167291, 7169862, 7172477, 7175070, 7177687, 7180299,
7182859, 7185447, 7188010, 7190543, 7193111, 7195725, 7198306, 7200837,
7203410, 7206026, 7208623, 7211221, 7213777, 7216339, 7218922, 7221467,
7224118, 7226696, 7229224, 7231835, 7234448, 7237074, 7239661, 7242248,
7244831, 7247438, 7250010, 7252624, 7255179, 7257777, 7260342, 7262872,
7265456, 7267970, 7270545, 7273095, 7275708, 7278251, 7280851, 7283410,
7285994, 7288560, 7291115, 7293745, 7296316, 7298848, 7301442, 7304018,
7306655, 7309180, 7311705, 7314293, 7316887, 7319531, 7322112, 7324659,
7327260, 7329881, 7332442, 7335022, 7337604, 7340210, 7342739, 7345280,
7347817, 7350378, 7352945, 7355504, 7358025, 7360615, 7363210, 7365832,
7368429, 7371013, 7373605, 7376145, 7378732, 7381276, 7383811, 7386365,
7388933, 7391502, 7394032, 7396642, 7399245, 7401866, 7404457, 7406982,
7409538, 7412102, 7414691, 7417288, 7419884, 7422441, 7424989, 7427522,
7430101, 7432639, 7435216, 7437740, 7440294, 7442912, 7445516, 7448114,
7450684, 7453261, 7455841, 7458445, 7461027, 7463635, 7466198, 7468787,
7471320, 7473930, 7476552, 7479118, 7481641, 7484264, 7486781, 7489342,
7491952, 7494521, 7497063, 7499688, 7502254, 7504815, 7507392, 7509988,
7512553, 7515087, 7517707, 7520308, 7522824, 7525392, 7527945, 7530543,
7533105, 7535700, 7538260, 7540804, 7543418, 7545943, 7548535, 7551130,
7553729, 7556313, 7558844, 7561435, 7563980, 7566505, 7569080, 7571641,
7574170, 7576783, 7579338, 7581897, 7584422, 7587022, 7589577, 7592151,
7594705, 7597276, 7599794, 7602390, 7604973, 7607619, 7610137, 7612748,
7615269, 7617858, 7620416, 7622960, 7625549, 7628196, 7630753, 7633277,
7635834, 7638354, 7640910, 7643496, 7646121, 7648660, 7651279, 7653833,
7656431, 7659011, 7661580, 7664134, 7666612, 7669193, 7671776, 7674356,
7676915, 7679488, 7682031, 7684595, 7687146, 7689731, 7692293, 7694861,
7697419, 7700031, 7702574, 7705205, 7707783, 7710348, 7712918, 7715474,
7718028, 7720597, 7723207, 7725778, 7728305, 7730889, 7733442, 7736038,
7738641, 7741178, 7743670, 7746199, 7748766, 7751407, 7753967, 7756540,
7759095, 7761686, 7764213, 7766793, 7769379, 7771905, 7774461, 7777035,
7779545, 7782119, 7784671, 7787226, 7789834, 7792385, 7795028, 7797627,
7800194, 7802758, 7805346, 7807903, 7810459, 7813000, 7815577, 7818155,
7820761, 7823285, 7825842, 7828445, 7830988, 7833550, 7836167, 7838714,
7841312, 7843890, 7846422, 7848885, 7851434, 7854000, 7856583, 7859172,
7861776, 7864364, 7866909, 7869478, 7872018, 7874591, 7877131, 7879768,
7882314, 7884851, 7887428, 7890024, 7892632, 7895233, 7897844, 7900429,
7902975, 7905546, 7908066, 7910582, 7913125, 7915728, 7918312, 7920913,
7923470, 7926037, 7928634, 7931211, 7933766, 7936281, 7938828, 7941378,
7943902, 7946432, 7949032, 7951602, 7954217, 7956760, 7959316, 7961868,
7964451, 7967003, 7969567, 7972124, 7974694, 7977293, 7979866, 7982413,
7985018, 7987569, 7990128, 7992722, 7995266, 7997861, 8000394, 8002935,
8005473, 8008047, 8010615, 8013200, 8015753, 8018323, 8020862, 8023413,
8025983, 8028499, 8031030, 8033583, 8036158, 8038758, 8041400, 8043966,
8046482, 8049029, 8051591, 8054132, 8056748, 8059305, 8061849, 8064377,
8066944, 8069508, 8072033, 8074668, 8077206, 8079782, 8082323, 8084914,
8087510, 8090092, 8092568, 8095135, 8097678, 8100189, 8102726, 8105256,
8107767, 8110337, 8112936, 8115467, 8118011, 8120631, 8123161, 8125719};
bool isPrime(int n) {
if (n == 1) return 0;
for (int i = 3; i * i <= n; ++i)
if (n % i == 0) return 0;
return 1;
}
const int di = 100000;
const int maxd = 2999;
int l, r, ans;
int main() {
scanf("%d%d", &l, &r);
int ans = 0;
int li = l / di;
int ri = r / di;
if (ri > li) {
ans += cnt[ri - 1] - cnt[li];
for (int i = (l), _b(li * di + di); i < _b; ++i)
if (i == 2 || i % 4 == 1 && isPrime(i)) ++ans;
for (int i = (ri * di), _b(r + 1); i < _b; ++i)
if (i == 2 || i % 4 == 1 && isPrime(i)) ++ans;
} else {
for (int i = (l), _b(r + 1); i < _b; ++i)
if (i == 2 || i % 4 == 1 && isPrime(i)) ++ans;
}
printf("%d\n", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3,no-stack-protector")
#pragma GCC target("tune=native")
using namespace std;
using ll = long long;
const int N = 120005;
struct node_t {
int tag, time, value, number;
ll answer;
} tree[N << 2];
int n, m, top_max, top_min, a[N], stack_max[N], stack_min[N];
vector<pair<int, int>> queries[N];
ll answer[N];
void add_value(int x, int value) {
tree[x].value += value;
tree[x].tag += value;
}
void add_time(int x, int value) {
tree[x].time += value;
tree[x].answer += (ll)value * tree[x].number;
}
void push_up(int x) {
tree[x].value = min(tree[x << 1].value, tree[x << 1 | 1].value);
tree[x].answer = tree[x << 1].answer + tree[x << 1 | 1].answer;
tree[x].number = 0;
if (tree[x].value == tree[x << 1].value) {
tree[x].number += tree[x << 1].number;
}
if (tree[x].value == tree[x << 1 | 1].value) {
tree[x].number += tree[x << 1 | 1].number;
}
}
void push_down(int x) {
if (tree[x].tag) {
add_value(x << 1, tree[x].tag);
add_value(x << 1 | 1, tree[x].tag);
tree[x].tag = 0;
}
if (tree[x].time) {
if (tree[x].value == tree[x << 1].value) {
add_time(x << 1, tree[x].time);
}
if (tree[x].value == tree[x << 1 | 1].value) {
add_time(x << 1 | 1, tree[x].time);
}
tree[x].time = 0;
}
}
void build(int x, int l, int r) {
tree[x].value = l;
tree[x].number = 1;
if (l == r) {
return;
}
int mid = (l + r) / 2;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
}
void modify(int x, int l, int r, int ql, int qr, int value) {
if (l == ql && r == qr) {
add_value(x, value);
return;
}
int mid = (l + r) / 2;
push_down(x);
if (qr <= mid) {
modify(x << 1, l, mid, ql, qr, value);
} else if (ql > mid) {
modify(x << 1 | 1, mid + 1, r, ql, qr, value);
} else {
modify(x << 1, l, mid, ql, mid, value);
modify(x << 1 | 1, mid + 1, r, mid + 1, qr, value);
}
push_up(x);
}
ll query(int x, int l, int r, int ql, int qr) {
if (l == ql && r == qr) {
return tree[x].answer;
}
int mid = (l + r) / 2;
push_down(x);
if (qr <= mid) {
return query(x << 1, l, mid, ql, qr);
} else if (ql > mid) {
return query(x << 1 | 1, mid + 1, r, ql, qr);
} else {
return query(x << 1, l, mid, ql, mid) +
query(x << 1 | 1, mid + 1, r, mid + 1, qr);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
cin >> m;
for (int i = 1; i <= m; ++i) {
int l, r;
cin >> l >> r;
queries[r].push_back(make_pair(l, i));
}
build(1, 1, n);
for (int i = 1; i <= n; ++i) {
add_value(1, -1);
while (top_max && a[stack_max[top_max]] < a[i]) {
modify(1, 1, n, stack_max[top_max - 1] + 1, stack_max[top_max],
a[i] - a[stack_max[top_max]]);
--top_max;
}
stack_max[++top_max] = i;
while (top_min && a[stack_min[top_min]] > a[i]) {
modify(1, 1, n, stack_min[top_min - 1] + 1, stack_min[top_min],
a[stack_min[top_min]] - a[i]);
--top_min;
}
stack_min[++top_min] = i;
add_time(1, 1);
for (auto q : queries[i]) {
answer[q.second] = query(1, 1, n, q.first, i);
}
}
for (int i = 1; i <= m; ++i) {
cout << answer[i] << '\n';
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100007;
long long int n, k, ans, arr[MAX];
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(10);
cout << fixed;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
long long int len = 1;
ans = 1;
for (int i = 1; i < n; i++) {
if (arr[i] != arr[i - 1]) {
len++;
ans = max(ans, len);
} else {
len = 1;
ans = max(ans, len);
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
char s[maxn], p[maxn];
int _dp[maxn * maxn * 2];
int ans[maxn];
int ls, lp;
int& dp(int poss, int posp, int alrp) {
return _dp[poss * 2 * maxn + alrp * lp + posp];
}
void updDp(int a, int b, int c, int d) {
int& x = dp(a, b, c);
if (x == -1 || x > d) {
x = d;
}
}
int main() {
scanf("%s", s);
scanf("%s", p);
ls = strlen(s);
lp = strlen(p);
memset(_dp, -1, sizeof _dp);
dp(0, 0, 0) = 0;
int maxIn = ls / lp + 1;
for (int i = 0; i < ls; i++)
for (int j = 0; j < lp; j++)
for (int alr = 0; alr < maxIn; alr++) {
int cur = dp(i, j, alr);
if (cur == -1) continue;
if (s[i] == p[j]) {
int ni = i + 1;
int nj = j + 1;
int nalr = alr;
if (nj == lp) {
nj = 0;
nalr++;
}
updDp(ni, nj, nalr, cur);
}
if (j == 0) {
int ni = i + 1;
int nj = 0;
int nalr = alr;
updDp(ni, nj, nalr, cur);
}
int ni = i + 1;
int nj = j;
int nalr = alr;
updDp(ni, nj, nalr, cur + 1);
}
for (int cnt = 0; cnt < maxIn; cnt++) {
int minDel = dp(ls, 0, cnt);
if (minDel == -1) continue;
int maxDel = ls - cnt * lp;
for (int i = minDel; i <= maxDel; i++) ans[i] = max(ans[i], cnt);
}
for (int i = 0; i <= ls; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long int mi(long long int n, long long int m) {
long long int pw = n;
long long int ex = m - 2;
long long int ans = 1;
while (ex) {
if (ex & 1) ans = ans * pw % m;
pw = pw * pw % m;
ex >>= 1;
}
return ans;
}
long long int pw(long long int a, long long int n) {
long long int pw = a;
long long int ex = n;
long long int ans = 1;
while (ex) {
if (ex & 1) ans = ans * pw;
pw = pw * pw;
ex >>= 1;
}
return ans;
}
void show(long long int x) { cout << x << " "; }
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return a / gcd(a, b) * b;
}
long long int max(long long int a, long long int b) { return a > b ? a : b; }
long long int min(long long int a, long long int b) { return a < b ? a : b; }
long long int Abs(long long int x) { return x > 0 ? x : (-x); }
bool comp(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, m;
cin >> n >> m;
vector<long long int> vec(n);
for (int i = 0; i < n; i++) cin >> vec[i];
sort(vec.begin(), vec.end());
vector<pair<long long int, long long int> > dp(n);
for (int i = 0; i < n; i++) {
if (i == 0 || i == n - 1) {
if (i == 0) {
dp[i].first = vec[i] - 1;
if (vec[i + 1] != vec[i] + 1)
dp[i].second = vec[i] + 1;
else
dp[i].second = 1e18;
} else {
dp[i].second = vec[i] + 1;
if (vec[i] - 1 != vec[i - 1])
dp[i].first = vec[i] - 1;
else
dp[i].first = -(1e18);
}
} else {
if (vec[i] + 1 != vec[i + 1])
dp[i].second = vec[i] + 1;
else
dp[i].second = 1e18;
if (vec[i] - 1 != vec[i - 1])
dp[i].first = vec[i] - 1;
else
dp[i].first = -(1e18);
}
}
map<long long int, bool> mp;
for (long long int i : vec) mp[i] = true;
set<int> st;
for (int i = 0; i < n; i++) st.insert(i);
vector<long long int> rk;
long long int cnt = 0;
long long int ans = 0;
while (cnt < m) {
vector<long long int> tmp;
for (auto it = st.begin(); it != st.end(); it++) {
int i = *it;
if (dp[i].first != -(1e18)) {
if (mp.count(dp[i].first))
dp[i].first = -(1e18);
else {
mp[dp[i].first] = true;
rk.push_back(dp[i].first);
ans += Abs(vec[i] - dp[i].first);
cnt++;
if (mp.count(dp[i].first - 1))
dp[i].first = -(1e18);
else
dp[i].first--;
if (cnt == m) break;
}
}
if (dp[i].second != 1e18) {
if (mp.count(dp[i].second))
dp[i].second = 1e18;
else {
mp[dp[i].second] = true;
rk.push_back(dp[i].second);
ans += Abs(dp[i].second - vec[i]);
cnt++;
if (mp.count(dp[i].second + 1))
dp[i].second = 1e18;
else
dp[i].second++;
if (cnt == m) break;
}
}
if (dp[i].first == -(1e18) && dp[i].second == 1e18) tmp.push_back(i);
}
for (long long int i : tmp) st.erase(i);
}
cout << ans << "\n";
for (long long int i : rk) show(i);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[100][100];
int v[100][100];
int n, count = 0;
int check = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = 0; j < n; j++) {
if (a[i][j] == '#') count++;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
v[i][j] = 0;
}
}
if (count % 5 != 0) {
cout << "NO\n";
} else {
for (int i = 1; i < n - 1; i++) {
for (int j = 1; j < n - 1; j++) {
if (a[i][j] == '#' && (!v[i][j]) && a[i - 1][j] == '#' &&
(!v[i - 1][j]) && a[i + 1][j] == '#' && (!v[i + 1][j]) &&
a[i][j - 1] == '#' && (!v[i][j - 1]) && a[i][j + 1] == '#' &&
(!v[i][j + 1])) {
check += 5;
v[i][j] = v[i - 1][j] = v[i + 1][j] = v[i][j - 1] = v[i][j + 1] = 1;
}
}
}
if (check != count) {
cout << "NO\n";
} else {
cout << "YES\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j, sum = 0;
string s;
cin >> n >> k >> s;
sort(s.begin(), s.end());
sum = sum + s[0] - 96;
k--;
for (i = 0; i < n - 1 && k > 0; i = j) {
for (j = i + 1; j < n; j++)
if (s[j] - s[i] > 1) {
sum += s[j] - 96;
k--;
break;
}
}
if (k > 0)
printf("-1\n");
else
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> number;
string name[146];
int need[146][146];
int cnt[146][146];
vector<pair<string, int> > v;
int toint(string s) {
stringstream ss(s);
int n;
ss >> n;
return n;
}
int main() {
int k, n, m, q;
cin >> k >> n >> m >> q;
for (int i = 0; i < n; i++) {
cin >> name[i];
number[name[i]] = i;
}
memset(need, 0, sizeof(need));
for (int j = 0; j < m; j++) {
string s;
cin >> s;
name[n + j] = s.substr(0, s.length() - 1);
number[name[n + j]] = n + j;
while (1) {
string cnt;
cin >> s >> cnt;
bool flag = false;
if (cnt[cnt.length() - 1] == ',') {
flag = true;
cnt = cnt.substr(0, cnt.length() - 1);
}
need[j][number[s]] = toint(cnt);
if (!flag) break;
}
}
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < q; i++) {
int fr;
string s;
cin >> fr >> s;
fr--;
cnt[fr][number[s]]++;
for (int j = 0; j < m; j++) {
bool good = true;
for (int k = 0; k < n; k++)
if (cnt[fr][k] < need[j][k]) good = false;
if (good) {
for (int k = 0; k < n; k++) cnt[fr][k] -= need[j][k];
cnt[fr][n + j]++;
}
}
}
for (int i = 0; i < k; i++) {
v.clear();
for (int j = 0; j < n + m; j++)
if (cnt[i][j] > 0) v.push_back(make_pair(name[j], cnt[i][j]));
sort(v.begin(), v.end());
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++)
cout << v[i].first << " " << v[i].second << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 - '0' + c, c = getchar();
x *= f;
}
int mod;
inline int Pow(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = 1ll * x * x % mod)
if (y & 1) res = 1ll * res * x % mod;
return res;
}
struct Graph {
int a[410][410], n;
void adde(int x, int y) {
if (x == y) return;
a[x][y]--, a[y][x]--, a[x][x]++, a[y][y]++;
}
int solve(int n) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) a[i][j] %= mod;
--n;
int res = 1;
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; ++j)
if (a[j][i]) {
if (j != i) {
for (int k = 1; k <= n; ++k) swap(a[j][k], a[i][k]);
res = mod - res;
}
break;
}
if (!a[i][i]) return 0;
res = 1ll * res * a[i][i] % mod;
int inv = Pow(a[i][i], mod - 2);
for (int k = i + 1; k <= n; ++k) {
int tmp = 1ll * a[k][i] * inv % mod;
for (int j = 1; j <= n; ++j)
a[k][j] = (a[k][j] - 1ll * a[i][j] * tmp) % mod;
}
}
return (res + mod) % mod;
}
} G[2];
const int N = 110;
int fa[N * N], id[N][N], ncnt;
int pid[N * N], pid_cnt[2];
int n, m;
char mp[N][N];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
bool un(int x, int y) {
x = find(x), y = find(y);
if (x == y) return 0;
fa[x] = y;
return 1;
}
void adde(int x1, int y1, int x2, int y2) {
G[(x1 + y1) % 2].adde(pid[find(id[x1][y1])], pid[find(id[x2][y2])]);
}
int main() {
rd(n), rd(m), rd(mod);
for (int i = 1; i <= n + 1; ++i)
for (int j = 1; j <= m + 1; ++j) id[i][j] = ++ncnt, fa[ncnt] = ncnt;
int ok[2] = {1, 1};
for (int i = 1; i <= n; ++i) {
scanf("%s", mp[i] + 1);
for (int j = 1; j <= m; ++j) {
if (mp[i][j] == '/') {
if (!un(id[i + 1][j], id[i][j + 1])) ok[(i + 1 + j) % 2] = 0;
}
if (mp[i][j] == '\\') {
if (!un(id[i][j], id[i + 1][j + 1])) ok[(i + j) % 2] = 0;
}
}
}
for (int i = 1; i <= n + 1; ++i)
for (int j = 1; j <= m + 1; ++j)
if (!pid[find(id[i][j])]) pid[find(id[i][j])] = ++pid_cnt[(i + j) % 2];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (mp[i][j] == '*') {
adde(i, j, i + 1, j + 1);
adde(i + 1, j, i, j + 1);
}
int res = ((ok[0] ? G[0].solve(pid_cnt[0]) : 0) +
(ok[1] ? G[1].solve(pid_cnt[1]) : 0)) %
mod;
printf("%d", res);
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
long long int powmod(long long int a, long long int b) {
long long int res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
int main() {
int t = 1;
while (t--) {
int n;
double t1, t2, k, a, b;
cin >> n >> t1 >> t2 >> k;
vector<pair<double, int>> p;
for (int i = (0); i < (n); i++) {
cin >> a >> b;
double x = .0, y = .0;
x += a * t1;
x *= (100.0 - k) / 100.0;
x += b * t2;
y += b * t1;
y *= (100.0 - k) / 100.0;
y += a * t2;
p.push_back(make_pair(-(max(x, y)), i + 1));
}
sort(p.begin(), p.end());
for (int j = (0); j < (n); j++) {
cout << p[j].second << " ";
cout << fixed << setprecision(2) << -(p[j].first) << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, count = 0, i, j;
string s, t = "";
getline(cin, s);
for (i = 0; i < s.size(); i++) {
if (s[i] == '}' || s[i] == '{' || s[i] == ',' || s[i] == ' ')
continue;
else {
t += s[i];
}
}
sort(t.begin(), t.end());
for (i = 0, j = 1; j < t.size(); i++, j++) {
if (t[i] != t[j]) count++;
}
if (t.empty())
cout << 0 << endl;
else
cout << count + 1 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int mod = (int)1e9 + 7;
const int N = 100005;
class Point {
public:
double x, y;
Point(double x, double y) : x(x), y(y) {}
Point operator-(const Point& b) { return Point(x - b.x, y - b.y); }
Point operator+(const Point& b) { return Point(x + b.x, y + b.y); }
void print() { cout << x << ' ' << y << '\n'; }
Point operator*(double d) { return Point(x * d, y * d); }
};
Point points[] = {Point(3.830127018922193, 3.366025403784439),
Point(-3.601321235851749, 10.057331467373021),
Point(0.466045194906253, 19.192786043799030),
Point(10.411264148588986, 18.147501411122495),
Point(12.490381056766580, 8.366025403784439)};
void solve() {
int k;
cin >> k;
cout << 4 * k + 1 << endl;
points[0].print();
for (int i = 0; i < k; ++i) {
Point add = (points[2] - points[0]) * i;
for (int j = 1; j < 5; ++j) {
(points[j] + add).print();
}
}
for (int n = 0; n < k; ++n) {
cout << abs(4 * n - 1) << ' ' << 4 * n + 2 << ' ' << 4 * n + 3 << ' '
<< 4 * n + 4 << ' ' << 4 * n + 5 << endl;
}
for (int n = k; n >= 0; --n) {
cout << abs(4 * n - 1) << ' ';
}
for (int n = 0; n < k; ++n) {
cout << (4 * n + 4) << ' ' << (4 * n + 2) << ' ' << (4 * n + 5) << ' '
<< (4 * n + 3) << ' ';
}
}
int main() {
ios_base::sync_with_stdio(false);
cout << fixed;
cout.precision(20);
solve();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int n, a[100100], b[100100];
long long h[100100], tr[800100];
int c[100100];
vector<int> G;
bool cmp(const int &o, const int &p) {
if (b[o] == b[p]) {
return a[o] > a[p];
}
return b[o] > b[p];
}
long long Q(int o, int L, int R, int l, int r) {
if (l > r) return 0;
long long res = 0;
if (l <= L && R <= r) return tr[o];
if (l <= ((L + R) >> 1)) res = max(res, Q((o << 1), L, ((L + R) >> 1), l, r));
if (r > ((L + R) >> 1))
res = max(res, Q((o << 1 | 1), ((L + R) >> 1) + 1, R, l, r));
return res;
}
void inc(int o, int L, int R, int pos, long long val) {
if (L == R) {
tr[o] = max(tr[o], val);
return;
}
if (pos <= ((L + R) >> 1)) {
inc((o << 1), L, ((L + R) >> 1), pos, val);
} else {
inc((o << 1 | 1), ((L + R) >> 1) + 1, R, pos, val);
}
tr[o] = max(tr[(o << 1)], tr[(o << 1 | 1)]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d%lld", &a[i], &b[i], &h[i]);
c[i] = i;
G.push_back(a[i]);
G.push_back(b[i]);
}
sort(c, c + n, cmp);
sort(G.begin(), G.end());
auto len = (int)(unique(G.begin(), G.end()) - G.begin());
for (int i = 0; i < n; ++i) {
a[i] = (int)(lower_bound(G.begin(), G.begin() + len, a[i]) - G.begin()) + 1;
b[i] = (int)(lower_bound(G.begin(), G.begin() + len, b[i]) - G.begin()) + 1;
}
for (int i = 0; i < n; ++i) {
inc(1, 1, len, a[c[i]], Q(1, 1, len, 1, b[c[i]] - 1) + h[c[i]]);
}
printf("%lld\n", Q(1, 1, len, 1, len));
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
char t[4][4];
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) cin >> t[i][j];
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) {
int w = 0, b = 0;
for (int l = 0; l < 2; l++)
for (int k = 0; k < 2; k++)
if (t[i + l][j + k] == '#')
w++;
else
b++;
if (w >= 3 || b >= 3) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
}
| 3 |
#include <bits/stdc++.h>
int n, m;
double fun(int x, int y) {
double ans = 1, temp = 1.0 * x / y;
int t = m;
while (t > 0) {
if (t & 1) ans *= temp;
temp = temp * temp;
t >>= 1;
}
return ans;
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
double ans = 0, temp = 0;
for (int i = 1; i <= n; i++) {
double temp1 = fun(i, n);
ans += (temp1 - temp) * i;
temp = temp1;
}
printf("%lf\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void in(long long int *a, long long int n) {
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
}
void out(long long int *a, long long int n) {
for (long long int i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
long long int modexpo(long long int a, long long int b) {
if (b == 0) return 1;
if (b == 1) return a;
long long int temp = modexpo(a, b / 2);
if (b % 2) return (temp % 1000000007 * temp % 1000000007 * a) % 1000000007;
return (temp % 1000000007 * temp % 1000000007) % 1000000007;
}
long long int fact(long long int n) {
long long int temp = 1;
long long int k = n;
while (k--) {
temp = (temp * n) % 1000000007;
n--;
}
return temp;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio;
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
vector<string> v;
string s;
long long int a[n][n], f = 0;
for (long long int i = 0; i < n; ++i) {
cin >> s;
v.push_back(s);
}
for (long long int i = 0; i < n; ++i) {
for (long long int j = 0; j < v[i].size(); ++j) {
a[i][j] = v[i][j] - '0';
}
}
for (long long int i = 0; i < (n - 1); ++i) {
for (long long int j = 0; j < (n - 1); ++j) {
if (a[i][j] == 1) {
if ((a[i + 1][j] == 0) && (a[i][j + 1] == 0)) {
f = 1;
break;
}
}
}
}
if (f == 0) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string c[2005];
bool p[2005][2005], q[2005][2005], l[2005][2005], r[2005][2005];
int main() {
long long ans = 0;
int n, m, i, j;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) cin >> c[i];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
p[i][j] = (i == 0 || p[i - 1][j]) && c[i][j] == '.';
l[i][j] = (j == 0 || l[i][j - 1]) && c[i][j] == '.';
}
}
for (i = n - 1; i >= 0; i--) {
for (j = m - 1; j >= 0; j--) {
q[i][j] = (i == n - 1 || q[i + 1][j]) && c[i][j] == '.';
r[i][j] = (j == m - 1 || r[i][j + 1]) && c[i][j] == '.';
}
}
for (i = 1; i + 1 < n; i++) ans += l[i][m - 1];
for (j = 1; j + 1 < m; j++) ans += p[n - 1][j];
for (i = 1; i + 1 < n; i++) {
for (j = 1; j + 1 < m; j++) {
ans += (p[i][j] && l[i][j]) + (p[i][j] && r[i][j]) +
(q[i][j] && l[i][j]) + (q[i][j] && r[i][j]);
}
}
for (i = 1; i + 1 < n; i++) {
int u = 0, v = 0, x = 0, y = 0;
for (j = 1; j < m - 1; j++) {
if (p[i][j]) ans += y + u;
if (q[i][j]) ans += x + v;
if (c[i][j] == '.') {
x += p[i][j];
y += q[i][j];
if (j - 1 > 0) {
u += p[i][j - 1];
v += q[i][j - 1];
}
} else {
u = 0;
v = 0;
x = 0;
y = 0;
}
}
}
for (j = 1; j < m - 1; j++) {
int u = 0, v = 0, x = 0, y = 0;
for (i = 1; i + 1 < n; i++) {
if (l[i][j]) ans += y + u;
if (r[i][j]) ans += x + v;
if (c[i][j] == '.') {
x += l[i][j];
y += r[i][j];
if (i - 1 > 0) {
u += l[i - 1][j];
v += r[i - 1][j];
}
} else {
u = 0;
v = 0;
x = 0;
y = 0;
}
}
}
printf("%I64d\n", ans);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, p[N], idx, vis[N], ty;
char s[N][N];
int main() {
cin >> n;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) s[i][j] = '.';
for (int i = (1); i <= (n); i++) scanf("%d", &p[i]);
for (int i = (1); i <= (n); i++)
if (!vis[i] && p[i] ^ i) {
ty = 1;
int j = i, ls = idx;
for (vis[i] = 1; idx++, p[j] ^ i; vis[j = p[j]] = 1)
if (j ^ 1) s[idx][j] = s[idx][p[j]] = j < p[j] ? '/' : '\\';
s[idx][j] = s[idx][1] = '\\';
if (i ^ 1) s[ls + 1][1] = '/';
}
cout << n - ty << endl;
for (int i = (1); i <= (n); i++) puts(s[i] + 1);
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int mod = 1e9 + 7;
const int N = 1e5 + 10;
inline int add(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
inline int mul(int x, int y) {
x = (1LL * x * y) % mod;
return x;
}
long long n, h;
long long binary_search(long long start, long long end) {
if (start <= end) {
long long mid = (start + end) / 2;
long long h1 = min(h, mid);
long long h2 = min(h, mid + 1);
if (mid * mid - (h1 * (h1 - 1)) / 2 <= n &&
(mid + 1) * (mid + 1) - (h2 * (h2 - 1)) / 2 > n) {
return mid;
} else if (mid * mid - (h1 * (h1 - 1)) / 2 <= n) {
return binary_search(mid + 1, end);
} else {
return binary_search(start, mid - 1);
}
}
}
int main() {
cin >> n >> h;
long long max_k = ((long long)sqrt(2 * n) + 1);
long long k = binary_search(1, max_k);
long long h1 = min(h, k);
if ((n - (k * k - (h1 * (h1 - 1)) / 2)) % k == 0) {
cout << 2 * k - 1 + (n - (k * k - (h1 - 1) * h1 / 2)) / k - (h1 - 1);
} else {
cout << 2 * k - 1 + (n - (k * k - h1 * (h1 - 1) / 2)) / k + 1 - (h1 - 1);
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t=1;
cin>>t;
while(t--){
long long p,a,b,c;
cin>>p>>a>>b>>c;
long long x=a-p%a;
long long y=b-p%b;
long long z=c-p%c;
if(p%a==0 || p%b==0 || p%c==0) cout<<0;
else cout<<min(x,min(y,z));
cout<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long int a, b, c, d, e, f, g, low[800009], high[800009], sum[800009],
leaf[200009], x[200009];
void Inp() {
memset(x, 0, sizeof(x));
for (int i = 1; i <= a; i++) {
cin >> d >> e;
x[d]++;
x[e + 1]--;
}
x[0] = 0;
for (int i = 1; i <= 200008; i++) {
x[i] = x[i] + x[i - 1];
if (x[i] >= b) {
d = leaf[i];
while (d != 0) {
sum[d]++;
d = d / 2;
}
}
}
}
void Built(long long int v, long long int l, long long int h) {
low[v] = l;
high[v] = h;
if (l == h) {
leaf[l] = v;
} else {
long long int m = (l + h) / 2;
Built(v * 2, l, m);
Built(v * 2 + 1, m + 1, h);
}
}
long long int Request(long long int v, long long int l, long long int h) {
if (low[v] > h || high[v] < l) {
return 0;
}
if (low[v] >= l && high[v] <= h) {
return sum[v];
}
return Request(v * 2, l, h) + Request(v * 2 + 1, l, h);
}
void Solve() {
for (int i = 1; i <= c; i++) {
cin >> d >> e;
cout << Request(1, d, e) << endl;
}
}
int main() {
cin >> a >> b >> c;
memset(sum, 0, sizeof(sum));
Built(1, 1, 200002);
Inp();
Solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void ritikio();
const long long int inff = LLONG_MAX;
const long long int minff = LLONG_MIN;
const long long int inf = 1e18;
const long long int pmod = 998244353;
const long long int mod = 1e9 + 7;
const long long int maxm = 2e6 + 3;
const long long int maxN = 1e5 + 3;
long long int T = 0;
void solve() {
string s;
cin >> s;
long long int n = s.length();
cout << 4 << endl;
cout << "L " << 2 << endl;
n++;
cout << "R " << n - 1 << endl;
n++;
cout << "L " << n - 1 << endl;
cout << "L " << 2 << endl;
}
signed main() {
ritikio();
long long int TT = 1;
T = 0;
while (++T < TT + 1) {
;
solve();
}
}
void ritikio() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long SIZE = 1e5 + 5;
const long long mod = 1e9 + 7;
vector<pair<long long, long long> > adj[SIZE];
vector<long long> dis(SIZE, INF);
long long par[SIZE];
bool marked[SIZE];
long long ans;
void dijkstra() {
dis[1] = 0;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
pq.push(make_pair(dis[1], 1));
par[1] = 1;
long long u, v, w, i;
while (!pq.empty()) {
u = pq.top().second;
pq.pop();
for (i = 0; i < adj[u].size(); i++) {
v = adj[u][i].first;
w = adj[u][i].second;
if (dis[v] > (dis[u] + w)) {
dis[v] = dis[u] + w;
par[v] = u;
pq.push(make_pair(dis[v], v));
}
}
}
}
void dfs(long long u, long long p) {
long long v, w, i;
for (i = 0; i < adj[u].size(); i++) {
v = adj[u][i].first;
w = adj[u][i].second;
if (v == p) continue;
if (!marked[v])
ans += (2 * w);
else
ans += w;
dfs(v, u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 0, n, x, y, z, i, j, k, g, p, q, sum = 0, c = 0;
cin >> n;
for (i = 1; i <= n - 1; i++) {
cin >> x >> y >> z;
adj[x].push_back(make_pair(y, z));
adj[y].push_back(make_pair(x, z));
}
dijkstra();
for (i = 1; i <= n; i++) {
if (dis[i] > c) {
c = dis[i];
p = i;
}
}
while (par[p] != p) {
marked[p] = 1;
p = par[p];
}
dfs(1, 1);
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
char ch;
int idx;
cin >> ch >> idx;
int loc = 0, roc = 0;
map<int, int> dfc;
map<int, char> where;
dfc[idx] = 0;
for (int i = 1; i < n; i++) {
cin >> ch >> idx;
if (ch == 'L') {
dfc[idx] = ++loc;
where[idx] = ch;
}
if (ch == 'R') {
dfc[idx] = ++roc;
where[idx] = ch;
}
if (ch == '?') {
if (where[idx] == 'L')
cout << min(loc - dfc[idx], dfc[idx] + roc);
else
cout << min(roc - dfc[idx], dfc[idx] + loc);
cout << '\n';
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long i, n, m, k, d[100002];
int main() {
cin >> n >> m >> k;
for (i = 0; i < n; i++) {
cin >> d[i];
cout << d[i] * m % k / m << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void scanint(int &x) {
register int c = getchar();
x = 0;
for (; (c < 48 || c > 57); c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
}
int modpow(int a, int b) {
int x = 1ll, y = a;
while (b) {
if (b % 2) x = (x * y);
y = (y * y);
b /= 2;
}
return x;
}
long long gcd(long long a, long long b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
int arr[10000], sum[10000], diff[10000], higher[10000];
int calcsum(int cur, int n) {
if ((cur * 2) >= n) {
higher[cur] = arr[cur];
return (sum[cur] = arr[cur]);
}
higher[cur] = max(calcsum(cur * 2, n), calcsum(cur * 2 + 1, n));
return (sum[cur] = arr[cur] + higher[cur]);
}
int calcreq(int req, int cur, int n) {
if ((cur * 2) >= n) {
return (req - arr[cur]);
}
int x = req - arr[cur] - higher[cur];
return (x + calcreq(req - (x + arr[cur]), cur * 2, n) +
calcreq(req - (x + arr[cur]), cur * 2 + 1, n));
}
int main() {
int n, i, j, x, y, z, maxlights, add;
scanint(n);
x = modpow(2, n + 1);
arr[1] = 0;
for (i = 2; i < x; i++) scanint(arr[i]);
maxlights = calcsum(1, x);
add = calcreq(maxlights, 1, x);
printf("%d\n", add);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> V;
int x, pr;
for (int i = 0; i < n; i++) {
pr = 1;
for (int j = 0; j < n; j++) {
cin >> x;
if ((j != i) && ((x == 1) || (x == 3))) {
pr = 0;
}
}
if (pr == 1) {
V.push_back(i);
}
}
cout << V.size() << endl;
if (V.size() != 0) {
for (int i = 0; i < (int)V.size(); i++) {
cout << V[i] + 1 << ' ';
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
for (int q = 0; q < t; ++q) {
long long s, n, k;
cin >> s >> n >> k;
if (s == k) {
cout << "YES" << endl;
continue;
}
if (s >= ((n / k) * k + n)) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
#define int long long
#define ll long long
#define endl '\n'
#define mod 1000000007
#define pb push_back
#define fi first
#define se second
#define all(v) (v).begin(), (v).end()
#define ii pair<int, int>
#define vi vector<int>
#define vii vector<ii>
#define rep(i, l, r) for (int i = (int)(l); i <= (int)(r); i++)
#define repi(i, l, r) for (int i = (int)(l); i >= (int)(r); i--)
const int inf = 1e18;
using namespace std;
vector<bool> prime(1000001, true);
vi prim;
void SieveOfEratosthenes(ll n) //O(nloglogn)
{
for (ll p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (ll i = p * p; i <= n; i += p)
prime[i] = false;
}
}
// prime[1] = false;
rep(i, 2, n)if (prime[i] == true)prim.push_back(i);
}
bool isPrime(ll n) //O(sqrt(n))
{
if (n < 2)
return false;
//For 2,3 does not the enter the for loop.
for (ll i = 2; i * i <= n; i++)
if (n % i == 0)
return false;
return true;
}
std::vector<ll> generatePrimeFactors(ll n) {
std::vector<ll> prime;
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
prime.pb(i);
while (n % i == 0)
n = n / i;
}
}
if (n != 1)
prime.pb(n);
return prime;
}
map<ll, ll> generatePrimeFactorization(ll n) {
map<ll, ll> cnt;
for (ll i = 2; i * i <= n; i++) {
while (n && n % i == 0) {
n /= i;
cnt[i]++;
}
}
if (n != 1)
cnt[n]++;
return cnt;
}
std::vector<ll> generateFactors(ll n) {
std::vector<ll> factors;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
factors.pb(i);
if (n / i != i)
factors.pb(n / i);
//24 - 1,2,3,4,6,8,12
}
}
// factors.pb(1);
// if (n != 1)
// factors.pb(n);
sort(factors.begin(), factors.end());
return factors;
}
ll extendedGCD(ll a, ll b, ll &x, ll &y) {
//produces correct results for negative integers as well
if (a == 0) {
x = 0;
y = 1;
return b;
}
ll x1, y1, d;
d = extendedGCD(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
ll gcd(ll a, ll b) //O(log min(a,b))
{
/*
recursive implementation below
if(!b) return a;
return gcd(b,a%b);
*/
//non-recursive implementation below
while (b) {
a %= b;
swap(a, b);
}
return a;
}
ll multiply(ll a, ll b, ll m);
ll singlemod(ll a, ll m);
ll modpow(ll x, ll n, ll m) //O(logn)// used for calculating (x^n)%m
{
if (n == 0)
return 1;
ll res = 1;
while (n) {
if (n % 2)
res = multiply(res, x, m);
x = multiply(x, x, m);
n = n >> 1;
}
return singlemod(res, m);
}
ll fastpow(ll x, ll n) {
if (n == 0)
return 1;
ll res = 1;
while (n) {
if (n % 2)
res = res * x;
x = x * x;
n = n >> 1;
}
return res;
}
ll modinverse(ll x, ll m) //O(logn)
{
return modpow(x, m - 2, m);
}
ll add(ll a, ll b, ll m) {
return (((a % m) + (b % m)) % m);
}
ll substract(ll a, ll b, ll m) {
// if (a < b)
// swap(a, b);
return (((a % m) - (b % m) + m) % m);
}
ll multiply(ll a, ll b, ll m) {
// if (a > b) swap(a, b);
// ll ans = 0;
// while (a)
// {
// if (a % 2)
// ans = add(ans, b, m);
// b = add(b, b, m);
// a = a >> 1;
// }
// return (ans % m);
return (((a % m) * (b % m)) % m);
}
ll divide(ll a, ll b, ll m) {
ll temp = modinverse(b, m);
return multiply(a, temp, m);
}
ll singlemod(ll a, ll m) {
return (((a % m) + m) % m);
}
ll eulerstotientfunction(ll n) //O(sqrt(n))
{
ll ans = n;
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0)
n = n / i;
ans -= ans / i;
}
}
if (n > 1)
ans -= ans / n;
return ans;
}
ll ncr(ll n, ll k, ll m) {
if (k > n)
return 0;
if (m == 0) {
ll res = 1;
k = min(k, n - k);
for (ll i = 1; i <= k; i++) {
res *= (n - i + 1);
res /= i;
}
return res;
} else {
ll res = 1;
k = min(k, n - k);
for (ll i = 1; i <= k; i++) {
res = multiply(res, n - i + 1, m);
res = divide(res, i, m);
}
return singlemod(res, m);
}
}
ll kadaneAlgo(const std::vector<ll> &arr) {
ll size = arr.size();
ll currmax = arr[0], maxsofar = arr[0];
for (ll i = 1; i < size; i++) {
//debug2(currmax,maxsofar);
currmax = max(arr[i], currmax + arr[i]);
maxsofar = max(maxsofar, currmax);
}
return maxsofar;
}
ll getDigitSum(ll n) {
ll co = 0;
while (n > 0) {
co += n % 10;
n = n / 10;
}
return co;
}
ll ceil(ll a, ll b) {
return (a + b - 1) / b;
}
ll lcm(ll a, ll b) {
return (a * b) / gcd(a, b);
}
//const int p1 = 13331,m1 = 1e9+9,p2 = 7919, m2 = 1e9+9;
//const int p1 = 97266353,m1 = 972663749,p2 = 97336357, m2 = 1000000007;
//const int p1 = 31 ,m1 = 1e9+7;
//grid cells
//D U R L
//ll dx[] = {1, -1, 0, 0};
//ll dy[] = {0, 0, 1, -1};
//ll dx[] = {-2,-2,-1,1,2,-2,1,-1};
//ll dy[] = {-1,1,2,2,1,-1,-2,-2};
//bool isSafe(ll x, ll y, ll n, ll m)
//{
// return (x >= 0 && x < n && y >= 0 && y < m);
//}
//---------------TEMPLATE ABOVE--------------//
void solve() {
int n;
cin >> n;
vi a(n), b(n), c(n);
rep(i, 0, n - 1)cin >> c[i];
rep(i, 0, n - 1)cin >> a[i];
rep(i, 0, n - 1)cin >> b[i];
int ans = 0, prev = 0;
rep(i, 1, n - 1) {
if (a[i] > b[i])swap(a[i], b[i]);
if (b[i] - a[i] == 0)prev = 0;
else prev = max(b[i] - a[i] ,prev - (b[i] - a[i]));
prev += 2 + c[i] - 1;
ans = max(ans,prev);
}
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
cin >> t;
rep(i, 1, t) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long n, m;
long long x;
int res = 0;
cin >> n >> m >> x;
n -= 2 * (x - 1);
m -= 2 * (x - 1);
if (n <= 0 || m <= 0) {
cout << 0;
return 0;
}
if (n == 1) res = m / 2 + (m & 0x01);
if (m == 1)
res = n / 2 + (n & 0x01);
else
res = n + m - 2;
if (res > 0)
cout << res;
else
cout << 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn(1e6 + 5);
const int mod(1e9 + 7);
inline void Inc(int &x, int y) { x = x + y >= mod ? x + y - mod : x + y; }
inline int Add(int x, int y) { return x + y >= mod ? x + y - mod : x + y; }
inline void Dec(int &x, int y) { x = x - y < 0 ? x - y + mod : x - y; }
inline int Sub(int x, int y) { return x - y < 0 ? x - y + mod : x - y; }
int n, val[maxn], mx, cnt[maxn], val1[maxn], val2[maxn], pw[maxn];
int pw10[10] = {1, 10, 100, 1000, 10000, 100000, 1000000};
long long ans;
int main() {
int i, j, s, nxt;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", &val[i]), mx = max(mx, val[i]);
for (pw[0] = i = 1; i <= n; ++i) pw[i] = Add(pw[i - 1], pw[i - 1]);
for (i = 1; i <= n; ++i)
Inc(val1[val[i]], val[i]), ++cnt[val[i]],
Inc(val2[val[i]], (long long)val[i] * val[i] % mod);
for (j = 1; j <= 6; ++j)
for (i = mx; ~i; --i) {
if (i / pw10[j - 1] % 10 == 9) continue;
nxt = i + pw10[j - 1];
Inc(val1[i], val1[nxt]), Inc(val2[i], val2[nxt]), Inc(cnt[i], cnt[nxt]);
}
for (i = 0; i <= mx; ++i)
if (cnt[i]) {
val1[i] = (long long)val1[i] * val1[i] % mod;
Dec(val1[i], val2[i]);
if (cnt[i] > 1)
val1[i] = (long long)val1[i] * pw[cnt[i] - 2] % mod;
else
val1[i] = 0;
val2[i] = (long long)val2[i] * pw[cnt[i] - 1] % mod;
Inc(val1[i], val2[i]);
}
for (j = 1; j <= 6; ++j)
for (i = 0; i <= mx; ++i) {
if (i / pw10[j - 1] % 10 == 9) continue;
nxt = i + pw10[j - 1], Dec(val1[i], val1[nxt]);
}
for (i = 0; i <= mx; ++i) ans ^= (long long)val1[i] * i;
printf("%lld\n", ans);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using ll = long long;
const int C = 5001, M = 998244353;
inline ll pow(ll a, ll b, ll M) {
if (b == 0) return 1;
ll c = 1;
while (b > 0) {
if (b % 2 == 1) c = (c * a) % M;
b /= 2;
a = (a * a) % M;
}
return c;
}
ll fac[C], af[C], inv[C], pw[C];
void formulate_fac(int n) {
int i;
fac[0] = af[0] = 1;
for (i = 1; i < n; i++) fac[i] = (i * fac[i - 1]) % M;
for (i = 1; i < n; i++) af[i] = (pow(i, M - 2, M) * af[i - 1]) % M;
}
inline ll cn(int n, int k) {
if (n < k || n < 0 || k < 0) return 0;
return (((fac[n] * af[k]) % M) * af[n - k]) % M;
}
int main() {
int n, i, j, sgn_outer, sgn_inner, k;
ll res = 0, partial_res, summa = 0, l;
formulate_fac(C);
pw[0] = 1;
for (i = 1; i < C; i++) inv[i] = pow(i, M - 2, M);
for (i = 1; i < C; i++) pw[i] = (pw[i - 1] * 2) % M;
scanf("%d %d %lld", &n, &k, &l);
sgn_outer = -1;
for (i = k; i <= n; i++) {
sgn_outer *= (-1);
partial_res = (((cn(n, i) * pw[i]) % M) * cn(i - 1, k - 1)) % M;
summa = 0, sgn_inner = -1;
for (j = 0; j <= i; j++) {
sgn_inner *= (-1);
summa = (summa + sgn_inner * cn(i, j) * inv[i + j + 1]) % M;
}
res = (res + partial_res * summa * sgn_outer) % M;
}
if (res < 0) res += M;
printf("%lld\n", (l * res) % M);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 1;
const int N = 2e6;
int main() {
map<int, int> m;
int a, b;
int n;
cin >> n;
while (n--) {
cin >> a >> b;
m[a] = b;
}
for (auto &it : m) {
int x = it.first + it.second;
if (!m.count(x)) continue;
auto it1 = m.find(x);
if (x + it1->second == it.first) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int inf = numeric_limits<int>::max();
const int N = 21;
int memo[1 << 21], cost[21][21];
bool vis[1 << 21];
int cost0[1 << 21], cnt[1 << 21], m;
int dp(int mask) {
int n = __builtin_popcount(mask);
if (n == m) return 0;
if (vis[mask]) return memo[mask];
vis[mask] = true;
int ans = inf;
for (int i = 0; i < m; i++)
if (!(mask & (1 << i))) {
ans = min(ans, cost0[mask | (1 << i)] + dp(mask | (1 << i)));
}
return memo[mask] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n >> m;
vector<char> s(n);
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n - 1; i++)
cost[s[i] - 'a'][s[i + 1] - 'a']++, cost[s[i + 1] - 'a'][s[i] - 'a']++;
for (int j = 0; j < (1 << m); j++)
for (int k = 0; k < m; k++)
for (int i = 0; i < m; i++)
if ((j & (1 << k)) && !(j & (1 << i))) cost0[j] += cost[k][i];
cout << dp(0) << endl;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int N = 305;
int c[N][N], first[N][N], cost[N][N], cnt[30], second, t, n;
string need;
int par[N], d[N];
bool use[N];
queue<int> q;
bool FBellman(int x, int y) {
for (int i = 0; i <= t; ++i) d[i] = INF;
q.push(x);
d[x] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
use[v] = false;
for (int i = 0; i <= t; ++i) {
int cf = c[v][i] - first[v][i];
if (cf > 0 && d[i] > d[v] + cost[v][i]) {
d[i] = d[v] + cost[v][i];
par[i] = v;
if (!use[i]) q.push(i);
use[i] = true;
}
}
}
return d[y] != INF;
}
int main() {
cin >> need >> n;
second = 0;
t = n + 27;
for (int j = 0; j < need.size(); ++j) cnt[need[j] - 'a']++;
for (int j = n + 1; j <= n + 26; ++j) c[j][t] = cnt[j - n - 1];
for (int i = 1; i <= n; ++i) {
string second;
int ai, cns[30] = {0};
cin >> second >> ai;
c[0][i] = ai;
cost[0][i] = i;
cost[i][0] = -i;
for (int j = 0; j < second.size(); ++j) cns[second[j] - 'a']++;
for (int j = 0; j < 26; ++j) c[i][j + n + 1] = cns[j];
}
int flow = 0, cst = 0;
while (FBellman(second, t)) {
int v = t, cf = INF;
while (v != second) {
cf = min(cf, c[par[v]][v] - first[par[v]][v]);
v = par[v];
}
flow += cf;
v = t;
while (v != second) {
first[par[v]][v] += cf;
first[v][par[v]] -= cf;
v = par[v];
}
cst += d[t] * cf;
}
if (flow == need.size())
cout << cst;
else
cout << -1;
return 0;
}
| 12 |
#include <bits/stdc++.h>
int main(void) {
int i = 0;
int n = 0;
char line[256] = {0};
int ans = 0;
int one = 0;
scanf("%d", &n);
getchar();
fgets(line, 256, stdin);
for (i = 0; i < n; ++i) {
if (' ' == line[i]) {
if (one > ans) ans = one;
one = 0;
} else if (line[i] >= 'A' && line[i] <= 'Z')
one++;
}
if (one > ans) ans = one;
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100010];
bitset<100010> coler;
long long ans;
const int mod = 1e9 + 7;
long long d[100010][2];
void dfs(int x, int p) {
for (int i = 0; i < g[x].size(); i++) {
if (g[x][i] != p) dfs(g[x][i], x);
}
d[x][coler.test(x)] = 1;
for (int i = 0; i < g[x].size(); i++) {
if (g[x][i] == p) continue;
d[x][1] = d[g[x][i]][1] * d[x][0] + d[g[x][i]][0] * d[x][1];
d[x][0] = d[g[x][i]][0] * d[x][0];
d[x][0] %= mod;
d[x][1] %= mod;
}
d[x][0] += d[x][1];
d[x][0] %= mod;
d[x][1] %= mod;
return;
}
int main() {
int n;
while (cin >> n) {
ans = 1;
coler.reset();
memset(d, 0, sizeof(d));
for (int i = 0; i < n; i++) g[i].clear();
int v;
for (int i = 1; i < n; i++) {
scanf("%d", &v);
g[i].push_back(v);
g[v].push_back(i);
}
for (int i = 0; i < n; i++) {
scanf("%d", &v);
if (v == 1) {
coler.set(i);
}
}
dfs(0, 0);
cout << d[0][1] << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <class P, class Q>
inline void smin(P &a, Q b) {
if (b < a) a = b;
}
template <class P, class Q>
inline void smax(P &a, Q b) {
if (a < b) a = b;
}
const int maxn = 100000 + 100;
int n, OL, OW;
vector<pair<int, int> > adj[maxn];
bool mark[maxn];
int sub_size[maxn];
long long ans;
int fen[maxn];
int get_size(int u, int par = -1) {
int ret = 1;
for (pair<int, int> vw : adj[u])
if (vw.first != par && !mark[vw.first]) ret += get_size(vw.first, u);
return sub_size[u] = ret;
}
int find_center(int u, int comp_size, int par = -1) {
int max_sub = comp_size - sub_size[u];
for (pair<int, int> vw : adj[u])
if (vw.first != par && !mark[vw.first]) {
int tmp = find_center(vw.first, comp_size, u);
if (tmp != -1) return tmp;
smax(max_sub, sub_size[vw.first]);
}
if (max_sub <= comp_size / 2) return u;
return -1;
}
vector<pair<int, int> > store;
void dfs_gen(int u, int par, int curL = 0, int curW = 0) {
if (mark[u] || curL > OL || curW > OW) return;
store.push_back({curW, curL});
for (pair<int, int> vw : adj[u])
if (vw.first != par) dfs_gen(vw.first, u, curL + 1, curW + vw.second);
}
inline void add_fen(int pos, int val) {
for (pos++; pos < maxn; pos += pos & -pos) fen[pos] += val;
}
inline int get_fen(int pos) {
int ret = 0;
for (pos = max(pos, 0); pos; pos -= pos & -pos) ret += fen[pos];
return ret;
}
long long cnt(int u, int par, int L, int W) {
store.clear();
dfs_gen(u, par);
sort((store).begin(), (store).end());
long long ret = 0;
int pos = 0;
for (int i = (int)((int((store).size()))), _x = (int)(0); i-- > _x;) {
while (pos < (int((store).size())) &&
store[pos].first + store[i].first <= W)
add_fen(store[pos].second, 1), pos++;
ret += get_fen(L - store[i].second + 1);
}
while (pos--) add_fen(store[pos].second, -1);
return ret;
}
void solve(int u) {
int comp_size = get_size(u);
u = find_center(u, comp_size);
ans += cnt(u, -1, OL, OW) - 1;
for (pair<int, int> vw : adj[u])
if (!mark[vw.first]) ans -= cnt(vw.first, u, OL - 2, OW - 2 * vw.second);
mark[u] = true;
for (pair<int, int> vw : adj[u])
if (!mark[vw.first]) solve(vw.first);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> OL >> OW;
for (int u = (int)(1), _n = (int)(n); u < _n; u++) {
int v, w;
cin >> v >> w;
v--;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
solve(0);
cout << ans / 2 << endl;
{ return 0; }
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<string> nor = {"great", "cool", "don't think so",
"not bad", "don't touch me", "no"};
for (int i = 0; i < 10; i++) {
cout << i << endl;
cout << flush;
string s;
getline(cin, s);
if (s == "no") continue;
if (find(nor.begin(), nor.end(), s) == nor.end() &&
find(nor.begin(), nor.end(), s.substr(0, s.length() - 2)) ==
nor.end()) {
cout << "grumpy" << endl;
return 0;
} else {
cout << "normal" << endl;
return 0;
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int ans[200000], n, k;
void f(vector<int> v, int l, int r, int &k) {
if (k == 0 || l + 1 == r || k == 1) {
for (int i = 0; i < v.size(); ++i) ans[i + l] = v[i];
return;
}
vector<int> R, L;
int mid = (l + r) / 2;
int pos = 0;
for (int i = mid; i < r; ++i) L.push_back(v[pos]), ++pos;
for (int i = pos; i < v.size(); ++i) R.push_back(v[i]);
k -= 2;
f(R, l, mid, k);
f(L, mid, r, k);
}
int main() {
cin >> n >> k;
vector<int> a;
for (int i = 1; i <= n; ++i) a.push_back(i);
--k;
f(a, 0, n, k);
if (k != 0) return cout << -1 << endl, 0;
for (int i = 0; i < n; ++i) cout << ans[i] << ' ';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int target;
int best = 10;
int op1[15], op2[15], op3[15], bop1[15], bop2[15], bop3[15];
int reg[15];
int N;
void dfs(int lv) {
if (lv >= best) return;
int i, j, k;
for (i = 0; i < N; i++)
if (lv < best && reg[i] == target) {
best = lv;
for (j = 0; j < lv; j++) {
bop1[j] = op1[j], bop2[j] = op2[j], bop3[j] = op3[j];
}
return;
}
if (lv >= best - 1) return;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
for (k = 1; k <= 8; k *= 2) {
if (reg[i] + k * reg[j] > target) continue;
reg[N++] = reg[i] + k * reg[j];
op1[lv] = i;
op2[lv] = k;
op3[lv] = j;
dfs(lv + 1);
N--;
}
}
int main() {
std::ios::sync_with_stdio(false);
cin >> target;
reg[0] = 1, reg[1] = 0;
N = 2;
dfs(0);
cout << best << endl;
int i;
for (i = 0; i < best; i++) {
cout << "lea e" << (char)('a' + 2 + i) << "x, [e" << (char)('a' + bop1[i])
<< "x + " << bop2[i] << "*e" << (char)('a' + bop3[i]) << "x]" << endl;
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int w;
int sum = 0;
int value = 0;
vector<int> nums;
vector<int> ans;
struct Saver {
int index;
int save;
Saver(int i) : index(i) {
ans.push_back(index);
save = ::value;
}
~Saver() {
ans.push_back(index);
::value = save + 1;
--nums[index];
}
};
void spend_to(int i, int dst) {
int &value = nums[i];
while (value > dst) {
Saver s(i);
}
}
void spend_careful(int i, int dst, int &care) {
int &value = nums[i];
while (care > 0 && value > dst) {
Saver s(i);
--care;
}
}
bool solve() {
if (nums.size() == 1) {
if (nums[0] == w) {
spend_to(0, 0);
return true;
} else
return false;
} else if (w == 1) {
vector<int>::iterator id_1 = std::find(nums.begin(), nums.end(), 1);
if (id_1 != nums.end()) {
int i1 = id_1 - nums.begin();
{
Saver s(i1);
for (int i = 0; i < nums.size(); i++)
if (i != i1) spend_to(i, 0);
}
return true;
} else
return false;
} else {
if (sum < w || w < 2) return false;
int need = w - 2;
int need0 = min(nums[0] - 1, need);
need -= need0;
int to_spend = sum - nums[0] - need - 1;
{
Saver s(0);
spend_careful(1, 1, to_spend);
for (int i = 2; i < nums.size(); ++i) spend_careful(i, 0, to_spend);
}
{
Saver s(1);
spend_to(0, need0);
}
for (int i = 0; i < nums.size(); i++) spend_to(i, 0);
return true;
}
}
int main() {
int n;
scanf("%d%d", &n, &w);
nums.resize(n);
for (int i = 0; i < n; i++) {
scanf("%d", &nums[i]);
sum += nums[i];
}
if (solve()) {
printf("Yes\n");
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i] + 1);
}
printf("\n");
assert(value == w);
} else {
printf("No\n");
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
struct Candy {
Candy() = default;
Candy(int from, int to) : m_from(from), m_to(to) {}
int m_from;
int m_to;
};
int Distance(const Candy &candy, int n) {
const int d = candy.m_to - candy.m_from;
return d < 0 ? d + n : d;
}
int Solve(int n, int start, const vector<vector<Candy>> &candies) {
int result = 0;
for (int step = 0; step < n; ++step) {
const int curr = (start + step) % n;
const auto &cs = candies[curr];
if (cs.empty()) continue;
result =
max<int>(result, step + n * (cs.size() - 1) + Distance(cs.front(), n));
}
return result;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<vector<Candy>> candies(n);
for (int i = 0; i < m; ++i) {
int from, to;
scanf("%d%d", &from, &to);
--from, --to;
candies[from].emplace_back(from, to);
}
for (auto &cs : candies) {
sort(cs.begin(), cs.end(), [&](const Candy &lhs, const Candy &rhs) {
return Distance(lhs, n) < Distance(rhs, n);
});
}
for (int i = 0; i < n; ++i) {
if (i != 0) printf(" ");
printf("%d", Solve(n, i, candies));
}
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long n, m, c, q, u, v, par[100005];
char type;
set<long> s[100005];
map<long, long> color[100005];
long find(int i) {
if (par[i] == i) {
return i;
} else {
return par[i] = find(par[i]);
}
}
void uni(int u, int v) {
long par_u = find(u), par_v = find(v);
if (par_u == par_v) {
return;
}
if (s[par_u].size() > s[par_v].size()) {
swap(s[par_u], s[par_v]);
}
for (auto w : s[par_u]) {
s[par_v].insert(w);
}
par[par_u] = par_v;
}
void add(int u, int v, int c) {
if (color[u][c] != 0) {
uni(v, color[u][c]);
}
if (color[v][c] != 0) {
uni(u, color[v][c]);
}
s[find(u)].insert(v);
s[find(v)].insert(u);
color[u][c] = v;
color[v][c] = u;
}
int main() {
scanf("%ld %ld %ld %ld", &n, &m, &c, &q);
for (int i = 1; i <= n; i++) {
par[i] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%ld %ld %ld", &u, &v, &c);
add(u, v, c);
}
for (int i = 1; i <= q; i++) {
cin >> type;
if (type == '+') {
scanf("%ld %ld %ld", &u, &v, &c);
add(u, v, c);
} else {
scanf("%ld %ld", &u, &v);
long par_u = find(u), par_v = find(v);
if (par_u == par_v || s[par_u].find(v) != s[par_u].end()) {
printf("Yes\n");
} else {
printf("No\n");
}
}
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
char ch = getchar();
bool flag = false;
x = 0;
while (!isdigit(ch)) flag |= (ch == '-'), ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
if (flag) x = -x;
}
const int inf = 0x3f3f3f3f;
const double eps = 10e-5;
const int Mod = 1e9 + 7;
const int N = 1e5 + 5, M = 105;
struct Edge {
int to, next;
} e[N * 2];
int head[N], c[N], cnt[N], sz[N];
int n, tot, son[N], Bigson;
long long ans[N], maxn, Sum;
void add(int x, int y) {
e[++tot].to = y;
e[tot].next = head[x];
head[x] = tot;
}
void dfs1(int u, int fa) {
sz[u] = 1;
for (int i = head[u]; ~i; i = e[i].next) {
int &v = e[i].to;
if (v == fa) continue;
dfs1(v, u);
sz[u] += sz[v];
if (sz[v] > sz[son[u]]) son[u] = v;
}
}
void update(int u, int fa, int val) {
cnt[c[u]] += val;
if (cnt[c[u]] > maxn)
maxn = cnt[c[u]], Sum = c[u];
else if (cnt[c[u]] == maxn)
Sum += c[u];
for (int i = head[u]; ~i; i = e[i].next) {
int &v = e[i].to;
if (v == fa || v == Bigson) continue;
update(v, u, val);
}
}
void dfs2(int u, int fa, int op) {
for (int i = head[u]; ~i; i = e[i].next) {
int &v = e[i].to;
if (v == fa || v == son[u]) continue;
dfs2(v, u, 0);
}
if (son[u]) dfs2(son[u], u, 1), Bigson = son[u];
update(u, fa, 1);
ans[u] = Sum, Bigson = 0;
if (!op) {
update(u, fa, -1);
Sum = maxn = 0;
}
}
int main() {
memset(head, -1, sizeof(head));
read(n);
for (int i = 1; i <= n; i++) read(c[i]);
for (int i = 1; i < n; i++) {
int x, y;
read(x), read(y);
add(x, y);
add(y, x);
}
dfs1(1, 0);
dfs2(1, 0, 0);
for (int i = 1; i <= n; i++) printf("%lld%c", ans[i], i != n ? ' ' : '\n');
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long int a[102];
int main() {
long long int n, i, j, sum, temp_sum;
while (cin >> n) {
for (i = 0; i < n; ++i) {
cin >> a[i];
}
sum = 100000000;
for (i = 1; i <= n; ++i) {
temp_sum = 0;
for (j = 1; j <= n; ++j) {
temp_sum = temp_sum +
(a[j - 1] * (2 * (abs(i - j) + abs(j - 1) + abs(1 - i))));
}
if (sum > temp_sum) sum = temp_sum;
}
cout << sum << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-9;
int sg[100001], mex[100001], _xor[100001];
int main() {
int n;
while (cin >> n) {
for (int i = 1; i <= n; ++i) {
for (int k = 2;; ++k) {
int mul = k * (k - 1) / 2;
if (mul >= i) break;
if ((i - mul) % k) continue;
int a = (i - mul) / k;
int t = _xor[a + k - 1] ^ _xor[a - 1];
mex[t] = i;
}
for (int j = 0;; ++j) {
if (mex[j] != i) {
sg[i] = j;
break;
}
}
_xor[i] = _xor[i - 1] ^ sg[i];
}
if (!sg[n]) {
printf("-1\n");
} else {
int k = 2;
for (;; ++k) {
int mul = k * (k - 1) / 2;
if ((n - mul) % k) continue;
int a = (n - mul) / k;
int t = _xor[a + k - 1] ^ _xor[a - 1];
if (!t) break;
}
printf("%d\n", k);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100004;
int n;
int pre[maxn], countx[maxn] = {0};
bool a[maxn], vis[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
a[i] = t;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &pre[i]);
countx[pre[i]]++;
}
memset(vis, false, sizeof(vis));
int max = 0, maxn;
for (int i = 1; i <= n; i++)
if (a[i]) {
int sum = 1, x = pre[i];
while (countx[x] <= 1 && x != 0 && (!vis[x])) {
vis[x] = true;
sum++;
x = pre[x];
}
if (sum > max) {
max = sum;
maxn = i;
}
}
stack<int> ans;
printf("%d\n", max);
int i;
for (i = maxn; max--; i = pre[i]) ans.push(i);
while (ans.size() > 0) {
printf("%d ", ans.top());
ans.pop();
}
printf("\n");
}
| 7 |
Subsets and Splits