solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long modexpo(long long x, long long p) {
long long res = 1;
x = x % 1000000007;
while (p) {
if (p % 2) res = res * x;
p >>= 1;
x = x * x % 1000000007;
res %= 1000000007;
}
return res;
}
struct compare {
bool operator()(const long long a, const long long b) const { return a < b; }
};
const long long nax = 1e5 + 5;
long long sieve[nax];
bool isPrime(long long x) {
if (x < 2) {
return false;
}
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
map<long long, long long> mp;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (long long i = 2; i < nax; i++) {
if (sieve[i]) {
continue;
}
sieve[i] = 1;
for (long long j = 2 * i; j < nax; j += i) {
sieve[j] = 2;
}
}
vector<long long> primes;
for (long long i = 2; i < nax; i++) {
if (sieve[i] == 1) {
primes.push_back(i);
mp[i] = 1;
}
}
long long n;
cin >> n;
if (isPrime(n)) {
cout << 1 << " " << n << "\n";
exit(0);
}
if (isPrime(n - 2)) {
cout << 2 << " " << n - 2 << " " << 2 << "\n";
exit(0);
}
if (isPrime(n - 4)) {
cout << 3 << " " << 2 << " " << 2 << " " << n - 4 << "\n";
exit(0);
}
long long x = n - 5;
cout << 3 << "\n";
for (long long i : primes) {
if (mp.count(x - i)) {
cout << 5 << " " << i << " " << x - i << "\n";
exit(0);
}
if (isPrime(x - i)) {
cout << 5 << " " << i << " " << x - i << "\n";
exit(0);
}
}
if (n % 3 == 0 && isPrime(n / 3)) {
cout << n / 3 << " " << n / 3 << " " << n / 3 << "\n";
}
assert(false);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b);
long long int power(long long int a, long long int b);
long long int powerwithmod(long long int a, long long int b);
long long int nCr(long long int n, long long int r);
long long int fact(long long int n);
vector<vector<int>> sol;
long long int a[10008];
void transfer(int i, int j, int x) {
a[i] = a[i] - (i * x);
a[j] = a[j] + (i * x);
sol.push_back({i, j, x});
}
void solve() {
sol.clear();
int n;
cin >> n;
long long int sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum % n != 0) {
cout << -1 << endl;
return;
}
int target = sum / n;
long long int k = 0;
for (int i = 2; i <= n; i++) {
if (a[i] % i) transfer(1, i, i - (a[i] % i));
transfer(i, 1, (a[i] / i));
}
for (int i = 2; i <= n; i++) {
transfer(1, i, target);
}
cout << sol.size() << endl;
for (auto iterator : sol) {
cout << iterator[0] << " " << iterator[1] << " " << iterator[2] << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t-- > 0) solve();
return 0;
}
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 powerwithmod(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return res % 1000000007;
}
long long int power(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a);
a = (a * a);
b >>= 1;
}
return res;
}
long long int nCr(long long int n, long long int r) {
return fact(n) / (fact(r) * fact(n - r));
}
long long int fact(long long int n) {
long long int res = 1;
for (long long int i = 2; i <= n; i++) res = (res * i) % 1000000007;
return (res) % 1000000007;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int lb(int x) { return x & -x; }
struct Fenwick {
int f[MAXN];
void add(int ind, int x) {
while (ind < MAXN) {
f[ind] += x;
ind += lb(ind);
}
}
int get(int ind) {
int ret = 0;
while (ind > 0) {
ret += f[ind];
ind -= lb(ind);
}
return ret;
}
int getR(int l, int r) { return get(r) - get(l - 1); }
};
Fenwick t[4][10][10];
string s;
int q;
int main() {
cin >> s;
s = " " + s;
map<char, int> m;
m['A'] = 0;
m['T'] = 1;
m['G'] = 2;
m['C'] = 3;
for (int i = 1; i < s.size(); i++) {
int ind = m[s[i]];
for (int j = 1; j <= 10; j++) t[ind][i % j][j - 1].add(i, 1);
}
cin >> q;
while (q--) {
int op;
cin >> op;
if (op == 1) {
int x;
cin >> x;
char c;
cin >> c;
int old = m[s[x]];
for (int i = 1; i <= 10; i++) t[old][x % i][i - 1].add(x, -1);
for (int i = 1; i <= 10; i++) t[m[c]][x % i][i - 1].add(x, 1);
s[x] = c;
} else {
int l, r;
string e;
cin >> l >> r >> e;
int ans = 0;
for (int i = 0; i < e.size(); i++)
ans += t[m[e[i]]][(l + i) % e.size()][e.size() - 1].getR(l, r);
cout << ans << "\n";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int maxn = 1000;
long long f[maxn];
int main() {
f[0] = 1;
for (long long i = 1; i < 1000; i++) f[i] = (f[i - 1] * 2) % MOD;
string s;
cin >> s;
long long len = s.size();
long long ans = 0, k = (len - 1) * 2;
for (long long i = 0; i < len; i++) {
if (s[i] == '1') ans = (ans + f[k - i]) % MOD;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int jiecheng(int x) {
if (x == 1)
return 1;
else
return x * jiecheng(x - 1);
}
int main() {
int A, B;
cin >> A >> B;
if (A > B)
cout << jiecheng(B);
else
cout << jiecheng(A);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct cell {
int x, y, cost;
cell(int i, int j, int k) {
x = i;
y = j;
cost = k;
}
};
int main() {
int n, m, s;
scanf("%d%d%d", &n, &m, &s);
s--;
int t1, t2, t3;
vector<vector<pair<int, int> > > g(n);
vector<int> qq(m), w(m), e(m);
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &t1, &t2, &t3);
t1--;
t2--;
qq[i] = t1;
w[i] = t2;
e[i] = t3;
g[t1].push_back(make_pair(t2, t3));
g[t2].push_back(make_pair(t1, t3));
}
int l;
scanf("%d", &l);
vector<int> d(n, 1000000000);
d[s] = 0;
queue<int> q;
q.push(s);
d[s] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (unsigned int i = 0; i < g[v].size(); i++) {
int to = g[v][i].first, len = g[v][i].second;
if (d[v] + len < d[to]) {
d[to] = d[v] + len;
q.push(to);
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i)
if (d[i] == l) ans++;
for (int i = 0; i < m; ++i) {
int x = qq[i], y = w[i], z = e[i];
int k1 = l - d[x];
if (k1 > 0 && k1 != z) {
int res = min(d[x] + k1, z - k1 + d[y]);
if (res == l) ans++;
}
int k2 = l - d[y];
if (k2 > 0 && k2 != z - k1 && k2 != z) {
int res = min(d[y] + k2, z - k2 + d[x]);
if (res == l) ans++;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string t;
cin >> t;
cout << t << string(t.rbegin(), t.rend());
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long mod = 1e9 + 7;
const int inf = 1e9 + 5;
const int N = 1e6 + 5;
int d[10];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int i, t, a, b, c;
cin >> t;
while (t--) {
cin >> a >> b >> c;
int ans = -inf, f1, f2, f3;
for (i = 1; i < 7; ++i) d[i] = i;
do {
int x = a, y = b, z = c, res = 0;
for (i = 1; i < 7; ++i) {
int r1 = 0, r2 = 0, r3 = 0;
if (d[i] & 1) ++r3;
if (d[i] & 2) ++r2;
if (d[i] & 4) ++r1;
if (x >= r1 && y >= r2 && z >= r3) {
++res;
x -= r1;
y -= r2;
z -= r3;
}
}
if (x >= 1 && y >= 1 && z >= 1) ++res;
ans = max(ans, res);
} while (next_permutation(d + 1, d + 7));
cout << ans << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[10005], x = 0, z = 0;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
x = max(x, a[i]);
z = gcd(z, a[i]);
}
cout << ((x / z - n) % 2 ? "Alice" : "Bob");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
double h, l;
cin >> h >> l;
cout << fixed << setprecision(13) << (l * l - h * h) / (2 * h);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, sum, k, i, m, c;
char ch;
while (cin >> n >> x) {
sum = x;
k = 0;
for (i = 1; i <= n; i++) {
cin >> ch >> m;
if (ch == '+') {
sum = sum + m;
} else {
c = sum;
sum = sum - m;
if (sum < 0) {
k++;
sum = c;
}
}
}
cout << sum << " " << k << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
struct segTree {
int value[800010];
void update(int k) { value[k] = value[2 * k] + value[2 * k + 1]; }
void set(int ind, int l = 1, int r = 200000, int v = 1) {
if (l == r)
value[v] = 1;
else {
int h = (l + r) / 2;
if (ind <= h)
set(ind, l, h, 2 * v);
else
set(ind, h + 1, r, 2 * v + 1);
update(v);
}
}
int sum(int L, int R, int l = 1, int r = 200000, int v = 1) {
if (L <= l && r <= R)
return value[v];
else if (R < l)
return 0;
else if (r < L)
return 0;
else {
int h = (l + r) / 2;
return sum(L, R, l, h, 2 * v) + sum(L, R, h + 1, r, 2 * v + 1);
}
}
} T;
struct str {
int x0;
int x1;
int y0;
} x[200010];
bool cmp1(str a, str b) { return a.x0 < b.x0; }
bool cmp2(str a, str b) {
if (a.y0 == b.y0) return a.x0 < b.x0;
return a.y0 > b.y0;
}
std::vector<int> V;
int main() {
int a;
scanf("%d", &a);
for (int i = 1; i <= a; i++) {
int b, c;
scanf("%d%d", &b, &c);
x[i] = {b, 0, c};
}
std::sort(x + 1, x + a + 1, cmp1);
int count = 0;
for (int i = 1; i <= a; i++) {
if (x[i].x0 != x[i - 1].x0) count++;
x[i].x1 = count;
}
std::sort(x + 1, x + a + 1, cmp2);
long long int ans = 0;
V.push_back(0);
for (int i = 1; i <= a; i++) {
if (x[i].y0 < x[i - 1].y0) {
for (int j = 1; j < V.size(); j++) {
long long int s1 = T.sum(V[j - 1] + 1, V[j]);
long long int s2 = T.sum(V[j], a);
ans += s1 * s2;
}
V.clear(), V.push_back(0);
}
V.push_back(x[i].x1);
T.set(x[i].x1);
}
for (int j = 1; j < V.size(); j++) {
long long int s1 = T.sum(V[j - 1] + 1, V[j]);
long long int s2 = T.sum(V[j], a);
ans += s1 * s2;
}
printf("%lld", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005];
int main() {
cin >> n;
if (n <= 2) {
cout << n << endl;
return 0;
}
for (int i = 1; i <= n; i++) cin >> a[i];
int cur = 0, ans = 2;
for (int i = 2; i <= n; i++) {
if (a[i] == a[i - 2] + a[i - 1]) {
if (cur == 0)
cur = min(3, i);
else
cur++;
} else {
cur = 0;
}
ans = max(ans, cur);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, M = 20, INF = 1e9;
int n, m, a[N], lst[M], go[M][N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int j = 0; j < M; j++) {
lst[j] = n + 1;
}
memset(go, 63, sizeof(go));
for (int i = n; i >= 1; i--) {
for (int j = 0; j < M; j++) {
if ((a[i] >> j) & 1) {
for (int k = 0; k < M; k++) {
go[k][i] = min(go[k][i], go[k][lst[j]]);
}
lst[j] = i;
go[j][i] = i;
}
}
}
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
bool p = false;
for (int j = 0; j < M; j++) {
p |= (((a[y] >> j) & 1) && go[j][x] <= y);
}
cout << (p ? "Shi" : "Fou") << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string max, min;
string current;
size_t k;
cin >> k;
cin >> current;
max = current;
min = current;
for (size_t i = 0; i < k - 1; ++i) {
cin >> current;
if (current > max) {
max = current;
}
if (current < min) {
min = current;
}
}
int answer = 0;
for (size_t i = 0; i < min.size(); ++i) {
if (min[i] != max[i]) break;
++answer;
}
cout << answer;
}
| 0 |
#include <bits/stdc++.h>
const int MAXN = 1e5 + 10;
const int MAXM = 1e6 + 10;
int n;
int f[MAXN];
int g[MAXN], m;
bool temp[MAXM];
int h[MAXM], cnt;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &f[i]);
for (int i = 1; i <= n; ++i)
if (f[f[i]] != f[i]) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; ++i) {
if ((!g[i]) && (!g[f[i]])) {
g[i] = ++m;
g[f[i]] = m;
} else if (!g[i])
g[i] = g[f[i]];
else if (!g[f[i]])
g[f[i]] = g[i];
else if (g[i] != g[f[i]]) {
printf("-1\n");
return 0;
}
}
for (int i = 1; i <= n; ++i)
if (i == f[i]) temp[i] = true, ++cnt;
if (cnt < m) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; ++i)
if (!h[g[i]] && temp[i]) h[g[i]] = i;
for (int i = 1; i <= m; ++i)
if (!h[i]) {
printf("-1\n");
return 0;
}
printf("%d\n", m);
for (int i = 1; i <= n; ++i) printf("%d ", g[i]);
printf("\n");
for (int i = 1; i <= m; ++i) printf("%d ", h[i]);
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int M[310][310];
int n;
int pd[2 * 310][310][310];
int Vx[] = {1, 0};
int Vy[] = {0, 1};
inline bool fora(int x, int y) {
if (max(x, y) >= n) return 1;
return 0;
}
int solve(int p, int l1, int l2) {
if (p == n + n - 2) return 0;
int& ret = pd[p][l1][l2];
if (ret != -1) return ret;
int c1 = p - l1, c2 = p - l2;
ret = -1000000000;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) {
int x1 = l1 + Vx[i], y1 = c1 + Vy[i];
int x2 = l2 + Vx[j], y2 = c2 + Vy[j];
if (fora(x1, y1) || fora(x2, y2)) continue;
int s = M[x1][y1] + M[x2][y2];
if (x1 == x2) s -= M[x1][y1];
ret = max(ret, s + solve(p + 1, x1, x2));
}
return ret;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> M[i][j];
memset(pd, -1, sizeof pd);
cout << M[0][0] + solve(0, 0, 0) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double esp = 1e-9;
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1000000007;
int dx[4] = {1, 1, -1, -1};
int dy[4] = {1, -1, 1, -1};
int s[110010];
int q[110010];
int main() {
int n, t;
memset(s, 0, sizeof(s));
memset(q, 0, sizeof(q));
scanf("%d", &n);
for (int x = 1; x <= n; x++) {
scanf("%d", &s[x]);
q[s[x]]++;
}
int flag = 0;
for (int x = 2; x <= 100000; x++)
if (q[x] > q[x - 1]) {
flag = 1;
break;
}
int ans = q[1];
memset(q, 0, sizeof(q));
if (flag)
printf("%d\n", -1);
else {
printf("%d\n", ans);
for (int x = 1; x <= n; x++) printf("%d ", ++q[s[x]]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int T;
cin >> T;
while (T--) {
int n, p;
cin >> n >> p;
vector<int> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
sort(v.begin(), v.end(), greater<int>());
if (p == 1) {
cout << (n & 1) << '\n';
continue;
}
long long nec = -1;
vector<pair<int, int>> cur;
function<void(int)> ins = [&](int a) {
if (cur.empty())
cur.emplace_back(a, 1);
else {
if (cur[cur.size() - 1].first == a) {
int cur_ct = cur[cur.size() - 1].second;
if (cur_ct == p - 1) {
cur.pop_back();
ins(a + 1);
} else
++cur[cur.size() - 1].second;
} else {
cur.emplace_back(a, 1);
}
}
};
for (int a : v) {
if (nec == -1) {
nec = a;
} else {
ins(a);
}
if (!cur.empty()) {
if (cur[cur.size() - 1].first == nec) {
nec = -1;
cur.clear();
}
}
}
if (nec == -1) {
cout << 0 << '\n';
continue;
}
long long ans = powmod(p, nec);
for (auto a : cur) {
ans = ((ans - powmod(p, a.first) * a.second % mod) % mod + mod) % mod;
}
cout << (ans + (long long)mod * mod) % mod << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
char s[maxn];
int c[maxn], n;
int sum(int x) {
int ans = 0;
while (x) {
ans += c[x];
x -= x & -x;
}
return ans;
}
void add(int x, int v) {
while (x <= n) {
c[x] += v;
x += x & -x;
}
}
int main() {
scanf("%d%s", &n, s + 1);
for (int i = 1; i <= n; i++) c[i] = 0;
queue<int> g[35];
for (int i = 1; i <= n; i++) {
g[s[i] - 'a'].push(i);
add(i, 1);
}
long long ans = 0;
for (int i = n; i; i--) {
int x = g[s[i] - 'a'].front();
g[s[i] - 'a'].pop();
ans += sum(x) - 1;
add(x, -1);
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main(int argc, const char* argv[]) {
int m, a[1000], x, y, sonuc = 0;
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", &a[i]);
scanf("%d %d", &x, &y);
for (int i = 0; i < m; i++) {
sonuc += a[i];
if (sonuc >= x && sonuc <= y) {
int sonuc2 = 0;
for (int j = i + 1; j < m; j++) sonuc2 += a[j];
if (sonuc2 >= x && sonuc2 <= y) {
printf("%d", i + 2);
return 0;
}
}
}
printf("0");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int s_digit(int a) {
int sum = 0, mod = 0, n;
n = a;
for (; a != 0; a /= 10) sum += (a % 10);
mod = sum % 4;
if (mod == 0)
return n;
else if (s_digit(n + (4 - mod)) == 0)
return n + (4 - mod);
else
s_digit(n + 1);
}
int main() {
int a;
cin >> a;
cout << s_digit(a) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, mod = 1e9 + 7;
struct Mat {
static const int N = 3;
int v[N][N];
Mat() {}
Mat(int x) {
memset(v, 0, sizeof v);
if (x == 1)
for (int i = 0; i < N; i++) v[i][i] = 1;
}
void set(int p) {
v[0][0] = 0, v[0][1] = 1, v[0][2] = 0;
v[1][0] = 1, v[1][1] = 1, v[1][2] = 0;
v[2][0] = 0, v[2][1] = p, v[2][2] = 1;
}
void print() {
for (int i = 0; i < 3; i++, puts(""))
for (int j = 0; j < 3; j++) printf("%3d ", v[i][j]);
puts("");
}
Mat operator*(Mat x) {
Mat ans(0);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
ans.v[i][j] = (1LL * v[i][k] * x.v[k][j] + ans.v[i][j]) % mod;
return ans;
}
Mat operator^(long long y) {
Mat x = *this, ans(1);
while (y) {
if (y & 1LL) ans = ans * x;
x = x * x, y >>= 1;
}
return ans;
}
};
long long k;
int m;
struct STR {
string s;
int id, ans;
} s[N];
string s1 = "a", s2 = "b", s3 = "ba", s4 = "bab";
bool cmpL(STR a, STR b) {
if (int(a.s.size()) == int(b.s.size())) return a.s < b.s;
return a.s.size() < b.s.size();
}
bool cmpid(STR a, STR b) { return a.id < b.id; }
int Fail[N];
char S1[N], S2[N];
int KMP(string &s1, string &s2) {
int n = s1.size(), m = s2.size();
for (int i = 1; i <= n; i++) S1[i] = s1[i - 1];
for (int i = 1; i <= m; i++) S2[i] = s2[i - 1];
Fail[0] = Fail[1] = 0;
for (int i = 2; i <= m; i++) {
int k = Fail[i - 1];
while (k && S2[i] != S2[k + 1]) k = Fail[k];
if (S2[i] == S2[k + 1]) k++;
Fail[i] = k;
}
int ans = 0, k = 0;
for (int i = 1; i <= n; i++) {
while (k && S1[i] != S2[k + 1]) k = Fail[k];
if (S1[i] == S2[k + 1]) k++;
if (k == m) {
ans++;
k = Fail[k];
}
}
return ans;
}
int main() {
cin >> k >> m;
for (int i = 1; i <= m; i++) {
cin >> s[i].s;
s[i].id = i;
}
sort(s + 1, s + m + 1, cmpL);
int cnt = 1;
for (int i = 1; i <= m; i++) {
while (cnt < k && int(s1.size()) < int(s[i].s.size())) {
s1 = s4 + s3;
swap(s1, s2), swap(s2, s3), swap(s3, s4);
cnt++;
}
if (cnt == k) {
s[i].ans = KMP(s1, s[i].s);
continue;
}
int a = KMP(s1, s[i].s), b = KMP(s2, s[i].s), c = KMP(s3, s[i].s),
d = KMP(s4, s[i].s);
int del1 = c - a - b, del2 = d - b - c;
Mat st(0), tn1(0), tn2(0);
st.v[0][0] = a, st.v[0][1] = b, st.v[0][2] = 1;
tn1.set(del1);
tn2.set(del2);
st = st * ((tn1 * tn2) ^ ((k - cnt) / 2));
if ((k - cnt) & 1) st = st * tn1;
s[i].ans = st.v[0][0];
}
sort(s + 1, s + m + 1, cmpid);
for (int i = 1; i <= m; i++) printf("%d\n", s[i].ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a >= b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a <= b)
return a;
else
return b;
}
long long diff(long long a, long long b) {
if (a >= b)
return a - b;
else
return b - a;
}
long long isPrime(long long n) {
if (n < 2) return 0;
if (n < 4) return 1;
if (n % 2 == 0 or n % 3 == 0) return 0;
for (long long i = 5; i * i <= n; i += 6)
if (n % i == 0 or n % (i + 2) == 0) return 0;
return 1;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void sort(long long arr[], long long n) {
for (long long i = 0; i <= n; i++) {
for (long long j = i; j <= n; j++) {
if (arr[i] > arr[j]) {
long long t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
}
}
long long modd(long long n, long long m) {
if (n - m > 0) {
return n - m;
} else {
return m - n;
}
}
long long fact(long long n) {
if (n == 1) {
return 1;
} else {
return n * fact(n - 1);
}
}
long long mod(long long n) {
if (n >= 0) {
return n;
} else {
return -n;
}
}
long long isperfectsquare(long long n) {
long long k = sqrt(n);
if (n % k == 0 && n / k == k) {
return 1;
} else {
return 0;
}
}
vector<long long> q;
vector<long long> v[500005];
map<long long, long long> ct;
long long vis[500005];
long long cnt = 1;
void dfs(long long x) {
vis[x] = cnt;
for (long long i = 0; i < v[x].size(); i++) {
if (vis[v[x][i]] == 0) {
dfs(v[x][i]);
}
}
}
void pairsort(long long a[], long long b[], long long n) {
pair<long long, long long> pairt[n];
for (long long i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (long long i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long ispalindrome(string s) {
long long palindrome = 1;
long long n = s.length();
for (long long i = 0; i < (n / 2); i++) {
if (s[i] != s[n - 1 - i]) {
palindrome = 0;
break;
}
}
return palindrome;
}
int32_t main() {
long long a, b;
cin >> a >> b;
long long m[a];
long long n[b];
for (long long i = 0; i < a; i++) {
cin >> m[i];
}
for (long long i = 0; i < b; i++) {
cin >> n[i];
}
long long cz = 0;
long long index = 0;
for (long long i = 0; i < a; i++) {
if (m[i] == 0) {
cz++;
index = i;
}
}
if (cz == 1) {
m[index] = n[0];
for (long long i = 0; i < a - 1; i++) {
if (m[i] >= m[i + 1]) {
cout << "Yes";
return 0;
}
}
cout << "No";
} else {
cout << "Yes";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int pos;
vector<int> V, V1, V2;
bool same[10];
int N, X, Y, ans, ans1, ans2;
void f(vector<int> V) {
int lo = 1, hi = V.size();
while (lo < hi) {
int med = (lo + hi) / 2;
printf("? %d", med);
for (int i = 0; i < (int)med; i++) printf(" %d", V[i]);
printf("\n");
fflush(stdout);
scanf("%d", &ans);
if (ans == 0 || ans == X)
lo = med + 1;
else
hi = med;
}
ans1 = V[lo - 1];
}
int main() {
scanf("%d", &N), scanf("%d", &X), scanf("%d", &Y);
for (int i = 0; i < (int)10; i++) {
V.clear();
for (int n = 1; n < (int)N + 1; n++)
if (n & (1 << i)) V.push_back(n);
if (V.empty()) {
same[i] = true;
continue;
}
printf("? %d", (int)V.size());
for (int i = 0; i < (int)V.size(); i++) printf(" %d", V[i]);
printf("\n");
fflush(stdout);
scanf("%d", &ans);
if (ans == 0 || ans == X)
same[i] = true;
else
pos = i;
}
for (int n = 1; n < (int)N + 1; n++)
if ((n & (1 << pos)) != 0) V1.push_back(n);
for (int n = 1; n < (int)N + 1; n++)
if ((n & (1 << pos)) == 0) V2.push_back(n);
if (V1.size() <= V2.size())
f(V1);
else
f(V2);
for (int i = 0; i < (int)10; i++) {
if ((ans1 & (1 << i)) != 0 && same[i]) ans2 |= 1 << i;
if ((ans1 & (1 << i)) == 0 && !same[i]) ans2 |= 1 << i;
}
if (ans1 > ans2) swap(ans1, ans2);
printf("! %d %d\n", ans1, ans2);
fflush(stdout);
}
| 8 |
#include <bits/stdc++.h>
long long n, s, i;
int main() {
for (std::cin >> n; std::cin >> n; std::cout << s << '\n')
for (s = n * (n + (i = 1)) / 2; i <= n; s -= i *= 2)
;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, q, f[MAXN];
struct node {
int score, maxpref, maxsuf, size;
};
node make_node(int a, int b, int c, int d) { return {a, b, c, d}; }
node operator+(node a, node b) {
node c;
c.score =
a.score + b.score - f[a.maxsuf] - f[b.maxpref] + f[a.maxsuf + b.maxpref];
if (a.maxpref == a.size)
c.maxpref = a.size + b.maxpref;
else
c.maxpref = a.maxpref;
if (b.maxsuf == b.size)
c.maxsuf = a.maxsuf + b.size;
else
c.maxsuf = b.maxsuf;
c.size = a.size + b.size;
return c;
}
node tree[4 * MAXN];
void init_tree(int i, int L, int R) {
if (L == R) {
tree[i] = {0, 0, 0, 1};
return;
}
int mid = (L + R) / 2;
init_tree(2 * i, L, mid);
init_tree(2 * i + 1, mid + 1, R);
tree[i] = tree[2 * i] + tree[2 * i + 1];
}
void update(int i, int L, int R, int p) {
if (p < L || R < p) return;
if (L == R) {
tree[i] = {f[1], 1, 1, 1};
return;
}
int mid = (L + R) / 2;
update(2 * i, L, mid, p);
update(2 * i + 1, mid + 1, R, p);
tree[i] = tree[2 * i] + tree[2 * i + 1];
}
node query(int i, int L, int R, int p, int q) {
if (q < p) return {0, 0, 0, 0};
if (q < L || R < p) return {0, 0, 0, 0};
if (p <= L && R <= q) return tree[i];
int mid = (L + R) / 2;
return query(2 * i, L, mid, p, q) + query(2 * i + 1, mid + 1, R, p, q);
}
struct path {
int index, u, v, w;
};
bool operator<(path a, path b) {
if (a.w != b.w)
return a.w < b.w;
else
return a.index < b.index;
}
int res[MAXN];
path edges[MAXN], queries[MAXN];
vector<int> G[MAXN];
int sz[MAXN], parent[MAXN];
void dfs_sz(int u, int par = -1) {
sz[u] = 1;
parent[u] = par;
for (int &v : G[u]) {
if (v == par) continue;
dfs_sz(v, u);
sz[u] += sz[v];
if (G[u][0] == par || sz[v] > G[u][0]) swap(v, G[u][0]);
}
}
int mtime, up[MAXN], Ltime[MAXN], Rtime[MAXN];
void dfs_hld(int u, int par = -1) {
Ltime[u] = Rtime[u] = mtime++;
for (int v : G[u]) {
if (v == par) continue;
if (v == G[u][0])
up[v] = up[u];
else
up[v] = v;
dfs_hld(v, u);
Rtime[u] = Rtime[v];
}
}
int s[MAXN];
int main() {
scanf("%d %d", &n, &q);
f[0] = 0;
for (int i = 1; i < n; i++) scanf("%d", &f[i]);
for (int i = 0; i < n - 1; i++) {
scanf("%d %d %d", &edges[i].u, &edges[i].v, &edges[i].w);
edges[i].u--, edges[i].v--;
G[edges[i].u].push_back(edges[i].v);
G[edges[i].v].push_back(edges[i].u);
edges[i].index = i;
}
sort(edges, edges + n - 1);
for (int i = 0; i < q; i++) {
scanf("%d %d %d", &queries[i].u, &queries[i].v, &queries[i].w);
queries[i].u--, queries[i].v--;
queries[i].index = i;
}
sort(queries, queries + q);
dfs_sz(0);
mtime = 0;
up[0] = 0;
dfs_hld(0);
init_tree(1, 0, n - 1);
memset(s, 0, sizeof s);
int j = n - 2;
for (int i = q - 1; i >= 0; i--) {
while (j >= 0 && edges[j].w >= queries[i].w) {
if (Ltime[edges[j].u] > Ltime[edges[j].v]) swap(edges[j].u, edges[j].v);
s[edges[j].v] = 1;
update(1, 0, n - 1, Ltime[edges[j].v]);
j--;
}
node a = {0, 0, 0, 0};
node b = {0, 0, 0, 0};
int u = queries[i].u, v = queries[i].v;
while (true) {
if (Ltime[up[u]] <= Ltime[v] && Rtime[v] <= Rtime[up[u]]) {
break;
} else {
a = query(1, 0, n - 1, Ltime[up[u]] + 1, Ltime[u]) + a;
a = make_node(f[s[up[u]]], s[up[u]], s[up[u]], 1) + a;
u = parent[up[u]];
}
}
while (up[v] != up[u]) {
b = query(1, 0, n - 1, Ltime[up[v]] + 1, Ltime[v]) + b;
b = make_node(f[s[up[v]]], s[up[v]], s[up[v]], 1) + b;
v = parent[up[v]];
}
if (Ltime[u] < Ltime[v]) {
b = query(1, 0, n - 1, Ltime[u] + 1, Ltime[v]) + b;
} else {
a = query(1, 0, n - 1, Ltime[v] + 1, Ltime[u]) + a;
}
swap(a.maxpref, a.maxsuf);
res[queries[i].index] = (a + b).score;
}
for (int i = 0; i < q; i++) printf("%d\n", res[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, now, i, j, k, cnt;
int l[105], r[105], d[205];
double ans[105], f[105][105];
double len, ll, rr, p1, p2, p3;
void calc(int L, int R) {
int i, j, k;
cnt = 1;
for (i = 0; i <= n; ++i)
for (j = 0; j <= n; ++j) f[i][j] = 0;
f[0][0] = 1;
for (i = 1; i <= n; ++i)
if (i != now) {
if (r[i] <= L) {
++cnt;
continue;
}
if (l[i] >= R) continue;
len = r[i] - l[i];
p1 = (L - l[i]) / len;
p2 = (R - L) / len;
p3 = (r[i] - R) / len;
for (j = i; j >= 0; --j)
for (k = i - j; k >= 0; --k) {
f[j + 1][k] += f[j][k] * p1;
f[j][k + 1] += f[j][k] * p2;
f[j][k] *= p3;
}
}
for (i = 0; i + cnt <= n; ++i) {
for (j = n - i - cnt; j >= 0; --j)
ans[i + cnt] += f[i][j] * (R - L) / (j + 1),
ans[i + j + 1 + cnt] -= f[i][j] * (R - L) / (j + 1);
}
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d%d", &l[i], &r[i]);
d[++m] = l[i];
d[++m] = r[i];
}
sort(d + 1, d + m + 1);
for (i = 2, k = 1; i <= m; ++i)
if (d[i] != d[i - 1]) {
++k;
if (k != i) d[k] = d[i];
}
m = k;
for (i = 1; i <= n; ++i) {
now = i;
for (j = 1; j <= n; ++j) ans[j] = 0;
for (j = 1; j < m; ++j)
if (l[i] <= d[j] && r[i] >= d[j + 1]) calc(d[j], d[j + 1]);
for (j = 1; j <= n; ++j) ans[j] += ans[j - 1];
for (j = 1; j <= n; ++j) printf("%.6lf ", ans[j] / (r[i] - l[i]));
printf("\n");
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, M;
bool dance[101][2];
for (int i = 0; i <= 100; i++) {
dance[i][0] = dance[i][1] = 0;
}
scanf("%d%d", &N, &M);
vector<pair<int, int> > sol;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (!dance[i][0] || !dance[j][1]) {
dance[i][0] = true;
dance[j][1] = true;
sol.push_back(make_pair(i, j));
}
}
}
printf("%d\n", sol.size());
for (int i = 0; i < sol.size(); i++) {
printf("%d %d\n", sol[i].first, sol[i].second);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 110;
long long dp[N][2], n, val[N], ans;
char s[N];
signed main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (long long i = 1; i <= n; ++i) val[i] = (s[i] == 'A');
dp[1][val[1]] = 1;
dp[0][0] = 1;
for (long long i = 2; i <= n; ++i) {
if (val[i]) {
dp[i][1] += dp[i - 1][0] + dp[i - 1][1];
if (!val[i - 1] && i != 2) dp[i][0] += dp[i - 2][0] + dp[i - 2][1];
} else
dp[i][0] += dp[i - 1][0];
}
if (val[1])
ans += dp[n][0] + dp[n][1];
else {
ans += dp[n][0];
if (val[2]) {
memset(dp, 0, sizeof dp);
dp[2][0] = 1;
for (long long i = 3; i <= n; ++i) {
if (val[i]) {
dp[i][1] += dp[i - 1][0] + dp[i - 1][1];
if (!val[i - 1] && i != 2) dp[i][0] += dp[i - 2][0] + dp[i - 2][1];
} else
dp[i][0] += dp[i - 1][0];
}
ans += dp[n][0] + dp[n][1];
}
}
memset(dp, 0, sizeof dp);
if (val[1] == 1 && val[n] == 0) {
dp[1][0] = 1;
for (long long i = 2; i < n; ++i) {
if (val[i]) {
dp[i][1] += dp[i - 1][0] + dp[i - 1][1];
if (!val[i - 1]) dp[i][0] += dp[i - 2][0] + dp[i - 2][1];
} else
dp[i][0] += dp[i - 1][0];
}
ans += dp[n - 1][0] + dp[n - 1][1];
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int i, j, n, s = 0, c = 0, x, k, y, m, z, ans = 0;
cin >> n >> m;
cin >> x >> z >> y;
vector<long long int> a(n), b(m);
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < m; i++) {
cin >> b[i];
}
if (n == m) {
for (i = 0; i < n; i++) {
if (a[i] != b[i]) {
cout << -1;
return;
}
}
cout << 0;
return;
}
if (m > n) {
cout << -1;
return;
}
i = 0;
j = 0;
k = 0;
long long int ma = INT_MIN, l;
while (i < n && j < m) {
if (a[i] != b[j]) {
ma = max(ma, a[i]);
i++;
} else {
l = i - k;
if (l == 0) {
i++;
j++;
k = i;
continue;
}
long long int maxel;
if (k > 0) {
maxel = max(a[k - 1], a[i]);
} else {
maxel = a[i];
}
if (l < z) {
if (maxel < ma) {
cout << -1;
return;
}
ans += l * y;
} else {
if (y * z < x && maxel > ma) {
ans += l * y;
} else if (y * z < x) {
l = l - z;
ans += x + l * y;
} else {
long long int rem = l % z;
long long int gro = l / z;
ans += gro * x + rem * y;
}
}
j++;
i++;
k = i;
ma = INT_MIN;
}
}
l = n - k;
for (long long int q = i; q < n; q++) {
ma = max(ma, a[q]);
}
if (l > 0) {
long long int maxel = a[k - 1];
if (l < z) {
if (maxel < ma) {
cout << -1;
return;
}
ans += l * y;
} else {
if (y * z < x && maxel > ma) {
ans += l * y;
} else if (y * z < x) {
l = l - z;
ans += x + l * y;
} else {
long long int rem = l % z;
long long int gro = l / z;
ans += gro * x + rem * y;
}
}
j++;
i++;
k = i;
ma = INT_MIN;
}
cout << ans;
}
int main() {
long long int t;
t = 1;
while (t--) {
solve();
cout << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 2e5 + 10;
int v[N];
int t[N];
int u[N];
int n, w, k;
class TreeArray {
public:
long long a[N];
TreeArray() { memset((a), (0), sizeof(a)); }
int lowbit(int x) { return x & -x; }
void add(int x, long long y) {
while (x < N) {
a[x] += y;
x += lowbit(x);
}
}
long long sum(int x) {
long long ret = 0;
while (x) {
ret += a[x];
x -= lowbit(x);
}
return ret;
}
} ta1, ta2, ta3;
int getT(int w, int tot) {
w = min(w, tot);
int l = 1, r = N - 2;
int k = 0;
int ks = 0;
while (l <= r) {
int mid = (l + r) / 2;
int low = ta1.sum(mid);
if (low <= tot - w)
k = mid, l = mid + 1;
else
r = mid - 1;
}
ks = ta1.sum(k);
int ret = ta2.sum(k) + ta3.sum(N - 2) - ta3.sum(k + 1);
int cnt = ta1.sum(k + 1) - ta1.sum(k);
int per = cnt == 0 ? 0 : (ta2.sum(k + 1) - ta2.sum(k)) / cnt;
if (ks <= tot - w) {
int o = tot - w - ks;
ret += o * per + (cnt - o) * ((per + 1) / 2);
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &t[i]);
u[i] = t[i];
}
sort(u, u + n);
int p = 0;
long long ans = 0;
long long res = 0;
for (int i = 0; i < n; i++) {
while (p < n) {
int o = lower_bound(u, u + n, t[p]) - u + 1;
ta1.add(o, 1);
ta2.add(o, t[p]);
ta3.add(o, (t[p] + 1) / 2);
if (getT(w, p - i + 1) <= k)
ans += v[p++];
else {
ta1.add(o, -1);
ta2.add(o, -t[p]);
ta3.add(o, -(t[p] + 1) / 2);
break;
}
}
res = max(res, ans);
ans -= v[i];
int o = lower_bound(u, u + n, t[i]) - u + 1;
ta1.add(o, -1);
ta2.add(o, -t[i]);
ta3.add(o, -(t[i] + 1) / 2);
}
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
char s[100 + 5], ans[100 + 5][250 + 5];
int main() {
int n, i, j, p, l, r;
scanf("%d%s", &n, s);
for (i = l = r = 0; i<n; ++i, r = l> r ? l : r) l += s[i] == '[' ? 2 : -2;
for (i = p = 0; i < n; ++i, ++p) {
ans[l][p] = ans[r][p] = '+';
for (j = l + 1; j < r; ++j) ans[j][p] = '|';
if (s[i] == '[') ans[l][p + 1] = ans[r][p + 1] = '-';
if (s[i] == ']') ans[l][p - 1] = ans[r][p - 1] = '-';
if (s[i] == '[' && s[i + 1] == '[') ++l, --r;
if (s[i] == '[' && s[i + 1] == ']') p += 3;
if (s[i] == ']' && s[i + 1] == ']') --l, ++r;
}
for (i = 0; i <= r; ++i, puts(""))
for (j = 0; j < p; ++j) putchar(ans[i][j] ? ans[i][j] : ' ');
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, i, n, k, s[2000001], minn, maxx, nr, d;
int main() {
minn = 99999999;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> a;
s[a]++;
if (a < minn) minn = a;
if (a > maxx) maxx = a;
}
if (k >= minn - 1)
cout << minn;
else {
for (i = 1; i <= maxx + k; i++) s[i] += s[i - 1];
nr = 0;
d = minn;
while (nr < n) {
nr = s[k];
for (i = 1; i <= maxx / d; i++) nr += s[d * i + k] - s[d * i - 1];
d--;
}
cout << d + 1;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, N = 1e5 + 5;
int n, m, sta[N], tp, tot, siz[N], low[N], dfn[N], be[N], bl, dep[N], f[N][22],
w[N];
vector<int> e[N], vec[N];
int read() {
int x = 0, f = 1;
char s;
while ((s = getchar()) > '9' || s < '0')
if (s == '-') f = -1;
while (s >= '0' && s <= '9')
x = (x << 1) + (x << 3) + (s ^ 48), s = getchar();
return x * f;
}
void addEdge(int u, int v) {
e[u].push_back(v);
e[v].push_back(u);
}
void tarjan(int u, int fa) {
sta[++tp] = u;
dfn[u] = low[u] = ++tot;
for (int i = 0; i < e[u].size(); ++i) {
int v = e[u][i];
if (v == fa) continue;
if (!dfn[v])
tarjan(v, u), low[u] = min(low[u], low[v]);
else
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
int v = 0;
++bl;
do {
v = sta[tp--];
be[v] = bl;
++siz[bl];
} while (v ^ u);
}
}
int LCA(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 20; i >= 0; --i)
if (dep[f[u][i]] >= dep[v]) u = f[u][i];
if (u == v) return u;
for (int i = 20; i >= 0; --i)
if (f[u][i] ^ f[v][i]) u = f[u][i], v = f[v][i];
return f[u][0];
}
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
f[u][0] = fa;
w[u] = w[fa] + (siz[u] > 1);
for (int i = 1; i <= 20; ++i) f[u][i] = f[f[u][i - 1]][i - 1];
for (int i = 0; i < vec[u].size(); ++i)
if (vec[u][i] ^ fa) dfs(vec[u][i], u);
}
int qkpow(int x, int y) {
int r = 1;
while (y) {
if (y & 1) r = 1ll * r * x % mod;
x = 1ll * x * x % mod;
y >>= 1;
}
return r;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; ++i) addEdge(read(), read());
tarjan(1, 0);
for (int i = 1; i <= n; ++i)
for (int j = 0; j < e[i].size(); ++j)
if (be[i] ^ be[e[i][j]]) vec[be[i]].push_back(be[e[i][j]]);
dfs(1, 0);
int u, v;
for (int t = read(); t; --t) {
u = be[read()], v = be[read()];
int lca = LCA(u, v);
printf("%d\n", qkpow(2, w[u] + w[v] - w[lca] * 2 + (siz[lca] > 1)));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v;
char c;
};
struct node {
int i;
unsigned long long ha;
};
struct hash {
int he[10000007], ne[10000007], cnt, p[10000007];
unsigned long long e[10000007];
void add(unsigned long long x, int a) {
int t = x % 10000007;
for (int i = he[t]; i; i = ne[i])
if (e[i] == x) {
p[i] += a;
return;
}
ne[++cnt] = he[t];
he[t] = cnt;
e[cnt] = x;
p[cnt] += a;
}
int find(unsigned long long x) {
int t = x % 10000007;
for (int i = he[t]; i; i = ne[i])
if (e[i] == x) return p[i];
return 0;
}
} HAHA;
vector<node> Q[100011];
vector<edge> G[100011];
int dep[100011], fa[100011][22], ans[100011], n, m;
char pre[100011], T[100011], P[100011], s[100011];
unsigned long long ha[100011], pw[100011], tmp[100011];
void dfs(int x, int f) {
fa[x][0] = f;
dep[x] = dep[f] + 1;
for (int i = 1; fa[x][i - 1]; i++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (auto t : G[x]) {
if (t.v == f) continue;
ha[t.v] = ha[x] * 1000003 + t.c - 'a' + 1;
pre[t.v] = t.c;
dfs(t.v, x);
}
}
int LCA(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 20; ~i; i--)
if (dep[fa[u][i]] >= dep[v]) u = fa[u][i];
if (u == v) return u;
for (int i = 20; ~i; i--)
if (fa[u][i] != fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
}
if (u == v) return u;
return fa[u][0];
}
unsigned long long getha(char *s) {
int len = strlen(s);
unsigned long long res = 0;
for (int i = 0; i < len; i++) res = res * 1000003 + s[i] - 'a' + 1;
return res;
}
int getans(char *S, int len, unsigned long long ha, int halen) {
if (len < halen) return 0;
if (!len) return 0;
tmp[0] = S[0] - 'a' + 1;
for (int i = 1; i < len; i++) tmp[i] = tmp[i - 1] * 1000003 + S[i] - 'a' + 1;
int res = 0;
if (tmp[halen - 1] == ha) res++;
for (int i = halen; i < len; i++)
if (tmp[i] - tmp[i - halen] * pw[halen] == ha) res++;
return res;
}
unsigned long long get(int a, int b) {
return ha[b] - ha[a] * pw[dep[b] - dep[a]];
}
void dfs2(int x, int f) {
for (int i = 1, u = f; u && i <= 100; i++, u = fa[u][0])
HAHA.add(get(u, x), 1);
for (auto t : Q[x])
if (t.i > 0)
ans[t.i] += HAHA.find(t.ha);
else
ans[-t.i] -= HAHA.find(t.ha);
for (auto t : G[x])
if (t.v != fa[x][0]) dfs2(t.v, x);
for (int i = 1, u = f; u && i <= 100; i++, u = fa[u][0])
HAHA.add(get(u, x), -1);
}
int jump(int u, int d) {
for (int i = 20; ~i; i--)
if (dep[fa[u][i]] >= d) u = fa[u][i];
return u;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d%s", &u, &v, s);
G[u].push_back(edge{v, s[0]});
G[v].push_back(edge{u, s[0]});
}
dfs(1, 0);
scanf("%d", &m);
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = pw[i - 1] * 1000003;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d%s", &u, &v, s);
int len = strlen(s), lca = LCA(u, v);
unsigned long long tt = getha(s);
int up = jump(u, dep[lca] + len - 1), vp = jump(v, dep[lca] + len - 1);
int t = 0;
for (int x = up; x != lca; x = fa[x][0]) T[t++] = pre[x];
int p = 0;
for (int x = vp; x != lca; x = fa[x][0]) P[p++] = pre[x];
for (int i = p - 1; ~i; i--) T[t++] = P[i];
ans[i] += getans(T, t, tt, len);
Q[v].push_back(node{i, tt});
Q[vp].push_back(node{-i, tt});
reverse(s, s + len);
tt = getha(s);
Q[u].push_back(node{i, tt});
Q[up].push_back(node{-i, tt});
}
dfs2(1, 0);
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int _gcd(int a, int b) { return (b == 0 ? a : _gcd(b, a % b)); }
bool cmp(int a, int b) { return a > b; }
int dx[3] = {1, 0, 1};
int dy[3] = {0, 1, 1};
bool check(string a, string b, string c) {
if (a == b && b == c) return true;
if (a > b) swap(a, b);
if (b > c) swap(b, c);
if (a > b) swap(a, b);
if (a[1] == b[1] && b[1] == c[1]) {
if (a[0] + 1 == b[0] && b[0] + 1 == c[0]) return true;
}
return false;
}
long long int ncr(long long int n, long long int k) {
long long int res = 1;
for (long long int i = n; i > n - k; --i) {
res *= i;
}
for (long long int i = 2; i <= k; ++i) {
res /= i;
}
return res;
}
const int mod = 1e9 + 7;
void solve() {
long long int n;
cin >> n;
vector<long long int> v(n + 1, 0);
for (long long int i = 1; i <= n; ++i) {
cin >> v[i];
}
vector<long long int> ans;
for (long long int i = 1; i <= n; ++i) {
if (i == 1 || i == n || (v[i - 1] < v[i]) != (v[i] < v[i + 1]))
ans.push_back(v[i]);
}
cout << ans.size() << endl;
for (auto x : ans) {
cout << x << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 55;
int n, K, hb[maxn];
ll c[maxn], lim[maxn][2], f[maxn][maxn][maxn][4][4];
void chk(ll &x, ll y) { if (x > y) x = y; }
int bit(ll x, int b) { return x >> b & 1; }
int main() {
scanf("%d %d", &n, &K);
for (int i = 1; i <= n; i++) {
scanf("%lld %lld", &lim[i][0], &lim[i][1]);
lim[i][0] += 1LL << K, lim[i][1] += 1LL << K;
lim[i][0]--, lim[i][1]++;
hb[i] = log2(lim[i][0] ^ lim[i][1]);
}
for (int i = 0; i < K; i++) {
scanf("%lld", &c[i]);
}
K++, memset(f, 0x3f, sizeof(f));
for (int i = 0; i <= n; i++) {
for (int sl : {0, 1}) for (int sr : {0, 1}) {
f[K][i][i + 1][sl][sr] = 0;
}
}
for (int i = K - 1; ~i; i--) {
for (int len = 2; len <= n + 2; len++) {
for (int l = 0, r = len - 1; r <= n + 1; l++, r++) {
for (int sl : {0, 1, 2, 3}) for (int sr : {0, 1, 2, 3}) {
if ((sl >> 1) && (i >= hb[l] || bit(lim[l][sl & 1], i) ^ (sl & 1)) ||
(sr >> 1) && (i >= hb[r] || bit(lim[r][sr & 1], i) ^ (sr & 1))) continue;
bool flag = 1;
for (int k = l + 1; k < r && flag; k++) {
flag &= i < hb[k] - 1;
}
if (flag) {
bool diff = bit(lim[l][sl & 1], i) ^ (sl >> 1) ^
bit(lim[r][sr & 1], i) ^ (sr >> 1);
chk(f[i][l][r][sl][sr], f[i + 1][l][r][sl & 1][sr & 1]
+ (l >= 1 && r <= n && diff) * c[i]);
}
for (int k = l + 1; k < r; k++) for (int sk : {2, 3}) {
chk(f[i][l][r][sl][sr], f[i][l][k][sl][sk] + f[i][k][r][sk][sr]);
}
}
}
}
}
printf("%lld\n", f[0][0][n + 1][0][0]);
return 0;
} | 13 |
#include <bits/stdc++.h>
using namespace std;
bool isint(double x) { return (int)x == x; }
int main() {
string s;
long long sum = 0;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (isupper(s[i])) {
sum += s[i] - '@';
} else if (islower(s[i])) {
sum -= s[i] - '`';
}
}
cout << sum;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void start() {}
void sober() {
long long int n, x = 0, a = 0, b = 0, y = 0, sum = 0, k = 0, m = 0;
cin >> n >> k;
vector<long long int> v(n), v1(n);
map<long long int, long long int> mp;
bool foo = 0;
for (long long int i = 0; i < n; i++) {
cin >> v[i];
v1[i] = v[i];
if (v[i] >= k) foo = 1;
}
if (!foo) {
cout << "0\n";
return;
}
foo = 0;
long long int ans = 0, maxx = 0;
for (long long int i = k; i < 101; i++) {
ans = 0, foo = 0;
for (long long int j = 0; j < n; j++) v[j] = v1[j];
for (long long int j = 0; j < n; j++) {
if (v[j] >= i) {
foo = 1;
}
}
if (!foo) {
break;
}
map<long long int, long long int> mp;
for (long long int j = 0; j < n; j++) {
if (v[j] < i) {
continue;
}
while (v[j] >= i) {
v[j] -= i;
mp[i]++;
}
if (v[j] >= k) {
mp[v[j]]++;
}
}
long long int cnt = 0;
cnt += mp[i];
for (auto j : mp) {
if (j.second and mp[i - j.first]) {
cnt += min(mp[i - j.first], j.first);
long long int temp = mp[i - j.first], flag = j.second;
mp[i - j.first] -= min(temp, flag);
mp[j.first] -= min(temp, flag);
}
}
ans = cnt * 1LL * i;
maxx = max(ans, maxx);
}
cout << maxx << "\n";
return;
}
signed main() {
start();
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
sober();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long 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 gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int N = 101000;
const int LIM = 500;
int q[N], hs[N], hv[N], dep[N], id[N], l[N], r[N], bel[N], f[N], s[N], t[N],
off[N], fg[N];
int n, p, tot, ans, v, m, in[N];
vector<int> cc[N], e[N];
vector<pair<int, int> >::iterator pit[N];
vector<pair<int, int> > zz[N], st[N];
pair<int, int> tmp[N];
void dfs(int u, int f) {
id[l[u] = ++tot] = u;
dep[u] = dep[f] + 1;
if (hv[u]) dfs(hv[u], u);
for (int j = 0; j < ((int)(e[u]).size()); j++)
if (e[u][j] != f && e[u][j] != hv[u]) dfs(e[u][j], u);
r[u] = tot;
}
void build(int u) {
for (auto v : cc[u]) st[u].push_back(make_pair(t[v], v));
sort((st[u]).begin(), (st[u]).end());
int cnt = 1;
for (int i = 1; i < ((int)(st[u]).size()); i++) {
if (st[u][i].first != st[u][i - 1].first)
zz[u].push_back(make_pair(st[u][i - 1].first, cnt)), cnt = 0;
cnt++;
}
zz[u].push_back(make_pair(st[u].back().first, cnt));
pit[u] = zz[u].begin();
}
void rebuild(int u) {
int t1 = 0;
for (auto p : st[u])
if (!fg[p.second]) tmp[t1++] = make_pair(t[p.second] += off[u], p.second);
int t2 = t1;
for (auto p : st[u])
if (fg[p.second]) tmp[t2++] = make_pair(t[p.second] += off[u], p.second);
inplace_merge(tmp, tmp + t1, tmp + t2);
st[u] = vector<pair<int, int> >(tmp, tmp + t2);
for (auto p : zz[u])
if (p.first + off[u] < 0) ans -= p.second;
off[u] = 0;
zz[u].clear();
int cnt = in[st[u][0].second];
for (int i = 1; i < ((int)(st[u]).size()); i++) {
if (st[u][i].first != st[u][i - 1].first)
zz[u].push_back(make_pair(st[u][i - 1].first, cnt)), cnt = 0;
cnt += in[st[u][i].second];
}
zz[u].push_back(make_pair(st[u].back().first, cnt));
pit[u] = zz[u].begin();
while (pit[u] != zz[u].end() && pit[u]->first < 0) ++pit[u];
for (auto p : zz[u])
if (p.first < 0) ans += p.second;
for (auto v : cc[u]) fg[v] = 0;
}
bool rrt[N];
void HLDoT(int rt) {
int t = 1;
q[0] = rt;
for (int i = 0; i < n; i++) {
int u = q[i];
for (int j = 0; j < ((int)(e[u]).size()); j++)
if (e[u][j] != f[u]) f[e[u][j]] = u, dep[q[t++] = e[u][j]] = dep[u] + 1;
}
for (int i = n - 1; i >= 0; i--) {
int u = q[i], p = f[u];
s[u]++, s[p] += s[u];
if (!l[u]) l[u] = 1;
if (hs[p] < s[u]) hs[p] = s[u], hv[p] = u, l[p] = l[u] + 1;
}
for (int i = 0; i < n; i++) {
int u = q[i];
if (!bel[u]) bel[u] = u;
if (hv[u]) bel[hv[u]] = bel[u];
}
dfs(rt, 0);
for (int i = 1; i < n + 1; i++)
if (bel[i] == i) rrt[i] = 1;
for (int i = 1; i < n + 1; i++)
if (rrt[i]) {
int u = i;
vector<int> chain;
chain.push_back(u);
while (hv[u]) {
u = hv[u];
chain.push_back(u);
}
int curf = chain[0];
for (int i = 0; i < ((int)(chain).size()); i++) {
if (i % LIM == 0) curf = chain[i];
bel[chain[i]] = curf;
cc[curf].push_back(chain[i]);
}
}
for (int i = 1; i < n + 1; i++)
if (bel[i] == i) build(i);
}
void modify(int u, int x) {
in[u] += x;
if (t[u] + off[bel[u]] < 0) ans += x;
for (auto &p : zz[bel[u]])
if (p.first == t[u]) p.second += x;
u = f[u];
while (u) {
int v = bel[u];
if (cc[v].back() == u) {
off[v] += x;
while (pit[v] != zz[v].end() && pit[v]->first + off[v] < 0) {
ans += pit[v]->second;
pit[v]++;
}
while (pit[v] != zz[v].begin() && (pit[v] - 1)->first + off[v] >= 0) {
ans -= (pit[v] - 1)->second;
pit[v]--;
}
} else {
while (1) {
t[u] += x;
fg[u] = 1;
if (u == v) break;
u = f[u];
}
rebuild(v);
}
u = f[v];
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n + 1; i++) in[i] = 1;
for (int i = 2; i < n + 1; i++) {
scanf("%d", &p);
e[p].push_back(i);
}
for (int i = 1; i < n + 1; i++) scanf("%d", t + i);
HLDoT(1);
for (int i = 0; i < m; i++) {
scanf("%d", &v);
if (v > 0)
modify(v, -1);
else
modify(-v, 1);
printf("%d%c", ans, " \n"[i == m - 1]);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int tree_max[4 * 100009], tree_sum[4 * 100009];
int a[100009];
void build_sum(int node, int start, int end) {
if (start == end) {
tree_sum[node] = a[start];
return;
}
int mid = (start + end) >> 1;
build_sum(2 * node + 1, start, mid);
build_sum(2 * node + 2, mid + 1, end);
tree_sum[node] = tree_sum[2 * node + 1] + tree_sum[2 * node + 2];
}
void build_max(int node, int start, int end) {
if (start == end) {
tree_max[node] = a[start];
return;
}
int mid = (start + end) >> 1;
build_max(2 * node + 1, start, mid);
build_max(2 * node + 2, mid + 1, end);
tree_max[node] = max(tree_max[2 * node + 1], tree_max[2 * node + 2]);
}
void point_update(int node, int start, int end, int idx, int val) {
if (start == end) {
tree_sum[node] = val;
tree_max[node] = val;
a[start] = val;
return;
}
int mid = (start + end) >> 1;
if (idx > mid) {
point_update(2 * node + 2, mid + 1, end, idx, val);
} else {
point_update(2 * node + 1, start, mid, idx, val);
}
tree_sum[node] = tree_sum[2 * node + 1] + tree_sum[2 * node + 2];
tree_max[node] = max(tree_max[2 * node + 1], tree_max[2 * node + 2]);
}
long long int sum_query(int node, int start, int end, int l, int r) {
if (l > end || r < start) {
return 0;
}
if (start >= l && end <= r) {
return tree_sum[node];
}
int mid = (start + end) >> 1;
long long int p1 = sum_query(2 * node + 1, start, mid, l, r);
long long int p2 = sum_query(2 * node + 2, mid + 1, end, l, r);
return p1 + p2;
}
void mod_update(int node, int start, int end, int l, int r, int val) {
if (l > end || r < start) {
return;
}
if (start == end) {
tree_sum[node] %= val;
tree_max[node] %= val;
a[start] %= val;
return;
}
if (l > end || r < start) {
return;
}
int mid = (start + end) >> 1;
if (tree_max[2 * node + 1] >= val) {
mod_update(2 * node + 1, start, mid, l, r, val);
}
if (tree_max[2 * node + 2] >= val) {
mod_update(2 * node + 2, mid + 1, end, l, r, val);
}
tree_sum[node] = tree_sum[2 * node + 1] + tree_sum[2 * node + 2];
tree_max[node] = max(tree_max[2 * node + 1], tree_max[2 * node + 2]);
}
int main() {
int i, j, n, m, k, x, y, z;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
build_max(0, 0, n - 1);
build_sum(0, 0, n - 1);
while (m--) {
scanf("%d", &x);
if (x == 1) {
scanf("%d%d", &y, &z);
y--;
z--;
long long int zz = sum_query(0, 0, n - 1, y, z);
printf("%lld\n", zz);
;
} else if (x == 2) {
scanf("%d%d%d", &x, &y, &z);
x--;
y--;
mod_update(0, 0, n - 1, x, y, z);
} else {
scanf("%d%d", &k, &y);
k--;
point_update(0, 0, n - 1, k, y);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Square {
pair<long long, long long> p[5];
};
Square a, b;
long long S(pair<long long, long long> x, pair<long long, long long> y,
pair<long long, long long> z) {
long long sx = (y.first - x.first) * (y.second + x.second);
long long sy = (z.first - y.first) * (z.second + y.second);
long long sz = (x.first - z.first) * (x.second + z.second);
return abs(sx + sy + sz);
}
long long SSquare(Square x) {
long long s0 =
(x.p[1].first - x.p[0].first) * (x.p[1].second + x.p[0].second);
long long s1 =
(x.p[2].first - x.p[1].first) * (x.p[2].second + x.p[1].second);
long long s2 =
(x.p[3].first - x.p[2].first) * (x.p[3].second + x.p[2].second);
long long s3 =
(x.p[0].first - x.p[3].first) * (x.p[0].second + x.p[3].second);
return abs(s0 + s1 + s2 + s3);
}
bool Check_Point_In_Site(pair<long long, long long> x, Square a) {
long long s = 0, ss = SSquare(a);
for (int i = 1; i <= 3; i++) s += S(x, a.p[i], a.p[i - 1]);
s += S(x, a.p[3], a.p[0]);
return (s == ss);
}
bool Check_In_Site(Square a, Square b) {
for (int i = 0; i <= 4; i++) {
if (Check_Point_In_Site(a.p[i], b)) return true;
if (Check_Point_In_Site(b.p[i], a)) return true;
}
return false;
}
pair<long long, long long> Center_Square(Square a) {
if (a.p[0].first == a.p[2].first) {
return make_pair(a.p[0].first, a.p[1].second);
}
if (a.p[1].first == a.p[3].first) {
return make_pair(a.p[1].first, a.p[2].second);
}
if (a.p[1].first != a.p[2].first) {
return make_pair(a.p[1].first + a.p[2].first >> 1,
a.p[0].second + a.p[1].second >> 1);
}
if (a.p[0].first != a.p[1].first) {
return make_pair(a.p[0].first + a.p[1].first >> 1,
a.p[1].second + a.p[2].second >> 1);
}
}
int main() {
for (int i = 0; i <= 3; i++) cin >> a.p[i].first >> a.p[i].second;
a.p[4] = Center_Square(a);
for (int i = 0; i <= 3; i++) cin >> b.p[i].first >> b.p[i].second;
b.p[4] = Center_Square(b);
if (Check_In_Site(a, b))
cout << "YES";
else
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
char Gc() {
static char now[1 << 20], *S, *T;
if (T == S) {
T = (S = now) + std::fread(now, 1, 1 << 20, stdin);
if (T == S) return EOF;
}
return *S++;
}
template <typename T>
void Read(T &x) {
x = 0;
int f = 1;
char c;
while ((c = Gc()) < '0' || c > '9')
if (c == '-') f = -1;
x = c - '0';
while ((c = Gc()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= f;
}
template <typename T, typename... Args>
void Read(T &x, Args &...args) {
Read(x);
Read(args...);
}
template <typename T>
void checkmax(T &x, T y) {
if (x < y) x = y;
}
template <typename T>
void checkmin(T &x, T y) {
if (x > y) x = y;
}
struct Edge {
int to, nxt, flow;
double cost;
} e[160000];
int n, x[401], y[401], E, head[1001], s, t, ed[1001], flow[1001], le[1001],
pre[1001];
double dis[1001];
bool vis[1001];
double Dis(int a, int b) { return std::hypot(x[a] - x[b], y[a] - y[b]); }
void Add(int f, int t, double c, int w) {
e[E].to = t;
e[E].cost = c;
e[E].flow = w;
e[E].nxt = head[f];
head[f] = E++;
}
bool Spfa() {
std::fill(dis + 1, dis + t + 1, 1e18);
std::memset(vis, false, sizeof(vis));
std::memset(flow, 0, sizeof(flow));
flow[s] = 1e9;
pre[t] = -1;
std::queue<int> q;
q.emplace(s);
vis[s] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = false;
for (int i = head[u]; i != -1; i = e[i].nxt) {
int v = e[i].to;
if (e[i].flow && dis[u] + e[i].cost < dis[v]) {
dis[v] = dis[u] + e[i].cost;
pre[v] = u;
flow[v] = std::min(flow[u], e[i].flow);
le[v] = i;
if (!vis[v]) {
q.emplace(v);
vis[v] = true;
}
}
}
}
return ~pre[t];
}
int main(int argc, char const *argv[]) {
std::memset(head, -1, sizeof(head));
Read(n);
t = 2 * n + 1;
for (int i = 1; i <= n; i++) {
Read(x[i], y[i]);
Add(s, i, 0.0, 2);
Add(i, s, 0.0, 0);
ed[i] = E;
Add(i + n, t, 0.0, 1);
Add(t, i + n, 0.0, 0);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (y[i] > y[j]) {
Add(i, n + j, Dis(i, j), 1);
Add(n + j, i, -Dis(i, j), 0);
}
double ans = 0.0;
while (Spfa()) {
ans += dis[t] * flow[t];
int p = t;
while (p != s) {
e[le[p]].flow -= flow[t];
e[le[p] ^ 1].flow += flow[t];
p = pre[p];
}
}
int sum = 0;
for (int i = 1; i <= n; i++) sum += e[ed[i]].flow;
if (sum > 1)
std::printf("-1");
else
std::printf("%.8lf", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int maxn = 1e6 + 4;
const int inf = 1e9;
void read(int &x) {
char ch;
bool flag = 0;
for (ch = getchar(); !isdigit(ch) && ((flag |= (ch == '-')) || 1);
ch = getchar())
;
for (x = 0; isdigit(ch); x = (x << 1) + (x << 3) + ch - 48, ch = getchar())
;
x *= 1 - 2 * flag;
}
char str[maxn];
pair<int, int> x[maxn] = {{4, 1}, {4, 3}},
y[] = {{1, 1}, {1, 2}, {1, 3}, {1, 4}};
int main() {
cin >> str;
int len = strlen(str);
int a = 0, b = 0;
for (int i = 0; i < len; i++) {
if (str[i] == '1') {
printf("%d %d\n", x[a % 2].first, x[a % 2].second);
a++;
} else {
printf("%d %d\n", y[b % 4].first, y[b % 4].second);
b++;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, int> a, pair<int, int> b) {
if (a.second == b.second) return a.first < b.first;
return a.second > b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k, ans = 1;
cin >> n >> m >> k;
vector<vector<int> > pos(m + 1);
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
pos[x].push_back(i);
}
for (int i = 1; i <= m; i++) {
int cost = 0, start = 0, cnt = 1;
for (int j = 1; j < pos[i].size(); j++) {
cost += pos[i][j] - pos[i][j - 1] - 1;
cnt++;
while (cost > k) {
cost -= (pos[i][start + 1] - pos[i][start] - 1);
cnt--;
start++;
}
ans = max(ans, cnt);
}
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
static void redirect(int argc, const char **argv) {
ios::sync_with_stdio(false);
if (argc > 1) {
static filebuf f;
f.open(argv[1], ios::in);
cin.rdbuf(&f);
if (!cin) {
cerr << "Failed to open '" << argv[1] << "'" << endl;
exit(1);
}
}
if (argc > 2) {
static filebuf f;
f.open(argv[2], ios::out | ios::trunc);
cout.rdbuf(&f);
if (!cout) {
cerr << "Failed to open '" << argv[2] << "'" << endl;
}
}
}
template <typename T>
static T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
static T mod(T a, T m) {
a %= m;
if (a < 0) a += m;
return a;
}
template <typename T>
static T inverse(T a, T m) {
a = mod(a, m);
if (a <= 1) return a;
return mod((1 - inverse(m, a) * m) / a, m);
}
template <typename T, typename C, T Modulus>
class MR {
private:
struct tag_plus {};
struct tag_minus {};
struct tag_good {};
T value;
static_assert(std::numeric_limits<C>::max() / Modulus / Modulus > 0,
"compute type is too small");
static_assert(Modulus < std::numeric_limits<T>::max() / 2,
"storage type is too small");
void reduce(tag_plus) {
if (value >= Modulus) value -= Modulus;
}
void reduce(tag_minus) {
if (value < 0) value += Modulus;
}
void reduce(tag_good) {}
public:
static const T modulus = Modulus;
MR() : value(0) {}
MR(C value) : value(value % Modulus) { reduce(tag_minus()); }
template <typename tag_t>
MR(T value, tag_t tag) : value(value) {
reduce(tag);
}
MR &operator=(C value) {
this->value = value % Modulus;
reduce(tag_minus());
return *this;
}
MR operator+(MR b) const { return MR(value + b.value, tag_plus()); }
MR operator-(MR b) const { return MR(value - b.value, tag_minus()); }
MR operator*(MR b) const {
return MR(C(value) * C(b.value) % Modulus, tag_good());
}
MR operator-() const { return MR(-value, tag_minus()); }
MR &operator+=(MR b) {
value += b.value;
reduce(tag_plus());
return *this;
}
MR &operator-=(MR b) {
value -= b.value;
reduce(tag_minus());
return *this;
}
MR &operator*=(MR b) {
value = C(value) * C(b.value) % Modulus;
return *this;
}
bool operator==(MR b) const { return value == b.value; }
bool operator!=(MR b) const { return value != b.value; }
T get() const { return value; }
MR inverse() const {
assert(value);
return MR(::inverse(C(value), C(Modulus)), tag_good());
}
MR operator/(MR b) const { return *this * b.inverse(); }
MR &operator/=(MR b) { return *this *= b.inverse(); }
};
template <typename T, typename C, T Modulus>
static inline std::ostream &operator<<(std::ostream &o, MR<T, C, Modulus> mr) {
return o << mr.get();
}
template <typename T>
static T power(const T &a, long long b) {
if (b == 0)
return T(1);
else if (b & 1)
return power(a, b - 1) * a;
else {
T tmp = power(a, b / 2);
return tmp * tmp;
}
}
template <typename T, typename U>
static T sumag(T a, T b, T s, U apow, U bpow) {
if (s == 1)
return (a + b - 1) * (b - a) / 2;
else {
auto inv = (s - 1).inverse();
T part = (b - 1) * power(s, bpow.get()) - a * power(s, apow.get()) +
inv * (power(s, apow.get() + 1) - power(s, bpow.get()));
return part * inv;
}
}
struct value {
MR<int, long long, 1000000007> base;
MR<int, long long, 1000000007> step;
};
static string line;
static int pos;
static value concat(const value &a, const value &b) {
return value{a.base * b.step + b.base, a.step * b.step};
}
static string parse_number() {
int stop = pos;
while (line[stop] >= '0' && line[stop] <= '9') stop++;
string out = line.substr(pos, stop - pos);
pos = stop;
return out;
}
template <typename T>
static T simple(const string &number) {
T out = 0;
for (char c : number) out = out * 10 + (c - '0');
return out;
}
static value value_of(const string &number) {
value out{0, 1};
for (char c : number) {
int d = c - '0';
out.base *= 10;
out.base += d;
out.step *= 10;
}
return out;
}
static value repeat(const string &r, const value &a) {
MR<int, long long, 1000000006> rv =
simple<MR<int, long long, 1000000006> >(r);
MR<int, long long, 1000000007> rm =
simple<MR<int, long long, 1000000007> >(r);
value out;
out.step = power(a.step, rv.get());
if (a.step.get() == 1)
out.base = rm * a.base;
else
out.base = (out.step - 1) / (a.step - 1) * a.base;
return out;
}
static value make_range1(long long d, const MR<int, long long, 1000000007> &a,
const MR<int, long long, 1000000007> &b,
const MR<int, long long, 1000000006> &ap,
const MR<int, long long, 1000000006> &bp) {
MR<int, long long, 1000000007> scale =
power(MR<int, long long, 1000000007>(10), ((bp - 1) * d).get());
MR<int, long long, 1000000007> s =
power(MR<int, long long, 1000000007>(10), d).inverse();
value out;
out.base = sumag(a, b, s, ap, bp) * scale;
MR<int, long long, 1000000006> digits = (bp - ap) * d;
out.step = power(MR<int, long long, 1000000007>(10), digits.get());
return out;
}
static value make_range(const string &a, const string &b) {
if (a.size() == b.size()) {
return make_range1(a.size(), simple<MR<int, long long, 1000000007> >(a),
simple<MR<int, long long, 1000000007> >(b) + 1,
simple<MR<int, long long, 1000000006> >(a),
simple<MR<int, long long, 1000000006> >(b) + 1);
} else {
value out =
make_range1(a.size(), simple<MR<int, long long, 1000000007> >(a),
power(MR<int, long long, 1000000007>(10), a.size()),
simple<MR<int, long long, 1000000006> >(a),
power(MR<int, long long, 1000000006>(10), a.size()));
for (int d = ((long long)(a).size()) + 1; d < ((long long)(b).size());
d++) {
value cur =
make_range1(d, power(MR<int, long long, 1000000007>(10), d - 1),
power(MR<int, long long, 1000000007>(10), d),
power(MR<int, long long, 1000000006>(10), d - 1),
power(MR<int, long long, 1000000006>(10), d));
out = concat(out, cur);
}
value last = make_range1(
b.size(),
power(MR<int, long long, 1000000007>(10), ((long long)(b).size()) - 1),
simple<MR<int, long long, 1000000007> >(b) + 1,
power(MR<int, long long, 1000000006>(10), ((long long)(b).size()) - 1),
simple<MR<int, long long, 1000000006> >(b) + 1);
out = concat(out, last);
return out;
}
}
static value parse_expression();
static value parse_term() {
string left = parse_number();
if (line[pos] == '-') {
pos++;
string right = parse_number();
return make_range(left, right);
} else if (line[pos] == '(') {
pos++;
value right = parse_expression();
assert(line[pos] == ')');
pos++;
return repeat(left, right);
} else
return value_of(left);
}
static value parse_expression() {
value left = parse_term();
if (line[pos] == '+') {
pos++;
value right = parse_expression();
return concat(left, right);
} else
return left;
};
int main(int argc, const char **argv) {
redirect(argc, argv);
cin >> line;
line += '$';
pos = 0;
value ans = parse_expression();
cout << ans.base << '\n';
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[500010], b[500010], s[500010];
int count(int l, int r) {
int n = 0;
for (int i = l + 1; i <= r; i++) {
if (a[i] < a[l]) continue;
int f = upper_bound(s, s + n, a[i]) - s;
if (f == n) {
s[n++] = a[i];
} else {
s[f] = a[i];
}
if (i == r) return (r - l) - (f + 1);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] -= i;
}
a[0] = -1000000001;
a[n + 1] = 1000000001;
b[0] = 0;
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
b[m + 1] = n + 1;
m++;
int fl = 0;
for (int i = 0; i < m; i++) {
if (a[b[i]] > a[b[i + 1]]) {
fl = 1;
break;
}
}
if (fl == 1) {
printf("-1");
return 0;
}
int cnt = 0;
for (int i = 0; i < m; i++) {
cnt += count(b[i], b[i + 1]);
}
printf("%d\n", cnt);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long x) { return x * (x - 1) / 2; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long n = -1, m = -1;
for (long long i = 0; f(i) <= a; i++)
if (f(i) == a) {
for (long long j = 0; f(j) <= d; j++)
if (f(j) == d) {
if (i * j == b + c) {
n = i, m = j;
break;
}
}
if (n != -1) break;
}
if (n == -1) {
cout << "Impossible" << endl;
return 0;
}
if (n == 0 && m == 0) {
cout << 0 << endl;
return 0;
}
long long s = n + m;
for (long long i = 0; i < s; i++) {
if (c >= n) {
m--;
c -= n;
cout << 1;
} else {
n--;
cout << 0;
}
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int solTimes[n][3];
bool canHack[n][3];
int numSol[3];
int canHackCount[3];
int totalCanHack = 0;
memset(numSol, 0, sizeof numSol);
memset(canHackCount, 0, sizeof canHackCount);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> solTimes[i][j];
if (solTimes[i][j] < 0) {
solTimes[i][j] *= -1;
canHack[i][j] = true;
canHackCount[j]++;
totalCanHack++;
} else {
canHack[i][j] = false;
}
if (solTimes[i][j] != 0) {
numSol[j]++;
}
}
}
int maxSol[7];
int c = n;
maxSol[0] = c;
while (n < 2 * c && 2 * c <= 2 * n) c--;
maxSol[1] = c;
while (n < 4 * c && 4 * c <= 2 * n) c--;
maxSol[2] = c;
while (n < 8 * c && 8 * c <= 2 * n) c--;
maxSol[3] = c;
while (n < 16 * c && 16 * c <= 2 * n) c--;
maxSol[4] = c;
while (n < 32 * c && 32 * c <= 2 * n) c--;
maxSol[5] = c;
maxSol[6] = -1;
int bestAns = n;
if (totalCanHack > 90) {
bestAns = 1;
} else {
int currMaxScores[3];
int numToHack[3];
for (int i1 = 0; i1 < 6; i1++) {
if (numSol[0] <= maxSol[i1 + 1]) continue;
currMaxScores[0] = 500 + i1 * 500;
numToHack[0] = min(canHackCount[0], numSol[0] - maxSol[i1 + 1] - 1);
if (numSol[0] - numToHack[0] > maxSol[i1]) continue;
for (int i2 = 0; i2 < 6; i2++) {
if (numSol[1] <= maxSol[i2 + 1]) continue;
currMaxScores[1] = 500 + i2 * 500;
numToHack[1] = min(canHackCount[1], numSol[1] - maxSol[i2 + 1] - 1);
if (numSol[1] - numToHack[1] > maxSol[i2]) continue;
for (int i3 = 0; i3 < 6; i3++) {
if (numSol[2] <= maxSol[i3 + 1]) continue;
currMaxScores[2] = 500 + i3 * 500;
numToHack[2] = min(canHackCount[2], numSol[2] - maxSol[i3 + 1] - 1);
if (numSol[2] - numToHack[2] > maxSol[i3]) continue;
vector<pair<int, int> > scores;
for (int i = 0; i < n; i++) {
int score = 0;
for (int j = 0; j < 3; j++) {
if (solTimes[i][j] > 0) {
score -= currMaxScores[j] * (250 - solTimes[i][j]) / 250;
}
}
if (i == 0)
score -= (numToHack[0] + numToHack[1] + numToHack[2]) * 100;
scores.push_back(pair<int, int>(score, i));
}
int ourScore = -scores[0].first;
sort(scores.begin(), scores.end());
if (scores[0].second == 0) {
bestAns = 1;
break;
}
int z = 0;
while (scores[z].second != 0) z++;
int reducedNumToHack[3];
for (int j = 0; j < 3; j++) reducedNumToHack[j] = 0;
for (int i = 0; i < z; i++) {
for (int j = 0; j < 3; j++) {
if (canHack[scores[i].second][j]) reducedNumToHack[j]++;
}
}
for (int j = 0; j < 3; j++)
reducedNumToHack[j] = min(reducedNumToHack[j], numToHack[j]);
int dp[z][reducedNumToHack[0] + 1][reducedNumToHack[1] + 1]
[reducedNumToHack[2] + 1];
memset(dp, 0, sizeof dp);
for (int pp = 0; pp < z; pp++) {
int p = scores[pp].second;
for (int k1 = 0; k1 <= reducedNumToHack[0]; k1++) {
for (int k2 = 0; k2 <= reducedNumToHack[1]; k2++) {
for (int k3 = 0; k3 <= reducedNumToHack[2]; k3++) {
int k[3];
k[0] = k1;
k[1] = k2;
k[2] = k3;
for (int hackBits = 0; hackBits < (1 << 3); hackBits++) {
int hacks[3];
for (int j = 0; j < 3; j++) {
hacks[j] = ((hackBits & (1 << j)) > 0) ? 1 : 0;
}
bool hackable = true;
for (int j = 0; j < 3; j++) {
if (hacks[j] > 0 && (k[j] == 0 || !canHack[p][j])) {
hackable = false;
break;
}
}
if (!hackable) continue;
int hackedScore = 0;
for (int j = 0; j < 3; j++) {
if (solTimes[p][j] > 0 && hacks[j] == 0) {
hackedScore +=
currMaxScores[j] * (250 - solTimes[p][j]) / 250;
}
}
int res = 0;
if (pp > 0)
res = dp[pp - 1][k[0] - hacks[0]][k[1] - hacks[1]]
[k[2] - hacks[2]];
if (hackedScore <= ourScore) res++;
dp[pp][k[0]][k[1]][k[2]] =
max(dp[pp][k[0]][k[1]][k[2]], res);
}
}
}
}
}
bestAns =
min(bestAns, z + 1 -
dp[z - 1][reducedNumToHack[0]]
[reducedNumToHack[1]][reducedNumToHack[2]]);
}
}
}
}
cout << bestAns << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int s[6000];
int a[6000];
int ans[6000], op[6000];
int main() {
int n, m, j, i, t, k, o, l;
while (scanf("%d", &n) != EOF) {
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
m = n / 2;
if (n & 1)
m = m + 2;
else
m = m + 1;
j = 1;
for (i = n; i >= m; i--) op[j++] = a[i];
for (i = 1; i < m; i++) s[i] = a[i];
l = o = 1;
for (i = 1; i <= n; i++) {
if (i & 1)
ans[i] = s[l++];
else
ans[i] = op[o++];
}
for (i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int countt = 0;
char prev = '1';
for (int i = 0; i < n; i++) {
if (s[i] == '1') countt++;
if (s[i] == '0' && prev == '0') {
cout << 0;
} else if (s[i] == '0' && prev == '1') {
cout << countt;
countt = 0;
}
prev = s[i];
}
cout << countt;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 909, MAXM = 2e5 + 9;
bool con[MAXN][MAXN];
struct Edge {
int to, next;
} edge[MAXM];
int box[MAXN], low[MAXN], id[MAXN], st[MAXN], col[MAXN], cnt, nd_num, n, m;
vector<int> yy[MAXN];
vector<pair<int, int> > br;
void add(int a, int b) {
edge[cnt].to = b, edge[cnt].next = box[a], box[a] = cnt++;
}
void dfs(int u, int pre, int dep) {
st[u] = 1, id[u] = low[u] = dep;
bool flag = true;
for (int i = box[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (v == pre && flag) {
flag = false;
continue;
}
if (st[v] == 1)
low[u] = min(low[u], id[v]);
else if (st[v] == 0) {
dfs(v, u, dep + 1);
low[u] = min(low[u], low[v]);
}
if (low[v] > id[u]) br.push_back(make_pair(u, v));
}
st[u] = 2;
}
void st_col(int u) {
yy[col[u]].push_back(u);
for (int i = box[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (col[v]) continue;
if (low[v] > id[u]) {
col[v] = ++nd_num;
yy[nd_num].clear();
} else
col[v] = col[u];
st_col(v);
}
}
int du[MAXN];
vector<pair<int, int> > ans;
bool vst[2 * MAXN];
bool find(int u, int v, int pre) {
if (u == v) return true;
for (int i = box[u]; i != -1; i = edge[i].next) {
int nx = edge[i].to;
if (nx == pre) continue;
if (find(nx, v, u)) {
vst[i] = vst[i ^ 1] = true;
return true;
}
}
return false;
}
bool ck() {
memset(vst, 0, sizeof(vst));
for (vector<pair<int, int> >::iterator it = ans.begin(); it != ans.end();
it++)
find(col[it->first], col[it->second], 0);
for (int i = 0; i < cnt; i += 2)
if (!vst[i]) return false;
return true;
}
pair<int, int> x[MAXN][MAXN];
int main() {
srand(time(0));
cin >> n >> m;
if (n == 2) return cout << -1, 0;
cnt = 0;
memset(box, -1, sizeof(box)), memset(con, 0, sizeof(con));
for (int i = 0; i < m; i++) {
int u, v;
cin >> v >> u;
if (con[u][v]) return cout << -1, 0;
con[u][v] = con[v][u] = true;
add(u, v);
add(v, u);
}
br.clear(), memset(st, 0, sizeof(st));
dfs(1, 0, 0);
memset(col, 0, sizeof(col));
yy[1].clear(), col[1] = nd_num = 1, st_col(1);
if (nd_num == 1) return cout << 0, 0;
memset(box, -1, sizeof(box));
cnt = 0;
memset(du, 0, sizeof(du));
for (vector<pair<int, int> >::iterator it = br.begin(); it != br.end();
it++) {
int u = it->first, v = it->second;
add(col[u], col[v]);
add(col[v], col[u]);
du[col[u]]++;
du[col[v]]++;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (col[i] != col[j] && !con[i][j]) x[col[i]][col[j]] = make_pair(i, j);
vector<int> leaves;
for (int i = 1; i <= nd_num; i++)
if (du[i] == 1) leaves.push_back(i);
int sz = (int)leaves.size();
while (true) {
ans.clear();
for (int i = 1; i < sz; i += 2) {
ans.push_back(x[leaves[i - 1]][leaves[i]]);
}
if (sz & 1) ans.push_back(x[leaves[0]][leaves[sz - 1]]);
if (ck()) {
cout << (sz + 1) / 2 << '\n';
for (vector<pair<int, int> >::iterator it = ans.begin(); it != ans.end();
it++)
cout << it->first << " " << it->second << '\n';
return 0;
}
random_shuffle(leaves.begin(), leaves.end());
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void flc(T &A, int x) {
memset(A, x, sizeof(A));
}
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m;
struct node {
int v, nex, id;
} b[600050];
int head[300050];
int cnt;
void init() {
cnt = 0;
flc(head, -1);
}
void add(int u, int v, int id) {
b[cnt].v = v;
b[cnt].id = id;
b[cnt].nex = head[u];
head[u] = cnt++;
}
int inx[300050], iny[300050];
int a[300050];
int d[300050];
int vis[300050];
int fa[300050];
int sum[300050];
int z[300050];
void dfs(int u, int faa) {
vis[u] = 1;
if (a[u] != -1 && d[u] % 2 != a[u]) {
sum[u] ^= 1;
}
for (int i = head[u]; i != -1; i = b[i].nex) {
int v = b[i].v;
int id = b[i].id;
if (v != faa) {
if (vis[v] == -1) {
fa[v] = id;
dfs(v, u);
sum[u] ^= sum[v];
}
}
}
}
int ot[300050 * 2];
int main() {
flc(z, 0);
flc(sum, 0);
flc(d, 0);
init();
flc(vis, -1);
n = read();
m = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i <= m; ++i) {
inx[i] = read();
iny[i] = read();
add(inx[i], iny[i], i);
add(iny[i], inx[i], i);
d[inx[i]]++;
d[iny[i]]++;
}
int res = 0;
int r2 = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] != -1 && a[i] != d[i] % 2) {
res++;
}
if (a[i] == -1) {
r2++;
}
}
if (res & 1) {
if (r2 == 0) {
printf("-1\n");
return 0;
} else {
for (int i = 1; i <= n; ++i) {
if (a[i] == -1) {
if (d[i] & 1) {
a[i] = 0;
} else {
a[i] = 1;
}
break;
}
}
}
}
dfs(1, -1);
flc(ot, -1);
for (int i = 1; i <= n; ++i) {
if (sum[i] & 1) {
ot[fa[i]] = 1;
}
}
res = 0;
for (int i = 1; i <= m; ++i) {
if (ot[i] == -1) {
res++;
}
}
printf("%d\n", res);
for (int i = 1; i <= m; ++i) {
if (ot[i] == -1) {
printf("%d\n", i);
}
}
}
| 6 |
#include <bits/stdc++.h>
const long long mod = 1000 * 1000 * 1000 + 7;
const long long mod1 = 998244353;
const long long INF = 1ll * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 7;
using namespace std;
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (long long)(res * x);
y = y >> 1;
x = (long long)(x * x);
}
return res;
}
template <typename T>
T MIN(T first) {
return first;
}
template <typename T, typename... Args>
T MIN(T first, Args... args) {
return min(first, MIN(args...));
}
template <typename T>
T MAX(T first) {
return first;
}
template <typename T, typename... Args>
T MAX(T first, Args... args) {
return max(first, MAX(args...));
}
template <typename... Args>
void logger(string vars, Args&&... values) {
cout << vars << " = ";
string delim = "";
(..., (cout << delim << values, delim = ", "));
}
long long rec(vector<string> temp, char x) {
vector<long long> res;
long long tans = 0;
long long dif = 0;
for (int(i) = (0); (i) < (int((temp).size())); ++(i)) {
long long cnt = 0;
for (int(j) = (0); (j) < ((int)temp[i].length()); ++(j)) {
if (temp[i][j] == x) cnt += 1;
}
if (2 * cnt > (int)temp[i].length()) {
tans += 1;
dif += 2 * cnt - temp[i].length();
} else {
res.push_back(abs(2 * cnt - (long long)temp[i].length()));
}
}
sort(res.begin(), res.end());
for (int(i) = (0); (i) < (int((res).size())); ++(i)) {
if (dif > res[i]) {
tans += 1;
dif -= res[i];
}
}
return tans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T;
cin >> T;
while (T--) {
long long n;
cin >> n;
vector<string> a(n);
for (int(i) = (0); (i) < (n); ++(i)) cin >> a[i];
long long ans = 0;
for (char i = 'a'; i <= 'e'; i++) {
ans = max(ans, rec(a, i));
}
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int block = 400;
const long double eps = 1e-7;
const long long pe = 137;
const long long pe2 = 1181;
const long long N = 1e6 + 200;
const long long mod = 1e9 + 7;
const long long cmod = 998244353;
const long long INF = 1e16;
int n, m, st, ed, nw, nw2;
int was[N], p[N];
vector<int> g[N];
bool cycle = 0;
vector<int> vv;
void dfs(int v) {
if (st) return;
was[v] = 1;
for (auto to : g[v]) {
if (st) return;
if (was[to] == 1) {
st = to, ed = v;
while (ed != st && ed) {
vv.push_back(ed);
ed = p[ed];
}
vv.push_back(st);
return;
} else if (was[to] == 0) {
p[to] = v;
dfs(to);
}
}
was[v] = 2;
}
void dfs2(int v) {
was[v] = 1;
for (auto to : g[v]) {
if (v == nw && to == nw2) continue;
if (was[to] == 1)
cycle = 1;
else if (was[to] == 0)
dfs2(to);
}
was[v] = 2;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
if (!was[i] && !st) {
dfs(i);
}
}
if (!st) {
cout << "YES";
return 0;
}
reverse(vv.begin(), vv.end());
for (int i = 0; i < vv.size(); i++) {
memset(was, 0, sizeof(was));
int next = (i + 1) % (int)vv.size();
nw = vv[i], nw2 = vv[next];
cycle = 0;
for (int j = 1; j <= n; j++) {
if (!was[j] && cycle == 0) {
dfs2(j);
}
}
if (!cycle) {
cout << "YES";
return 0;
}
}
cout << "NO";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int c[500 + 10];
int f[500 + 10][500 + 10];
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &c[i]);
for (int len = 1; len <= n; ++len)
for (int l = 1, r = len; r <= n; ++l, ++r) {
if (len == 1)
f[l][r] = 1;
else {
f[l][r] = 1 + f[l + 1][r];
if (c[l] == c[l + 1]) f[l][r] = min(f[l][r], 1 + f[l + 2][r]);
for (int Find = l + 2; Find <= r; ++Find)
if (c[Find] == c[l])
f[l][r] = min(f[l][r], f[l + 1][Find - 1] + f[Find + 1][r]);
}
}
printf("%d\n", f[1][n]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s, t;
cin >> s >> t;
int ns = s.length(), nt = t.length();
vector<int> pos[26];
for (int i = 0; i < ns; ++i) pos[s[i] - 'a'].push_back(i);
int g = 1;
vector<int> pos_used(nt);
if (pos[t[0] - 'a'].empty()) {
cout << "-1\n";
return;
}
pos_used[0] = pos[t[0] - 'a'].front();
for (int i = 1; i < nt; ++i) {
char c = t[i];
if (pos[c - 'a'].empty()) {
cout << "-1\n";
return;
}
auto itr =
upper_bound(pos[c - 'a'].begin(), pos[c - 'a'].end(), pos_used[i - 1]);
if (itr == pos[c - 'a'].end()) {
g++;
pos_used[i] = pos[c - 'a'].front();
} else {
pos_used[i] = *itr;
}
}
cout << g << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
cin >> T;
while (T--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, t;
std::cin >> n >> t;
int dp[22][22][22][12];
for (int i = 0; i < 21; ++i) {
for (int j = 0; j < 21; ++j) {
for (int k = 0; k < 21; ++k) {
for (int l = 0; l < 12; ++l) {
dp[i][j][k][l] = 0;
}
}
}
}
for (int l = 0; l < 12; ++l) {
dp[0][0][2][l] = 1;
}
for (int i = 0; i < 20; ++i) {
for (int j = 0; j < 20; ++j) {
for (int k = 2; k < 20; ++k) {
for (int l = 0; l < 12; ++l) {
if (l == 0) {
dp[i + 1][j][k + 1][3] += dp[i][j][k][l];
dp[i][j][k + 1][4] += dp[i][j][k][l];
dp[i][j][k + 1][5] += dp[i][j][k][l];
} else if (l == 1) {
dp[i + 1][j][k + 1][6] += dp[i][j][k][l];
dp[i + 1][j][k + 1][7] += dp[i][j][k][l];
dp[i][j][k + 1][8] += dp[i][j][k][l];
} else if (l == 2) {
dp[i + 1][j][k + 1][9] += dp[i][j][k][l];
dp[i + 1][j][k + 1][10] += dp[i][j][k][l];
dp[i + 1][j][k + 1][11] += dp[i][j][k][l];
} else if (l == 3) {
dp[i][j + 1][k + 1][0] += dp[i][j][k][l];
dp[i][j + 1][k + 1][1] += dp[i][j][k][l];
dp[i][j + 1][k + 1][2] += dp[i][j][k][l];
} else if (l == 4) {
dp[i + 1][j][k + 1][6] += dp[i][j][k][l];
dp[i + 1][j][k + 1][7] += dp[i][j][k][l];
dp[i][j][k + 1][8] += dp[i][j][k][l];
} else if (l == 5) {
dp[i + 1][j][k + 1][9] += dp[i][j][k][l];
dp[i + 1][j][k + 1][10] += dp[i][j][k][l];
dp[i + 1][j][k + 1][11] += dp[i][j][k][l];
} else if (l == 6) {
dp[i][j + 1][k + 1][0] += dp[i][j][k][l];
dp[i][j + 1][k + 1][1] += dp[i][j][k][l];
dp[i][j + 1][k + 1][2] += dp[i][j][k][l];
} else if (l == 7) {
dp[i][j][k + 1][3] += dp[i][j][k][l];
dp[i][j + 1][k + 1][4] += dp[i][j][k][l];
dp[i][j + 1][k + 1][5] += dp[i][j][k][l];
} else if (l == 8) {
dp[i + 1][j][k + 1][9] += dp[i][j][k][l];
dp[i + 1][j][k + 1][10] += dp[i][j][k][l];
dp[i + 1][j][k + 1][11] += dp[i][j][k][l];
} else if (l == 9) {
dp[i][j + 1][k + 1][0] += dp[i][j][k][l];
dp[i][j + 1][k + 1][1] += dp[i][j][k][l];
dp[i][j + 1][k + 1][2] += dp[i][j][k][l];
} else if (l == 10) {
dp[i][j][k + 1][3] += dp[i][j][k][l];
dp[i][j + 1][k + 1][4] += dp[i][j][k][l];
dp[i][j + 1][k + 1][5] += dp[i][j][k][l];
} else {
dp[i][j][k + 1][6] += dp[i][j][k][l];
dp[i][j][k + 1][7] += dp[i][j][k][l];
dp[i][j + 1][k + 1][8] += dp[i][j][k][l];
}
}
}
}
}
int q = 0;
for (int l = 0; l < 12; ++l) {
q += dp[t][t - 1][n][l];
}
std::cout << q;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int n, x, y;
long long int cnt(long long int d) {
long long int res = 0;
long long int xv, yv;
xv = min(x - 1, d - 1);
yv = min(y - 1, d - 1);
res += max(xv + yv - d + 1, 0LL);
xv = min(n - x, d - 1);
yv = min(n - y, d - 1);
res += max(xv + yv - d + 1, 0LL);
xv = min(n - x, d - 1);
yv = min(y - 1, d - 1);
res += max(xv + yv - d + 1, 0LL);
xv = min(x - 1, d - 1);
yv = min(n - y, d - 1);
res += max(xv + yv - d + 1, 0LL);
res += (x > d);
res += (y > d);
res += ((x + d) <= n);
res += ((y + d) <= n);
return res;
}
int main() {
long long int c;
cin >> n >> x >> y >> c;
long long int res = 1;
for (long long int i = 1;; i++) {
if (res >= c) {
cout << i - 1 << endl;
return 0;
}
res += cnt(i);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, Ans, F[105][105][2];
struct Nod {
int x, l;
} A[105];
bool Cmp(Nod a, Nod b) { return a.x < b.x; }
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d%d", &A[i].x, &A[i].l);
sort(A + 1, A + N + 1, Cmp);
A[0].x = -(1 << 30);
for (int i = 0; i <= N; i++)
for (int j = 0; j <= i; j++)
for (int k = 0; k <= 1; k++) {
int Pr = A[j].x + k * A[j].l, Max = -1, a, b;
Ans = max(Ans, F[i][j][k]);
for (int t = i + 1; t <= N; t++)
for (int p = 0; p <= 1; p++) {
int Nr = A[t].x + p * A[t].l;
if (Nr > Max) Max = Nr, a = t, b = p;
F[t][a][b] =
max(F[t][a][b], F[i][j][k] + min(A[t].l, Nr - Pr) + Max - Nr);
}
}
printf("%d\n", Ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 99;
vector<int> g[N], c;
set<int> e[N];
int n, m, pre[N];
bool vis[N];
bool bfs(int u) {
queue<pair<int, int> > q;
q.push({1, 0});
memset(pre, -1, sizeof pre);
vis[1] = 1;
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
int u = p.first, dis = p.second;
for (int i = 0; i < g[u].size(); i++)
if (!vis[g[u][i]]) {
vis[g[u][i]] = 1;
pre[g[u][i]] = u;
if (dis < 4) q.push({g[u][i], dis + 1});
}
}
while (!q.empty()) q.pop();
if (pre[n] == -1) return 0;
int pos = n;
vector<int> ans;
ans.push_back(pos);
while (pre[pos] != -1) {
ans.push_back(pre[pos]);
pos = pre[pos];
}
reverse(ans.begin(), ans.end());
if (ans.size() > 5) return 0;
printf("%d\n", ans.size() - 1);
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
}
void bfs2(int x) {
vis[x] = 1;
queue<int> q;
q.push(x);
c.push_back(x);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < g[u].size(); i++)
if (!vis[g[u][i]] && u != 1) {
vis[g[u][i]] = 1;
q.push(g[u][i]);
c.push_back(g[u][i]);
}
}
}
int main() {
scanf("%d%d", &n, &m);
if (!m) {
printf("-1");
return 0;
}
int x, y;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
e[x].insert(y);
e[y].insert(x);
}
if (bfs(1)) return 0;
memset(vis, 0, sizeof vis);
for (int i = 0; i < g[1].size(); i++) vis[g[1][i]] = 1;
for (int i = 0; i < g[1].size(); i++)
for (int j = 0; j < g[g[1][i]].size(); j++) {
int u = g[g[1][i]][j];
if (u != 1 && !vis[u]) {
printf("4\n1 %d %d 1 %d\n", g[1][i], u, n);
return 0;
}
}
memset(vis, 0, sizeof vis);
for (int i = 0; i < g[1].size(); i++)
if (!vis[g[1][i]]) {
c.clear();
int u = g[1][i];
bfs2(u);
if (g[u].size() < c.size())
for (int j = 0; j < c.size(); j++)
if (e[c[j]].count(1) && g[c[j]].size() < c.size()) {
u = c[j];
for (int k = 0; k < g[1].size(); k++)
if (vis[g[1][k]] && !e[g[1][k]].count(u) && u != g[1][k] &&
g[g[1][k]].size() < c.size()) {
int z = g[1][k];
for (int l = 0; l < g[z].size(); l++)
if (e[g[z][l]].count(1) && e[g[z][l]].count(u) &&
g[z][l] != 1) {
printf("5\n1 %d %d %d %d %d", u, g[z][l], z, u, n);
return 0;
}
}
}
}
printf("-1");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
const int inf = 0x3f3f3f3f;
long long n, k, a, b;
long long ans;
int main() {
cin >> n >> k >> a >> b;
if (k == 1)
ans = (n - 1) * a;
else {
while (n > 1) {
if (n % k == 0) {
long long m = n / k;
if ((n - m) * a < b)
ans += (n - m) * a;
else
ans += b;
n = m;
} else {
long long m = n % k;
n -= m;
if (n < 1)
ans += (m - 1) * a;
else
ans += m * a;
}
}
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("-Ofast", "-funroll-all-loops", "-ffast-math")
#pragma GCC optimize("-fno-math-errno")
#pragma GCC optimize("-funsafe-math-optimizations")
#pragma GCC optimize("-freciprocal-math")
#pragma GCC optimize("-fno-trapping-math")
#pragma GCC optimize("-ffinite-math-only")
#pragma GCC optimize("-ftree-vectorize")
#pragma GCC target("avx2", "sse4.2", "fma")
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3f;
__inline__ __attribute__((always_inline)) unsigned int rnd() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
return a >= 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) {
return a < b ? b : a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) {
return a < b ? a : b;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
(b < a) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
char ch(getchar());
bool f(false);
while (!isdigit(ch)) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (isdigit(ch)) x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
f && (x = -x);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b,
const Args &...args) {
return a < b ? min(a, args...) : min(b, args...);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b,
const Args &...args) {
return a < b ? max(b, args...) : max(a, args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
char *tar = s;
*tar = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 100005;
const int lim = 600;
double dp[2][lim + 5], f[2][lim + 5];
int main() {
int n, k;
read(n, k);
f[0][1] = 1;
for (int i = 0; i < n; ++i) {
memset(f[!(i & 1)], 0, sizeof(f[!(i & 1)]));
memset(dp[!(i & 1)], 0, sizeof(dp[!(i & 1)]));
for (int j = 0; j <= lim && j <= i + 1; ++j) {
double p = 1.0 / (k * (j + 1));
double A = 1.0 * (k - 1) / k, B = p * j;
f[!(i & 1)][j] += 1.0 * f[i & 1][j] * (A + B);
f[!(i & 1)][j + 1] += 1.0 * f[i & 1][j] * p;
dp[!(i & 1)][j] +=
1.0 * dp[i & 1][j] * (A + B) + 1.0 * f[i & 1][j] * j / (2.0 * k);
dp[!(i & 1)][j + 1] += 1.0 * (dp[i & 1][j] + f[i & 1][j] * j) * p;
}
}
double ans = 0;
for (int i = 0; i <= lim; ++i) ans += dp[n & 1][i];
printf("%.12lf\n", ans * k);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, a, b;
cin >> n >> a >> b;
string s;
cin >> s;
long long ct = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == '1') {
continue;
}
ct++;
long long j = i;
while (j < n and s[j] == '0') j++;
i = j - 1;
}
if (ct == 0) {
cout << 0 << "\n";
return 0;
}
if (a >= b) {
cout << ct * b << "\n";
return 0;
} else {
cout << (ct - 1) * a + b << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 20010;
vector<int> g[M];
int a[M * 10];
vector<int> p;
void dele(int x) {
for (int i = 0; i < g[x].size(); i++) {
int j = g[x][i];
a[j]--;
if (a[j] == 1) p.push_back(j);
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
a[x]++;
a[y]++;
}
for (int i = 1; i <= n; i++)
if (a[i] == 1) p.push_back(i);
while (p.size() > 1) {
int x = p[0];
int y = p[1];
int ans;
cout << "? " << x << " " << y << endl;
cin >> ans;
if (ans == x || ans == y) {
cout << "! " << ans << endl;
return 0;
}
dele(x);
dele(y);
p.erase(p.begin());
p.erase(p.begin());
}
cout << "! " << p[0] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int i;
for (i = 0; i < s.length(); i++) {
if (s[i] != 'a') break;
}
if (!s[i]) s[i - 1] = 'z';
while (s[i] > 'a') s[i++]--;
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 757;
priority_queue<long long> q;
long long a[N], b[N];
int main() {
int n, m, t = 0, i;
long long w;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) scanf("%lld", a + i);
for (i = n; i; --i) {
while (!q.empty() && a[i] >= 0) a[i] += q.top(), q.pop();
if (a[i] < 0) q.push(a[i]);
}
while (!q.empty()) ++t, b[t] = b[t - 1] - q.top(), q.pop();
while (m--)
scanf("%lld", &w),
printf("%d\n", t - (upper_bound(b, b + t + 1, w) - b - 1));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int n;
int l[100005], r[100005];
int tot;
int inv[100005];
int val[100005];
vector<int> adj[100005];
int sub[100005], st[100005], en[100005], at[100005], in = 1;
int tree[2][4 * 100005];
int lazy[2][4 * 100005];
int dep[100005];
int ans = 0;
inline int add(int x, int y) {
x += y;
return (x >= MOD ? x - MOD : x);
}
int powmod(int a, int b) {
int an = 1;
while (b > 0) {
if ((b & 1)) an = (an * 1ll * a) % MOD;
a = (a * 1ll * a) % MOD;
b >>= 1;
}
return an;
}
inline void lazify(int s, int e, int i) {
if (lazy[0][i] || lazy[1][i]) {
for (int j = 0; j <= 1; j++)
tree[j][i] = add(tree[j][i], (lazy[j][i] * 1ll * (e - s + 1)) % MOD);
if (s != e) {
for (int j = 0; j <= 1; j++) {
lazy[j][2 * i] = add(lazy[j][2 * i], lazy[j][i]);
lazy[j][2 * i + 1] = add(lazy[j][2 * i + 1], lazy[j][i]);
}
}
lazy[0][i] = lazy[1][i] = 0;
}
}
void upd(int l, int r, int s, int e, int i, int x, int y) {
lazify(s, e, i);
if (s > r || e < l) return;
if (s >= l && e <= r) {
lazy[0][i] = add(lazy[0][i], x);
lazy[1][i] = add(lazy[1][i], y);
lazify(s, e, i);
return;
}
int mid = (s + e) >> 1;
upd(l, r, s, mid, 2 * i, x, y);
upd(l, r, mid + 1, e, 2 * i + 1, x, y);
for (int j = 0; j <= 1; j++)
tree[j][i] = add(tree[j][2 * i], tree[j][2 * i + 1]);
}
pair<int, int> qur(int l, int r, int s, int e, int i) {
if (s > r || e < l) return make_pair(0, 0);
lazify(s, e, i);
if (s >= l && e <= r) return make_pair(tree[0][i], tree[1][i]);
int mid = (s + e) >> 1;
auto a = qur(l, r, s, mid, 2 * i);
auto b = qur(l, r, mid + 1, e, 2 * i + 1);
b.first = add(b.first, a.first);
b.second = add(b.second, a.second);
return b;
}
void predfs(int i, int p, int d) {
dep[i] = d;
at[in] = i;
st[i] = in++;
sub[i] = 1;
for (auto j : adj[i])
if (j != p) predfs(j, i, d + 1), sub[i] += sub[j];
en[i] = in;
}
void dfs(int i, int p, int z) {
int big = 0;
for (auto j : adj[i])
if (j != p && sub[j] > sub[big]) big = j;
for (auto j : adj[i])
if (j != p && j != big) dfs(j, i, 0);
if (big) dfs(big, i, 1);
auto a = qur(l[i], r[i], 1, 100000, 1);
a.first = add(a.first, (a.second * 1ll * (MOD - dep[i])) % MOD);
a.first = (a.first * 1ll * val[i]) % MOD;
ans = add(ans, a.first);
upd(l[i], r[i], 1, 100000, 1, (dep[i] * 1ll * inv[i]) % MOD, inv[i]);
a = qur(1, 100000, 1, 100000, 1);
for (auto j : adj[i]) {
if (j != p && j != big) {
for (int h = st[j]; h < en[j]; h++) {
int u = at[h];
auto a = qur(l[u], r[u], 1, 100000, 1);
a.first =
add(a.first,
(a.second * 1ll * ((MOD + dep[u] - 2 * dep[i]) % MOD)) % MOD);
a.first = (a.first * 1ll * val[u]) % MOD;
ans = add(ans, a.first);
}
for (int h = st[j]; h < en[j]; h++) {
int u = at[h];
upd(l[u], r[u], 1, 100000, 1, (dep[u] * 1ll * inv[u]) % MOD, inv[u]);
}
}
}
if (!z) {
for (int h = st[i]; h < en[i]; h++) {
int u = at[h];
upd(l[u], r[u], 1, 100000, 1, MOD - ((dep[u] * 1ll * inv[u]) % MOD),
MOD - inv[u]);
}
}
}
void sd(int &x) {
bool neg = false;
register int c;
x = 0;
c = getchar();
if (c == '-') {
neg = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) x = (x << 1) + (x << 3) + c - 48;
if (neg) x *= -1;
}
int main() {
sd(n);
tot = 1;
for (int i = 1; i <= n; i++) {
sd(l[i]);
sd(r[i]);
tot = (tot * 1ll * (r[i] - l[i] + 1)) % MOD;
inv[i] = powmod(r[i] - l[i] + 1, MOD - 2);
}
for (int i = 1; i < n; i++) {
int x, y;
sd(x);
sd(y);
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= n; i++) val[i] = (tot * 1ll * inv[i]) % MOD;
predfs(1, 1, 1);
dfs(1, 1, 1);
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string n;
int sz;
long long mul;
long long ans;
long long powe(long long a, long long b) {
if (!b) return 1;
long long tmp = powe(a, b / 2);
tmp = (tmp * tmp) % 1000000007;
if (b % 2 == 1)
return (tmp * a) % 1000000007;
else
return tmp;
}
int main() {
cin >> n;
sz = ((int)n.size());
mul = powe(2, sz - 1);
long long tp = 1;
for (int i = sz - 1; i >= 0; i--) {
if (n[i] == '1') {
ans = (ans + ((tp * mul) % 1000000007)) % 1000000007;
}
tp = (tp * 2) % 1000000007;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 900011;
const double pi = acos(-1.0);
struct cp {
double x, y;
cp() {}
cp(double x, double y) : x(x), y(y) {}
cp operator+(const cp &a) const { return cp(x + a.x, y + a.y); }
cp operator-(const cp &a) const { return cp(x - a.x, y - a.y); }
cp operator*(const cp &a) const {
return cp(x * a.x - y * a.y, x * a.y + y * a.x);
}
cp operator/(const double &a) const { return cp(x / a, y / a); }
};
int inv[N];
void fft(cp *a, int len, int tp) {
for (int i = 0; i < len; i++)
if (i < inv[i]) swap(a[i], a[inv[i]]);
for (int i = 1; i < len; i <<= 1) {
cp w0(cos(pi / i), tp * sin(pi / i));
for (int j = 0; j < len; j += (i << 1)) {
cp w(1, 0);
for (int k = 0; k < i; k++, w = w * w0) {
cp w1 = a[j + k], w2 = w * a[j + k + i];
a[j + k] = w1 + w2, a[j + k + i] = w1 - w2;
}
}
}
if (tp == -1)
for (int i = 0; i < len; i++) a[i] = a[i] / len;
}
int st, ss, n, m, k;
cp a[N], b[N], c[N];
char T[N], S[N];
int len = 1, pl;
int ctr[N];
void fuck(char ch) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
for (int i = 0; i < st; i++)
if (T[i] == ch) b[i].x = 1.0;
int pr = -1;
for (int i = 0; i < ss; i++) {
if (S[i] == ch) pr = i;
if (pr >= 0 && i - pr <= k) a[i].x = 1.0;
}
pr = -1;
for (int i = ss - 1; i >= 0; i--) {
if (S[i] == ch) pr = i;
if (pr >= 0 && pr - i <= k) a[i].x = 1.0;
}
fft(a, len, 1), fft(b, len, 1);
for (int i = 0; i < len; i++) c[i] = a[i] * b[i];
fft(c, len, -1);
for (int i = 0; i < len; i++) ctr[i] += (int)(c[i].x + 0.5);
}
int main() {
scanf("%d%d%d%s%s", &ss, &st, &k, S, T);
for (int i = 0; st - i - 1 > i; i++) swap(T[i], T[st - i - 1]);
while (len < ss * 2) len <<= 1, pl++;
for (int i = 1; i < len; i++)
inv[i] = (inv[i >> 1] >> 1) | ((i & 1) << (pl - 1));
fuck('A'), fuck('G'), fuck('C'), fuck('T');
int ans = 0;
for (int i = 0; i < ss; i++)
if (ctr[i] >= st) ans++;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
const int M = 1e6 + 10;
const int MOD = 1e9 + 7;
double const pi = acos(-1);
const double eps = 1e-8;
void fre() { freopen("in.txt", "r", stdin); }
int a[N];
vector<int> s[N];
int n, k;
long long ans;
void dfs(int u, int f) {
for (int i = 0; i < (int)s[u].size(); i++) {
int v = s[u][i];
if (v == f) continue;
dfs(v, u);
a[u] += a[v];
ans += min(a[v], 2 * k - a[v]);
}
return;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < 2 * k; i++) {
int x;
scanf("%d", &x);
a[x] = 1;
}
for (int i = 0; i <= n; i++) s[i].clear();
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
s[x].push_back(y);
s[y].push_back(x);
}
ans = 0;
dfs(1, -1);
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
while (scanf("%d%d", &a, &b) != EOF) {
int max = 0;
int number1 = a, number2 = b;
int number, c = 0, count = 0;
while (number1) {
if (number1 % 10 > max) max = number1 % 10;
number1 /= 10;
}
while (number2) {
if (number2 % 10 > max) max = number2 % 10;
number2 /= 10;
}
max++;
while (a && b) {
number = a % 10 + b % 10 + c;
c = number / max;
count++;
a /= 10;
b /= 10;
}
while (a) {
number = a % 10 + c;
c = number / max;
count++;
a /= 10;
}
while (b) {
number = b % 10 + c;
c = number / max;
count++;
b /= 10;
}
while (number >= max) {
number -= max;
count++;
}
printf("%d\n", count);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500010;
const int maxk = 110;
const int oo = 100000007;
int n, k, base, a[maxn], t1[4 * maxk], t2[4 * maxk], f[3][maxn];
void update1(int i, int tt) {
while (i <= maxk) {
t1[i] = min(t1[i], tt);
i += i & -i;
}
}
int get1(int i) {
int res = oo;
while (i > 0) {
res = min(res, t1[i]);
i -= i & -i;
}
return res;
}
void update2(int i, int tt) {
while (i > 0) {
t2[i] = min(t2[i], tt);
i -= i & -i;
}
}
int get2(int i) {
int res = oo;
while (i <= maxk) {
res = min(res, t2[i]);
i += i & -i;
}
return res;
}
int main() {
cin >> n >> k >> base;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] = (a[i - 1] + a[i]) % base;
}
int t = 0;
memset(f[1 - t], oo, sizeof(f[1 - t]));
f[1 - t][0] = 0;
for (int ti = 1; ti <= k; ti++) {
memset(t1, oo, sizeof(t1));
memset(t2, oo, sizeof(t2));
memset(f[t], oo, sizeof(f[t]));
for (int i = 1; i <= n; i++) {
update1(a[i - 1] + 1, f[1 - t][i - 1] - a[i - 1]);
update2(a[i - 1] + 1, f[1 - t][i - 1] - a[i - 1]);
f[t][i] = min(f[t][i], get1(a[i] + 1) + a[i]);
f[t][i] = min(f[t][i], get2(a[i] + 1 + 1) + a[i] + base);
}
t = 1 - t;
}
cout << f[1 - t][n] << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K, t, t1, t2, x, y, pt, ans;
int ne[2000], st[2000], go[2000];
int f[2000][2000];
int tt[2000];
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 1; i <= M; i++) {
scanf("%d%d", &x, &y);
ne[++pt] = st[x];
st[x] = pt;
go[pt] = y;
ne[++pt] = st[y];
st[y] = pt;
go[pt] = x;
}
memset(f, 0, sizeof(f));
for (int j = 0; j < (1 << N); j++) {
tt[j] = 0;
for (int k = 0; k < N; k++)
if (j & (1 << k)) tt[j]++;
if (tt[j] == K) f[(1 << N) - 1][j] = 1;
}
for (int i = (1 << N) - 1; i >= 0; i--)
for (int j = 0; j < (1 << N); j++)
if (f[i][j]) {
t = 0;
for (int k = 0; k < N; k++)
if (j & (1 << k)) {
t = k + 1;
break;
}
if (t == 0) continue;
for (int k = st[t]; k; k = ne[k])
if (i & (1 << (go[k] - 1)))
if (!(j & (1 << (go[k] - 1)))) {
x = i - (1 << (t - 1));
y = j - (1 << (t - 1)) + (1 << (go[k] - 1));
f[x][y] += f[i][j];
x = i - (1 << (t - 1));
y = j - (1 << (t - 1));
f[x][y] += f[i][j];
}
}
for (int i = 0; i < (1 << N); i++)
if (tt[i] == 2) {
for (int j = 0; j < N; j++)
if (i & (1 << j)) {
t2 = t1;
t1 = j;
}
for (int j = st[t1 + 1]; j; j = ne[j])
if (t2 + 1 == go[j]) {
ans += f[i][i];
break;
}
}
printf("%d", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxc = 10000001;
int d[maxc];
int main(void) {
for (int i = 1; i < maxc; i++) d[i] = 1;
for (int i = 2; i * i < maxc; i++) {
for (int j = i * i; j < maxc; j += i * i) d[j] = i * i;
}
int a, n;
scanf("%d %d", &a, &n);
long long ans = 0;
for (int i = 0; i < n; i++) ans += (a + i) / d[a + i];
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mn = 311111;
int vis1[mn], vis2[mn], a[mn], b[mn];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
memset(vis1, 0, sizeof(vis1));
memset(vis2, 0, sizeof(vis2));
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
vis1[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
vis2[b[i]] = i;
}
int ans = n - 1;
for (int i = 2; i <= n; i++) {
if (vis2[a[i]] > vis2[a[i - 1]])
ans--;
else
break;
}
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, mx = 0;
scanf("%d", &n);
int a[n + 1];
for (int i = 0; i <= n; i++) a[i] = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
a[x] = a[x - 1] + 1;
if (a[x] > mx) mx = a[x];
}
printf("%d", n - mx);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int dx4[4] = {0, 1, 0, -1};
const long long int dy4[4] = {-1, 0, 1, 0};
const long long int dx8[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const long long int dy8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
vector<string> vec_splitter(string s) {
for (char &c : s) c = c == ',' ? ' ' : c;
stringstream ss;
ss << s;
vector<string> res;
for (string z; ss >> z; res.push_back(z))
;
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) long long int idx) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, long long int idx, Head H, Tail... T) {
if (idx > 0) cerr << ", ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, T...);
}
const long long int MAXN = 1e5 + 5;
vector<long long int> ar[MAXN], g[MAXN], p, q;
long long int N, freq[MAXN];
set<long long int> s;
set<long long int> tri[MAXN];
map<pair<long long int, long long int>, long long int> cnt_edge;
bool vis[MAXN];
inline void init() {
for (long long int i = 1; i <= N; ++i) {
tri[i].clear();
g[i].clear();
freq[i] = vis[i] = 0;
}
s.clear();
cnt_edge.clear();
p.clear();
q.clear();
}
void dfs(long long int u) {
vis[u] = 1;
p.push_back(u);
for (auto &v : g[u]) {
if (vis[v] == 1) continue;
dfs(v);
}
}
void find_p() {
for (auto &x : cnt_edge) {
if (x.second == 1) {
long long int u, v;
tie(u, v) = x.first;
g[u].push_back(v);
g[v].push_back(u);
}
}
dfs(1);
}
void find_q() {
for (long long int i = 1; i <= N; ++i) {
if (freq[i] == 1) {
s.insert(i);
}
}
for (long long int i = 1; i <= N - 2; ++i) {
long long int x = *s.begin();
long long int j = *tri[x].begin();
auto p = ar[j];
q.push_back(j);
for (long long int k = 0; k < 3; ++k) {
long long int x = p[k];
tri[x].erase(j);
--freq[x];
if (!freq[x]) s.erase(x);
if (freq[x] == 1) s.insert(x);
}
}
}
void solve() {
init();
cin >> N;
for (long long int i = 1; i <= N - 2; ++i) {
long long int a, b, c;
cin >> a >> b >> c;
ar[i] = {a, b, c};
sort(ar[i].begin(), ar[i].end());
for (long long int j = 0; j < 3; ++j) {
long long int x = ar[i][j];
++freq[x];
tri[x].insert(i);
}
for (long long int j = 0; j < 3; ++j) {
for (long long int k = j + 1; k < 3; ++k) {
++cnt_edge[{ar[i][j], ar[i][k]}];
}
}
}
find_p();
for (auto &x : p) cout << x << " ";
cout << '\n';
find_q();
for (auto &x : q) cout << x << " ";
cout << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long int T = 1;
cin >> T;
for (long long int i = 1; i <= T; ++i) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void checkmax(T &x, T y) {
if (x < y) x = y;
}
template <class T>
inline void checkmin(T &x, T y) {
if (x > y) x = y;
}
template <class T>
inline T Min(T x, T y) {
return (x > y ? y : x);
}
template <class T>
inline T Max(T x, T y) {
return (x < y ? y : x);
}
template <class T>
T Abs(T a) {
return a > 0 ? a : (-a);
}
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
int sum[111111];
int st[111111];
char s[111111];
int l, r, ans, top = 0;
bool f(char x, char y) {
return (x == '(' && y == ')') || (x == '[' && y == ']');
}
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
sum[0] = 0;
ans = 0;
for (int i = 1; i <= (int)(n); ++i) {
sum[i] = sum[i - 1] + (s[i] == '[');
if (top == 0)
st[++top] = i;
else {
if (f(s[st[top]], s[i])) {
top--;
if (top == 0) {
if (ans < sum[i]) ans = sum[i], l = 1, r = i;
} else {
if (ans < sum[i] - sum[st[top]])
ans = sum[i] - sum[st[top]], l = st[top] + 1, r = i;
}
} else
st[++top] = i;
}
}
printf("%d\n", ans);
if (ans)
for (int i = l; i <= (int)(r); ++i) putchar(s[i]);
if (ans) puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long a, b, p;
cin >> a >> b >> p;
string s;
cin >> s;
long long n = s.size();
long long i = n - 2;
if (p < min(a, b)) {
cout << n << endl;
continue;
}
while (i >= 0) {
if (s[i] == 'A') {
if (p < a) {
p = -1;
cout << i + 2 << endl;
break;
}
p -= a;
while (s[i] == 'A') {
i--;
if (i < 0) break;
}
}
if (i < 0) break;
if (s[i] == 'B') {
if (p < b) {
p = -1;
cout << i + 2 << endl;
break;
}
p -= b;
while (s[i] == 'B') {
i--;
if (i < 0) break;
}
}
}
if (p >= 0) {
cout << 1 << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, l;
long long arr[100005], res[100005];
long long sum;
long long ans() {
int i = lower_bound(res + n - 1, res + m + 2, sum) - res;
return min(res[i] - sum, sum - res[i - 1]);
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void print(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
inline void print(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
int main() {
n = read();
m = read();
q = read();
for (int i = 1; i <= n; i++) {
sum += (i & 1 ? 1 : -1) * read();
}
for (int i = 1; i <= m; i++) {
arr[i] = arr[i - 1] + (i & 1 ? 1 : -1) * read();
if (i >= n) {
res[i] = ((i - n) & 1 ? -1 : 1) * (arr[i] - arr[i - n]);
}
}
sort(res + n, res + m + 1);
res[n - 1] = -1e18, res[m + 1] = 1e18;
print(ans());
putchar('\n');
while (q--) {
if (l = read(), (read() - l + 1) & 1)
sum += (l & 1 ? 1 : -1) * read();
else
read();
print(ans());
putchar('\n');
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long h[100010];
long long p[100010];
int n, m;
bool can(long long cur, long long l, long long r, long long t) {
l = max(cur - l, 0LL);
r = max(r - cur, 0LL);
return t >= l + r + min(l, r);
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) scanf("%I64d", h + i);
for (int i = 0; i < m; i++) scanf("%I64d", p + i);
long long lo = 0;
long long hi = 200000000000LL;
while (lo < hi) {
long long mi = (lo + hi) / 2;
int t;
int i, j;
for (i = 0, j = 0; i < n && j < m; j = t, i++) {
for (t = j; t < m; t++) {
if (!can(h[i], p[j], p[t], mi)) break;
}
}
if (j < m)
lo = mi + 1;
else
hi = mi;
}
printf("%I64d\n", lo);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
FILE *in;
FILE *out;
struct Point {
double pos;
int type;
bool operator<(const Point &r) const {
if (fabs(pos - r.pos) > 0.00000001) return pos < r.pos;
return type < r.type;
}
};
int n;
Point a[262144];
double ans[262144];
double l, v1, v2;
int main(void) {
in = stdin;
out = stdout;
fscanf(in, "%d", &n);
fscanf(in, "%lf", &l);
fscanf(in, "%lf %lf", &v1, &v2);
double t = l / (v1 + v2);
double d = t * v2;
int cnt = 0;
double last = 0.0;
for (int i = 0; i < n; i++) {
int pos;
fscanf(in, "%d", &pos);
if (pos >= 0 && pos < d) cnt++;
a[i * 2].pos = pos - d;
a[i * 2].type = 1;
if (a[i * 2].pos < 0.0) a[i * 2].pos += l * 2;
a[i * 2 + 1].pos = pos;
a[i * 2 + 1].type = 0;
}
sort(a, a + 2 * n);
for (int i = 0; i < 262144; i++) ans[i] = 0.0;
for (int i = 0; i < 2 * n; i++) {
ans[cnt] += a[i].pos - last;
last = a[i].pos;
if (a[i].type == 0)
cnt--;
else
cnt++;
}
ans[cnt] += 2 * l - last;
ans[0] = 2 * l;
for (int i = 1; i <= n; i++) ans[0] -= ans[i];
for (int i = 0; i <= n; i++) fprintf(out, "%.12lf\n", ans[i] / (2.0 * l));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
const int N = 101;
int b[N], last[N];
int n, k, m, a;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> k >> m >> a;
if (n == 1) {
cout << 1;
return 0;
}
for (int i = 1; i <= a; i++) {
int first;
cin >> first;
b[first]++;
last[first] = i;
}
if (a == m) {
for (int i = 1; i <= n; i++) {
int p = 0;
for (int j = 1; j <= n; j++) {
if (b[i] > b[j] || (b[i] == b[j] && last[i] < last[j])) {
p++;
}
}
if (b[i] > 0 && p >= n - k) {
cout << "1 ";
} else {
cout << "3 ";
}
}
return 0;
}
if (n == k) {
for (int i = 1; i <= n; i++) {
cout << (b[i] ? "1 " : "2 ");
}
return 0;
}
int ost = m - a;
for (int i = 1; i <= n; i++) {
vector<pair<int, int> > c;
for (int j = 1; j <= n; j++) {
if (j != i) {
c.push_back({b[j], -last[j]});
}
}
sort((c).begin(), (c).end());
reverse((c).begin(), (c).end());
if (c[k - 1].first >= ost + b[i]) {
cout << "3 ";
} else {
int f = 0;
for (int j = 0; j < k; j++) {
if (c[j].first < b[i]) {
f += (b[i] - c[j].first + 1);
} else if (c[j].first == b[i] && -c[j].second > last[i]) {
f += 1;
}
}
cout << ((f > ost) ? "1 " : "2 ");
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int b, g, n;
cin >> b >> g >> n;
cout << min(abs(b + g - n), min(b, min(g, n))) + 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char str[2010][2010];
void go(int x, int y) {
int l, r, u, d;
d = (int)(str[x + 1][y] == '.');
u = (int)(str[x - 1][y] == '.');
r = (int)(str[x][y + 1] == '.');
l = (int)(str[x][y - 1] == '.');
if (!d && !u && !r && !l) {
cout << "Not unique" << endl;
exit(0);
}
if (l && !r && !u && !d) {
str[x][y - 1] = '<';
str[x][y] = '>';
if (str[x][y - 2] == '.') go(x, y - 2);
if (str[x - 1][y - 1] == '.') go(x - 1, y - 1);
if (str[x + 1][y - 1] == '.') go(x + 1, y - 1);
}
if (r && !l && !u && !d) {
str[x][y] = '<';
str[x][y + 1] = '>';
if (str[x][y + 2] == '.') go(x, y + 2);
if (str[x - 1][y + 1] == '.') go(x - 1, y + 1);
if (str[x + 1][y + 1] == '.') go(x + 1, y + 1);
}
if (u && !l && !r && !d) {
str[x - 1][y] = '^';
str[x][y] = 'v';
if (str[x - 2][y] == '.') go(x - 2, y);
if (str[x - 1][y + 1] == '.') go(x - 1, y + 1);
if (str[x - 1][y - 1] == '.') go(x - 1, y - 1);
}
if (d && !l && !r && !u) {
str[x][y] = '^';
str[x + 1][y] = 'v';
if (str[x + 2][y] == '.') go(x + 2, y);
if (str[x + 1][y - 1] == '.') go(x + 1, y - 1);
if (str[x + 1][y + 1] == '.') go(x + 1, y + 1);
}
return;
}
int main() {
int n, m, i, j;
for (i = 0; i < 2010; i++)
for (j = 0; j < 2010; j++) str[i][j] = '*';
scanf("%d%d", &n, &m);
getchar();
for (i = 1; i <= n; i++) {
gets(str[i] + 1);
str[i][m + 1] = '*';
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (str[i][j] == '.') go(i, j);
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (str[i][j] == '.') {
cout << "Not unique" << endl;
return 0;
}
}
}
for (i = 1; i <= n; i++) {
str[i][m + 1] = 0;
printf("%s\n", str[i] + 1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
std::vector<int> factors;
int mood[100000];
int N;
void calcfactors(int num) {
for (int i = 3; i <= num; i++) {
if (num % i == 0) {
factors.push_back(i);
while (num % i == 0) {
num /= i;
}
}
}
}
bool lucky() {
calcfactors(N);
for (int i = 0; i < factors.size(); i++) {
int skip = N / factors[i];
for (int j = 0; j < skip; j++) {
for (int k = j;; k += skip) {
if (k >= N) {
return true;
}
if (mood[k] == 0) {
break;
}
}
}
}
return false;
}
int main() {
std::cin >> N;
for (int i = 0; i < N; i++) {
std::cin >> mood[i];
}
if (lucky()) {
std::cout << "YES" << std::endl;
} else {
std::cout << "NO" << std::endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
int ah = 911382323;
int bh = 972663749;
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
typename vector<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
typename set<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
typename map<F, S>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
long long dx[8] = {1, -1, 0, 0, 1, 1, -1, -1};
long long dy[8] = {0, 0, 1, -1, 1, -1, 1, -1};
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long(t);
cin >> (t);
while ((t)--) {
long long n;
cin >> n;
if (n == 2 || n == 3)
cout << (-1) << " ";
else if (n % 2 == 0) {
vector<long long> ans;
long long x = 1;
while (x < n - 3) {
ans.emplace_back(x);
x += 2;
}
x += 2;
ans.emplace_back(x);
x -= 2;
ans.emplace_back(x);
x = n;
while (x > 0) {
ans.emplace_back(x);
x -= 2;
}
for (auto x : ans) cout << (x) << " ";
} else {
vector<long long> ans;
long long x = 1;
while (x <= n) {
ans.emplace_back(x);
x += 2;
}
x -= 2;
x -= 3;
ans.emplace_back(x);
x += 2;
ans.emplace_back(x);
x -= 4;
while (x > 0) {
ans.emplace_back(x);
x -= 2;
}
for (auto x : ans) cout << (x) << " ";
}
cout << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5, M = 1e9 + 7;
mt19937_64 rng(std::chrono::system_clock::now().time_since_epoch().count());
int n, m, ans = 1e8;
string c = "ACGT", s[N], bst[N], TEMP[N];
void solve(string perm[2]) {
int sum = 0;
for (int i = 0; i < n; i++) {
int temp = 0, temp1 = 0;
for (int j = 0; j < m; j++) temp += s[i][j] != perm[i & 1][j & 1];
swap(perm[i & 1][0], perm[i & 1][1]);
for (int j = 0; j < m; j++) temp1 += s[i][j] != perm[i & 1][j & 1];
swap(perm[i & 1][0], perm[i & 1][1]);
if (temp > temp1) swap(perm[i & 1][0], perm[i & 1][1]);
for (int j = 0; j < m; j++) TEMP[i][j] = perm[i & 1][j & 1];
if (temp > temp1) swap(perm[i & 1][0], perm[i & 1][1]);
sum += min(temp, temp1);
}
if (sum < ans) {
ans = sum;
for (int i = 0; i < n; i++) bst[i] = TEMP[i];
}
}
void solve1(string perm[2]) {
int sum = 0;
for (int j = 0; j < m; j++) {
int temp = 0, temp1 = 0;
for (int i = 0; i < n; i++) temp += s[i][j] != perm[j & 1][i & 1];
swap(perm[j & 1][0], perm[j & 1][1]);
for (int i = 0; i < n; i++) temp1 += s[i][j] != perm[j & 1][i & 1];
swap(perm[j & 1][0], perm[j & 1][1]);
if (temp > temp1) swap(perm[j & 1][0], perm[j & 1][1]);
for (int i = 0; i < n; i++) TEMP[i][j] = perm[j & 1][i & 1];
if (temp > temp1) swap(perm[j & 1][0], perm[j & 1][1]);
sum += min(temp, temp1);
}
if (sum < ans) {
ans = sum;
for (int i = 0; i < n; i++) bst[i] = TEMP[i];
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) TEMP[i] += s[i][j];
do {
string temp[2];
temp[0] = c[0];
temp[0] += c[1];
temp[1] += c[2];
temp[1] += c[3];
solve(temp);
} while (next_permutation(c.begin(), c.end()));
do {
string temp[2];
temp[0] = c[0];
temp[0] += c[1];
temp[1] += c[2];
temp[1] += c[3];
solve1(temp);
} while (next_permutation(c.begin(), c.end()));
for (int i = 0; i < n; i++, puts(""))
for (int j = 0; j < m; j++) printf("%c", bst[i][j]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void pv(std::vector<int> v) {
for (int i = 0; i < v.size(); ++i) {
cout << v[i] << " ";
}
cout << "" << endl;
}
void pa(int a[], int n, int p) {
for (int i = p; i < n + p; ++i) {
cout << a[i] << " ";
}
cout << "" << endl;
}
const double pi = 3.141592653589793238;
const long long int inf = (long long int)10e16;
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, ans = 0;
cin >> n;
set<int, greater<int> > a1;
ans++;
a1.insert(n);
while (n != 1) {
n++;
while (n % 10 == 0) {
n = n / 10;
}
if (n != 1) {
a1.insert(n);
ans++;
}
}
for (int i = 1; i <= 9; i += 1)
if (!a1.count(i)) {
a1.insert(i);
ans++;
}
cout << ans << endl;
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, f = 0, x = 0, u = 0, l = 0, d = 0, r = 0, i;
char c[1000];
cin >> n;
for (i = 0; i < n; i++) {
cin >> c[i];
if (c[i] == 'U')
u++;
else if (c[i] == 'D')
d++;
else if (c[i] == 'L')
l++;
else if (c[i] == 'R')
r++;
}
if (u == d) x += u + d;
if (l == r) x += l + r;
if (u != 0 && d != 0) {
if (u > d)
x += 2 * d;
else if (d > u)
x += 2 * u;
}
if (l != 0 && r != 0) {
if (l > r)
x += 2 * r;
else if (r > l)
x += 2 * l;
}
cout << x;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m;
int q[N];
int book[N], mark[N];
int min_ans[N];
int main() {
for (int i = 0; i < N; i++) min_ans[i] = 1e7 + 1;
cin >> n;
for (int i = 1; i <= n; i++) cin >> q[i];
cin >> m;
int ans = 0;
int temp_a, temp_b, temp_c;
for (int i = 1; i <= m; i++) {
cin >> temp_a >> temp_b >> temp_c;
if (q[temp_a] <= q[temp_b]) {
cout << -1 << endl;
return 0;
}
if (book[temp_b]) {
book[temp_b]++;
ans -= mark[temp_b];
ans += min(mark[temp_b], temp_c);
mark[temp_b] = min(mark[temp_b], temp_c);
continue;
}
mark[temp_b] = temp_c;
ans += temp_c;
book[temp_b]++;
}
int sum = 0;
for (int i = 1; i <= n; i++) {
if (book[i] == 0) {
sum++;
}
}
if (sum != 1) {
cout << -1 << endl;
return 0;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int sg[50][50][50][50][2];
char maze[50][50];
int get(int x1, int x2, int y1, int y2, int f) {
if (x1 > x2 || y1 > y2) return sg[x1][x2][y1][y2][f] = 0;
if (sg[x1][x2][y1][y2][f] != -1) return sg[x1][x2][y1][y2][f];
bool vis[205];
memset(vis, false, sizeof(vis));
for (int i = (1); i < (n + 1); i++) {
for (int j = (1); j < (m + 1); j++) {
if (((i + j) & 1) == f) {
int x = i + j;
int y = i - j + m;
if (x1 <= x && x <= x2 && y1 <= y && y <= y2) {
if (maze[i][j] == 'L')
vis[get(x1, x - 1, y1, y2, f) ^ get(x + 1, x2, y1, y2, f)] = true;
else if (maze[i][j] == 'R')
vis[get(x1, x2, y1, y - 1, f) ^ get(x1, x2, y + 1, y2, f)] = true;
else
vis[get(x1, x - 1, y1, y - 1, f) ^ get(x + 1, x2, y1, y - 1, f) ^
get(x1, x - 1, y + 1, y2, f) ^ get(x + 1, x2, y + 1, y2, f)] =
true;
}
}
}
}
for (int i = (0); i < (1000); i++) {
if (!vis[i]) {
return sg[x1][x2][y1][y2][f] = i;
}
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(sg, -1, sizeof(sg));
cin >> n >> m;
for (int i = (1); i < (n + 1); i++) {
for (int j = (1); j < (m + 1); j++) cin >> maze[i][j];
}
if (get(1, n + m, 1, n + m, 1) ^ get(1, n + m, 1, n + m, 0)) {
cout << "WIN"
<< "\n";
} else {
cout << "LOSE"
<< "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, q, x;
cin >> n >> q;
while (q--) {
cin >> x;
if (x & 1) {
cout << (x + 1) / 2 << endl;
continue;
} else {
while (!(x & 1)) {
x = n + (x / 2);
}
cout << (x + 1) / 2 << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005], dp[100005][5];
bool solve(int i, int j) {
if (i == n - 1) return true;
if (dp[i][j] == -1) {
bool ans = false;
if (a[i] < a[i + 1])
for (int k = j + 1; k < 5; k++) ans |= solve(i + 1, k);
else if (a[i] > a[i + 1])
for (int k = 0; k < j; k++) ans |= solve(i + 1, k);
else
for (int k = 0; k < 5; k++)
if (j != k) ans |= solve(i + 1, k);
dp[i][j] = ans;
}
return dp[i][j];
}
void print(int i, int j) {
cout << j + 1 << " ";
if (i == n - 1) {
cout << endl;
return;
}
if (a[i] < a[i + 1]) {
for (int k = j + 1; k < 5; k++) {
if (solve(i + 1, k)) {
print(i + 1, k);
return;
}
}
} else if (a[i] > a[i + 1]) {
for (int k = 0; k < j; k++) {
if (solve(i + 1, k)) {
print(i + 1, k);
return;
}
}
} else {
for (int k = 0; k < 5; k++) {
if (j != k && solve(i + 1, k)) {
print(i + 1, k);
return;
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
memset(dp, -1, sizeof(dp));
for (int j = 0; j < 5; j++) {
if (solve(0, j)) {
print(0, j);
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long mod = 1000000007, N = 1000005;
long long pref[N], suff[N], wcnt[N], xcnt[N], bcnt[N];
long long power(long long y, long long x = 2) {
long long res = 1LL;
while (y) {
if (y & 1) res = (res * x) % mod;
x = (x * x) % mod;
y = (y / 2);
}
return res;
}
void solve() {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
xcnt[0] = wcnt[0] = bcnt[0] = 0;
for (long long i = 1; i <= n; i++) {
xcnt[i] = (xcnt[i - 1] + (s[i - 1] == 'X'));
bcnt[i] = (bcnt[i - 1] + (s[i - 1] == 'B'));
wcnt[i] = (wcnt[i - 1] + (s[i - 1] == 'W'));
}
pref[0] = 1;
for (long long i = 1; i <= n; i++) {
pref[i] = (pref[i - 1] * ((s[i - 1] == 'X') ? 2 : 1)) % mod;
if (i == k && wcnt[i - k] == wcnt[i]) {
pref[i] += (mod - pref[i - k]);
pref[i] %= mod;
}
if (i > k && wcnt[i - k] == wcnt[i] && s[i - k - 1] != 'B') {
pref[i] += (mod - pref[i - k - 1]);
pref[i] %= mod;
}
}
suff[n] = 1;
for (long long i = (n - 1); i >= 0; i--) {
suff[i] = (suff[i + 1] * ((s[i] == 'X') ? 2 : 1)) % mod;
if (i == (n - k) && bcnt[i] == bcnt[i + k]) {
suff[i] += (mod - suff[i + k]);
suff[i] %= mod;
}
if (i < (n - k) && bcnt[i] == bcnt[i + k] && s[i + k] != 'W') {
suff[i] += (mod - suff[i + k + 1]);
suff[i] %= mod;
}
}
long long res = 0;
for (long long i = k; i <= (n - k); i++) {
if (i == k && wcnt[i] == wcnt[i - k]) {
res += (pref[i - k] * (power(xcnt[n] - xcnt[i]) - suff[i] + mod)) % mod;
res %= mod;
}
if (i > k && wcnt[i] == wcnt[i - k] && s[i - k - 1] != 'B') {
res +=
(pref[i - k - 1] * (power(xcnt[n] - xcnt[i]) - suff[i] + mod)) % mod;
res %= mod;
}
}
cout << res << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long int off;
long long int p[1010];
long long int a[1010 * 2], ds[1010 * 2];
long long int mem[1010][1010 * 2];
long long int inf = LONG_LONG_MAX;
long long int dp(int prs, int key) {
if (prs == 0) return 0;
if (key < prs) return inf;
if (mem[prs][key] != -1) return mem[prs][key];
long long int mi = inf;
mi = min(mi, dp(prs, key - 1));
mi = min(mi, max(dp(prs - 1, key - 1), abs(p[prs] - a[key]) + ds[key]));
return mem[prs][key] = mi;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> off;
memset(mem, -1, sizeof(mem));
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = 1; i <= k; i++) cin >> a[i];
sort(p + 1, p + n + 1);
sort(a + 1, a + k + 1);
for (int i = 1; i <= k; i++) {
ds[i] = abs(a[i] - off);
}
cout << dp(n, k) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string x;
int n;
int main() {
string ans;
cin >> n;
cin >> x;
ans = x;
for (int i = 0; i < n; i++) {
string temp = "";
int cnt = (10 - (int)(x[i] - '0')) % 10;
for (int j = 0; j < n; j++)
temp += (char)(((int)(x[(i + j) % n] - '0' + cnt) % 10) + '0');
ans = min(ans, temp);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const long long INF = (long long)1e17 + 10;
int n, m, s, t;
int a[N], b[N], l[N];
struct edge {
int to, cost;
edge(int to, int cost) : to(to), cost(cost) {}
};
vector<edge> e;
vector<int> g[N];
vector<int> g2[N];
long long diss[N], dist[N];
long long len;
bool vis[N], ans[N];
map<int, long long> mp;
set<pair<pair<long long, long long>, int> > st;
void dijkstra(int sc, vector<int> g[N], long long *dis) {
fill(dis + 1, dis + n + 1, INF);
priority_queue<pair<long long, int> > pq;
pq.push(make_pair(0, sc));
memset(vis, 0, sizeof(vis));
while (!pq.empty()) {
pair<long long, int> tmp = pq.top();
pq.pop();
if (vis[tmp.second]) continue;
vis[tmp.second] = 1;
dis[tmp.second] = -tmp.first;
for (auto j : g[tmp.second]) {
int u = e[j].to;
int c = e[j].cost;
if (vis[u]) continue;
pair<long long, int> nxt = make_pair(-dis[tmp.second] - c, u);
pq.push(nxt);
}
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &s, &t);
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", a + i, b + i, l + i);
g[a[i]].push_back(e.size());
e.push_back(edge(b[i], l[i]));
g2[b[i]].push_back(e.size());
e.push_back(edge(a[i], l[i]));
}
dijkstra(s, g, diss);
dijkstra(t, g2, dist);
len = diss[t];
for (int i = 0; i < m; ++i) {
if (diss[a[i]] + dist[b[i]] + l[i] == len) {
st.insert(make_pair(make_pair(diss[a[i]], diss[b[i]]), i));
ans[i] = 1;
}
}
long long mx = 0;
for (auto k : st) {
mp[k.second] = mx;
mx = max(k.first.second, mx);
}
for (int i = 0; i < m; ++i) {
if (diss[a[i]] + dist[b[i]] + l[i] == len) {
st.erase(make_pair(make_pair(diss[a[i]], diss[b[i]]), i));
auto it = st.lower_bound(make_pair(make_pair(diss[a[i]], -1), -1));
if (!(it == st.end() || it->first.first == diss[b[i]])) {
ans[i] = 0;
}
if (mp[i] > diss[a[i]]) {
ans[i] = 0;
}
st.insert(make_pair(make_pair(diss[a[i]], diss[b[i]]), i));
}
}
for (int i = 0; i < m; ++i) {
if (ans[i]) {
puts("YES");
} else {
long long mn = diss[a[i]] + dist[b[i]];
if (len - 1 > mn) {
printf("CAN %d\n", l[i] - (len - 1 - mn));
} else {
puts("NO");
}
}
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.