solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long L, v, l, r;
cin >> L >> v >> l >> r;
if (l % v != 0) l = (l - l % v) + v;
L -= L % v;
r -= r % v;
cout << (L / v) - (r - l) / v - 1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll dp_sum[5][200001];
ll dp_no[5][200001];
bool vis[200001];
vector<int> adj[200001];
int k;
ll ans = 0LL;
ll ans2 = 0LL;
void dfs(int v, int par) {
vis[v] = 1;
for (auto u : adj[v]) {
if (u != par) {
dfs(u, v);
for (int i = 1; i <= k; i++) {
dp_sum[i % k][v] += dp_no[i - 1][u] + dp_sum[i - 1][u];
dp_no[i % k][v] += dp_no[i - 1][u];
}
}
}
for (auto u : adj[v]) {
if (u == par) continue;
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
ll no_paths = dp_no[(i + k - 1) % k][u] *
(dp_no[j][v] - dp_no[(j + k - 1) % k][u]);
ans += (dp_sum[(i + k - 1) % k][u] + dp_no[(i + k - 1) % k][u]) *
(dp_no[j][v] - dp_no[(j + k - 1) % k][u]);
ans += (dp_sum[j][v] - dp_sum[(j + k - 1) % k][u] -
dp_no[(j + k - 1) % k][u]) *
dp_no[(i + k - 1) % k][u];
ans += ((k + k - i - j) % k) * no_paths;
}
}
}
for (int i = 0; i < k; i++) {
ans2 += dp_sum[i][v] + ((k - i) % k) * dp_no[i][v];
}
dp_no[0][v]++;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n >> k;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(1, -1);
cout << ll(ans / ll(k + k)) + ll(ans2 / ll(k)) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long OO = 1e9;
const long long OOL = 1e18;
const long long MODi = 1e9 + 7;
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
const int N = 100;
vector<int> prime;
bool mat[1000001] = {0};
void generate_primes(int n) {
prime.clear();
prime.push_back(2);
for (int i = 3; i * i <= n; i += 2) {
if (mat[i] == 0) {
for (int j = i * i; j < n; j += 2 * i) mat[j] = 1;
}
}
for (int i = 3; i <= n; i += 2)
if (!mat[i]) prime.push_back(i);
}
unsigned long long gcd(unsigned long long a, unsigned long long b) {
return (b == 0 ? a : gcd(b, a % b));
}
unsigned long long lcm(unsigned long long a, unsigned long long b) {
return (a * (b / gcd(a, b)));
}
unsigned long long power(unsigned long long a, unsigned long long b) {
if (b == 0) return 1;
if (b == 1) return a;
unsigned long long ans = power(a, b / 2);
ans = ans * ans;
if (b % 2 != 0) ans *= a;
return ans;
}
long long memo[50][2][2][2];
int s[50] = {0}, x[50] = {0};
long long dp(int cur, int carry, int zerofirst, int zerosecond) {
if (cur == 50) {
if (!zerofirst && !zerosecond && carry == 0) return 1;
return 0;
}
long long &ret = memo[cur][carry][zerofirst][zerosecond];
if (ret != -1) return ret;
if (x[cur] == 1) {
long long cnt = 0;
if (s[cur] == 1) {
if (carry == 0) {
cnt += dp(cur + 1, 0, zerofirst, 0);
cnt += dp(cur + 1, 0, 0, zerosecond);
}
return ret = cnt;
} else {
if (carry == 1) {
cnt += dp(cur + 1, 1, zerofirst, 0);
cnt += dp(cur + 1, 1, 0, zerosecond);
}
return ret = cnt;
}
} else {
long long cnt = 0;
if (s[cur] == 1) {
if (carry == 1) {
cnt += dp(cur + 1, 0, zerofirst, zerosecond);
cnt += dp(cur + 1, 1, 0, 0);
}
return ret = cnt;
} else {
if (carry == 0) {
cnt += dp(cur + 1, 1, 0, 0);
cnt += dp(cur + 1, 0, zerofirst, zerosecond);
}
return ret = cnt;
}
}
}
int main() {
ios::sync_with_stdio(false);
memset(memo, -1, sizeof(memo));
long long xx, ss;
cin >> ss >> xx;
int idx = 0;
while (xx) x[idx++] = xx % 2, xx /= 2;
idx = 0;
while (ss) s[idx++] = ss % 2, ss /= 2;
cout << dp(0, 0, 1, 1) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
const int inf = 0x3f3f3f3f;
int n, m, k, top;
char s[N], t[N], stk[N];
int c00, c01, c10, c11, c20, c21;
int nxt[N];
void init() {
for (int i = 2; i <= m; ++i) {
while (k && t[k + 1] != t[i]) k = nxt[k];
if (t[k + 1] == t[i]) ++k;
nxt[i] = k;
}
for (int i = 1; i <= m; ++i)
if (t[i] == '0')
++c00;
else
++c01;
for (int i = k + 1; i <= m; ++i)
if (t[i] == '0')
++c10;
else
++c11;
for (int i = 1; i <= n; ++i)
if (s[i] == '0')
++c20;
else
++c21;
}
int main() {
scanf("%s%s", s + 1, t + 1);
n = strlen(s + 1), m = strlen(t + 1);
init();
if (c20 < c00 || c21 < c01) {
puts(s + 1);
return 0;
}
c20 -= c00, c21 -= c01;
for (int i = 1; i <= m; ++i) stk[++top] = t[i];
while (c20 >= c10 && c21 >= c11) {
c20 -= c10, c21 -= c11;
for (int i = k + 1; i <= m; ++i) stk[++top] = t[i];
}
while (c20) --c20, stk[++top] = '0';
while (c21) --c21, stk[++top] = '1';
stk[++top] = '\0';
puts(stk + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
string s2 = s;
sort(s.begin(), s.end());
int ct = 0;
for (int i = 0; i < n; i++) {
if (s[i] != s2[i]) ct++;
}
cout << ct << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m;
scanf("%d%d", &n, &m);
vector<int> x(n);
for (int i = 0; i < int(n); ++i) scanf("%d", &x[i]);
vector<vector<int>> a(n, vector<int>(m));
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j) scanf("%1d", &a[i][j]);
int ans = -1;
vector<int> best;
for (int mask = 0; mask < int(1 << n); ++mask) {
vector<int> val(m);
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j)
if (a[i][j]) val[j] += ((mask >> i) & 1) ? +1 : -1;
int res = 0;
for (int i = 0; i < int(n); ++i) res += ((mask >> i) & 1) ? -x[i] : x[i];
vector<int> p(m);
iota(p.begin(), p.end(), 0);
sort(p.begin(), p.end(), [&](int x, int y) { return val[x] < val[y]; });
for (int i = 0; i < int(m); ++i) res += val[p[i]] * (i + 1);
if (res > ans) ans = res, best = p;
}
vector<int> ansPerm(m);
for (int i = 0; i < int(m); ++i) ansPerm[best[i]] = i;
for (int i = 0; i < int(m); ++i) printf("%d ", ansPerm[i] + 1);
puts("");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, v;
int a, b;
int yo[3005], oy[3005];
int ans;
int main() {
cin >> n >> v;
for (int i = 0; i < n; i++) {
cin >> a >> b;
yo[a] += b;
}
for (int i = 1; i <= 3001; i++) {
int take = 0;
if (oy[i] > v) {
ans += v;
oy[i + 1] = yo[i];
} else {
take = oy[i];
ans += oy[i];
int more = v - take;
if (more >= yo[i]) {
ans += yo[i];
} else {
ans += more;
int add = yo[i] - more;
oy[i + 1] = add;
}
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 4e18;
const int MAX_LOG = 21;
const int MAX_N = (1 << 17);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k, a, b, c, d;
cin >> n >> k >> a >> b >> c >> d;
if (n < 5 || k < n + 1) {
cout << -1 << endl;
} else {
int arr[n];
arr[0] = a, arr[n - 1] = b, arr[1] = c, arr[n - 2] = d;
vector<bool> taken(n + 1);
taken[a] = taken[b] = taken[c] = taken[d] = true;
int id = 1;
for (int i = 2; i < n - 2; i++) {
while (taken[id]) {
id++;
}
arr[i] = id;
taken[id] = true;
}
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
vector<int> v;
v.push_back(c);
v.push_back(a);
v.push_back(arr[2]);
for (int i = 3; i <= n - 3; i++) {
v.push_back(arr[i]);
}
v.push_back(b);
v.push_back(d);
for (int x : v) {
cout << x << " ";
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v;
long long w;
bool operator<(const edge &b) const { return w > b.w; }
};
const int MAX = 1005;
vector<edge> g1[MAX];
vector<edge> g2[MAX];
bitset<MAX> vis;
int pre[MAX];
long long dist[MAX];
int N, M, ini, fin;
void dijkstra(int u, vector<edge> (&g)[MAX]) {
priority_queue<edge> pq;
pq.push({u, 0});
dist[u] = 0;
while (pq.size()) {
u = pq.top().v;
pq.pop();
if (!vis[u]) {
vis[u] = true;
for (auto nx : g[u]) {
int v = nx.v;
if (!vis[v] && dist[v] > dist[u] + nx.w) {
dist[v] = dist[u] + nx.w;
pre[v] = u;
pq.push({v, dist[v]});
}
}
}
}
}
void init() {
for (int i = 0; i <= N; i++) {
dist[i] = (1ll << 62);
vis[i] = false;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int u, v;
long long w, d, c;
cin >> N >> M >> ini >> fin;
ini--;
fin--;
for (int i = 0; i < M; i++) {
cin >> u >> v >> w;
u--;
v--;
g1[u].push_back({v, w});
g1[v].push_back({u, w});
}
for (int i = 0; i < N; i++) {
cin >> d >> c;
init();
dijkstra(i, g1);
for (int j = 0; j < N; j++) {
if (dist[j] <= d) {
g2[i].push_back({j, c});
}
}
}
init();
dijkstra(ini, g2);
if (dist[fin] != (1ll << 62))
cout << dist[fin] << "\n";
else
cout << "-1\n";
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long sqr(long long x) { return x * x; }
long double sqrd(long double x) { return x * x; }
inline long long gcd(long long a, long long b) {
while (b) {
a %= b, swap(a, b);
}
return a;
}
inline long long lcm(long long a, long long b) {
return a * b / max(1ll, gcd(a, b));
}
mt19937 Random((long long)time(0));
inline long long rnd(long long x) { return Random() % x; }
const long long INF = (long long)1e9 + 282;
const long long MOD = (long long)1e9 + 7;
const long double PI = acosl(-1.0);
const long long N = 3e5 + 10;
vector<vector<long long>> first, ff;
vector<vector<vector<long long>>> rs, cs;
pair<long long, long long> w[4][4];
char ccc[4] = {'A', 'T', 'G', 'C'};
void calcR(long long r, long long a, long long b, long long n, long long m) {
for (long long i = 0; i < m; i++) {
if (i % 2 == 0) {
rs[r][a][b] += first[r][i] != a;
} else {
rs[r][a][b] += first[r][i] != b;
}
}
}
void calcC(long long c, long long a, long long b, long long n, long long m) {
for (long long i = 0; i < n; i++) {
if (i % 2 == 0) {
cs[c][a][b] += first[i][c] != a;
} else {
cs[c][a][b] += first[i][c] != b;
}
}
}
pair<long long, pair<long long, long long>> goV(long long n, long long m) {
pair<long long, pair<long long, long long>> ans = {INF, {-1, -1}};
for (long long a = 0; a < 4; a++) {
for (long long b = a + 1; b < 4; b++) {
long long c = w[a][b].first, d = w[a][b].second;
long long cur = 0;
for (long long i = 0; i < m; i++) {
if (i % 2 == 0) {
cur += min(cs[i][a][b], cs[i][b][a]);
} else {
cur += min(cs[i][c][d], cs[i][d][c]);
}
}
if (cur < ans.first) {
ans = {cur, {a, b}};
}
}
}
return ans;
}
pair<long long, pair<long long, long long>> goH(long long n, long long m) {
pair<long long, pair<long long, long long>> ans = {INF, {-1, -1}};
for (long long a = 0; a < 4; a++) {
for (long long b = a + 1; b < 4; b++) {
long long c = w[a][b].first, d = w[a][b].second;
long long cur = 0;
for (long long i = 0; i < n; i++) {
if (i % 2 == 0) {
cur += min(rs[i][a][b], rs[i][b][a]);
} else {
cur += min(rs[i][c][d], rs[i][d][c]);
}
}
if (cur < ans.first) {
ans = {cur, {a, b}};
}
}
}
return ans;
}
void goAnsV(long long n, long long m, long long a, long long b) {
long long c = w[a][b].first, d = w[a][b].second;
for (long long i = 0; i < m; i++) {
if (i % 2 == 0) {
if (cs[i][a][b] < cs[i][b][a]) {
for (long long j = 0; j < n; j++) {
if (j % 2 == 0) {
ff[j][i] = a;
} else {
ff[j][i] = b;
}
}
} else {
for (long long j = 0; j < n; j++) {
if (j % 2 == 0) {
ff[j][i] = b;
} else {
ff[j][i] = a;
}
}
}
} else {
if (cs[i][c][d] < cs[i][d][c]) {
for (long long j = 0; j < n; j++) {
if (j % 2 == 0) {
ff[j][i] = c;
} else {
ff[j][i] = d;
}
}
} else {
for (long long j = 0; j < n; j++) {
if (j % 2 == 0) {
ff[j][i] = d;
} else {
ff[j][i] = c;
}
}
}
}
}
}
void goAnsH(long long n, long long m, long long a, long long b) {
long long c = w[a][b].first, d = w[a][b].second;
for (long long i = 0; i < n; i++) {
if (i % 2 == 0) {
if (rs[i][a][b] < rs[i][b][a]) {
for (long long j = 0; j < m; j++) {
if (j % 2 == 0) {
ff[i][j] = a;
} else {
ff[i][j] = b;
}
}
} else {
for (long long j = 0; j < m; j++) {
if (j % 2 == 0) {
ff[i][j] = b;
} else {
ff[i][j] = a;
}
}
}
} else {
if (rs[i][c][d] < rs[i][d][c]) {
for (long long j = 0; j < m; j++) {
if (j % 2 == 0) {
ff[i][j] = c;
} else {
ff[i][j] = d;
}
}
} else {
for (long long j = 0; j < m; j++) {
if (j % 2 == 0) {
ff[i][j] = d;
} else {
ff[i][j] = c;
}
}
}
}
}
}
void mane() {
long long n, m;
cin >> n >> m;
first.resize(n, vector<long long>(m, 0));
map<char, long long> mp;
mp['A'] = 0;
mp['T'] = 1;
mp['G'] = 2;
mp['C'] = 3;
for (long long i = 0; i < 4; i++) {
for (long long j = i + 1; j < 4; j++) {
set<long long> st;
for (long long k = 0; k < 4; k++) {
st.insert(k);
}
st.erase(i);
st.erase(j);
w[i][j].first = *st.begin();
st.erase(st.begin());
w[i][j].second = *st.begin();
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
char c;
cin >> c;
first[i][j] = mp[c];
}
}
rs.resize(n, vector<vector<long long>>(4, vector<long long>(4, 0)));
cs.resize(m, vector<vector<long long>>(4, vector<long long>(4, 0)));
for (long long i = 0; i < n; i++) {
for (long long a = 0; a < 4; a++) {
for (long long b = 0; b < 4; b++) {
if (a == b) {
continue;
}
calcR(i, a, b, n, m);
}
}
}
for (long long i = 0; i < m; i++) {
for (long long a = 0; a < 4; a++) {
for (long long b = 0; b < 4; b++) {
if (a == b) {
continue;
}
calcC(i, a, b, n, m);
}
}
}
auto v = goV(n, m), h = goH(n, m);
ff = first;
if (v.first < h.first) {
goAnsV(n, m, v.second.first, v.second.second);
} else {
goAnsH(n, m, h.second.first, h.second.second);
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cout << ccc[ff[i][j]];
}
cout << "\n";
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios_base::fixed, ios_base::floatfield);
cout.precision(12);
mane();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<string, priority_queue<long long> > choi;
set<string> used;
long long psum[200005];
long long psum2[200005];
string reverse(string A) {
string B = "";
for (long long a = (long long)A.length() - 1; a >= 0; a--) B += A[a];
return B;
}
int main() {
long long a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q;
string A, B, C, D, E;
char X[100005];
scanf("%lld %lld", &a, &b);
for (c = 1; c <= a; c++) {
scanf(" %s%lld", &X, &d);
choi[string(X)].push(d);
}
g = 0;
h = 0;
for (auto it : choi) {
A = it.first;
B = reverse(A);
if (used.count(A) || used.count(B)) continue;
used.insert(A);
used.insert(B);
if (A == B) {
auto x = it.second;
while (!x.empty()) {
e = x.top();
x.pop();
if (e <= 0) break;
if (x.empty()) {
psum[++h] = e;
psum2[h] = 0;
break;
}
f = x.top();
x.pop();
if (f < 0 && e + f > 0) {
psum[++h] = e;
psum2[h] = e + f;
break;
}
if (e + f <= 0) {
psum[++h] = e;
psum2[h] = 0;
break;
}
g += e + f;
}
} else {
auto x = it.second;
auto y = choi[B];
while (!x.empty() && !y.empty()) {
e = x.top();
f = y.top();
x.pop();
y.pop();
if (e + f <= 0) break;
g += e + f;
}
}
}
psum[0] = psum2[0] = 0;
for (c = 1; c <= h; c++) {
psum[c] += psum[c - 1];
psum2[c] += psum2[c - 1];
}
j = 0;
for (c = 1; c <= h; c++) {
i = psum[c] - psum[c - 1] + psum2[h] - (psum2[c] - psum2[c - 1]);
j = max(j, i);
}
g += j;
printf("%lld\n", g);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, counter = 0, lewat = 0, garis = 0, naik, in, i;
vector<int> line;
scanf("%u", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &in);
line.push_back(in);
}
naik = 1;
while (counter < n) {
if (naik == 1) {
for (i = 1; i <= line.size(); i++) {
if (line[i - 1] <= lewat) {
counter++;
lewat++;
line[i - 1] = 1000;
}
}
naik = 0;
if (counter < n) {
garis++;
}
} else if (naik == 0) {
for (i = line.size(); i >= 1; i--) {
if (line[i - 1] <= lewat) {
counter++;
lewat++;
line[i - 1] = 1000;
}
}
naik = 1;
if (counter < n) {
garis++;
}
}
}
printf("%d", garis);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool check(string &a, string &g) {
int c1 = 0, c2 = 0;
for (int i = 0; i < a.length(); i += 1) c1 += (a[i] == 's');
for (int i = 0; i < g.length(); i += 1) c2 += (g[i] == 's');
return c1 * (g.length() - c2) > c2 * (a.length() - c1);
}
int main() {
int n;
cin >> n;
string s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
int count = 0;
}
sort(s, s + n, check);
string sf = "";
for (int i = 0; i < n; i++) sf.append(s[i]);
int count = 0;
for (long long int i = 0; i < sf.length(); i++) {
if (sf[i] == 'h') count++;
}
long long int sum = 0;
for (int i = 0; i < sf.size(); i++) {
if (sf[i] == 'h')
count--;
else if (count > 0)
sum = sum + count;
}
cout << sum << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000000000001;
const long long MOD = 1000000007;
void solve() {
long long n, k;
cin >> n >> k;
unordered_map<char, long long> mp;
for (long long i = 0; i < n; i++) {
char c;
cin >> c;
mp[c]++;
}
vector<pair<long long, char> > a;
for (auto x : mp) {
a.push_back(make_pair(x.second, x.first));
}
sort(a.rbegin(), a.rend());
long long ans = 0;
for (auto x : a) {
if (x.first >= k) {
ans += k * k;
break;
} else {
k -= x.first;
ans += x.first * x.first;
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, x;
set<int> st;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
while (x % 2 == 0) x /= 2;
while (x % 3 == 0) x /= 3;
st.insert(x);
}
if (st.size() == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4000;
int n, v[N], dp[N][N], nxt[N][N], at[N], freq[N];
vector<int> hs;
int calc(int a, int b) {
if (b == n) return 0;
int &res = dp[a][b];
if (res != -1) return res;
res = 0;
int x = nxt[b][v[a]];
if (x < n && nxt[x][v[b]] < n)
res = calc(x, nxt[x][v[b]]) + 2;
else if (x < n)
res = 1;
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &v[i]);
hs.push_back(v[i]);
for (int j = i; j < n; ++j) dp[i][j] = dp[j][i] = -1;
}
sort(hs.begin(), hs.end());
int res = 0;
for (int i = 0; i < n; ++i) {
v[i] = lower_bound(hs.begin(), hs.end(), v[i]) - hs.begin();
++freq[v[i]];
res = max(res, freq[v[i]]);
}
for (size_t i = 0; i < hs.size(); ++i) at[i] = n;
for (int i = n - 1; i >= 0; --i) {
for (size_t j = 0; j < hs.size(); ++j) nxt[i][j] = at[j];
at[v[i]] = i;
}
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) res = max(res, calc(i, j) + 2);
printf("%d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int d[1000005];
int k[200][5];
int solve[5];
int n;
bool check(long long int d) {
int i, j;
long long int sb = 0;
long long int sa = 0;
long long int u = n + d;
for (i = 0; i < 5; i++) {
if (k[0][i] == -1 && k[1][i] == -1) {
} else if (k[0][i] == -1) {
if (n + d >= (solve[i] + 1) * 32) {
sb += (250 - k[1][i]) * 12;
} else if (n + d >= (solve[i] + 1) * 16) {
sb += (250 - k[1][i]) * 10;
} else if (n + d >= (solve[i] + 1) * 8) {
sb += (250 - k[1][i]) * 8;
} else if (n + d >= (solve[i] + 1) * 4) {
sb += (250 - k[1][i]) * 6;
} else if (n + d >= (solve[i] + 1) * 2) {
sb += (250 - k[1][i]) * 4;
} else {
sb += (250 - k[1][i]) * 2;
}
} else if (k[1][i] == -1) {
if (n + d >= (solve[i] + 1) * 32) {
sa += (250 - k[0][i]) * 12;
} else if (n + d >= (solve[i] + 1) * 16) {
sa += (250 - k[0][i]) * 10;
} else if (n + d >= (solve[i] + 1) * 8) {
sa += (250 - k[0][i]) * 8;
} else if (n + d >= (solve[i] + 1) * 4) {
sa += (250 - k[0][i]) * 6;
} else if (n + d >= (solve[i] + 1) * 2) {
sa += (250 - k[0][i]) * 4;
} else {
sa += (250 - k[0][i]) * 2;
}
} else if (k[1][i] < k[0][i]) {
if (n + d >= (solve[i] + 2 + d) * 32) {
sa += (250 - k[0][i]) * 12;
sb += (250 - k[1][i]) * 12;
} else if (n + d >= (solve[i] + 2 + d) * 16) {
sa += (250 - k[0][i]) * 10;
sb += (250 - k[1][i]) * 10;
} else if (n + d >= (solve[i] + 2 + d) * 8) {
sa += (250 - k[0][i]) * 8;
sb += (250 - k[1][i]) * 8;
} else if (n + d >= (solve[i] + 2 + d) * 4) {
sa += (250 - k[0][i]) * 6;
sb += (250 - k[1][i]) * 6;
} else if (n + d >= (solve[i] + 2 + d) * 2) {
sa += (250 - k[0][i]) * 4;
sb += (250 - k[1][i]) * 4;
} else {
sa += (250 - k[0][i]) * 2;
sb += (250 - k[1][i]) * 2;
}
} else {
if (n + d >= (solve[i] + 2) * 32) {
sa += (250 - k[0][i]) * 12;
sb += (250 - k[1][i]) * 12;
} else if (n + d >= (solve[i] + 2) * 16) {
sa += (250 - k[0][i]) * 10;
sb += (250 - k[1][i]) * 10;
} else if (n + d >= (solve[i] + 2) * 8) {
sa += (250 - k[0][i]) * 8;
sb += (250 - k[1][i]) * 8;
} else if (n + d >= (solve[i] + 2) * 4) {
sa += (250 - k[0][i]) * 6;
sb += (250 - k[1][i]) * 6;
} else if (n + d >= (solve[i] + 2) * 2) {
sa += (250 - k[0][i]) * 4;
sb += (250 - k[1][i]) * 4;
} else {
sa += (250 - k[0][i]) * 2;
sb += (250 - k[1][i]) * 2;
}
}
}
if (sa > sb)
return true;
else
return false;
}
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
long long int ans;
cin >> n;
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < 5; j++) {
cin >> k[i][j];
}
}
for (i = 2; i < n; i++) {
for (j = 0; j < 5; j++) {
if (k[i][j] != -1) solve[j]++;
}
}
long long int low, high, mid;
low = 0;
high = 1000000007;
for (i = 0; i <= 1000000; i++) {
if (check(i)) break;
}
if (i > 1000000)
cout << -1;
else
cout << i << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long LINF = (long long)1e18;
const int INF = (int)1e9 + 7;
const int N = (int)1e5 + 1;
bool u[N + 5];
int n, mx, mn = 12;
int a[11];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
mx = max(mx, a[i]);
}
mx ^= a[n];
cout << mx << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 998244353;
const int xn = 2e5 + 10;
const int xm = -20 + 10;
const int SQ = 320;
const int sq = 320 + 10;
const int inf = 1e9 + 10;
const long long INF = 1e10 + 10;
long long power(long long a, long long b) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2) % md
: power(a * a % md, b / 2) % md));
}
long long zarb(long long a, long long b) { return (a * b + 10 * md) % md; }
long long jaam(long long a, long long b) { return (a + b + 10 * md) % md; }
string abc = "abcdefghijklmnopqrstuvwxyz";
long long n, k, l, dp[xn], fact[xn], ifact[xn], ans, inv, res;
long long C(long long r, long long n) {
if (r < 0 || r > n || n <= 0) return 0;
return fact[n] * (ifact[r] * ifact[n - r] % md) % md;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k >> l;
dp[0] = 1;
for (long long i = 2; i < xn; i += 2) dp[i] = (dp[i - 2] * (i - 1) % md);
fact[0] = ifact[0] = 1;
for (long long i = 1; i < xn; ++i) {
fact[i] = fact[i - 1] * i % md;
ifact[i] = power(fact[i], md - 2);
}
for (long long i = 1; i < n + n; ++i) {
for (long long j = k; j <= min(i, n + n - i); ++j) {
res = C(j, i) * C(j, n + n - i) % md;
res = res * (dp[i - j] * dp[n + n - i - j] % md) % md;
res = res * fact[j] % md;
ans = (ans + res) % md;
}
}
ans = ans * power(dp[n + n], md - 2) % md;
ans = ans * (l * power(n + n + 1, md - 2) % md) % md;
cout << ans << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 7;
const int M = 7;
const int inf = 1e9 + 7;
const long long base = 1e18;
const double pi = acos(-1);
const double ep = 1e-18;
int L[8][N][N];
int dp[N], dp1[N];
int tmp[N][N], tmp1[N][N], tmp2[N][N];
int a[8], last = -1;
void multi(int a[N][N], int b[N][N], int last) {
memset(tmp1, 0, sizeof(tmp1));
for (int u = 0; u < 1 << last; u++)
for (int v = 0; v < 1 << last; v++) {
tmp1[u][v] = 0;
for (int k = 0; k < 1 << last; k++)
tmp1[u][v] =
((long long)tmp1[u][v] + (long long)a[u][k] * b[k][v] % inf) % inf;
}
for (int u = 0; u < 1 << last; u++)
for (int v = 0; v < 1 << last; v++) a[u][v] = tmp1[u][v];
}
int main() {
for (int u = 0; u < 2; u++)
for (int v = 0; v < 2; v++) L[1][u][v] = !(u & v);
for (int i = 2; i < M + 1; i++) {
int m = 1 << i;
for (int u = 0; u < m; u++) {
for (int v = u; v < m; v++) {
L[i][u][v] = 0;
for (int tmp = 0; tmp < 1 << (i - 1); tmp++) {
int t = (tmp << 1) | 1 | m;
int kt = 1;
for (int j = 0; j < i; j++)
if (((t & (1 << j)) && (u & (1 << j)) && (v & (1 << j)) &&
(t & (1 << (j + 1)))))
kt = 0;
L[i][u][v] += kt;
}
L[i][v][u] = L[i][u][v];
}
}
}
for (int i = 1; i < 8; i++) {
cin >> a[i];
if (last == -1 && a[i] > 0) last = i;
}
dp[(1 << last) - 1] = 1;
int fir = last;
for (int i = 1; i < M + 1; i++) {
if (a[i] == 0) continue;
if (i != fir) {
memset(dp1, 0, sizeof(dp1));
int comMask = 0, preLast = last;
for (; last < i;) comMask |= 1 << last++;
for (int mask = 0; mask < 1 << preLast; mask++)
dp1[mask | comMask] = dp[mask];
for (int mask = 0; mask < 1 << last; mask++) dp[mask] = dp1[mask];
}
memset(tmp2, 0, sizeof(tmp2));
for (int j = 0; j < 1 << i; j++) tmp2[j][j] = 1;
memcpy(tmp, L[i], sizeof(L[i]));
while (a[i] > 0) {
if (a[i] % 2 == 1) multi(tmp2, tmp, i);
multi(tmp, tmp, i);
a[i] /= 2;
}
memset(dp1, 0, sizeof(dp1));
for (int u = 0; u < 1 << i; u++)
for (int v = 0; v < 1 << i; v++)
dp1[u] =
((long long)dp1[u] + (long long)dp[v] * tmp2[v][u] % inf) % inf;
for (int mask = 0; mask < 1 << i; mask++) dp[mask] = dp1[mask];
}
cout << dp[(1 << last) - 1];
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5002, M = 998244353;
int n, i, f[N][N], s[N][N], j, p, a[N];
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
f[0][0] = s[0][0] = 1;
for (i = 1; i <= n; i++) {
for (p = 1; p <= n && a[p] * 2 <= a[i]; p++)
;
for (j = 1; j <= i; j++) f[i][j] = s[p - 1][j - 1];
for (j = 1; j <= p; j++)
f[i][j] = (1ll * f[i][j - 1] * (p - 1 - (j - 2)) + f[i][j]) % M;
for (j = 0; j <= i; j++) s[i][j] = (s[i - 1][j] + f[i][j]) % M;
}
printf("%d", f[n][n]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[200005];
int a, b, k;
int x[200005];
void doc() {
cin >> n >> k >> a >> b;
int dem = 0;
bool ok = true;
x[0] = -1;
for (int i = 1; i <= n; i++) {
if (a > b)
x[i] = 1, a--;
else {
x[i] = 0, b--;
}
if (x[i] != x[i - 1])
dem = 1;
else
dem++;
if (dem == k && i != n) {
if (x[i] == 1)
x[i + 1] = 0, b--, ++i;
else {
x[i + 1] = 1, a--, ++i;
}
if (a < 0 || b < 0) ok = false;
}
}
if (ok) {
for (int i = 1; i <= n; i++) {
if (x[i])
cout << "G";
else
cout << "B";
}
} else
cout << "NO";
}
int main() { doc(); }
| 3 |
#include <bits/stdc++.h>
int n;
long long ans;
long long sum(long long x, long long m) {
return !m ? 0
: (x & 1) ? (x ^ sum(x + 1, m - 1))
: (m & 1) ? ((x + m - 1) ^ sum(x, m - 1))
: (m & 2) ? 1
: 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
long long x, m;
scanf("%I64d%I64d", &x, &m);
ans ^= sum(x, m);
}
if (ans)
puts("tolik");
else
puts("bolik");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
os << "]";
return os;
}
template <class T>
ostream &operator<<(ostream &os, set<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class T>
ostream &operator<<(ostream &os, multiset<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
void solve() {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
if (k == 0) {
cout << a[n - 1] - a[0];
return;
}
long long res = a[n - 1];
long long idx = n - 2;
while (k--) {
res += a[idx];
idx--;
if (idx < 0) {
break;
}
}
cout << res << endl;
}
int32_t main() {
long long t;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include<iostream>
#include<algorithm>
#include<cstring>
#include <random>
#include <chrono>
#include<math.h>
#include<cstdio>
#include<vector>
#include<stdio.h>
#include<cstring>
#include<string>
#include<string.h>
#include<set>
#include<map>
#include<stack>
#include<list>
#define speed ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
using ll = long long;
using namespace std;
inline int gcd(int a, int b) {
return b > 0 ? gcd(b, a % b) : a;
}
long long ksm(long long a, long long b) {
long long ans = 1, base = a;
while (b != 0) {
if (b & 1 != 0) {
ans = (ans * base);
}
base *= base;
b >>= 1;
}
return ans;
}
int main() {
int t;
cin >> t;
while (t--) {
ll a, b, c;
cin >> a >> b >> c;
ll sum = 0;
sum = min((a - 1) + (b - 1) * a, (b - 1) + (a - 1) * b);
if (sum != c)cout << "NO" << endl;
else cout << "YES" << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 9;
const int inf = 0x3f3f3f3f;
int n, d, m;
inline int read() {
int a = 1, b = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') a = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
b = (b << 1) + (b << 3) + c - '0';
c = getchar();
}
return a * b;
}
inline void print(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
int main() {
int xx, yy;
n = read(), d = read();
m = read();
while (m--) {
xx = read(), yy = read();
if (-xx + d <= yy && -xx + 2 * n - d >= yy && xx - d <= yy &&
xx + d >= yy) {
puts("YES");
} else
puts("NO");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int fact(int n) {
long long ans = n;
for (int i = n - 1; i > 0; --i) {
ans = (ans * i) % MOD;
}
return ans;
}
int pow2(int n) {
long long ans = 1, b = 2;
while (n > 0) {
if (n % 2) {
ans = (ans * b) % MOD;
}
b = (b * b) % MOD;
n /= 2;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
cout << (fact(n) - pow2(n - 1) + MOD) % MOD;
}
| 3 |
#include <iostream>
#include <vector>
using namespace std;
using LL = long long;
const int DIV = 1e5;
inline LL ceil(LL x, LL y) {
return (x + y - 1) / y;
}
int main() {
int T, M; cin >> T >> M;
vector<bool> is_seen(M + 1, false);
is_seen[0] = true;
vector<int> answer(M + 1, -1);
answer[0] = 0;
for (int timestep = 1; timestep <= T; timestep++) {
auto new_is_seen = is_seen;
int t, y;
LL x;
cin >> t >> x >> y;
auto operation = [&] (long long &curr) {
if (t == 1) {
curr = curr + ceil(x, DIV);
} else {
curr = ceil(curr * x, DIV);
}
};
for (int k = 0; k <= M; k++) {
if (is_seen[k]) {
long long curr = k;
operation(curr);
for (int a = 1; a <= y;) {
if (curr > M) break;
if (is_seen[curr]) break;
new_is_seen[curr] = true;
answer[curr] = timestep;
a++;
operation(curr);
}
}
}
is_seen = new_is_seen;
}
for (int i = 1; i <= M; i++)
cout << answer[i] << " ";
cout << endl;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
inline void add(long long &x, long long y) { x = (x + y) % 1000000007ll; }
long long n;
int K, R;
struct M {
long long a[35][35];
void Z() { memset(a, 0, sizeof a); }
void E() {
Z();
for (int i = 0; i < int(R); ++i) a[i][i] = 1;
}
friend M operator*(const M &x, const M &y) {
M z;
z.Z();
for (int i = 0; i < int(R); ++i)
for (int j = 0; j < int(R); ++j)
for (int k = 0; k < int(R); ++k) add(z.a[i][j], x.a[i][k] * y.a[k][j]);
return z;
}
};
M r[35];
M o[70];
int main() {
cin >> n >> K;
R = K + 1;
int N[70], B = 0;
while (n) N[B++] = n % K, n /= K;
r[0].E();
r[1].Z();
r[1].a[0][0] = 1;
for (int j = 1; j <= int(K); ++j) r[1].a[j % K + 1][j] = 1;
for (int i = 1; i <= int(K); ++i) r[i] = r[1] * r[i - 1];
o[0].E();
for (int i = 0; i < int(R); ++i) o[0].a[1][i] = 1;
for (int i = 1; i <= int(B); ++i) {
o[i].E();
for (int j = 0; j < int(K); ++j) o[i] = r[j] * o[i - 1] * r[K - j] * o[i];
}
M res;
res.E();
int s = 0;
for (int i = 0; i < int(B); ++i)
for (int j = 0; j < int(N[B - 1 - i]); ++j)
res = r[s % K] * o[B - 1 - i] * r[K - s % K] * res, s++;
long long ans = 0;
for (int i = 0; i < int(R); ++i) add(ans, res.a[i][0]);
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
long long INF = LLONG_MAX / 4;
vector<string> &split(const std::string &s, char delim, vector<string> &e) {
stringstream ss(s);
string item;
while (getline(ss, item, delim)) e.push_back(item);
return e;
}
long long Pow(long long a, long long b, long long Mo) {
long long ans = 1;
for (; b; b >>= 1, a = a * a % Mo)
if (b & 1) ans = ans * a % Mo;
return ans;
}
long long nCr(long long n, long long r) {
static long long MAXF = 1e6;
static std::vector<long long> fact(MAXF, 1);
for (int i = 1; i < MAXF; ++i) fact[i] = (fact[i - 1] * i) % MOD;
MAXF = 0;
return (fact[n] * Pow((fact[r] * fact[n - r]) % MOD, MOD - 2, MOD)) % MOD;
}
vector<int> Zfunc(string &s) {
int n = s.length();
vector<int> z(n, 0);
for (int i = 1, l = 0, r = 0; i < n; i++) {
if (i <= r) z[i] = min(z[i - l], r - i + 1);
while (i + z[i] < n && s[i + z[i]] == s[z[i]]) z[i]++;
if (r < i + z[i] - 1) l = i, r = i + z[i] - 1;
}
return z;
}
int main(int argc, char const *argv[]) {
std::ios::sync_with_stdio(false);
cin.tie(0);
long long n, m, c;
cin >> n >> m >> c;
std::vector<long long> vl;
std::vector<long long> vr;
int cl = (c + 1) / 2;
for (int i = 0; i < m; ++i) {
int p;
cin >> p;
if (p <= cl) {
int ub = upper_bound(vl.begin(), vl.end(), p) - vl.begin();
if (ub == vl.size()) vl.push_back(0);
vl[ub] = p;
cout << (ub + 1) << '\n';
} else {
int ub = upper_bound(vr.begin(), vr.end(), -p) - vr.begin();
if (ub == vr.size()) vr.push_back(0);
vr[ub] = -p;
cout << (n - ub) << '\n';
}
cout.flush();
if (vr.size() + vl.size() == n) break;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, a[110], i, j, k, c, max = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
for (k = i; k <= j; k++) {
if (a[k] == 1)
a[k] = 0;
else
a[k] = 1;
}
c = 0;
for (k = 0; k < n; k++) {
if (a[k] == 1) c++;
}
if (c > max) max = c;
for (k = i; k <= j; k++) {
if (a[k] == 1)
a[k] = 0;
else
a[k] = 1;
}
}
}
printf("%d\n", max);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct intervals {
int no;
int lidz;
};
string aizpilda_v(const vector<intervals> &intervali, const string cur_virkne,
const int len, const int beigu_p) {
int cur_punkti = beigu_p;
string rez = cur_virkne;
for (int i = len - 1; i > 0; --i) {
if (cur_virkne[i] == 'W' && cur_punkti - 1 <= intervali.at(i - 1).lidz &&
cur_punkti - 1 >= intervali.at(i - 1).no)
--cur_punkti;
else if (cur_virkne[i] == 'L' &&
cur_punkti + 1 <= intervali.at(i - 1).lidz &&
cur_punkti + 1 >= intervali.at(i - 1).no)
++cur_punkti;
else if (cur_virkne[i] == '?') {
if (cur_punkti == intervali.at(i - 1).lidz ||
cur_punkti == intervali.at(i - 1).no)
rez[i] = 'D';
else if (cur_punkti - 1 <= intervali.at(i - 1).lidz &&
cur_punkti - 1 >= intervali.at(i - 1).no) {
rez[i] = 'W';
--cur_punkti;
} else if (cur_punkti + 1 <= intervali.at(i - 1).lidz &&
cur_punkti + 1 >= intervali.at(i - 1).no) {
rez[i] = 'L';
++cur_punkti;
} else {
return "NO";
}
} else if (!(cur_virkne[i] == 'D' &&
(cur_punkti <= intervali.at(i - 1).lidz ||
cur_punkti >= intervali.at(i - 1).no))) {
return "NO";
}
}
if (cur_virkne[0] == 'W' && cur_punkti != 1)
rez = "NO";
else if (cur_virkne[0] == 'L' && cur_punkti != -1)
rez = "NO";
else if (cur_virkne[0] == 'D' && cur_punkti != 0)
rez = "NO";
else {
if (cur_punkti == 0) {
rez[0] = 'D';
} else if (cur_punkti == 1)
rez[0] = 'W';
else if (cur_punkti == -1)
rez[0] = 'L';
else
rez = "NO";
}
return rez;
}
string atrod_rez(const string virkne, const int len, const int limits) {
vector<intervals> intervali(len);
string rez;
intervals cur_intervals;
cur_intervals.no = 0;
cur_intervals.lidz = 0;
for (int i = 0; i < len - 1; ++i) {
if (virkne[i] == 'W') {
if (cur_intervals.lidz < limits - 1) ++cur_intervals.lidz;
if (cur_intervals.no < cur_intervals.lidz) ++cur_intervals.no;
} else if (virkne[i] == 'L') {
if (cur_intervals.no > -limits + 1) --cur_intervals.no;
if (cur_intervals.lidz > cur_intervals.no) --cur_intervals.lidz;
} else if (virkne[i] == '?') {
if (cur_intervals.no > -limits + 1) --cur_intervals.no;
if (cur_intervals.lidz < limits - 1) ++cur_intervals.lidz;
}
intervali.at(i) = cur_intervals;
}
if (virkne[len - 1] == 'W') {
++cur_intervals.no;
++cur_intervals.lidz;
} else if (virkne[len - 1] == 'L') {
--cur_intervals.no;
--cur_intervals.lidz;
} else if (virkne[len - 1] == '?') {
--cur_intervals.no;
++cur_intervals.lidz;
} else
return "NO";
intervali.back() = cur_intervals;
rez = "NO";
if (virkne[len - 1] == 'W' && limits <= intervali.back().lidz &&
limits >= intervali.back().no) {
rez = aizpilda_v(intervali, virkne, len, limits);
} else if (virkne[len - 1] == 'L' && -limits <= intervali.back().lidz &&
-limits >= intervali.back().no) {
rez = aizpilda_v(intervali, virkne, len, -limits);
} else if (virkne[len - 1] == '?') {
string temp_v = virkne;
if (limits <= intervali.back().lidz && limits >= intervali.back().no) {
temp_v[len - 1] = 'W';
rez = aizpilda_v(intervali, temp_v, len, limits);
}
if (rez == "NO" && -limits <= intervali.back().lidz &&
-limits >= intervali.back().no) {
temp_v[len - 1] = 'L';
rez = aizpilda_v(intervali, temp_v, len, -limits);
}
}
return rez;
}
int main() {
int len, limits;
string virkne;
cin >> len >> limits;
cin >> virkne;
cout << atrod_rez(virkne, len, limits) << endl;
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const int MAX_N = (int)3e5 + 17;
const int mod = (int)1e9 + 7;
int N, M, S, T, K;
int a[MAX_N], w[MAX_N];
struct Fenwick_0 {
long long bt[MAX_N];
void init() {
for (int i = 0; i <= N; i++) bt[i] = 0;
}
void add(int idx, int w) {
for (; idx <= N; idx += idx & -idx) bt[idx] += w;
}
long long sum(int idx) {
long long ans = 0;
for (; idx > 0; idx -= idx & -idx) ans += bt[idx];
return ans;
}
} W;
struct Fenwick_1 {
int bt[MAX_N];
void init() {
for (int i = 0; i <= N; i++) bt[i] = 0;
}
void add(int idx, int w) {
for (; idx <= N; idx += idx & -idx) (bt[idx] += w) %= mod;
}
int sum(int idx) {
int ans = 0;
for (; idx > 0; idx -= idx & -idx) (ans += bt[idx]) %= mod;
return ans;
}
} F;
int main() {
while (~scanf("%d %d", &N, &M)) {
W.init();
F.init();
for (int i = 1; i <= N; i++) {
scanf("%d", &a[i]);
a[i] -= i;
}
for (int i = 1; i <= N; i++) {
scanf("%d", &w[i]);
W.add(i, w[i]);
F.add(i, 1LL * a[i] * w[i] % mod);
}
while (M--) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
x *= -1;
W.add(x, y - w[x]);
F.add(x, 1LL * (y - w[x]) * a[x] % mod);
w[x] = y;
} else {
long long sl = W.sum(x - 1), sr = W.sum(y);
sr = (sr - sl + 1) / 2;
int l = x, r = y;
while (l <= r) {
int mid = (l + r) >> 1;
if (W.sum(mid) - sl >= sr)
r = mid - 1;
else
l = mid + 1;
}
long long ans = (F.sum(y) - F.sum(l)) -
(W.sum(y) - W.sum(l)) % mod * 1LL * a[l] % mod -
((F.sum(l) - F.sum(x - 1)) -
(W.sum(l) - W.sum(x - 1)) % mod * 1LL * a[l] % mod);
printf("%lld\n", (ans % mod + mod) % mod);
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
(n >= 29) ? printf("%d\n", m) : printf("%d\n", m % (int)pow(2, n));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5, M = 2000;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double pai = acos(-1);
int n;
string s, a;
long long f(long long x);
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> n >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '4') {
a += "322";
} else if (s[i] == '8') {
a += "2227";
} else if (s[i] == '6') {
a += "53";
} else if (s[i] == '9') {
s += "3327";
} else if (s[i] != '1' && s[i] != '0')
a += s[i];
}
sort(a.begin(), a.end(), greater<char>());
cout << a;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100009;
long long a, b, mod;
const long long up = 1000000000;
int n;
int mat[5009][5009];
int col[5009];
int h[5009];
stack<int> s;
void dfs(int v, int l) {
if (h[v] != 0) {
if (l - h[v] == 3) {
int c = s.top();
s.pop();
int b = s.top();
s.pop();
int a = s.top();
s.pop();
cout << a << " " << b << " " << c << endl;
exit(0);
}
return;
}
s.push(v);
h[v] = l;
for (int i = 1; i <= n; i++) {
if (col[i] == 0 && mat[v][i] == 1 && (h[i] == 0 || l + 1 - h[i] == 3))
dfs(i, l + 1);
}
col[v] = 1;
s.pop();
}
int pp[5009];
int main() {
cin >> a >> b >> mod;
for (long long i = 0; i <= min(mod, a); i++) {
long long tmp = (i * up) % mod;
if (tmp != 0 && mod - tmp > b) {
printf("1 %09I64d\n", i);
return 0;
}
}
cout << 2 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, max_ = 0, l;
int v[40][40];
int v_[40][40];
void cambiar_columnas(int q[40][40], int a, int b) {
int c;
for (int i = (0); i < (n); i++) {
c = q[i][a];
q[i][a] = q[i][b];
q[i][b] = c;
}
}
void revision(int q[40][40]) {
int cont;
max_ = 0;
for (int i = (0); i < (n); i++) {
cont = 0;
for (int j = (0); j < (m); j++) {
if (q[i][j] != j + 1) {
cont++;
}
}
if (cont >= 3) {
l = i;
}
max_ = max(max_, cont);
}
}
int main() {
cin >> n >> m;
vector<int> r;
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
cin >> x;
v[i][j] = x;
}
}
revision(v);
if (max_ <= 2) {
cout << "YES";
}
if (max_ > 4) {
cout << "NO";
}
if (max_ > 2 && max_ <= 4) {
int w = 0;
for (int j = (0); j < (m); j++) {
if (v[l][j] != j + 1) {
r.push_back(j);
}
}
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
v_[i][j] = v[i][j];
}
}
for (int k = (0); k < (r.size() - 1); k++) {
for (int p = (k + 1); p < (r.size()); p++) {
cambiar_columnas(v_, r[k], r[p]);
revision(v_);
if (max_ <= 2) {
w = 1;
}
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
v_[i][j] = v[i][j];
}
}
}
}
if (w == 1) {
cout << "YES";
} else {
cout << "NO";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long a, b, an = 0;
cin >> a >> b;
long long temp = abs(a - b);
an += temp / 5;
temp %= 5;
an += temp / 2;
temp %= 2;
an += temp / 1;
cout << an << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long p;
long long n, m;
vector<int> Factorize(int num) {
vector<int> res;
for (int div = 2; div * div <= num; div++) {
if (num % div == 0) {
res.push_back(div);
while (num % div == 0) {
num /= div;
}
}
}
if (num != 1) {
res.push_back(num);
}
return res;
}
long long Sum(long long num, long long div) {
num -= num % div;
return (num * (num / div + 1) / 2) % p;
}
long long Solve(long long x, long long y) {
if (y <= 0) {
return 0;
}
auto factors = Factorize(x);
int f = factors.size();
long long quan = 0;
long long sum = 0;
for (int mask = 0; mask < 1 << f; mask++) {
bool odd = 0;
long long div = 1;
for (int i = 0; i < f; i++) {
if (mask & 1 << i) {
odd ^= 1;
div *= factors[i];
}
}
sum = ((sum + (odd ? -1 : 1) * Sum(y, div)) % p + p) % p;
quan = quan + (odd ? -1 : 1) * y / div;
}
return ((m * quan - sum + quan) % p + p) % p;
}
int main() {
ios_base::sync_with_stdio(false);
long long l, r;
cin >> n >> m >> l >> r >> p;
long long res = 0;
for (long long x = 1, ly = m, ry = m; x <= n; x++) {
while (x * x + ly * ly >= l * l && ly > 0) {
ly--;
}
while (x * x + ry * ry > r * r && ry > 0) {
ry--;
}
res =
((res + 2LL * (n - x + 1) * (Solve(x, ry) - Solve(x, ly))) % p + p) % p;
}
res = (res + (l <= 1 ? (n + 1) * m + (m + 1) * n : 0)) % p;
cout << res << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
inline pair<pair<int, int>, int> make(int x, int y, int z) {
return pair<pair<int, int>, int>(pair<int, int>(x, y), z);
}
const int MAXN = 102;
string s1, s2, virus;
int n, m, l;
int f[MAXN][MAXN][MAXN];
pair<pair<int, int>, int> p[MAXN][MAXN][MAXN];
int gp[MAXN][256];
inline int get_pref(int x, char c) {
if (gp[x][(int)c] != -1) return gp[x][(int)c];
int res = 0;
string sa, sb;
for (int i = x; i >= 0; --i) {
sa = virus.substr(0, i + 1);
sb = virus.substr(x - i, i) + c;
if (sa == sb) {
res = i + 1;
break;
}
}
return gp[x][(int)c] = res;
}
int rec(int x, int y, int z) {
if (z == l) return -2;
if (x == n || y == m) return 0;
if (f[x][y][z] != -1) return f[x][y][z];
int res = rec(x + 1, y, z);
p[x][y][z] = make(x + 1, y, z);
int cur = rec(x, y + 1, z);
if (res < cur) {
res = cur;
p[x][y][z] = make(x, y + 1, z);
}
if (s1[x] == s2[y]) {
int nz = get_pref(z, s1[x]);
int cur = rec(x + 1, y + 1, nz);
if (cur != -2) ++cur;
if (res < cur) {
res = cur;
p[x][y][z] = make(x + 1, y + 1, nz);
}
}
return f[x][y][z] = res;
}
inline void init() {
memset(f, -1, sizeof f);
memset(gp, -1, sizeof gp);
cin >> s1 >> s2 >> virus;
n = (int)s1.length();
m = (int)s2.length();
l = (int)virus.length();
}
int main() {
init();
int res = rec(0, 0, 0);
if (!res || res == -2) {
cout << 0 << endl;
return 0;
}
string ans = "";
int x = 0, y = 0, z = 0;
while (x < n && y < m) {
int nx = p[x][y][z].first.first;
int ny = p[x][y][z].first.second;
int nz = p[x][y][z].second;
if (nx != x && ny != y) ans += s1[x];
x = nx;
y = ny;
z = nz;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, m, u, v, q, r, ql, qr, k, l, s, w, z, x, y, d;
const int N = 1e6 + 1;
const int K = 1001;
const int LN = 20;
const long long mod = 1e9 + 7;
const long long INF = 1LL << 52LL;
int a[N], Tm[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
int mn = mod, mx = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
mn = min(mn, a[i]);
}
for (int i = 1; i <= n; ++i) {
a[i] -= mn;
mx = max(mx, a[i]);
}
mn *= k;
Tm[0] = 0;
cout << mn << " ";
for (int i = 1; i <= mx * k; ++i) {
Tm[i] = k + 1;
for (int j = 1; j <= n; ++j) {
if (i - a[j] >= 0) Tm[i] = min(Tm[i], Tm[i - a[j]] + 1);
}
if (Tm[i] <= k) cout << i + mn << " ";
}
cout << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, u, v, ans;
set<int> E[100005], uvis;
void dfs(int x) {
vector<int> V;
for (auto v : uvis)
if (!E[x].count(v)) V.push_back(v);
for (auto &i : V) uvis.erase(i);
for (auto &i : V) dfs(i);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) uvis.insert(i);
for (int i = 1; i <= m; i++)
scanf("%d%d", &u, &v), E[u].insert(v), E[v].insert(u);
for (int i = 1; i <= n; i++)
if (uvis.count(i)) {
uvis.erase(i);
dfs(i), ans++;
}
printf("%d", ans - 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int x1, y2, x2, y1;
while (~(scanf("%d%d", &x1, &y1))) {
scanf("%d%d", &x2, &y2);
int x, y;
x = abs(x1 - x2);
y = abs(y1 - y2);
if (x > y) {
int t = x;
x = y;
y = t;
}
int ans;
ans = x;
ans += y - x;
printf("%d\n", ans);
}
}
| 0 |
#include <bits/stdc++.h>
template <typename T>
void read(T& re) {
re = 0;
int re2 = 1;
char ch = '!';
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') re2 = -1, ch = getchar();
while (ch >= '0' && ch <= '9') {
re = re * 10 + ch - '0';
ch = getchar();
}
re *= re2;
}
template <typename T, typename... Args>
void read(T& re, Args&... args) {
read(re);
read(args...);
}
template <typename T>
void write(T A) {
if (A < 0) {
A = -A;
putchar('-');
}
if (A / 10) write(A / 10);
putchar(A % 10 + '0');
}
int T;
const int MAXN = 2e5 + 7;
int n, n2;
int a[MAXN];
int app[MAXN], maxx1, maxx2;
std::vector<std::pair<int, int> > pos[MAXN];
int ans;
int mp[MAXN << 1];
void getans1(int col) {
memset(mp, 0x3f, sizeof(mp));
mp[n] = 0;
for (int i = 1, cnt = 0; i <= n; i++) {
if (a[i] == maxx2) cnt++;
if (a[i] == col) cnt--;
ans = (ans > i - mp[cnt + n] ? ans : i - mp[cnt + n]);
mp[cnt + n] = (mp[cnt + n] > i ? i : mp[cnt + n]);
}
}
std::vector<std::pair<int, int> > pos2;
void getans2(int col) {
pos2.clear();
int now1, cnt = 1;
std::vector<std::pair<int, int> >::iterator I =
lower_bound(pos[maxx2].begin(), pos[maxx2].end(), pos[col][0]);
if (I == pos[maxx2].end())
now1 = maxx1 - 1;
else
now1 = I->second;
now1 = (now1 - app[col] - 1 > 0 ? now1 - app[col] - 1 : 0);
int now2 = 0;
while (now1 < (int)pos[maxx2].size() && now2 < (int)pos[col].size() &&
cnt <= (int)pos[col].size() * 2 + 1) {
if (pos[maxx2][now1].first < pos[col][now2].first) {
pos2.push_back(std::make_pair(pos[maxx2][now1].first, -1));
now1++;
cnt++;
} else {
pos2.push_back(std::make_pair(pos[col][now2].first, 1));
now2++;
}
}
while (now1 < (int)pos[maxx2].size() && cnt <= (int)pos[col].size() * 2 + 1) {
pos2.push_back(std::make_pair(pos[maxx2][now1].first, -1));
now1++;
cnt++;
}
while (now2 < (int)pos[col].size()) {
pos2.push_back(std::make_pair(pos[col][now2].first, 1));
now2++;
}
memset(mp, 0x3f, sizeof(mp));
mp[n] = pos2[0].first - 1;
for (int i = 0, cnt2 = 0; i < pos2.size(); i++) {
cnt2 += pos2[i].second;
if (i != pos2.size() - 1)
ans = (ans > pos2[i + 1].first - 1 - mp[cnt2 + n]
? ans
: pos2[i + 1].first - 1 - mp[cnt2 + n]);
else {
if (now1 < pos[maxx2].size())
ans = (ans > pos[maxx2][now1].first - 1 - mp[cnt2 + n]
? ans
: pos[maxx2][now1].first - 1 - mp[cnt2 + n]);
else
ans = (ans > n - mp[cnt2 + n] ? ans : n - mp[cnt2 + n]);
}
mp[cnt2 + n] =
(mp[cnt2 + n] > pos2[i].first ? pos2[i].first : mp[cnt2 + n]);
}
}
int main() {
T = 1;
while (T--) {
maxx1 = 0;
read(n);
n2 = sqrt(n);
for (int i = 1, i2; i <= n; i++) {
read(a[i]);
i2 = pos[a[i]].size();
pos[a[i]].push_back(std::make_pair(i, i2));
app[a[i]]++;
if (app[a[i]] > maxx1) {
maxx1 = app[a[i]];
maxx2 = a[i];
}
}
for (int i = 1; i <= n; i++) {
if (!app[i]) continue;
if (i == maxx2) continue;
if (app[i] >= n2)
getans1(i);
else
getans1(i);
}
std::cout << ans << std::endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int go(int a, int b, int r) {
cout << "? " << a + 1 << " " << b + 1 << " " << r + 1 << endl;
int c;
cin >> c;
--c;
return c;
}
long long h, n, a, b, c, r;
map<int, int> ma;
bool ok(int a) {
int num = 0;
int cnt = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i; ++j) {
if (i == a || j == a) continue;
int c = go(i, j, a);
if (c == a) ++num;
if (c == i || c == j) ++cnt;
}
}
return (num == 9 && cnt == 4);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> h;
n = (1 << h) - 1;
if (h == 3) {
int i = 0;
while (i < n - 1 && !ok(i)) ++i;
cout << "! " << i + 1 << endl;
return 0;
}
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> distrib(0, n - 1);
for (int ex = 0; ex < 420; ++ex) {
a = b = r = 0;
while (!(a != b && b != r && a != r)) {
a = distrib(gen);
b = distrib(gen);
r = distrib(gen);
}
++ma[go(a, b, r)];
}
vector<pair<int, int> > v;
for (auto el : ma) v.push_back({el.second, el.first});
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int a = v[0].second;
int b = v[1].second;
for (int i = 0; i < n; ++i) {
if (i == a || i == b) continue;
if (go(a, b, i) == i) {
cout << "! " << i + 1 << endl;
return 0;
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9, mod = 1e9 + 7;
int dX[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dY[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
long long n, x[N], y[N], d, ans, r;
int main() {
scanf("%lld%lld ", &n, &d);
for (int i = 0; i < n; i++) scanf("%lld", &x[i]);
for (int i = 0; i < n; i++) scanf("%lld", &y[i]);
ans = x[d - 1] + y[0];
int j = n - 1;
r = d;
for (int i = 0, j = n - 1; i < d - 1; i++) {
if (x[i] + y[j] <= ans) {
r--;
j--;
}
}
cout << r;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1000 + 1;
int a[MAX_N][MAX_N], n;
int main() {
cin >> n;
if (n == 4) {
puts("-1");
return 0;
}
for (int i = 0; i < n; ++i) {
a[i][(i + 1) % n] = 1;
}
for (int i = 0; i < n; ++i) {
for (int j = i + 2; j < n; ++j) {
if (i == 0 && j == n - 1) continue;
if ((i - j) % 2 == 0)
a[i][j] = 1;
else
a[j][i] = 1;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
printf("%d ", a[i][j]);
}
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j)
cout << k << " ";
else
cout << 0 << " ";
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[200100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
for (int j = l; j <= r; j++) {
arr[j]++;
}
}
for (int i = 1; i <= n; i++) {
if (arr[i] != 1) {
cout << i << ' ' << arr[i] << endl;
return 0;
}
}
cout << "OK" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int a[100005], b[100005], l[100005], r[100005];
int main() {
int i, j, x, y, n, m;
scanf("%d%d%d%d", &n, &m, &x, &y);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) scanf("%d", &b[i]);
int s1 = 1, s2 = 1, num = 0;
while (s1 <= n && s2 <= m) {
if (a[s1] - x <= b[s2] && b[s2] <= a[s1] + y) {
l[num] = s1++;
r[num++] = s2++;
} else if (a[s1] - x > b[s2])
s2++;
else if (a[s1] + y < b[s2])
s1++;
}
printf("%d\n", num);
for (i = 0; i < num; i++) printf("%d %d\n", l[i], r[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, int> M, mt;
M['a'] = M['e'] = M['i'] = M['o'] = M['u'] = 1;
string s;
cin >> s;
int cnt = 0;
char p = 0;
for (int i = 0; i < s.size(); i++) {
if (M.count(s[i])) cnt = 0, mt.clear();
if (!M.count(s[i])) cnt++, mt[s[i]]++;
if (cnt >= 3 && mt.size() >= 2) {
putchar(' '), cnt = 0, mt.clear();
mt[s[i]]++;
cnt++;
}
putchar(s[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000002;
const int INF = 1000000000;
bool used[100000];
int cntBig = 0;
long long gr[30] = {1, 2, 1, 4, 3, 2, 1, 5, 6, 2, 1, 8, 7, 5, 9,
8, 7, 3, 4, 7, 4, 2, 1, 10, 9, 3, 6, 11, 12, 14};
long long n;
long long k;
long long len(long long x) {
long long p = x;
long long res = 0;
while (p <= n) {
res++;
if (p <= k) {
used[p] = true;
} else {
cntBig++;
}
if (x == 1) {
break;
}
p *= x;
}
return res;
}
unordered_map<int, int> mem;
int get(int msk) {
if (mem.find(msk) != mem.end()) {
return mem[msk];
}
vector<int> mex(40);
for (int i = 0; i < (int)(30); i++) {
if ((msk & (1 << i)) > 0) {
int newMsk = msk;
int j = i;
while (j < 30) {
if ((newMsk & (1 << j)) > 0) {
newMsk ^= (1 << j);
}
j += i + 1;
}
mex[get(newMsk)] = 1;
}
}
int res = 0;
for (int i = 0; i < (int)(40); i++) {
if (mex[i] == 0) {
res = i;
break;
}
}
mem[msk] = res;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
k = (int)min(100000ll, n);
long long res = 0;
for (int i = (int)1; i <= (int)(k); i++) {
if (!used[i]) {
long long l = len(i) - 1;
assert(l < 30);
res ^= gr[l];
}
}
res ^= (n - k - cntBig) % 2;
if (res == 0) {
cout << "Petya\n";
} else {
cout << "Vasya\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v);
template <typename A, typename B>
ostream &operator<<(ostream &cout, pair<A, B> const &p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
template <typename A, typename B>
istream &operator>>(istream &cin, pair<A, B> &p) {
cin >> p.first;
return cin >> p.second;
}
mt19937 rng(steady_clock::now().time_since_epoch().count());
void usaco(string filename) {
freopen((filename + ".in").c_str(), "r", stdin);
freopen((filename + ".out").c_str(), "w", stdout);
}
const long double pi = 3.14159265358979323846;
long long n, m, k, q, l, r, x, y, z;
long long a[1000005];
long long b[1000005];
long long c[1000005];
string second, t;
long long ans = 0;
long long cn[300];
string ss[400005];
void solve(int tc) {
cin >> n >> second;
memset(cn, 0, sizeof(cn));
for (long long i = 0; i < (n); ++i) ++cn[second[i]];
int nodd = 0;
for (long long i = 0; i < (300); ++i) nodd += cn[i] & 1;
for (long long m = (n); m >= (1); --m) {
if (n % m == 0) {
int k = n / m;
if (m & 1) {
if (nodd <= k && (nodd & 1) == (k & 1)) {
int p = m / 2;
for (long long i = 0; i < (k); ++i) ss[i] = string(m, '0');
int pt = 0;
for (long long i = 0; i < (k); ++i) {
if (nodd > 0) {
while (pt < 300 && (cn[pt] & 1) == 0) ++pt;
} else {
while (pt < 300 && cn[pt] == 0) ++pt;
}
ss[i][p] = pt;
--cn[pt];
if (nodd == 1) pt = 0;
--nodd;
}
cout << k << '\n';
pt = 0;
for (long long i = 0; i < (k); ++i) {
for (long long j = 0; j < (m / 2); ++j) {
while (pt < 300 && cn[pt] == 0) ++pt;
ss[i][j] = ss[i][m - 1 - j] = pt;
cn[pt] -= 2;
}
cout << ss[i] << " ";
}
return;
}
} else {
if (nodd == 0) {
for (long long i = 0; i < (k); ++i) ss[i] = string(m, '0');
int pt = 0;
cout << k << '\n';
for (long long i = 0; i < (k); ++i) {
for (long long j = 0; j < (m / 2); ++j) {
while (pt < 300 && cn[pt] == 0) ++pt;
ss[i][j] = ss[i][m - 1 - j] = pt;
cn[pt] -= 2;
}
cout << ss[i] << " ";
}
return;
}
}
}
}
}
int main() {
{ ios_base::sync_with_stdio(false); }
{
cin.tie(NULL);
cout.tie(NULL);
}
int tc;
tc = 1;
for (int t = 0; t < tc; t++) solve(t);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-11;
long long gcd(long long a, long long b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
long long n;
n = (long long)a * (long long)b / gcd(a, b);
return n;
}
int main() {
long long a, b, mm, gg, num1 = 0, num2 = 0;
long long t1, t2;
cin >> a >> b;
if (a >= b) {
gg = gcd(a, b);
mm = lcm(a, b);
} else {
gg = gcd(b, a);
mm = lcm(b, a);
}
num1 = mm / a;
num2 = mm / b;
if (abs((long)(num1 - num2)) == 1)
cout << "Equal";
else if (num1 < num2)
cout << "Masha";
else if (num1 > num2)
cout << "Dasha";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
void fmain(int tid) {
scanf("%d%d", &n, &k);
int a = 0, b = 0;
ln = n;
while (n % 2 == 0) {
a++;
n /= 2;
}
while (n % 5 == 0) {
b++;
n /= 5;
}
while (a < k) {
a++;
ln *= 2;
}
while (b < k) {
b++;
ln *= 5;
}
printf("%lld\n", ln);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long lca(long long a, long long b) { return a / gcd(a, b) * b; }
int main() {
long long n;
int y1, y2, yw, xb, yb, r;
cin >> y1 >> y2 >> yw >> xb >> yb >> r;
long double x, L = 0, R = xb;
long double vX, vY = yw - r - yb;
while (abs(R - L) > 1e-12) {
long double m = (L + R) / 2;
vX = abs(m - (long double)xb);
long double t = m / vX;
long double yres = (long double)yw - (long double)r - (long double)vY * t;
long double A = vY, B = vX, C = -B * yres;
bool bad = false;
if (abs((B * y2 + C) / sqrt(A * A + B * B)) <= r) bad = true;
if (yres < y1)
R = m;
else if (yres < y2 - r && yres > y1 + r && !bad) {
cout << fixed << setprecision(12) << m;
return 0;
} else if (yres >= y2 - r || bad)
L = m;
else
R = m;
}
cout << -1;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf, obuf[1 << 23], *O = obuf;
inline int read() {
int x = 0, sign = 0;
char s = getchar();
while (!isdigit(s)) sign |= s == '-', s = getchar();
while (isdigit(s)) x = (x << 1) + (x << 3) + (s - '0'), s = getchar();
return sign ? -x : x;
}
void print(int x) {
if (x > 9) print(x / 10);
(*O++ = x % 10 + '0');
}
const int N = 305;
int n, fa[N][9], dep[N], c[N], l[N], leaf;
vector<int> e[N];
void dfs(int id, int f, int d) {
fa[id][0] = f, dep[id] = d;
int isl = 1;
for (auto to : e[id])
if (to != f) dfs(to, id, d + 1), isl = 0;
leaf += isl;
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 8; ~i; i--)
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
if (x == y) return x;
for (int i = 8; ~i; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
void check(int id, int f) {
for (auto to : e[id])
if (to != f) check(to, id), c[id] += c[to];
if (id > 1 && c[id] != 2) puts("-1"), exit(0);
}
void move(int from, int to) {
int rev = 0;
if (dep[from] < dep[to]) swap(from, to), rev = 1;
vector<int> p;
while (from != to) {
p.push_back(rev ? from : fa[from][0]);
from = fa[from][0];
}
if (rev) reverse(p.begin(), p.end());
for (auto it : p) cout << it << " ";
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1, 0, 1);
for (int i = 1; i < 9; i++)
for (int j = 1; j <= n; j++) fa[j][i] = fa[fa[j][i - 1]][i - 1];
l[0] = 0, l[leaf + 1] = 1;
for (int i = 1; i <= leaf; i++) {
cin >> l[i];
}
for (int i = 1; i <= leaf + 1; i++) {
c[l[i]]++, c[l[i - 1]]++;
c[LCA(l[i], l[i - 1])] -= 2;
}
check(1, 0);
for (int i = 1; i <= leaf + 1; i++) {
int d = LCA(l[i - 1], l[i]);
move(l[i - 1], d), move(d, l[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200050;
int son[N], dep[N];
struct edge {
int v, nxt;
long long w;
} e[N << 1];
int head[N], ecnt, du[N];
int n, m;
long long G, B;
inline void ad(int u, int v, long long w) {
e[++ecnt].v = v;
e[ecnt].w = w;
e[ecnt].nxt = head[u];
head[u] = ecnt;
du[v]++;
}
void dfs1(int u, int fa) {
son[u] = 1;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
dep[v] = dep[u] + 1;
dfs1(v, u);
son[u] += son[v];
}
}
void dfs2(int u, int fa) {
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
dfs2(v, u);
long long L = son[v];
long long R = n - son[v];
long long T = min(L, R);
B += T * (long long)e[i].w;
}
}
int dfs3(int u, int fa) {
int num = 0;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
int p = dfs3(v, u);
num += p;
G += (long long)p * (long long)e[i].w;
}
if (du[u] == 1 || num % 2 == 0)
return 1;
else
return 0;
}
int main() {
int Test;
scanf("%d", &Test);
while (Test--) {
scanf("%d", &n);
n *= 2;
G = B = 0;
memset(head, 0, (n + 10) * sizeof(int));
ecnt = 0;
memset(son, 0, (n + 10) * sizeof(int));
memset(dep, 0, (n + 10) * sizeof(int));
memset(du, 0, (n + 10) * sizeof(int));
dep[1] = 1;
for (int i = 1; i < n; ++i) {
int x, y;
long long w;
scanf("%d%d%lld", &x, &y, &w);
ad(x, y, w), ad(y, x, w);
}
dfs1(1, 0);
dfs2(1, 0);
dfs3(1, 0);
printf("%lld ", G);
printf("%lld\n", B);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int N = 2e5 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
using namespace std;
map<int, int> m[N];
int f[N];
int n;
int bfs() {
int p = 1;
queue<int> q;
if (f[1] != 1) return 0;
q.push(f[1]);
p++;
while (!q.empty()) {
int u = q.front();
q.pop();
int v = f[p];
while (m[u][v]) {
q.push(v);
v = f[++p];
}
}
if (p == n + 1)
return 1;
else
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int i;
cin >> n;
for (i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
m[x][y] = m[y][x] = 1;
}
for (i = 1; i <= n; i++) cin >> f[i];
if (bfs())
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char n[13], m[13];
int a[13], b[13];
int bb[13];
int main() {
int i, j;
scanf("%s", n);
scanf("%s", m);
int flag = 1;
if (n[0] == '0' && m[0] == '0' && strlen(n) == strlen(m) && strlen(n) == 1)
flag = 1;
else if (strlen(n) != strlen(m))
flag = 0;
else if (n[0] == '0' || m[0] == '0')
flag = 0;
else {
for (i = 0; i < strlen(m); i++) b[i] = m[i] - '0';
sort(b, b + i);
for (i = 0; i < strlen(m); i++) a[i] = n[i] - '0';
sort(a, a + i);
for (i = 0; i < strlen(m); i++) {
if (a[i] != b[i]) {
flag = 0;
break;
}
}
int k = 1;
for (i = 0; i < strlen(n); i++) {
if (b[i] == 0)
bb[k++] = b[i];
else {
bb[0] = b[i];
break;
}
}
for (i = k; i < strlen(n); i++) bb[i] = b[i];
for (i = 0; i < strlen(n); i++) {
if ((m[i] - '0') != bb[i]) {
flag = 0;
break;
}
}
}
if (flag)
printf("OK\n");
else
printf("WRONG_ANSWER\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000000 + 7;
const long long rt = 500000004;
long long n, a[5000 + 10], dp[5000 + 10][2], cnt[5000 + 10];
void solve() {
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) dp[i][1] = cnt[i];
for (int k = 0; k < 2 * n - 2; k++) {
for (int i = n; i >= (k + 1) / 2; i--) {
dp[i + 1][0] = dp[i][0] * a[i] % M;
if (k & 1) {
dp[i + 1][0] = (dp[i + 1][0] + dp[i][1] * a[i] % M) % M;
if (k == 1) {
dp[i][1] = (a[i - 1] * (a[i - 1] - 1) / 2) % M * cnt[i - 1] % M;
} else {
dp[i][1] = (dp[i][1] * a[i - 1] % M) * rt % M;
}
} else {
dp[i + 1][1] = dp[i][1] * a[i] % M * (k == 0 ? 1 : 2) % M;
}
}
long long res = 0;
for (int i = 1; i <= n; i++) {
res = (res + dp[i][0] + dp[i][1]) % M;
}
printf("%I64d%c", res, k == 2 * n - 3 ? '\n' : ' ');
}
}
int main() {
cin >> n;
a[0] = cnt[1] = 1;
a[n] = 0;
for (int i = 1; i < n; i++) {
cin >> a[i];
cnt[i + 1] = cnt[i] * a[i] % M;
}
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tt;
tt = 1;
while (tt--) {
int n, m;
cin >> n >> m;
vector<vector<int>> aa(n, vector<int>(m));
vector<vector<int>> mark(n, vector<int>(m, 0));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> aa[i][j];
vector<int> ans;
ans.clear();
int dx[] = {0, 1, 0, -1};
int dy[] = {-1, 0, 1, -0};
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (!mark[i][j]) {
queue<pair<int, int>> qq;
qq.push({i, j});
mark[i][j] = 1;
int v = 0;
while (!qq.empty()) {
int x = qq.front().first;
int y = qq.front().second;
qq.pop();
v++;
int u = aa[x][y];
for (int l = 0; l < 4; l++) {
int fx = x + dx[l];
int fy = y + dy[l];
if (fx < 0 || fy < 0 || fx > n - 1 || fy > m - 1 ||
mark[fx][fy] || (u & (1 << l)) != 0)
continue;
mark[fx][fy] = 1;
qq.push({fx, fy});
}
}
ans.push_back(v);
}
}
}
sort(ans.begin(), ans.end());
reverse(ans.begin(), ans.end());
for (auto &it : ans) cout << it << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool solve(string A, string B) {
long long n = A.length();
long long m = B.length();
if (n > m) {
return false;
} else {
sort(A.begin(), A.end());
for (long long i = 0; i < m; i++) {
if (i + n - 1 >= m) return false;
string str = "";
for (long long j = 0; j < n; j++) str.push_back(B[i + j]);
sort(str.begin(), str.end());
if (str == A) return true;
}
}
}
int main() {
int t;
cin >> t;
while (t--) {
string a, b;
cin >> a >> b;
if (solve(a, b)) {
cout << "YES" << '\n';
} else
cout << "NO" << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int x[100005], y[100005];
long long hx[100005], hy[100005];
int main(void) {
while (scanf("%d", &n) != EOF) {
int i, j;
for (i = 1; i <= n; i++) {
scanf("%d %d", &x[i], &y[i]);
}
memset(hx, 0, sizeof(hx));
memset(hy, 0, sizeof(hy));
long long ans = 0;
for (i = 1; i <= n; i++) {
ans = ans + (long long)(n - 1) * (x[i] * x[i]);
ans = ans + (long long)(n - 1) * (y[i] * y[i]);
}
hx[n] = x[n], hy[n] = y[n];
for (i = n; i > 1; i--) {
hx[i - 1] = hx[i] + x[i - 1];
hy[i - 1] = hy[i] + y[i - 1];
}
for (i = 1; i <= n; i++) {
ans += (long long)(hx[i] - x[i]) * x[i] * (-2);
ans += (long long)(hy[i] - y[i]) * y[i] * (-2);
}
printf("%I64d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
char pt[20];
void make_pt(long long a) {
for (int i = 0; i < 18; i++) {
pt[i] = a % 10 % 2 + '0';
a /= 10;
}
pt[18] = '\0';
}
int main() {
int q;
char str[20];
while (scanf("%d", &q) == 1) {
mp.clear();
char tp[10];
long long a;
while (q--) {
scanf("%s", &tp);
if (tp[0] == '+') {
scanf("%I64d", &a);
make_pt(a);
mp[pt]++;
} else if (tp[0] == '-') {
scanf("%I64d", &a);
make_pt(a);
mp[pt]--;
} else {
scanf("%s", str);
int n = strlen(str);
for (int i = 0; i < n; i++) {
pt[n - i - 1] = str[i];
}
for (int i = n; i < 18; i++) pt[i] = '0';
pt[18] = '\0';
printf("%d\n", mp[pt]);
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
long long so() {
long long n, m;
cin >> n >> m;
long long mod = m;
vector<long long> dp(n * 2 + 1), s(n * 2 + 1);
dp[1] = 1;
dp[2] = dp[1] + 1;
s[1] = 1;
s[2] = 3;
for (long long i = (3); i <= (n); ++i) {
long long t = sqrt(i);
dp[i] = (dp[i] + s[i - 1]) % mod;
for (long long j = 2, rt; j <= i; j = rt + 1) {
rt = min(i / (i / j), n);
dp[i] = (dp[i] + (rt - j + 1) * dp[i / j] % mod) % mod;
}
s[i] = (s[i - 1] + dp[i]) % mod;
}
return dp[n];
}
signed main() { cout << so() << '\n'; }
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:255000000")
bool firstout = 1;
template <class T>
T &minn(T &a, T b) {
if (b < a) a = b;
return a;
}
template <class T>
T &maxx(T &a, T b) {
if (a < b) a = b;
return a;
}
int &madd(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
return a;
}
int &msub(int &a, int b) {
a -= b;
if (a < 0) a += 1000000007;
return a;
}
int &mmult(int &a, int b) { return a = (long long)a * b % 1000000007; }
int mdiv(long long a, long long b, long long m) {
a = (a % m + m) % m;
b = (b % m + m) % m;
if (a % b == 0) return a / b;
return (a + m * mdiv(-a, m, b)) / b;
}
int n, m, q;
int A[2012];
int main() {
int i, j, k;
char c;
int a, d;
int ts;
for (ts = 1; scanf("%"
"d",
&(n)) > 0;
++ts) {
for (i = (0); i < (n); ++i)
scanf(
"%"
"d",
&(A[i]));
for (i = (0); i < (n); ++i)
if (A[i] < 0) A[i] *= -1;
int res = 0;
for (i = (0); i < (n); ++i) {
int a, b;
a = b = 0;
for (j = (0); j < (i); ++j)
if (A[j] < A[i]) ++a;
for (j = (i + 1); j < (n); ++j)
if (A[j] < A[i]) ++b;
res += min(a, b);
}
printf(
"%"
"d",
(res));
printf("\n"), firstout = 1;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int64_t d2i(double d) {
union {
double d;
int64_t i;
} t;
t.d = d;
if (t.i == 1ll << 63)
t.i = -1;
else if (t.i < 0) {
t.i = ~t.i;
t.i |= 1ll << 63;
assert(t.i < 0);
}
return t.i;
}
int sgn(double x, double y = 0) {
return fabs(x - y) < 1e-8 ? 0 : x > y ? 1 : -1;
}
struct P {
double x = 0, y = 0;
P() {}
P(double x, double y) : x(x), y(y) {}
P operator+(const P &q) const { return P(x + q.x, y + q.y); }
P operator-(const P &q) const { return P(x - q.x, y - q.y); }
double operator*(const P &q) const { return x * q.x + y * q.y; }
int operator%(const P &q) const { return sgn(x * q.y, y * q.x); }
P operator*(double f) const { return P(x * f, y * f); }
P operator/(double f) const { return P(x / f, y / f); }
friend ostream &operator<<(ostream &o, const P &p) {
return o << "(" << p.x << ", " << p.y << ")";
}
};
int crs(const P &o, const P &a, const P &b) { return (a - o) % (b - o); }
struct L {
double a = 0, b = 0, c = 0;
L() {}
L(double a, double b, double c) : a(a), b(b), c(c) {}
L(const P &p, const P &q)
: a(q.y - p.y), b(p.x - q.x), c(-a * p.x - b * p.y) {}
double test(const P &p) const { return p * P(a, b) + c; }
};
P solve(const L &f, const L &g) {
double d = f.a * g.b - f.b * g.a;
return P(f.b * g.c - f.c * g.b, f.c * g.a - f.a * g.c) / d;
}
L zcx(const P &a, const P &b) {
P p = (a + b) * .5;
P q = b - a;
swap(q.x, q.y);
q.y = -q.y;
return L(p, p + q);
}
int main() {
int T;
for (scanf("%d", &T); T--;) {
P in[3];
for (int i = 0; i < 3; ++i) {
int x, y;
scanf("%d%d", &x, &y);
in[i].x = x;
in[i].y = y;
}
if (crs(in[0], in[1], in[2]) == 0) {
puts("NO\n");
continue;
}
int o[3] = {0, 1, 2};
bool ans = false;
do {
P a = in[o[0]], b = in[o[1]], c = in[o[2]];
P p = solve(zcx(b + b - a, b), zcx(c, b));
P q = solve(zcx(a, b), zcx(b + b - c, b));
P s = c + c - p;
P t = a + a - q;
if (crs(s, p, q) > 0 && crs(p, q, t) > 0 && crs(q, t, s) > 0 &&
crs(t, s, p) > 0) {
ans = true;
puts("YES");
printf("%.9lf %.9lf %.9lf %.9lf %.9lf %.9lf %.9lf %.9lf \n", s.x, s.y,
p.x, p.y, q.x, q.y, t.x, t.y);
break;
}
} while (next_permutation(o, o + 3));
if (!ans) puts("NO\n");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1111;
const long long mod = 1000 * 1000 * 1000 + 7;
long long c[maxn][maxn / 10];
long long dp[maxn][maxn / 10];
long long n, m, x[maxn], y[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin >> m;
for (int i = 1; i <= m; ++i) cin >> x[i];
for (int i = 1; i <= m; ++i) cin >> y[i];
for (int i = 1; i <= m; ++i) n += x[i];
for (int i = 0; i < maxn; ++i) c[i][0] = 1;
for (int i = 1; i < maxn; ++i)
for (int j = 1; j < maxn / 10; ++j)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
long long ans = 1;
int cp = n;
for (int i = 1; i <= m; ++i) {
ans *= c[cp][x[i]];
cp -= x[i];
ans %= mod;
}
for (int i = 0; i <= n; ++i)
if (i <= y[m])
dp[i][m] = 1;
else
dp[i][m] = 0;
for (int j = m - 1; j >= 1; --j)
for (int i = 0; i <= n; ++i)
for (int l = 0; l <= min(y[j], (long long)i); ++l) {
dp[i][j] += (dp[i - l + x[j + 1]][j + 1] * c[i][l]) % mod;
dp[i][j] %= mod;
}
cout << (ans * dp[x[1]][1]) % mod << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5e3 + 9, INF = 1e9 + 9;
int n, a, b, root, dp[MAX][MAX], sz[MAX], dp2[MAX];
vector<int> g[MAX];
void dfs(int v, int p) {
dp[v][0] = 0;
for (auto u : g[v])
if (u != p) {
dfs(u, v);
for (int i = 0; i <= sz[v] + sz[u]; i++) dp2[i] = INF;
for (int i = 0; i <= sz[v]; i++) {
for (int j = 0; j <= sz[u]; j++)
dp2[i + j] = min(dp2[i + j], dp[v][i] + dp[u][j]);
for (int j = 0; j <= sz[u]; j++)
dp2[i + j] = min(dp2[i + j], dp[v][i] + dp[u][sz[u] - j] + 1);
}
sz[v] += sz[u];
for (int i = 0; i <= sz[v]; i++) dp[v][i] = dp2[i];
}
if (g[v].size() == 1) sz[v] = 1;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++)
cin >> a >> b, a--, b--, g[a].push_back(b), g[b].push_back(a);
if (n == 2) return cout << 1, 0;
for (int i = 0; i < MAX; i++)
for (int j = 0; j < MAX; j++) dp[i][j] = INF;
for (int i = 0; i < n; i++)
if (g[i].size() > 1) root = i;
dfs(root, -1);
cout << dp[root][sz[root] / 2];
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, lo, hi = 1000005, mi, ans, y[1000005];
char x[1000005];
vector<vector<int> > va;
vector<int> vb;
int main() {
scanf("%d%s", &n, x);
va.push_back(vector<int>());
for (int i = 0; i < n; i++)
if (x[i] == '*')
va.back().push_back(i), ans++;
else if (x[i] == 'P') {
va.push_back(vector<int>());
vb.push_back(i);
}
if (vb.size() == 1 && !va[0].empty() && !va[1].empty()) {
printf("%d ", ans - min(va[0].size(), va[1].size()));
if (va[0].size() < va[1].size())
printf("%d\n", va[1].back() - vb[0]);
else if (va[0].size() > va[1].size())
printf("%d\n", vb[0] - va[0][0]);
else
printf("%d\n", min(va[1].back() - vb[0], vb[0] - va[0][0]));
} else {
printf("%d ", ans);
while (lo < hi) {
mi = (lo + hi) / 2;
for (int i = 0; i < vb.size(); i++) {
y[i + 1] = -1;
if (y[i] != -1) {
if (y[i] != va[i].size()) {
if (vb[i] - va[i][y[i]] <= mi) y[i + 1] = 0;
} else {
y[i + 1] = 0;
while (y[i + 1] < va[i + 1].size() &&
va[i + 1][y[i + 1]] - vb[i] <= mi)
y[i + 1]++;
}
}
if (i && y[i - 1] != -1 && y[i - 1] != va[i - 1].size() &&
vb[i] - va[i - 1][y[i - 1]] <= mi) {
y[i + 1] = max(y[i + 1], 0);
while (y[i + 1] < va[i + 1].size() &&
va[i + 1][y[i + 1]] - vb[i - 1] <= mi)
y[i + 1]++;
}
}
if (y[vb.size()] == va.back().size())
hi = mi;
else
lo = mi + 1;
}
printf("%d\n", lo);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1000010;
int a[maxn], ans[maxn];
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) a[i] = i;
int ty, x;
int sum = 0, num1 = 0, num2 = 0;
for (int i = 1; i <= q; i++) {
scanf("%d", &ty);
if (ty == 1) {
scanf("%d", &x);
sum += x;
} else {
if ((sum + num1 + 1) % 2 == 0) {
num1--;
num2++;
} else {
num1++;
num2--;
}
}
num1 = num1 % n;
num2 = num2 % n;
sum = sum % n;
}
for (int i = 1; i <= n; i++) {
if (i % 2)
a[i] = a[i] + num1 + sum;
else
a[i] = a[i] + num2 + sum;
while (a[i] > n) a[i] -= n;
while (a[i] <= 0) a[i] += n;
}
for (int i = 1; i <= n; i++) ans[a[i]] = i;
for (int i = 1; i <= n; i++) {
printf("%d", ans[i]);
if (i < n)
printf(" ");
else
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 123;
const long long INF = (long long)1e18 + 123;
const int inf = (int)1e9 + 123;
const int MOD = (int)1e9 + 7;
int n, m;
int sub[N];
vector<pair<int, int> > g[N];
bool u[N];
long long ans;
int PHI;
inline int mult(int a, int b) { return 1ll * a * b % m; }
inline int _minus(int a, int b) {
a -= b;
a %= m;
if (a < 0) a += m;
a %= m;
return a;
}
inline int _plus(int a, int b) { return (a + b) % m; }
inline int phi(int a) {
int res = a;
for (int i = 2; 1ll * i * i <= a; i++) {
if (a % i == 0) {
while (a % i == 0) {
a /= i;
}
res -= res / i;
}
}
if (a > 1) res -= res / a;
return res;
}
inline int binpow(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) res = mult(res, a);
a = mult(a, a);
b >>= 1;
}
return res;
}
int h[N], up[N], down[N];
map<int, int> cnt_up, cnt_up_col[N];
int ptr, col[N];
void calc_sub(int x, int par = -1) {
h[x] = up[x] = down[x] = 0;
sub[x] = 1;
for (auto to : g[x]) {
if (u[to.first] || to.first == par) continue;
calc_sub(to.first, x);
sub[x] += sub[to.first];
}
}
inline int get_centroid(int x, int Len) {
int res = x, par = -1;
while (1) {
bool changed = 0;
for (auto to : g[res]) {
if (u[to.first] || to.first == par) continue;
if ((sub[to.first] << 1) >= Len) {
par = res, res = to.first, changed = 1;
break;
}
}
if (!changed) break;
}
return res;
}
void calc_sth(int x, int centroid, int par = -1) {
if (par == centroid)
col[x] = ++ptr;
else if (par != -1)
col[x] = col[par];
if (x != centroid) cnt_up_col[col[x]][up[x]]++;
if (par != -1) cnt_up[up[x]]++;
for (auto to : g[x]) {
if (u[to.first] || to.first == par) continue;
down[to.first] = _plus(mult(down[x], 10), to.second);
up[to.first] = _plus(mult(to.second, binpow(10, h[x])), up[x]);
h[to.first] = h[x] + 1;
calc_sth(to.first, centroid, x);
}
}
long long get(int x, int par = -1) {
long long tmp = 0;
if (par != -1) {
long long tmp1 = _minus(0, down[x]), tmp2 = binpow(10, h[x]);
tmp2 = binpow(tmp2, PHI - 1);
tmp1 = mult(tmp1, tmp2);
long long lleefftt = cnt_up[tmp1] - cnt_up_col[col[x]][tmp1];
tmp += lleefftt;
if (down[x] == 0) tmp++;
if (up[x] == 0) tmp++;
}
for (auto to : g[x]) {
if (u[to.first] || to.first == par) continue;
tmp += get(to.first, x);
}
return tmp;
}
void solve(int x) {
calc_sub(x);
cnt_up.clear();
for (int i = 1; i <= ptr; i++) cnt_up_col[i].clear();
ptr = 0;
int centroid = get_centroid(x, sub[x]);
calc_sth(centroid, centroid);
ans += get(centroid);
u[centroid] = 1;
for (auto to : g[centroid]) {
if (!u[to.first]) {
solve(to.first);
}
}
}
int main() {
scanf("%d%d", &n, &m);
PHI = phi(m);
for (int i = 0, a, b, c; i < n - 1; i++) {
scanf("%d%d%d", &a, &b, &c);
g[a].push_back({b, c}), g[b].push_back({a, c});
}
solve(0);
printf("%I64d", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
struct node {
int l, r, m, cnt, g;
} tr[400005];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
void build(int l, int r, int id) {
tr[id].l = l;
tr[id].r = r;
if (l == r) {
tr[id].g = a[l];
tr[id].m = l;
tr[id].cnt = 1;
} else {
int mid = (tr[id].l + tr[id].r) / 2;
build(l, mid, (2 * id));
build(mid + 1, r, (2 * id + 1));
tr[id].g = gcd(tr[(2 * id)].g, tr[(2 * id + 1)].g);
if (a[tr[(2 * id)].m] < a[tr[(2 * id + 1)].m]) {
tr[id].m = tr[(2 * id)].m;
tr[id].cnt = tr[(2 * id)].cnt;
} else if (a[tr[(2 * id)].m] > a[tr[(2 * id + 1)].m]) {
tr[id].m = tr[(2 * id + 1)].m;
tr[id].cnt = tr[(2 * id + 1)].cnt;
} else {
tr[id].m = tr[(2 * id)].m;
tr[id].cnt = tr[(2 * id)].cnt + tr[(2 * id + 1)].cnt;
}
}
}
int query(int l, int r, int id, int &cnt, int &g) {
if (l <= tr[id].l && r >= tr[id].r) {
g = tr[id].g;
cnt = tr[id].cnt;
return tr[id].m;
}
int mid = (tr[id].l + tr[id].r) >> 1;
if (r <= mid)
return query(l, r, (2 * id), cnt, g);
else if (l > mid)
return query(l, r, (2 * id + 1), cnt, g);
else {
int m, m1, cnt1 = 0, m2, cnt2 = 0, g1, g2;
m1 = query(l, mid, (2 * id), cnt1, g1);
m2 = query(mid + 1, r, (2 * id + 1), cnt2, g2);
if (a[m1] < a[m2]) {
m = m1;
cnt = cnt1;
} else if (a[m1] > a[m2]) {
m = m2;
cnt = cnt2;
} else {
m = m1;
cnt = cnt1 + cnt2;
}
g = gcd(g1, g2);
return m;
}
}
int L[100005], R[100005];
void solve(int n) {
int cnt, g, id;
L[1] = 1;
for (int i = 2; i <= n; i++) {
if (a[i - 1] % a[i] != 0)
L[i] = i;
else {
int l = 1, r = L[i - 1];
while (l < r) {
int mid = (l + r) >> 1;
id = query(mid, i, 1, cnt, g);
if (g < a[i])
l = mid + 1;
else
r = mid;
}
L[i] = l;
}
}
R[n] = n;
for (int i = n - 1; i >= 1; i--) {
if (a[i + 1] % a[i] != 0)
R[i] = i;
else {
int l = R[i + 1], r = n;
while (l + 1 < r) {
int mid = (l + r) >> 1;
id = query(i, mid, 1, cnt, g);
if (g < a[i])
r = mid - 1;
else
l = mid;
}
id = query(i, r, 1, cnt, g);
if (g == a[i])
R[i] = r;
else
R[i] = l;
}
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, n, 1);
solve(n);
int Q;
scanf("%d", &Q);
while (Q--) {
int l, r;
scanf("%d%d", &l, &r);
int cnt, id, g;
id = query(l, r, 1, cnt, g);
if (L[id] <= l && R[id] >= r)
printf("%d\n", r - l + 1 - cnt);
else
printf("%d\n", r - l + 1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = (int)1e9 + 7;
const double pi = acos(-1.0);
const double eps = 1e-9;
int a[1105][1105], n, m, b[1105][1105];
int dp[1105][1105], used[1105][1105];
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
string second;
bool OK(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
void dfs(int x, int y) {
used[x][y] = 1;
for (int d = 0; d < 4; d++) {
int i = x + dx[d];
int j = y + dy[d];
if (OK(i, j) && !used[i][j]) dfs(i, j);
}
}
int calc(int n, int m) {
if (n < 0 || m < 0) return 0;
return dp[n][m];
}
int calc(int x1, int stupid_cmath, int x2, int y2) {
return calc(x2, y2) - calc(x2, stupid_cmath - 1) - calc(x1 - 1, y2) +
calc(x1 - 1, stupid_cmath - 1);
}
void isRectangle() {
int x1 = inf, stupid_cmath = inf, x2 = -1, y2 = -1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (!a[i][j]) continue;
x1 = min(x1, i);
stupid_cmath = min(stupid_cmath, j);
x2 = max(x2, i);
y2 = max(y2, j);
}
if (x1 == inf) {
cout << 0 << endl;
exit(0);
}
int cnt = calc(x1, stupid_cmath, x2, y2);
if (cnt == (x2 - x1 + 1) * (y2 - stupid_cmath + 1)) {
cout << min((x2 - x1 + 1), (y2 - stupid_cmath + 1)) << endl;
exit(0);
}
}
void init() {
memset(b, 0, sizeof b);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) b[i][j] = a[i][j];
}
void print() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << b[i][j];
cout << endl;
}
cout << endl;
}
bool ok(int h, int w) {
if (h <= 0 || w <= 0) return false;
init();
int curi = -1, curj = -1;
for (int i = 0; i < n && curi == -1; i++) {
for (int j = 0; j < m && curj == -1; j++) {
if (b[i][j]) {
curi = i;
curj = j;
}
}
}
if (curi + h > n || curj + w > m) return false;
int cnt = calc(curi, curj, curi + h - 1, curj + w - 1);
if (cnt != h * w) return false;
for (int i = curi; i < curi + h; i++)
for (int j = curj; j < curj + w; j++) b[i][j] = 0;
while (true) {
if (b[curi + h][curj] == 0 && b[curi][curj + w] == 0) break;
if (b[curi + h][curj] && b[curi][curj + w]) return false;
if (b[curi + h][curj]) {
for (int i = curj; i < curj + w; i++) {
if (!b[curi + h][i]) return false;
b[curi + h][i] = 0;
}
curi++;
} else {
for (int i = curi; i < curi + h; i++) {
if (!b[i][curj + w]) return false;
b[i][curj + w] = 0;
}
curj++;
}
}
int k = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) k += b[i][j];
return k == 0;
}
int main() {
scanf("%d%d\n", &n, &m);
for (int i = 0; i < n; i++) {
getline(cin, second);
for (int j = 0; j < m; j++)
if (second[j] == 'X') a[i][j] = 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
dp[i][j] = a[i][j] + calc(i, j - 1) + calc(i - 1, j) - calc(i - 1, j - 1);
}
isRectangle();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j]) {
dfs(i, j);
for (int i1 = 0; i1 < n; i1++)
for (int j1 = 0; j1 < m; j1++)
if (a[i1][j1] && !used[i1][j1]) {
cout << -1 << endl;
return 0;
}
int h = 0, w = 0;
int t = i;
while (t < n && a[t][j]) {
t++;
h++;
}
t = j;
while (t < m && a[i][t]) {
t++;
w++;
}
int ans = inf;
if (ok(h, w)) ans = min(ans, h * w);
if (ok(1, w)) ans = min(ans, w);
if (ok(h, 1)) ans = min(ans, h);
if (ok(1, 1)) ans = min(ans, 1);
if (i + h < n) {
t = j;
while (t < m && !a[i + h][t]) t++;
if (t < j + w) {
for (int d = -5; d <= 5; d++)
if (ok(h, j + w - t + d)) ans = min(ans, h * (j + w - t + d));
}
}
if (j + w < m) {
t = i;
while (t < n && !a[t][j + w]) t++;
if (t < i + h) {
for (int d = -5; d <= 5; d++)
if (ok(i + h - t + d, w)) ans = min(ans, w * (d + i + h - t));
}
}
if (ans == inf) ans = -1;
cout << ans << endl;
return 0;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
long long P[(200005) >> 1] = {2}, L(1), cn[1 + ((200005) >> 6)];
void gen() {
(cn[0 >> 6] |= 1ULL << ((0 & 63))), (cn[1 >> 6] |= 1ULL << ((1 & 63)));
int Q(1 + sqrt((200005)));
for (long long i(4); i < (200005); i += 2) (cn[i >> 6] |= 1ULL << ((i & 63)));
for (int k(3); k <= Q; k += 2)
if (!((cn[k >> 6] >> (k & 63)) & 1))
for (long long h(k << 1), j(k * k); j < (200005); j += h)
(cn[j >> 6] |= 1ULL << ((j & 63)));
for (int i(3); i < (200005); i += 2)
if (!((cn[i >> 6] >> (i & 63)) & 1)) P[L++] = i;
}
vector<int> g[(200005)];
int N, Q, A[(200005)], B[(200005)], E[(200005)], W[(200005)], a, b, c, C, M;
void dfs(int u, int p) {
B[u] = C, W[C++] = A[u];
for (auto &h : g[u])
if (h ^ p) dfs(h, u);
E[u] = C - 1;
}
bitset<1024> RT(bitset<1024> b, int m) { return b << m | b >> (M - m); }
bitset<1024> y, p;
struct sX {
bitset<1024> G[2 * (200005)];
int N, R[2 * (200005)];
void clr(int u, int B, int E, int n) {
if (B >= n) return;
if (B == E) {
G[u][W[B] % M] = 1;
return;
}
clr(u << 1, B, (B + E) >> 1, n), clr(u << 1 | 1, (B + E) / 2 + 1, E, n);
G[u] = G[u << 1] | G[u << 1 | 1];
}
void ini(int n) {
N = 1 << (int(log2(n) - (1e-10)) + 1);
(memset(R, 0, sizeof(R))), clr(1, 0, N - 1, n);
}
bitset<1024> gt(int u) { return RT(G[u], R[u]); }
void ud(int b, int e, int r) { st(b, e, r, 1, 0, N - 1); }
void st(int b, int e, int r, int u, int B, int E) {
if (B > e || E < b) return;
if (b <= B && e >= E) {
R[u] += r, R[u] %= M;
return;
}
st(b, e, r, u << 1, B, (B + E) >> 1),
st(b, e, r, u << 1 | 1, (B + E) / 2 + 1, E);
G[u] = gt(u << 1) | gt(u << 1 | 1);
}
bitset<1024> gt(int b, int e) { return gt(b, e, 1, 0, N - 1); }
bitset<1024> gt(int b, int e, int u, int B, int E) {
if (B > e || E < b) return y;
if (b <= B && e >= E) return gt(u);
return RT(gt(b, e, u << 1, B, (B + E) >> 1) |
gt(b, e, u << 1 | 1, (B + E) / 2 + 1, E),
R[u]);
}
} T;
int pm(bitset<1024> a) { return (p & a).count(); }
int main(void) {
scanf("%d%d", &N, &M), ga(N, A), gen();
for (int k(2); k < M; k++)
if (!((cn[k >> 6] >> (k & 63)) & 1)) p[k] = 1;
for (int i(0); i < N - 1; i++)
scanf("%d%d", &a, &b), g[--b].push_back(--a), g[a].push_back(b);
dfs(0, -1), T.ini(N);
int Q;
scanf("%d", &Q);
for (int i(0); i < Q; i++) {
scanf("%d%d", &a, &b), --b;
if (a - 1)
printf("%d\n", pm(T.gt(B[b], E[b])));
else
scanf("%d", &c), T.ud(B[b], E[b], c % M);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long cal(string x) {
int ndig = x.length();
if (ndig == 1) return atoll(x.c_str());
long long sol = 0;
if (x[0] == x[ndig - 1]) {
string xx = x;
xx.pop_back();
xx.erase(xx.begin());
if (xx == "") {
int f = x[0] - 48;
sol += f;
} else {
long long x1 = atoll(xx.c_str());
sol += (x1 + 1);
int f = x[0] - 48;
int len = ndig - 2;
sol += (1ll * f - 1) * pow(1ll * 10, len);
len--;
while (len >= 0) {
sol += 9 * (long long)pow(1ll * 10, len);
len--;
}
}
sol += 9;
} else {
long long num = atoll(x.c_str());
while (1) {
string s = to_string(num);
if (s[0] == s[(int)s.length() - 1])
break;
else
num--;
}
return cal(to_string(num));
}
return sol;
}
int main() {
long long l, r;
scanf("%lld", &l);
scanf("%lld", &r);
l--;
cout << cal(to_string(r)) - cal(to_string(l)) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, c = 0;
cin >> a >> b;
while (b) {
c += b % 10;
c *= 10;
b /= 10;
}
cout << a + c / 10;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long l, r;
cin >> l >> r;
long long mask = 0;
for (int i = 0; i < 63; ++i) {
if ((l | (1LL << mask)) <= r) {
l |= (1LL << mask);
++mask;
} else
break;
}
cout << l << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
inline long long d(long long a) { return (a % 9) ? (a % 9) : 9; }
long long cnt[10], n, ansx;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cnt[d(i)]++;
}
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= 9; j++) {
for (int k = 1; k <= 9; k++) {
if (i * j % 9 == k % 9) {
ans += cnt[i] * cnt[j] * cnt[k];
}
}
}
}
for (long long l = 1, r; l <= n; l = r + 1) {
r = min(n, n / (n / l));
ans -= (n / l) * (r - l + 1);
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[5], b[5], aa[5][5];
for (int i = 1; i <= 3; i++) {
scanf("%s", aa[i]);
a[i] = aa[i][0];
b[i] = aa[i][1];
}
if ((a[1] == a[2]) && (a[2] == a[3]) && (b[1] == b[2]) && (b[2] == b[3])) {
printf("0\n");
return 0;
}
if (!(strcmp(aa[1], aa[2])) || !strcmp(aa[2], aa[3]) ||
!strcmp(aa[1], aa[3])) {
printf("1\n");
return 0;
}
int c[5], d[5];
for (int i = 1; i <= 3; i++) {
c[i] = a[i] - 48;
d[i] = a[i] - 48;
}
sort(c + 1, c + 4);
if (((c[3] - c[2]) == 1) && ((c[2] - c[1]) == 1) && (b[1] == b[2]) &&
(b[2] == b[3])) {
printf("0\n");
return 0;
}
if (b[1] == b[2]) {
if ((abs(d[1] - d[2]) == 1) || (abs(d[1] - d[2]) == 2)) {
printf("1\n");
return 0;
}
}
if (b[2] == b[3]) {
if ((abs(d[2] - d[3]) == 1) || (abs(d[3] - d[2]) == 2)) {
printf("1\n");
return 0;
}
}
if (b[1] == b[3]) {
if ((abs(d[1] - d[3]) == 1) || (abs(d[1] - d[3]) == 2)) {
printf("1\n");
return 0;
}
}
printf("2\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
int matr[50][50];
bool cmp(string a, string b) {
if (((int)(a).size()) != ((int)(b).size()))
return ((int)(a).size()) < ((int)(b).size());
return a < b;
}
int x1, y95874, x2, y2;
int d[50][50];
queue<pair<int, int> > q;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int mask;
int good(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m &&
(make_pair(x1, y95874) == make_pair(x, y) ||
make_pair(x2, y2) == make_pair(x, y) ||
((1 << matr[x][y]) & mask) != 0);
}
void parse(pair<int, int> o) {
int x = o.first;
int y = o.second;
int dist = d[x][y];
for (int i = 0; i < (4); i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (good(nx, ny) && d[nx][ny] == -1) {
d[nx][ny] = dist + 1;
q.push(make_pair(nx, ny));
}
}
}
string getans(int mask) {
::mask = mask;
memset(d, -1, sizeof(d));
q.push(make_pair(x2, y2));
d[x2][y2] = 0;
while (!q.empty()) {
parse(q.front());
q.pop();
}
if (d[x1][y95874] == -1) return "-";
int cx = x1, cy = y95874;
string ans = "";
vector<pair<int, int> > v;
v.push_back(make_pair(x1, y95874));
vector<pair<int, int> > tmp;
tmp.reserve(1000);
while (1) {
int dist = d[v[0].first][v[0].second];
if (dist == 1) break;
char bc = 'z' + 1;
for (int o = 0; o < (((int)(v).size())); o++)
for (int i = 0; i < (4); i++) {
int nx = v[o].first + dx[i];
int ny = v[o].second + dy[i];
if (good(nx, ny) && d[nx][ny] == dist - 1) {
if (matr[nx][ny] + 'a' < bc) {
bc = matr[nx][ny] + 'a';
}
}
}
tmp.clear();
for (int o = 0; o < (((int)(v).size())); o++)
for (int i = 0; i < (4); i++) {
int nx = v[o].first + dx[i];
int ny = v[o].second + dy[i];
if (good(nx, ny) && d[nx][ny] == dist - 1) {
if (matr[nx][ny] + 'a' == bc) {
tmp.push_back(make_pair(nx, ny));
}
}
}
sort((tmp).begin(), (tmp).end());
tmp.resize(unique((tmp).begin(), (tmp).end()) - tmp.begin());
ans += bc;
v = tmp;
}
return ans;
}
int main() {
int k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < (n); i++) {
char s[1000];
scanf("%s", s);
for (int j = 0; j < (m); j++) {
matr[i][j] = s[j] - 'a';
if (s[j] == 'S') {
x1 = i;
y95874 = j;
}
if (s[j] == 'T') {
x2 = i;
y2 = j;
}
}
}
vector<int> v;
v.reserve(20000);
for (int i = 0; i < ((1 << 26)); i++) {
if (__builtin_popcount(i) <= k) v.push_back(i);
}
string res = "-";
for (int i = 0; i < (((int)(v).size())); i++) {
string ans = getans(v[i]);
if (ans != "-")
if (res == "-" || cmp(ans, res)) res = ans;
}
if (res == "-")
cout << -1 << endl;
else
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long gc(long long n, int k);
int main() {
long long int t;
cin >> t;
for (long long int j = 0; j < t; j++) {
long long int n, m, k, min = INT64_MAX;
cin >> n >> k;
long long int sum = 0;
int c = (int)log2(k) + 1;
;
for (int i = 0; i <= c; i++) {
long long int z = k - n + 1 - (gc(k + 1, i) - gc(n, i));
if (n != 1 && (z) < min) {
min = z;
} else if (n == 1) {
z = k - gc(k + 1, i);
if ((z) < min) {
min = z;
}
}
}
cout << min << "\n";
}
return 0;
}
long long gc(long long n, int k) {
long long res = (n >> (k + 1)) << k;
if ((n >> k) & 1) res += n & ((1ll << k) - 1);
return res;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
int n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
string s, a, b;
cin >> s;
if (s[4] == 'd') {
string aa = "";
cin >> a >> b;
int cnta = 0;
for (int j = 0; j < a.size(); j++)
if (a[j] != '&' && a[j] != '*')
aa += a[j];
else if (a[j] == '&')
cnta--;
else
cnta++;
if (mp.find(aa) == mp.end() && aa != "void") {
mp[b] = -1;
continue;
}
if (mp.find(b) == mp.end()) mp[b] = 0;
if (aa == "void") {
if (cnta < 0)
mp[b] = -1;
else
mp[b] = cnta;
} else if (mp[aa] < 0)
mp[b] = -1;
else
mp[b] = mp[aa] + cnta;
} else {
cin >> a;
string aa = "";
int cnta = 0;
for (int j = 0; j < a.size(); j++)
if (a[j] != '&' && a[j] != '*')
aa += a[j];
else if (a[j] == '&')
cnta--;
else
cnta++;
if (mp.find(aa) == mp.end() && aa != "void")
cout << "errtype" << endl;
else if (mp[aa] < 0)
cout << "errtype" << endl;
else if (mp[aa] + cnta < 0)
cout << "errtype" << endl;
else {
cout << "void";
for (int j = 0; j < mp[aa] + cnta; j++) cout << "*";
cout << endl;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<int, int>, pair<int, int> > > by;
vector<pair<int, int> > Bn, Sn;
int n, m, w;
multiset<int> bigs, sms;
long long bn[300005], sn[300005];
int pb[300005], ps[300005];
long long bC[300005], sC[300005];
long long ans;
int point, ad;
int way[300005];
void modify(long long a[], int x, int dx, int up) {
for (x++; x < up; x += x & (-x)) a[x] += dx;
}
long long getsum(long long a[], int x) {
long long res = 0;
for (x++; x; x -= x & (-x)) res += a[x];
return res;
}
long long figure(int s, int d, int start) {
if (start + 1 < d || (int)by.size() - start - 1 + 2 * d < s) return -1;
int l = 0, r = n, mk;
while (r >= l) {
int m = (l + r) >> 1;
if (getsum(bn, m) >= d)
mk = m, r = m - 1;
else
l = m + 1;
}
long long sum = getsum(bC, mk);
l = 0, r = n;
d = w - 2 * d;
while (r >= l) {
int m = (l + r) >> 1;
if (getsum(sn, m) >= d)
mk = m, r = m - 1;
else
l = m + 1;
}
sum += getsum(sC, mk);
return sum;
}
void bigdel(int k) {
bigs.erase(bigs.find(by[k].second.second));
modify(bn, pb[k], -1, n + 2);
modify(bC, pb[k], -by[k].second.second, n + 2);
}
void sminsert(int k) {
sms.insert(by[k].second.first);
modify(sn, ps[k], 1, n + 2);
modify(sC, ps[k], by[k].second.first, n + 2);
}
int main() {
scanf("%d%d", &n, &w);
for (int i = 1; i <= n; i++) {
int a, b;
scanf("%d%d", &a, &b);
by.push_back(pair<pair<int, int>, pair<int, int> >(pair<int, int>(b - a, i),
pair<int, int>(a, b)));
ans += b;
}
sort(by.begin(), by.end());
for (int i = 0; i < by.size(); i++) {
Sn.push_back(pair<int, int>(by[i].second.first, i));
Bn.push_back(pair<int, int>(by[i].second.second, i));
}
sort(Bn.begin(), Bn.end());
for (int i = 0; i < Bn.size(); i++) pb[Bn[i].second] = i;
sort(Sn.begin(), Sn.end());
for (int i = 0; i < Sn.size(); i++) ps[Sn[i].second] = i;
for (int i = 0; i < by.size(); i++) {
bigs.insert(by[i].second.second);
modify(bn, pb[i], 1, n + 2);
modify(bC, pb[i], by[i].second.second, n + 2);
}
int start = by.size() - 1, doub = w >> 1;
for (int i = start; i >= -1; i--) {
int tmp = doub;
long long t1 = figure(w, tmp - 1, i);
long long t2 = figure(w, tmp, i);
if (t1 > 0 && t1 <= ans) ans = t1, doub = tmp - 1, point = i;
if (t2 > 0 && t2 <= ans) ans = t2, doub = tmp, point = i;
if (i >= 0) {
bigdel(i);
sminsert(i);
}
}
cout << ans << endl;
Bn.clear();
for (int i = 0; i <= point; i++)
Bn.push_back(pair<int, int>(by[i].second.second, by[i].first.second));
sort(Bn.begin(), Bn.end());
for (int i = 0; i < doub; i++) way[Bn[i].second] = 2;
Bn.clear();
for (int i = point + 1; i < by.size(); i++)
Bn.push_back(pair<int, int>(by[i].second.first, by[i].first.second));
sort(Bn.begin(), Bn.end());
for (int i = 0; i < w - 2 * doub; i++) way[Bn[i].second] = 1;
for (int i = 1; i <= n; i++) cout << way[i];
cout << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
vector<int> graph[102], myvec, myvec2;
vector<int>::iterator it2;
map<int, int> m1;
map<int, int>::iterator it;
bool vis[102] = {false};
int bfs(int start) {
queue<int> q;
q.push(start);
int c = 0;
while (!q.empty()) {
c++;
int u = q.front();
q.pop();
vis[u] = true;
for (int i = 0; i < graph[u].size(); i++) {
if (vis[graph[u][i]] == false) q.push(graph[u][i]);
}
}
return c;
}
int main() {
int x, n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
graph[i].push_back(x);
m1[x] = 1;
}
int f = 0;
for (int i = 1; i <= n; i++) {
if (m1[i] == 0) f = 1;
}
if (f == 1)
cout << "-1" << endl;
else {
int num;
long long int ans = 1;
for (int i = 1; i <= n; i++) {
if (vis[i] == false) {
num = bfs(i);
if (num % 2 == 0)
ans = (ans * (num / 2)) / gcd(ans, num / 2);
else
ans = (ans * num) / gcd(ans, num);
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, t;
int main() {
cin >> n >> m;
k = n / m;
t = n % m;
for (int i = 1; i <= t; i++) cout << k + 1 << " ";
for (int i = t; i < m; i++) cout << k << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[100005], dpac[100005], N;
int sz, here[100005];
int mex(int sz) {
sort(here, here + sz);
sz = unique(here, here + sz) - here;
int lo = -1, hi = sz, mid;
while (hi - lo > 1) {
mid = (lo + hi) / 2;
if (mid != here[mid])
hi = mid;
else
lo = mid;
}
return hi;
}
int main() {
cin >> N;
int ans;
for (int n = 3; n <= N; n++) {
ans = 1 << 30;
sz = 0;
for (int j = 2; j * j <= 2 * n; j++)
if (2 * n % j == 0) {
int k = j, a;
if ((2 * n - k * k + k) % (2 * k) == 0) {
a = (2 * n - k * k + k) / (2 * k);
if (a > 0) {
here[sz++] = dpac[a + k - 1] ^ dpac[a - 1];
if (here[sz - 1] == 0) ans = min(ans, k);
}
}
k = (2 * n) / j;
if ((2 * n - k * k + k) % (2 * k) == 0) {
a = (2 * n - k * k + k) / (2 * k);
if (a > 0) {
here[sz++] = dpac[a + k - 1] ^ dpac[a - 1];
if (here[sz - 1] == 0) ans = min(ans, k);
}
}
}
dp[n] = mex(sz);
dpac[n] = dpac[n - 1] ^ dp[n];
}
if (dp[N]) {
cout << ans << endl;
} else {
cout << -1 << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1450, mod = 1000000009, INF = 1e8;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
string s;
cin >> s;
int x = s.size() + 20;
int arr[3][x];
memset(arr, 0, sizeof arr);
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < 3; ++j) {
if (s[i] - 'a' != j) ++arr[j][i];
arr[j][i] += arr[j][i + 3];
}
}
string str[6] = {"abc", "acb", "bac", "bca", "cab", "cba"};
int l, r;
while (m--) {
cin >> l >> r;
--l, --r;
if (r - l + 1 == 1) {
cout << 0 << "\n";
} else if (r - l + 1 == 2) {
if (s[l] == s[r])
cout << 1 << "\n";
else
cout << 0 << "\n";
} else {
int x = (r - l) / 3;
x = l + 3 * x + 3;
++l;
int y = (r - l) / 3;
y = l + 3 * y + 3;
++l;
int z = (r - l) / 3;
z = l + 3 * z + 3;
int ans = 1e9;
l -= 2;
for (int i = 0; i < 6; ++i) {
int tmp1 = arr[str[i][0] - 'a'][l] - arr[str[i][0] - 'a'][x];
int tmp2 = arr[str[i][1] - 'a'][l + 1] - arr[str[i][1] - 'a'][y];
int tmp3 = arr[str[i][2] - 'a'][l + 2] - arr[str[i][2] - 'a'][z];
ans = min(ans, tmp1 + tmp2 + tmp3);
}
cout << ans << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 400555, log_n = 32, max_m = 111, mod = 1000000007,
inf = 1111111111;
int n, m, used[max_n], tin[max_n], fout[max_n], privet5, vertex[max_n], k,
used1[max_n], ptr[max_n], used_ind[max_n];
vector<pair<int, int> > v[max_n];
vector<pair<pair<int, int>, pair<int, int> > > v1[max_n];
vector<pair<int, int> > bridge[max_n];
pair<int, int> res[max_n];
void dfs(int x, int p) {
tin[x] = fout[x] = privet5++;
used[x] = 1;
int p1;
for (int i = 0; i < v[x].size(); ++i) {
int to = v[x][i].first;
if (to == p) {
p1 = i;
continue;
}
if (used[to])
fout[x] = min(fout[x], tin[to]);
else {
dfs(to, x);
fout[x] = min(fout[x], fout[to]);
if (fout[to] > tin[x]) {
bridge[x].push_back(v[x][i]);
used_ind[v[x][i].second] = 1;
}
}
}
if (fout[x] > tin[p]) {
bridge[x].push_back(v[x][p1]);
}
}
void dfs1(int x, int k) {
if (!used[x]) {
ptr[x] = k;
vertex[k]++;
for (int i = 0; i < bridge[x].size(); ++i) {
v1[k].push_back(
make_pair(bridge[x][i], make_pair(bridge[x][i].first, x)));
}
}
used[x] = 1;
while (v[x].size()) {
pair<int, int> g = v[x].back();
v[x].pop_back();
int to = g.first;
if (used_ind[g.second]) {
continue;
}
used_ind[g.second] = 1;
res[g.second] = make_pair(x, to);
dfs1(to, k);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int g, h;
scanf("%d%d", &g, &h);
g--;
h--;
v[g].push_back(make_pair(h, i));
v[h].push_back(make_pair(g, i));
}
dfs(0, -1);
for (int i = 0; i < n; ++i) used[i] = 0;
for (int i = 0; i < n; ++i)
if (!used[i]) {
dfs1(i, k++);
}
for (int i = 0; i < k; ++i) {
for (int q = 0; q < v1[i].size(); ++q) {
v1[i][q].first.first = ptr[v1[i][q].first.first];
}
}
set<pair<int, int> > s;
for (int i = 0; i < k; ++i) s.insert(make_pair(vertex[i], i));
int ans = inf;
while (s.size()) {
pair<int, int> g = *s.rbegin();
s.erase(g);
used1[g.second] = 1;
ans = min(ans, g.first);
for (int i = 0; i < v1[g.second].size(); ++i) {
int to = v1[g.second][i].first.first;
if (!used1[to]) {
int ind = v1[g.second][i].first.second;
res[ind] = v1[g.second][i].second;
s.erase(make_pair(vertex[to], to));
vertex[to] += g.first;
s.insert(make_pair(vertex[to], to));
}
}
}
cout << ans << "\n";
for (int i = 0; i < m; ++i)
printf("%d %d\n", res[i].first + 1, res[i].second + 1);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
int p = n / 2 - 1;
while (p > 0 && v[p] == v[p + 1]) {
p--;
}
int g = 1;
int b = 1;
while (g < p && v[g] == v[g - 1]) {
g++;
}
p--;
while (p > 0 && v[p] == v[p + 1] || b <= g) {
b++;
p--;
}
int s = p - g + 1;
if (p < g || g >= s || g >= b) {
cout << "0 0 0\n";
} else {
cout << g << " " << s << " " << b << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
cout << fixed;
cout << setprecision(8);
double mn = 1000000.0;
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
cout << fixed;
cout << setprecision(8);
double x = (double)a / b;
x *= (double)m;
mn = min(mn, x);
}
cout << mn << "\n";
}
signed main() {
mt19937_64 rnd(chrono::system_clock::now().time_since_epoch().count());
ios_base ::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> ar(n);
vector<bool> c(n, 0);
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
for (int i = 0; i < n; i++) {
if (c[((i + ar[i]) % n + n) % n]) {
cout << "NO\n";
return;
}
c[((i + ar[i]) % n + n) % n] = 1;
}
cout << "YES\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
bool isSubsequence(string s, string t) {
int index = 0;
if (s.length() == 0) {
return true;
}
for (int i = 0; i < t.length(); i++) {
if (s.at(index) == t.at(i)) {
index++;
}
if (index == s.length()) {
return true;
}
}
return false;
}
bool isPrime(int n) {
for (int i = 2; i < int(sqrt(n)) + 1; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
bool distinctDigits(int n) {
string s = to_string(n);
for (int i = 0; i < s.length(); i++) {
for (int j = i + 1; j < s.length(); j++) {
if (s.at(i) == s.at(j)) {
return false;
}
}
}
return true;
}
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
while (a.size()) {
int curr = *min_element(a.begin(), a.end());
for (int i = a.size() - 1; i > -1; i--) {
if (a[i] % curr == 0) {
a.erase(a.begin() + i);
}
}
ans += 1;
}
cout << ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
cout.flush();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
const int MX = 101000;
vector<pair<int, pair<int, long long> > > store[MX];
int a[MX];
long long f(int val, int in) {
auto it = distance(store[in].begin(),
upper_bound(store[in].begin(), store[in].end(),
pair<int, pair<int, long long> >(
val, pair<int, long long>(inf, inf))));
long long ret = 0;
if (it != store[in].size()) {
if (it - 1 >= 0) {
ret =
store[in].back().second.second - store[in][it - 1].second.second -
1LL *
(store[in].back().second.first - store[in][it - 1].second.first) *
val;
} else {
ret = store[in].back().second.second -
1LL * store[in].back().second.first * val;
}
}
--it;
;
;
if (it < 0) return ret;
ret += 1LL * store[in][it].second.first * val - store[in][it].second.second;
return ret;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> m >> n;
long long ans = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (i - 1 >= 0) ans += abs(a[i] - a[i - 1]);
}
int num = 1;
for (int i = 1, j = 1; i < n; ++i) {
if (a[i] != a[j - 1]) {
a[j++] = a[i];
};
num = j;
}
n = num;
;
for (int i = 0; i < n - 1; ++i) {
store[a[i]].push_back(
pair<int, pair<int, long long> >(a[i + 1], pair<int, long long>(1, 0)));
store[a[i + 1]].push_back(
pair<int, pair<int, long long> >(a[i], pair<int, long long>(1, 0)));
}
long long tot = ans;
for (int i = 1; i <= m; ++i) {
;
if (store[i].empty()) continue;
sort(store[i].begin(), store[i].end());
int len = 1;
for (int j = 1, k = 1; j < store[i].size(); ++j) {
if (store[i][j].first == store[i][k - 1].first)
store[i][k - 1].second.first++;
else {
store[i][k++] = store[i][j];
}
len = k;
}
store[i].erase(store[i].begin() + len, store[i].end());
;
for (int j = 0; j < store[i].size(); ++j) {
store[i][j].second.second =
1LL * store[i][j].first * store[i][j].second.first;
if (j - 1 >= 0) {
store[i][j].second.first += store[i][j - 1].second.first;
store[i][j].second.second += store[i][j - 1].second.second;
}
};
int low = 1, high = m;
while (low < high) {
;
int mid = (low + high) / 2;
if (f(mid, i) < f(mid + 1, i))
high = mid;
else
low = mid + 1;
};
;
ans = min(ans, tot - f(i, i) + f(low, i));
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[1005][1005], r, c;
long long slin, scol, splin, spcol, se, rez[1005][1005], aux[10], nrsm, nr, nrv;
struct ceva {
long long i, j;
} v[1000005];
int expon(long long a, long long b) {
long long rez = 1;
while (b != 0) {
if (b & 1) {
rez *= a;
rez %= 998244353;
}
b = b >> 1;
a = a * a;
a %= 998244353;
}
return rez;
}
int inv(int x) { return expon(x, 998244353 - 2); }
bool cmp(ceva x, ceva y) { return a[x.i][x.j] < a[y.i][y.j]; }
int main() {
int i, j, A, B;
long long val, VAL;
std::ios::sync_with_stdio(false);
cin >> n >> m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) cin >> a[i][j];
cin >> r >> c;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (a[i][j] <= a[r][c]) {
nrv++;
v[nrv].i = i;
v[nrv].j = j;
}
sort(v + 1, v + nrv + 1, cmp);
for (A = 1; A <= nrv;) {
VAL = a[v[A].i][v[A].j];
aux[1] = 0;
aux[2] = 0;
aux[3] = 0;
aux[4] = 0;
aux[5] = 0;
nr = 0;
long long invmod = inv(nrsm);
B = A;
while ((B <= nrv) && (a[v[B].i][v[B].j] == VAL)) {
i = v[B].i;
j = v[B].j;
val = se + splin + spcol - 2LL * i * slin - 2LL * j * scol;
while (val < 0) val += 998244353;
val %= 998244353;
if (nrsm != 0)
rez[i][j] = ((i * i + j * j) % 998244353 + (val * invmod) % 998244353) %
998244353;
aux[1] += i;
aux[2] += j;
aux[3] += i * i;
aux[4] += j * j;
aux[5] += rez[i][j];
nr++;
aux[1] %= 998244353;
aux[2] %= 998244353;
aux[3] %= 998244353;
aux[4] %= 998244353;
aux[5] %= 998244353;
B++;
}
if (rez[r][c] != 0) {
cout << rez[r][c];
return 0;
}
slin += aux[1];
scol += aux[2];
splin += aux[3];
spcol += aux[4];
se += aux[5];
nrsm += nr;
slin %= 998244353;
scol %= 998244353;
splin %= 998244353;
spcol %= 998244353;
se %= 998244353;
nrsm %= 998244353;
A = B;
}
cout << rez[r][c];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
void runCase(int caseNum) {
int n;
cin >> n;
vector<int> nums(n, -1);
vector<char> taken(n + 1, 0);
for (int i = 0; i < n; ++i) {
cin >> nums[i];
if (nums[i] >= 0) taken[nums[i]] = 1;
}
int all = 0, free = 0;
for (int i = 0; i < n; ++i) {
if (nums[i] < 0) {
++all;
if (taken[i + 1]) ++free;
}
}
int d = -1;
if (((all - free) & 1) == 0) d = 1;
long long res = 1;
for (int i = 1; i <= all; ++i) {
res *= i;
if (res >= MOD) res %= MOD;
}
for (int i = free; i < all; ++i) {
long long cur = 1;
int m = i - free;
for (int j = m + 1; j <= i; ++j) {
cur *= j;
if (cur >= MOD) cur %= MOD;
}
for (int j = all - free - m + 1; j <= all - free; ++j) {
cur *= j;
if (cur >= MOD) cur %= MOD;
}
cur *= d;
d *= -1;
res += cur;
if (res >= MOD) res %= MOD;
}
while (res < 0) res += MOD;
res %= MOD;
cout << res << endl;
}
int main(int argc, char* argv[]) {
runCase(0);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
void solve() {
string s;
cin >> s;
int n = s.size(), ans = 0;
s = ' ' + s;
for (int i = 1; i <= n; ++i) {
char x = s[i];
while (s[i] == x and i <= n) ++i;
--i;
if (x == '0') ++ans;
}
cout << min(2, ans) << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, ans = 0;
cin >> n;
long long int A[n + 1];
for (int i = 0; i < n; i++) cin >> A[i];
sort(A, A + n);
for (int i = 0; i < n; i++) {
long long int h = A[i] * (i + 1);
ans += h;
}
for (int i = 0; i < (n - 1); i++) {
ans += A[i];
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool dif = 0;
int n, m;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> m;
if (m == 1) dif = 1;
}
if (dif == 1)
cout << "HARD";
else
cout << "EASY";
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.