solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long nod(long long a, long long b) {
while (a && b) {
if (a > b)
a %= b;
else
b %= a;
}
return a + b;
}
unsigned long long when1[1048576];
unsigned long long when2[1048576];
int main() {
memset(when1, -1, sizeof(when1));
memset(when2, -1, sizeof(when2));
long long mod;
cin >> mod;
long long height1, need1;
long long x1, y1;
long long height2, need2;
long long x2, y2;
cin >> height1 >> need1;
cin >> x1 >> y1;
cin >> height2 >> need2;
cin >> x2 >> y2;
when1[height1] = 0;
when2[height2] = 0;
while (height1 != need1) {
long long lastheight = height1;
height1 *= x1;
height1 += y1;
height1 %= mod;
if (when1[height1] != -1) {
cout << -1 << endl;
return 0;
}
when1[height1] = when1[lastheight] + 1;
}
while (height2 != need2) {
long long lastheight = height2;
height2 *= x2;
height2 += y2;
height2 %= mod;
if (when2[height2] != -1) {
cout << -1 << endl;
return 0;
}
when2[height2] = when2[lastheight] + 1;
}
long long moment1 = when1[need1];
long long moment2 = when2[need2];
memset(when1, -1, sizeof(when1));
memset(when2, -1, sizeof(when2));
when1[need1] = 0;
when2[need2] = 0;
bool cycle1 = true;
bool cycle2 = true;
if (moment1 == moment2) {
cout << moment1 << endl;
return 0;
}
do {
long long lastheight = height1;
height1 *= x1;
height1 += y1;
height1 %= mod;
if (height1 != need1 && when1[height1] != -1) {
cycle1 = false;
break;
}
when1[height1] = when1[lastheight] + 1;
} while (height1 != need1);
long long speed1 = when1[need1];
do {
long long lastheight = height2;
height2 *= x2;
height2 += y2;
height2 %= mod;
if (height2 != need2 && when2[height2] != -1) {
cycle2 = false;
break;
}
when2[height2] = when2[lastheight] + 1;
} while (height2 != need2);
long long speed2 = when2[need2];
if (!cycle1 && !cycle2) {
cout << -1 << endl;
return 0;
}
if (cycle1 && !cycle2) {
if (moment1 < moment2) {
int DifferenceMoment = moment2 - moment1;
if (DifferenceMoment % speed1 == 0) {
cout << moment2 << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
if (!cycle1 && cycle2) {
if (moment1 > moment2) {
int DifferenceMoment = moment1 - moment2;
if (DifferenceMoment % speed2 == 0) {
cout << moment1 << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
long long difference = moment1 - moment2;
if (difference % nod(speed1, speed2)) {
cout << -1 << endl;
return 0;
}
while (moment1 != moment2) {
if (moment1 < moment2)
moment1 += speed1;
else
moment2 += speed2;
}
cout << moment1 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
char a[101];
scanf("%s", a);
int i;
int n = 101;
while (n > 0) {
for (i = 0; a[i + 2] != '\0'; i++) {
if (i % 2 == 0) {
char temp;
if (a[i] > a[i + 2]) {
temp = a[i];
a[i] = a[i + 2];
a[i + 2] = temp;
}
}
}
n--;
}
for (i = 0; a[i] != '\0'; i++) {
printf("%c", a[i]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using INT = long long;
const int NN = 100100;
int fl[27];
int calc(INT st, INT ed, INT p, int a, int b) {
if (p < 20) {
memset(fl, 0, sizeof fl);
fl[p] = a;
fl[p - 1] = b;
for (int i = p - 2; i > p / 2; i--) {
if ((p - i) % 2 == 0)
fl[i] = a;
else
fl[i] = b;
}
for (int i = p / 2; i; i--) {
fl[i] |= 3 ^ fl[i + 1];
if (i * 2 <= ed)
fl[i] |= 3 ^ fl[i * 2];
else
fl[i] |= 1;
}
return fl[st];
}
if (st > p / 2) {
if ((p - st) % 2 == 0) return a;
return b;
}
INT mx = p / 2 + 1;
int v;
if ((p - mx) % 2 == 0)
v = a;
else
v = b;
int val = 0, VAL = 0;
val |= 3 ^ v;
if (p % 2 == 0)
val |= 3 ^ a;
else
val |= 3 ^ b;
VAL |= 3 ^ val;
if (p % 2 == 0)
VAL |= 3 ^ a;
else
VAL |= 3 ^ b;
return calc(st, ed, p / 2, val, VAL);
}
INT a[NN], b[NN], ret[NN];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%I64d%I64d", a + i, b + i);
for (int i = 1; i <= n; i++) {
if (a[i] == b[i]) {
ret[i] = 1;
continue;
}
if (b[i] == 2) {
ret[i] = 2;
continue;
}
ret[i] = calc(a[i], b[i], b[i], 1, 3);
}
int val = 1;
for (int i = 1; i <= n; i++) {
int VAL = 0;
if (val & 1) VAL |= ret[i];
if (val & 2) VAL |= 3 ^ ret[i];
val = VAL;
}
if (val & 2)
cout << 1 << ' ';
else
cout << 0 << ' ';
cout << (val & 1) << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> adj[1005];
long long arr[1005][1005], dep[1005][1005];
long long w[1005];
long long n, m, x, y;
void djikstras(long long so, long long d, long long arr[], long long dep[]) {
for (long long i = 1; i <= n; i++) {
arr[i] = 1e16;
dep[i] = 1e16;
}
arr[so] = 0;
set<pair<long long, long long>> s;
s.insert({0, so});
while (!s.empty()) {
auto x = *(s.begin());
s.erase(x);
dep[x.second] = arr[x.second];
for (auto it : adj[x.second]) {
if (arr[it.first] > dep[x.second] + it.second) {
s.erase({arr[it.first], it.first});
arr[it.first] = dep[x.second] + it.second;
s.insert({arr[it.first], it.first});
}
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long s;
cin >> n >> m >> x >> y;
for (long long i = 1; i <= m; i++) {
long long a, b, c;
cin >> a >> b >> w[i];
adj[a].push_back({b, w[i]});
adj[b].push_back({a, w[i]});
}
for (long long i = 1; i <= n; i++) djikstras(i, i, arr[i], dep[i]);
for (long long i = 1; i <= n; i++) adj[i].clear();
for (long long i = 1; i <= n; i++) {
long long p, q;
cin >> p >> q;
for (long long j = 1; j <= n; j++) {
if (dep[i][j] <= p) {
adj[i].push_back({j, q});
}
}
}
djikstras(x, x, arr[0], dep[0]);
if (arr[0][y] >= 1e16)
cout << "-1";
else
cout << arr[0][y] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int index, val, st;
bool operator<(const node no) const {
return val > no.val || (val == no.val && index > no.index);
}
} no[200005];
int n, m, l, r, idx, ma, cnt = 1;
int a[200005], b[200005];
int ri[200005], t[200005];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i], b[i] = a[i];
for (int i = 1; i <= m; i++) {
cin >> no[i].st >> no[i].val;
no[i].index = i;
if (ma < no[i].val) ma = no[i].val;
}
sort(b + 1, b + ma + 1);
sort(no + 1, no + m + 1);
l = 1;
r = idx = ma;
ma = no[1].index;
ri[1] = no[1].val;
t[1] = no[1].st;
for (int i = 2; i <= m; i++) {
if (no[i].index < ma) continue;
ma = no[i].index;
ri[++cnt] = no[i].val;
t[cnt] = no[i].st;
}
for (int i = 1; i <= cnt; i++) {
int num = ri[i] - ri[i + 1], st = t[i];
if (st == 1)
while (num--) a[idx--] = b[r--];
else
while (num--) a[idx--] = b[l++];
}
for (int i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int64_t seed;
mt19937 rng(seed = chrono::steady_clock::now().time_since_epoch().count());
inline int64_t rnd(int64_t l = 0, int64_t r = numeric_limits<int64_t>::max()) {
return uniform_int_distribution<int64_t>(l, r)(rng);
}
template <typename T, typename G>
ostream& operator<<(ostream& out, const pair<T, G>& a) {
return out << "( " << a.first << ", " << a.second << ")";
}
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
out << "[ ";
for (const auto& i : a) out << i << ", ";
return out << "]" << endl;
}
template <typename T>
ostream& operator<<(ostream& out, const set<T>& a) {
out << "{ ";
for (const auto& i : a) out << i << ", ";
return out << "}" << endl;
}
template <typename T, typename G>
ostream& operator<<(ostream& out, const map<T, G>& a) {
out << "< ";
for (const auto& i : a) out << i << ", ";
return out << ">" << endl;
}
template <typename T, size_t N>
typename enable_if<!is_same<typename remove_cv<T>::type, char>::value,
ostream&>::type
operator<<(ostream& out, T (&a)[N]) {
out << "[ ";
for (const auto& i : a) out << i << ", ";
return out << "]" << endl;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << (H) << ' ';
debug_out(T...);
}
const int64_t inf = 2e15;
vector<vector<int64_t> > a;
vector<vector<vector<int64_t> > > dp, vis;
int64_t calc(int64_t row, int64_t col, int64_t zigzag) {
if (col == a[0].size()) {
if (row == 2) return 0;
return -inf;
}
int64_t& val = dp[row][col][zigzag];
if (vis[row][col][zigzag]) return val;
vis[row][col][zigzag] = 1;
int64_t col_sum = a[0][col] + a[1][col] + a[2][col];
if (zigzag) {
val = max(val, calc(row, col + 1, 1) + col_sum);
if (row == 0) {
for (int64_t i = 0, sum = 0; i < 3; ++i) {
sum += a[i][col];
val = max(val, calc(i, col + 1, 0) + sum);
}
} else {
for (int64_t i = 2, sum = 0; i >= 0; --i) {
sum += a[i][col];
val = max(val, calc(i, col + 1, 0) + sum);
}
}
return val;
}
if (row == 0) {
for (int64_t i = 0, sum = 0; i < 3; ++i) {
sum += a[i][col];
val = max(val, calc(i, col + 1, 0) + sum);
}
} else if (row == 2) {
for (int64_t i = 2, sum = 0; i >= 0; --i) {
sum += a[i][col];
val = max(val, calc(i, col + 1, 0) + sum);
}
} else {
val = max(val, calc(0, col + 1, 0) + a[1][col] + a[0][col]);
val = max(val, calc(1, col + 1, 0) + a[1][col]);
val = max(val, calc(2, col + 1, 0) + a[1][col] + a[2][col]);
return val;
}
val = max(val, calc(2 - row, col + 1, 1) + col_sum);
return val;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int64_t n;
cin >> n;
a.assign(3, vector<int64_t>(n));
dp.assign(3, vector<vector<int64_t> >(n, vector<int64_t>(2, -inf)));
vis.assign(3, vector<vector<int64_t> >(n, vector<int64_t>(2, 0)));
for (int64_t i = 0; i < 3; ++i)
for (int64_t j = 0; j < n; ++j) cin >> a[i][j];
cout << calc(0, 0, 0) << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8, inf = 1e5;
inline int read() {
int ans = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') f = ch == '-' ? -1 : f, ch = getchar();
while (ch >= '0' && ch <= '9')
ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
return ans * f;
}
inline int sgn(double x) {
if (fabs(x) < eps) return 0;
if (x > eps) return 1;
return -1;
}
struct pot {
double x, y;
pot() {}
pot(double _x, double _y) : x(_x), y(_y) {}
inline friend pot operator+(const pot &a, const pot &b) {
return (pot){a.x + b.x, a.y + b.y};
}
inline friend pot operator-(const pot &a, const pot &b) {
return (pot){a.x - b.x, a.y - b.y};
}
inline friend double operator*(const pot &a, const pot &b) {
return a.x * b.y - a.y * b.x;
}
inline friend bool operator==(const pot &a, const pot &b) {
return !sgn(a.x - b.x) && !sgn(a.y - b.y);
}
inline friend double operator&(const pot &a, const pot &b) {
return a.x * b.x + a.y * b.y;
}
inline friend pot operator/(const pot &a, double t) {
return (pot){a.x / t, a.y / t};
}
inline friend pot operator*(const pot &a, double t) {
return (pot){a.x * t, a.y * t};
}
inline double norm() { return sqrt(x * x + y * y); }
};
struct vec {
pot a, b;
};
pot p[310];
vec t[610];
vec h[310];
int n, m, k, m1, k1;
int cnt, last;
int q[610], id[610];
pot g[610], ans[2];
inline bool onsegment(const pot &a, const pot &b, const pot &c) {
if (sgn((b - a) * (c - a))) return 0;
if (sgn(a.x - b.x) * sgn(a.x - c.x) > 0 ||
sgn(a.y - b.y) * sgn(a.y - c.y) > 0)
return 0;
return 1;
}
inline pot cross(const vec &a, const vec &b) {
pot da = a.b - a.a, db = b.b - b.a, dc = b.a - a.a;
if (!sgn(da * db)) {
if (sgn(da.x) == sgn(db.x))
return (pot){inf, 1};
else
return (pot){inf, -1};
}
double t = (db * dc) / (db * da);
return a.a + (da * t);
}
inline bool cmp(int x, int y) {
double t1 = atan2((t[x].b - t[x].a).y, (t[x].b - t[x].a).x),
t2 = atan2((t[y].b - t[y].a).y, (t[y].b - t[y].a).x);
if (fabs(t1 - t2) > eps) return t1 < t2;
return (t[x].b - t[x].a) * (t[y].a - t[x].a) < -eps;
}
inline double planemeet(int cas) {
for (int i = 0; i < cnt; i++) id[i] = i;
m = 0, k = 0;
q[++m] = id[0];
m1 = 1, k1 = 1;
for (int i = 1; i < cnt; i++) {
int v = id[i];
while (k1 <= k && (t[v].b - t[v].a) * (g[k] - t[v].a) <= 0) m--, k--;
while (k1 <= k && (t[v].b - t[v].a) * (g[k1] - t[v].a) <= 0) m1++, k1++;
g[++k] = cross(t[q[m]], t[v]);
if (fabs(g[k].x - inf) < eps) {
if (g[k].y == -1) return 0;
k--;
continue;
}
q[++m] = v;
}
while (k1 < k && (t[q[m1]].b - t[q[m1]].a) * (g[k] - t[q[m1]].a) <= 0)
m--, k--;
if (k1 == k) return 0;
ans[cas] = g[k];
return 1;
}
bool check(int dl, int dr, int cas) {
if (dl == dr) {
ans[cas] = p[dr];
return 1;
}
if ((p[dl + 1] - p[dl]) * (p[dr + 1] - p[dr]) <= 0) return 0;
if (dl > dr) dr += n;
cnt = 0;
for (int i = dl; i <= dr; i++) t[cnt++] = h[i % n];
for (int i = dl; i <= dr; i++) t[cnt++] = (vec){p[i % n], p[(i + 1) % n]};
return planemeet(cas);
}
bool check(double x) {
last = 2;
ans[0] = p[2];
for (int i = 0; i <= n; i++) {
pot da = p[i + 1] - p[i], fa = (pot){-da.y, da.x};
fa = fa / fa.norm() * x;
h[i] = (vec){p[i + 1] + fa, p[i] + fa};
}
for (int i = 1; i <= n; i++) {
while (i != last + 1 && check(i, last + 1, 0)) last = (last + 1) % n;
if (check(last + 1, i - 1, 1)) return 1;
}
return 0;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) p[i].x = read(), p[i].y = read();
p[0] = p[n];
p[n + 1] = p[1];
double l = 0, r = inf;
while (sgn(r - l)) {
double mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%.10f\n", r);
check(r);
printf("%.10f %.10f\n", ans[0].x, ans[0].y);
printf("%.10f %.10f\n", ans[1].x, ans[1].y);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct node {
char c;
node *child[26];
bool win;
bool lose;
};
node *trie;
string s;
int len;
void printTree(node **t, int d) {
if (!(*t)) return;
for (int i = 0; i < d * 4; i++) printf(" ");
printf("%c,w=%d,l=%d\n", (*t)->c, (*t)->win, (*t)->lose);
for (int i = 0; i < 26; i++) {
if ((*t)->child[i]) {
printTree(&((*t)->child[i]), d + 1);
} else {
break;
}
}
}
void createTrie(node **t, int curp) {
for (int i = 0; i < 26; i++) {
if ((*t)->child[i] == NULL) {
(*t)->child[i] = new node;
for (int j = 0; j < 26; j++) {
(*t)->child[i]->child[j] = NULL;
}
(*t)->child[i]->lose = false;
(*t)->child[i]->win = false;
(*t)->child[i]->c = s[curp];
if (curp + 1 == len) {
(*t)->child[i]->lose = true;
(*t)->child[i]->win = false;
return;
}
createTrie(&((*t)->child[i]), curp + 1);
break;
}
if ((*t)->child[i]->c == s[curp]) {
if (curp + 1 == len) {
(*t)->child[i]->lose = true;
(*t)->child[i]->win = false;
return;
}
createTrie(&((*t)->child[i]), curp + 1);
break;
}
}
}
void searchTree(node **t) {
if (!(*t)) return;
if (!(*t)->child[0]) return;
bool w = false;
bool l = false;
for (int i = 0; i < 26; i++) {
if ((*t)->child[i]) {
searchTree(&((*t)->child[i]));
w |= !((*t)->child[i]->win);
l |= !((*t)->child[i]->lose);
} else
break;
}
(*t)->win = w;
(*t)->lose = l;
}
int main() {
int n, k;
trie = new node;
trie->c = 't';
for (int i = 0; i < 26; i++) {
trie->child[i] = NULL;
}
trie->win = false;
trie->lose = false;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> s;
len = s.size();
createTrie(&trie, 0);
}
searchTree(&trie);
if (trie->win && trie->lose) {
printf("First\n");
} else if (trie->win && !trie->lose) {
if (k % 2 == 1)
printf("First\n");
else
printf("Second\n");
} else if (!trie->win) {
printf("Second\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
long long a, b, c, d;
void solve() {
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
if (a > b * c) {
puts("-1");
return;
}
if (a <= d * b) {
printf("%lld\n", a);
} else {
long long k = a / (d * b) + 1;
long long ret = a * k - d * b * k * (k - 1) / 2;
printf("%lld\n", ret);
}
}
int main() {
int T = 1;
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
static const int INF = 500000000;
template <class T>
void debug(T a, T b) {
for (; a != b; ++a) cerr << *a << ' ';
cerr << endl;
}
int n, m;
int k[1005];
int c[1005][1005];
int all[1005];
int large[1005], same[1005], other[1005];
long double prob[1005][1005];
long double C[1005][1005];
long double dp[1005][1005], way[1005][1005];
int main() {
for (int i = 0; i < 1005; ++i) {
C[i][0] = 1.0;
for (int j = 1; j < i + 1; ++j) C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
}
int cnt = 0;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
scanf("%d", &k[i]);
for (int j = 0; j < k[i]; ++j) scanf("%d", &c[i][j]), all[cnt++] = c[i][j];
sort(c[i], c[i] + k[i], greater<int>());
}
sort(all, all + cnt, greater<int>());
int border = all[n - 1];
for (int i = 0; i < m; ++i)
for (int j = 0; j < k[i]; ++j) {
if (c[i][j] > border)
++large[i];
else if (c[i][j] == border)
++same[i];
else
++other[i];
}
for (int i = 0; i < m; ++i) {
for (int j = large[i]; j <= large[i] + same[i]; ++j) {
prob[i][j] = C[same[i]][j - large[i]] / C[k[i]][j];
}
}
for (int i = 0; i < 1005; ++i)
for (int j = 0; j < 1005; ++j) dp[i][j] = way[i][j] = 0;
dp[0][0] = 1;
way[0][0] = 1;
for (int i = 0; i < m; ++i)
for (int j = 0; j < n + 1; ++j) {
if (dp[i][j] > 1e-11) {
for (int j2 = large[i]; j2 <= large[i] + same[i] && j + j2 <= n; ++j2) {
dp[i + 1][j + j2] += dp[i][j] * prob[i][j2];
}
}
if (way[i][j] > 1e-11) {
for (int j2 = large[i]; j2 <= large[i] + same[i] && j + j2 <= n; ++j2) {
way[i + 1][j + j2] += way[i][j];
}
}
}
printf("%.11lf\n", (double)(dp[m][n] / way[m][n]));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void NO() {
puts("NO");
exit(0);
}
void YES() {
puts("YES");
exit(0);
}
int main() {
map<pair<int, int>, int> Mp;
map<int, int> Mx, My;
map<pair<pair<int, int>, pair<int, int> >, int> M;
for (int i = (0); i < (4); i++) {
pair<int, int> s, t;
scanf("%d%d%d%d", &s.first, &s.second, &t.first, &t.second);
if (s == t) NO();
Mp[s]++;
Mp[t]++;
Mx[s.first]++;
My[s.second]++;
Mx[t.first]++;
My[t.second]++;
if (s > t) swap(s, t);
M[make_pair(s, t)]++;
}
for (map<pair<int, int>, int>::iterator it = Mp.begin(); it != Mp.end(); it++)
if (it->second != 2) NO();
for (map<int, int>::iterator it = Mx.begin(); it != Mx.end(); it++)
if (it->second != 4) NO();
for (map<int, int>::iterator it = My.begin(); it != My.end(); it++)
if (it->second != 4) NO();
for (map<pair<pair<int, int>, pair<int, int> >, int>::iterator it = M.begin();
it != M.end(); it++)
if (it->second != 1) NO();
YES();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long ksm(long long x, long long y) {
long long aa = 1ll;
for (x %= 1000000007; y; y >>= 1, x = (x * x) % 1000000007)
if (y & 1) aa = (aa * x) % 1000000007;
return aa % 1000000007;
}
long long fac[3000005], ans, inv[3000005];
inline long long A(int x, int y) {
if (x < y) return 0;
if (x == y) return fac[x] % 1000000007;
return fac[x] * inv[x - y] % 1000000007;
}
int main() {
scanf("%d%d", &k, &n);
fac[0] = 1ll;
for (int i = 1; i <= 3 * k; ++i) fac[i] = fac[i - 1] * i % 1000000007;
inv[3 * k] = ksm(fac[3 * k], 1000000007 - 2);
for (int i = 3 * k - 1; i >= 0; --i)
inv[i] = (inv[i + 1] * (i + 1)) % 1000000007;
for (int x = n + 1; x <= n + k; ++x) {
long long tmp, rua;
if (2 * n > x) {
tmp = (x - n) * A(k - 1, x - n - 1) % 1000000007;
ans = (ans +
((2 * tmp * A(k, x - n) % 1000000007 - tmp * tmp % 1000000007) %
1000000007 +
1000000007) %
1000000007 * ksm(k, 2 * n - x)) %
1000000007;
} else {
rua = A(k - x + 2 * n - 1, n - 1);
rua = rua * rua % 1000000007 * (k - x + 2 * n) % 1000000007;
tmp = A(k, x - 2 * n);
ans = (ans + tmp * rua % 1000000007) % 1000000007;
rua = A(k - x + 2 * n - 2, n - 2) * (n - 1) % 1000000007;
ans = (ans + tmp * (k - x + 2 * n) % 1000000007 * (k - x + 2 * n - 1) %
1000000007 *
((2 * rua * A(k - x + 2 * n - 1, n - 1) - rua * rua) %
1000000007 +
1000000007) %
1000000007) %
1000000007;
}
}
if (!ans)
puts("-1");
else
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[367][2] = {0}, i, x1, x2, ma = 0, n;
char y;
cin >> n;
while (n--) {
cin >> y >> x1 >> x2;
if (y == 'F') {
for (i = x1; i <= x2; i++) {
a[i][0]++;
a[i][1]--;
}
} else if (y == 'M') {
for (i = x1; i <= x2; i++) {
a[i][0]++;
a[i][1]++;
}
}
}
for (i = 1; i < 367; i++)
if (a[i][1] < 0) a[i][1] *= (-1);
for (i = 1, ma; i < 367; i++) {
if (a[i][0] - a[i][1] > ma) ma = a[i][0] - a[i][1];
}
cout << ma << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char com[200];
char *p;
int man = 0;
int sum = 0;
int i;
int word;
while (scanf("%c", com) == 1) {
i = 1;
while ((com[i] = getchar()) != '\n') i++;
com[i] = '\0';
word = 0;
if (com[0] == '+') {
man++;
continue;
}
if (com[0] == '-') {
man--;
continue;
}
p = strchr(com, ':');
p += 1;
while (*(p++) != '\0') {
word++;
}
sum += word * man;
}
printf("%d", sum);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.push_back(move(x));
return v;
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
err(++it, args...);
}
int N, M;
int inRoom[100013];
int isLeader[100013];
int event[100013];
int onlyOne = -1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
for (int i = 0; i < N; i++) {
inRoom[i] = -1;
isLeader[i] = -1;
}
for (int i = 0; i < M; i++) {
string s;
int p;
cin >> s >> p;
p--;
event[i] = p;
if (inRoom[p] == -1) {
if (s[0] == '+') {
inRoom[p] = 0;
} else {
inRoom[p] = 1;
}
}
}
int atLeast = 0;
for (int i = 0; i < N; i++) {
if (inRoom[i] == -1) {
isLeader[i] = 1;
}
if (inRoom[i] == 1) {
atLeast++;
}
}
for (int i = 0; i < M; i++) {
if (inRoom[event[i]] == 0) {
atLeast++;
inRoom[event[i]] = 1;
if (atLeast - 1) {
isLeader[event[i]] = 0;
} else {
if (onlyOne != -1) {
if (onlyOne == event[i]) {
continue;
}
isLeader[onlyOne] = 0;
break;
}
onlyOne = event[i];
for (int j = 0; j < N; j++) {
if (isLeader[j] == -1 && event[i] != j) isLeader[j] = 0;
}
}
} else if (inRoom[event[i]] == 1) {
atLeast--;
inRoom[event[i]] = 0;
if (atLeast) {
isLeader[event[i]] = 0;
} else {
if (onlyOne != -1) {
if (onlyOne == event[i]) {
continue;
}
isLeader[onlyOne] = 0;
break;
}
onlyOne = event[i];
for (int j = 0; j < N; j++) {
if (isLeader[j] == -1 && event[i] != j) isLeader[j] = 0;
}
}
} else {
throw domain_error("crapp!");
}
}
int k = 0;
vector<int> ans;
for (int i = 0; i < N; i++) {
if (isLeader[i] == -1 && i != onlyOne) {
{
vector<string> _v = split("i", ',');
err(_v.begin(), i);
};
throw domain_error("crap v2");
}
if (isLeader[i] != 0) {
k++;
ans.push_back(i + 1);
}
}
cout << k << endl;
for (int x : ans) {
cout << x << ' ';
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, l, a[1000009], b[1000009], p[1000009], ans, cn, t, x, y, z,
mx, mn, s;
double db;
char c[1000009], d[1000009], ch;
int main() {
while (scanf("%d %d %d %d", &i, &j, &k, &l) != EOF) {
ans = 42;
db = (1.0 * j) / (1.0 * i);
if ((j - i == k - j) && (k - j == l - k)) {
ans = l + j - i;
} else if ((j * j == i * k) && (k * k == j * l) && (i != 0) && (db != 0) &&
(db != 1)) {
ans = l * db;
if (ans * k != l * l) {
ans = 42;
}
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
inline long long read() {
register long long x = 0, f = 1;
register char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * f;
}
void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(long long x) {
write(x);
puts("");
}
const int BASE = 32;
int n, P, a[50005];
bitset<BASE> f[BASE + 1][50005];
int b[233];
int main() {
n = read(), P = read();
for (register int i = (1); i <= int(n); ++i) {
a[i] = read();
}
int m = n;
n = 0;
for (register int i = (1); i <= int(m); ++i)
if (a[i] < BASE) b[++n] = i;
f[0][0].set(0);
for (register int i = (0); i < int(n); ++i) {
f[i + 1][a[b[i + 1]] % P].set(a[b[i + 1]]);
for (register int j = (0); j < int(P); ++j) {
for (register int k = (0); k < int(BASE); ++k)
if (f[i][j][k]) {
f[i + 1][(1ll * j * (a[b[i + 1]] >= 10 ? 100 : 10) + a[b[i + 1]]) % P]
.set(k ^ a[b[i + 1]]);
f[i + 1][j].set(k);
}
}
}
int Xor = 0, Rem = 0;
vector<int> ans;
ans.clear();
for (register int i = (n); i >= int(1); --i) {
bool flag = false;
for (int x = 0; x < P && (!flag); ++x) {
for (int y = 0; y < BASE && (!flag); ++y) {
if (f[i - 1][x][y] &&
(1ll * x * (a[b[i]] >= 10 ? 100 : 10) + a[b[i]]) % P == Rem &&
(y ^ a[b[i]]) == Xor) {
ans.push_back(b[i]);
Rem = x;
Xor = y;
flag = true;
break;
}
}
}
if (flag && Rem == 0 && Xor == 0) break;
}
if (ans.size()) {
reverse(ans.begin(), ans.end());
puts("Yes");
writeln(ans.size());
for (unsigned i = 0; i < ans.size(); ++i) write(ans[i]), putchar(' ');
} else
puts("No");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
printf("%d", n / 2 + 1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int t[150005];
vector<int> cag;
bool respeto(int j) {
if (j >= n - 1 || j < 0) return true;
if (j % 2 == 0) {
return t[j] < t[j + 1];
} else {
return t[j] > t[j + 1];
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &t[i]);
}
for (int i = 0; i < n; i++) {
if (!respeto(i)) {
cag.push_back(i);
}
}
if (cag.size() > 4) {
puts("0");
return 0;
}
int r = 0;
for (int j = 0; j < n; j++) {
if (j != cag[0]) {
swap(t[cag[0]], t[j]);
if (respeto(j) && respeto(j - 1) && respeto(j + 1) && respeto(cag[0]) &&
respeto(cag[0] - 1) && respeto(cag[0] + 1)) {
int u = 0;
while (u < cag.size() && respeto(cag[u]) && respeto(cag[u] - 1)) {
u++;
}
if (u == (int)cag.size()) r++;
}
swap(t[cag[0]], t[j]);
}
if (cag[0] != n - 1 && j != cag[0] + 1 && j != cag[0]) {
swap(t[cag[0] + 1], t[j]);
if (respeto(j) && respeto(j - 1) && respeto(cag[0]) &&
respeto(cag[0] + 1) && respeto(cag[0] + 2) && respeto(j + 1)) {
int u = 0;
while (u < cag.size() && respeto(cag[u]) && respeto(cag[u] - 1)) {
u++;
}
if (u == (int)cag.size()) r++;
}
swap(t[cag[0] + 1], t[j]);
}
}
printf("%d\n", r);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long long int maxn = 1e3 + 4;
const long long mod = 1e9 + 7;
using namespace std;
long long int power(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b % 2 == 1) res = res * a;
a = a * a;
b = b / 2;
}
return res;
}
long long po(long long x, long long y) {
long long res = 1;
x = x % mod;
while (y > 0) {
if (y & 1) res = ((res % mod) * (x % mod)) % mod;
y = y >> 1;
x = ((x % mod) * (x % mod)) % mod;
}
return res;
}
vector<long long> a(maxn);
vector<long long> b(maxn);
vector<int> adj[maxn];
int visited[maxn];
int cnt = 0;
vector<int> p[maxn];
void dfs(int node) {
visited[node] = 1;
p[cnt].push_back(node);
for (int i = 0; i < adj[node].size(); i++) {
if (visited[adj[node][i]]) continue;
dfs(adj[node][i]);
}
}
int dp[maxn][maxn];
long long int fun(int i, int w) {
if (i < 0) return 0;
if (dp[i][w] != -1) return dp[i][w];
long long int ans = 0, beauty = 0, weight = 0;
for (int j = 0; j < p[i].size(); j++) {
if (a[p[i][j]] <= w)
ans = max(ans, b[p[i][j]] + fun(i - 1, w - a[p[i][j]]));
beauty += b[p[i][j]];
weight += a[p[i][j]];
}
if (w >= weight)
return dp[i][w] =
max(ans, max(fun(i - 1, w), beauty + fun(i - 1, w - weight)));
else
return dp[i][w] = max(ans, fun(i - 1, w));
}
int main() {
int t = 1;
memset(dp, -1, sizeof(dp));
while (t--) {
int n, m, w;
cin >> n >> m >> w;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (visited[i]) continue;
dfs(i);
cnt++;
}
cout << fun(cnt - 1, w) << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
vector<int> v[200005];
bool used[200005];
bool dfs(int k, int p, int t) {
if (v[k].size() > 2) return 0;
for (int i = 0; i < v[k].size(); i++) {
if (v[k][i] == p && t > 1) return 1;
if (used[v[k][i]] == 0) {
used[v[k][i]] = 1;
return dfs(v[k][i], p, t + 1);
}
}
return 0;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[y].push_back(x);
v[x].push_back(y);
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (used[i] == 0) {
used[i] = 1;
if (dfs(i, i, 0)) res++;
}
}
cout << res;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 100;
int a[maxn];
int b[maxn];
int n, q;
set<int> second;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
second.insert(i);
}
cin >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int p, x;
cin >> p >> x;
p--;
int rem = x;
while (second.lower_bound(p) != second.end()) {
auto it = *second.lower_bound(p);
if (rem + b[it] <= a[it]) {
b[it] += rem;
if (b[it] == a[it]) second.erase(it);
break;
} else {
rem -= a[it] - b[it];
b[it] = a[it];
second.erase(it);
}
}
} else if (t == 2) {
int x;
cin >> x;
x--;
cout << b[x] << endl;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, y1, x2, y2;
while (cin >> x1 >> y1 >> x2 >> y2) {
int ans = 0;
if (x1 + y1 <= max(x2, y2)) ans = 1;
if (x1 <= x2 && y1 <= y2) ans = 1;
if (ans)
cout << "Polycarp\n";
else
cout << "Vasiliy\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, -1, 0, 1};
int dist[1001][1001];
pair<int, int> e;
int r, c;
string g[1001];
void bfs(pair<int, int> start) {
for (int(i) = (0); (i) < (r); (i)++)
for (int(j) = (0); (j) < (c); (j)++) dist[i][j] = (1 << 30);
dist[start.first][start.second] = 0;
queue<pair<int, int> > Q;
Q.push(start);
while (!Q.empty()) {
pair<int, int> curr = Q.front();
int xx = curr.first;
int yy = curr.second;
Q.pop();
for (int(i) = (0); (i) < (4); (i)++) {
if (xx + dx[i] < r && xx + dx[i] >= 0 && yy + dy[i] < c &&
yy + dy[i] >= 0 && g[xx + dx[i]][yy + dy[i]] != 'T' &&
dist[xx + dx[i]][yy + dy[i]] == (1 << 30)) {
Q.push(make_pair(xx + dx[i], yy + dy[i]));
dist[xx + dx[i]][yy + dy[i]] = 1 + dist[xx][yy];
}
}
}
}
int main() {
cin >> r >> c;
pair<int, int> me;
for (int(i) = (0); (i) < (r); (i)++) {
cin >> g[i];
for (int(j) = (0); (j) < (c); (j)++) {
if (g[i][j] == 'S')
me = make_pair(i, j);
else if (g[i][j] == 'E')
e = make_pair(i, j);
dist[i][j] = (1 << 30);
}
}
bfs(e);
int mydist = dist[me.first][me.second];
int ans = 0;
for (int(i) = (0); (i) < (r); (i)++) {
for (int(j) = (0); (j) < (c); (j)++) {
if (g[i][j] >= '1' && g[i][j] <= '9') {
if (dist[i][j] <= mydist) ans += (int)(g[i][j] - '0');
}
}
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool cp(pair<long long, long long> i, pair<long long, long long> j) {
return i.first < j.first;
}
long long n;
int a[200005];
vector<long long> ad[200005];
long long dp[200005];
bool vis[200005];
void dfs(long long i) {
vis[i] = true;
long long k = a[i];
for (auto u : ad[i]) {
if (!vis[u]) {
dfs(u);
k = max(k, k + dp[u]);
}
}
dp[i] = k;
}
void dfs2(long long i, long long j) {
dp[i] = max(dp[i], dp[i] + j);
vis[i] = true;
for (auto u : ad[i]) {
if (!vis[u]) {
dfs2(u, dp[i] - max(dp[u], 0LL));
}
}
return;
}
int main() {
cin >> n;
for (long long i = 1; i < n + 1; i = i + 1) cin >> a[i];
for (long long i = 1; i < n + 1; i = i + 1)
if (!a[i]) a[i]--;
for (long long i = 0; i < n - 1; i = i + 1) {
long long u, v;
cin >> u >> v;
ad[u].push_back(v);
ad[v].push_back(u);
}
memset(vis, false, sizeof(vis));
memset(dp, 0, sizeof(dp));
dfs(1);
memset(vis, false, sizeof(vis));
dfs2(1, 0);
for (long long i = 1; i < n + 1; i = i + 1) cout << dp[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int INF = 1e9 + 5;
const long long mod = 1e9 + 7;
const double pi = 3.1415926536;
int dx[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dy[] = {0, 0, 1, -1, 1, -1, -1, 1};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios_base::sync_with_stdio(0);
;
int n, r;
cin >> n >> r;
int arr[n + 5];
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
int cnt = 0, i = 1;
while (i <= n) {
int idx = 0;
for (int j = n; j > 0; j--) {
if (arr[j] && abs(i - j) < r) {
idx = j + r;
break;
}
}
i = idx;
if (idx == 0) {
return cout << "-1\n", 0;
}
cnt++;
}
cout << cnt << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct point {
double x, y;
point(double _x = 0, double _y = 0) {
x = _x;
y = _y;
}
point operator+(point w) { return point(x + w.x, y + w.y); }
point operator-(point w) { return point(x - w.x, y - w.y); }
point operator*(double H) { return point(x * H, y * H); }
double operator/(point w) {
if (abs(w.x) > 1E-8) return x / w.x;
return y / w.y;
}
bool operator==(point w) {
return (abs(x - w.x) < 1E-8 && abs(y - w.y) < 1E-8);
}
};
double sp(point a, point b) { return (a.x * b.x + a.y * b.y); }
inline double EQ_null(double A) { return false; }
int ORI(point a, point b) {
double O = a.x * b.y - a.y * b.x;
return (EQ_null(O) || abs(O) < 1E-8) ? 0 : (O > 0 ? 1 : -1);
}
struct prava {
double a, b, c;
prava(point f = point(0, 0), point t = point(1, 1)) {
a = t.y - f.y;
b = f.x - t.x;
c = t.x * f.y - f.x * t.y;
}
point IP(prava w) {
point ret;
if (abs(a) < 1E-8) {
ret.y = (-c) / b;
ret.x = (-w.b * ret.y - w.c) / w.a;
} else {
ret.y = (w.a * c - a * w.c) / (a * w.b - w.a * b);
ret.x = (-b * ret.y - c) / a;
}
return ret;
}
};
point BEG;
double X1, Y1, Z1, X2, Y2, Z2, D;
int n;
point M[10000];
point L1, L2;
bool is_in(point w) {
w = w - BEG;
if (ORI(L1, L2) == 0) {
if (!(L1 == point(0, 0)) && ORI(L1, w) == 0 && (w / L1 >= 0)) return true;
if (!(L2 == point(0, 0)) && ORI(L2, w) == 0 && (w / L2 >= 0)) return true;
return false;
}
return (ORI(L1, L2) * ORI(L1, w) >= 0 && ORI(L2, L1) * ORI(L2, w) >= 0);
}
double t1 = 1E9, t2 = 1E9;
void get_time(point w) {
if (ORI(L1, L2) != 0) {
prava B(BEG, BEG + L1);
double T1, T2, T3;
point WIND(X2, Y2);
T3 = (B.a * w.x + B.b * w.y + B.c) / (B.a * WIND.x + B.b * WIND.y);
if (T3 < 0 && abs(T3) < 1E-8) T3 = 0;
if (T3 < 0) return;
T1 = point(w - WIND * T3 - BEG) / point(X1, Y1);
if (T1 < 0 && abs(T1) < 1E-8) T1 = 0;
if (T1 < 0) return;
T2 = (T1 * Z1 + T3 * Z2) / (-D);
if (T2 < 0 && abs(T2) < 1E-8) T2 = 0;
if (T2 < 0) return;
if (t1 > T1 || (abs(t1 - T1) < 1E-8 && t2 > T2)) {
t1 = T1;
t2 = T2;
}
} else {
double T1, T2, T3;
if (!(point(X1, Y1) == point(0, 0)) && point(X2, Y2) / point(X1, Y1) < 0) {
T1 = (w - BEG) / point(X1, Y1);
T2 = (-Z1 * T1) / D;
if (T1 < 0 && abs(T1) < 1E-8) T1 = 0;
if (T2 < 0 && abs(T2) < 1E-8) T2 = 0;
if (T1 < 0 || T2 < 0) goto NEXT_TYPE;
if (t1 > T1 || (abs(t1 - T1) < 1E-8 && t2 > T2)) {
t1 = T1;
t2 = T2;
}
NEXT_TYPE:
point SUM = point(X1, Y1) + point(X2, Y2) * (-Z1 / Z2);
if (SUM == point(0, 0)) return;
T1 = (w - BEG) / SUM;
T2 = 0;
if (T1 < 0 && abs(T1) < 1E-8) T1 = 0;
if (T1 < 0 || T2 < 0) return;
if (t1 > T1 || (abs(t1 - T1) < 1E-8 && t2 > T2)) {
t1 = T1;
t2 = T2;
}
} else {
point SUM = point(X1, Y1) + point(X2, Y2) * (-Z1 / Z2);
if (SUM == point(0, 0)) return;
T1 = (w - BEG) / SUM;
T2 = 0;
if (T1 < 0 && abs(T1) < 1E-8) T1 = 0;
if (T1 < 0 || T2 < 0) return;
if (t1 > T1 || (abs(t1 - T1) < 1E-8 && t2 > T2)) {
t1 = T1;
t2 = T2;
}
}
}
}
int main() {
int i, j, k, l;
scanf("%d", &n);
for (i = 0; i < n; ++i) scanf("%lf%lf", &M[i].x, &M[i].y);
scanf("%lf%lf", &BEG.x, &BEG.y);
scanf("%lf%lf%lf%lf%lf%lf%lf", &X1, &Y1, &Z1, &D, &X2, &Y2, &Z2);
L1 = point(X1, Y1);
L2 = L1 - point(X2, Y2) * (Z1 / Z2);
for (i = 0; i < n; ++i)
if (is_in(M[i])) get_time(M[i]);
for (i = 0; i < n; ++i) {
j = i + 1;
if (j >= n) j -= n;
if (ORI(L1, M[i] - BEG) * ORI(L1, M[j] - BEG) < 0) {
point T = prava(BEG, BEG + L1).IP(prava(M[i], M[j]));
if (is_in(T)) get_time(T);
}
if (ORI(L2, M[i] - BEG) * ORI(L2, M[j] - BEG) < 0) {
point T = prava(BEG, BEG + L2).IP(prava(M[i], M[j]));
if (is_in(T)) get_time(T);
}
}
if (t1 < 1E9)
printf("%.12lf %.12lf\n", t1, t2);
else
printf("-1 -1\n");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int C(int n, int r) {
long long int ans = 1;
for (int i = 0; i < r; ++i) {
ans = (ans * (n - i));
}
for (int i = 2; i <= r; ++i) {
ans /= i;
}
return ans;
}
int main() {
int n, k;
long long int ans = 1;
scanf("%d", &n), scanf("%d", &k);
for (int i = 2; i <= k; ++i) {
ans += (C(n, i) * pow(i - 1, i - 2));
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> get_factors(
map<long long int, long long int> prime_factorzn) {
long long int total = 1;
vector<long long int> powers, primes, answer;
for (auto it : prime_factorzn) {
total *= (it.second + 1);
powers.push_back(it.second + 1);
primes.push_back(it.first);
}
for (int i = 0; i < total; i++) {
long long int factor = 1, tmp_i = i;
for (int j = 0; j < powers.size(); j++) {
factor *= pow(primes[j], tmp_i % powers[j]);
tmp_i = tmp_i / powers[j];
}
answer.push_back(factor);
}
return answer;
}
int main() {
long long int n;
cin >> n;
vector<long long int> a(n + 1);
for (int i = 1; i <= n / 2; i++) {
scanf("%lld", &a[2 * i]);
}
bool not_prime[200001] = {};
int spf[200001];
vector<map<long long int, long long int>> factors(200001);
for (long long int i = 2; i <= 200000; i++) {
if (!not_prime[i]) {
spf[i] = i;
for (long long int j = i * i; j <= 200000; j += i) {
if (!not_prime[j]) {
spf[j] = i;
not_prime[j] = 1;
}
}
}
}
for (int i = 1; i <= n / 2; i++) {
long long int tmp = a[2 * i];
while (tmp != 1) {
long long int factor = spf[tmp], pwr = 0;
while (tmp != 1 && tmp % factor == 0) {
tmp = tmp / factor;
pwr++;
}
factors[a[2 * i]][factor] = pwr;
}
}
vector<vector<long long int>> divisors(n + 1);
for (int i = 1; i <= n / 2; i++) {
divisors[2 * i] = get_factors(factors[a[2 * i]]);
}
int no = 0;
vector<long long int> numbers(n + 1);
for (int i = 1; i <= n / 2; i++) {
vector<long long int> vec = divisors[2 * i];
int sz = (int)vec.size();
numbers[2 * i - 1] = -1;
long long int a_t = 1e18, a_v = 1e18;
for (int j = 0; j < sz; j++) {
long long int num1 = vec[j], num2 = a[2 * i] / num1;
long long int t = (+num1 + num2), v = (-num1 + num2);
if ((num1 < num2) && (v % 2 == 0) &&
((i == 1) || (v / 2 > numbers[2 * i - 2]))) {
if (t < a_t) {
a_t = t;
a_v = v;
}
}
}
if (a_t == 1e18 || a_v == 1e18) {
no = 1;
break;
}
numbers[2 * i - 1] = a_v / 2;
numbers[2 * i] = a_t / 2;
if (i == 1)
a[1] = (a_v / 2) * (a_v / 2);
else
a[2 * i - 1] =
(a_v / 2) * (a_v / 2) - numbers[2 * i - 2] * numbers[2 * i - 2];
if (a[2 * i - 1] <= 0) {
no = 1;
cout << i << endl;
break;
}
}
if (no == 1) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
for (int i = 1; i <= n; i++) cout << a[i] << " ";
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[5010];
int dp[5010][5010 >> 1][3];
void init() {
for (int i = 0; i < 5010; ++i) {
for (int j = 0; j < 5010 >> 1; ++j)
dp[i][j][0] = dp[i][j][1] = dp[i][j][2] = INT_MAX >> 1;
dp[i][0][0] = 0;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
init();
cin >> n;
a[0] = INT_MAX;
for (int i = 1; i <= n; ++i) cin >> a[i];
dp[1][1][1] = 0;
dp[1][0][2] = 0;
dp[0][0][1] = dp[0][0][0] = dp[0][0][2] = 0;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= (n + 1) >> 1; ++j) {
int l = min(a[i - 2] - 1, a[i - 1]);
dp[i][j][1] = min(dp[i][j][1],
min(dp[i - 1][j - 1][0] + max(0, a[i - 1] - a[i] + 1),
dp[i - 1][j - 1][2] + max(0, l - a[i] + 1)));
dp[i][j][0] = min(dp[i][j][0], min(dp[i - 1][j][0], dp[i - 1][j][2]));
dp[i][j][2] =
min(dp[i][j][2], dp[i - 1][j][1] + max(0, a[i] - a[i - 1] + 1));
}
}
for (int j = 1; j <= (n + 1) >> 1; ++j)
cout << min(dp[n][j][0], min(dp[n][j][1], dp[n][j][2])) << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> Graph, cenTree;
vector<int> par, sz, height;
vector<bool> visited, centroidMarked;
vector<char> ans;
int dfs1(int v, int depth, int parent) {
int curr = 1;
visited[v] = true;
par[v] = parent;
for (auto vv : Graph[v])
if (!visited[vv]) curr += dfs1(vv, depth + 1, v);
return sz[v] = curr;
}
int dfs2(int v, int parent) {
int curr = 1;
for (auto vv : Graph[v])
if (!centroidMarked[vv] && vv != parent) curr += dfs2(vv, v);
return sz[v] = curr;
}
void dfs3(int v, int depth) {
visited[v] = true;
ans[v] = 'A' + depth;
for (auto vv : cenTree[v])
if (!visited[vv]) dfs3(vv, depth + 1);
}
int getCentroid(int v, int parent, int subTreeSize) {
for (auto vv : Graph[v])
if (!centroidMarked[vv] && vv != parent && sz[vv] > subTreeSize / 2)
return getCentroid(vv, v, subTreeSize);
return v;
}
int decompose(int v, int n, int subTreeSize) {
int centroid = getCentroid(v, -1, subTreeSize);
centroidMarked[centroid] = true;
for (auto vv : Graph[centroid])
if (!centroidMarked[vv]) {
int newSubTreeSize = dfs2(vv, v);
int childCentroid = decompose(vv, n, newSubTreeSize);
cenTree[centroid].push_back(childCentroid);
cenTree[childCentroid].push_back(centroid);
}
return centroid;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, u, v;
cin >> n;
Graph.resize(n + 5), cenTree.resize(n + 5), par.resize(n + 5),
sz.resize(n + 5), visited.resize(n + 5), centroidMarked.resize(n + 5),
ans.resize(n + 5);
for (int i = 0; i < n - 1; ++i) {
cin >> u >> v;
Graph[u].push_back(v);
Graph[v].push_back(u);
}
dfs1(1, 0, 0);
int cenTreeRoot = decompose(1, n, n);
visited.clear();
visited.resize(n + 5);
dfs3(cenTreeRoot, 0);
for (int i = 1; i <= n; ++i) cout << ans[i] << " ";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<ld, ld>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<ld>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
str Tout[2] = {"NO", "YES"};
str tout[2] = {"No", "Yes"};
int main() {
int n, ans;
cin >> n;
if (n % 2)
ans = 100000011;
else
ans = 100000010;
cout << ans << " " << ans - n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double sqaure(int x) { return 1.0 * x * x; }
struct point {
int x, y;
void input() { scanf("%d%d", &x, &y); }
double distance_to(const point& p) const {
return sqrt(sqaure(x - p.x) + sqaure(y - p.y));
}
};
int main() {
point pa, pb, po;
double total_distance = 0.0;
pa.input();
pb.input();
po.input();
int n_points;
scanf("%d", &n_points);
std::vector<pair<double, int>> distances_to_a, distances_to_b;
for (int i = 0; i < n_points; ++i) {
point foo;
foo.input();
total_distance += 2 * foo.distance_to(po);
distances_to_a.push_back(
make_pair(foo.distance_to(pa) - foo.distance_to(po), i));
distances_to_b.push_back(
make_pair(foo.distance_to(pb) - foo.distance_to(po), i));
}
sort(distances_to_a.begin(), distances_to_a.end());
sort(distances_to_b.begin(), distances_to_b.end());
double final_distance = total_distance;
if (distances_to_a[0].first > 0 || distances_to_b[0].first > 0 ||
n_points == 1) {
final_distance +=
std::min(distances_to_a[0].first, distances_to_b[0].first);
} else {
double min_cost_greed_a = distances_to_a[0].first;
if (distances_to_b[0].second == distances_to_a[0].second) {
min_cost_greed_a += std::min(0.0, distances_to_b[1].first);
} else {
min_cost_greed_a += distances_to_b[0].first;
}
double min_cost_greed_b = distances_to_b[0].first;
if (distances_to_a[0].second == distances_to_b[0].second) {
min_cost_greed_b += std::min(0.0, distances_to_a[1].first);
} else {
min_cost_greed_b += distances_to_a[0].first;
}
final_distance += std::min(min_cost_greed_a, min_cost_greed_b);
}
printf("%.10lf\n", final_distance);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b, i, j, k, r = 0, c = 0, s = 0;
int x[31][31];
cin >> n;
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
cin >> x[i][j];
}
}
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
r = 0;
c = 0;
for (k = 0; k < n; ++k) {
r += x[i][k];
c += x[k][j];
}
if (c > r) s++;
}
}
cout << s;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 19;
const int N = 2e5 + 25;
struct Trie {
int sz;
vector<int> val, lazy;
Trie(int k) {
sz = 1 << (k + 1);
val.resize(sz, inf);
lazy.resize(sz, 0);
}
void push(int v) {
if (lazy[v]) {
val[v] += lazy[v];
if (val[v] > inf) val[v] = inf;
if ((v << 1) < sz) {
lazy[v << 1] += lazy[v];
lazy[(v << 1) ^ 1] += lazy[v];
}
lazy[v] = 0;
}
}
void insert(string s, int x) {
reverse(s.begin(), s.end());
int rt = 1;
for (auto ch : s) {
push(rt);
rt <<= 1;
if (ch == '1') rt ^= 1;
}
push(rt);
while (rt) {
val[rt] = min(val[rt], x);
rt >>= 1;
}
}
void update(int x) { lazy[1] += x; }
int query(string s) {
reverse(s.begin(), s.end());
int rt = 1;
for (auto ch : s) {
push(rt);
rt <<= 1;
if (ch == '1') rt ^= 1;
}
push(rt);
return val[rt];
}
};
int k;
string s[N];
inline int compute(int x, int y) {
if (x == 0) return k;
for (int len = k; len >= 1; len--) {
if (s[x].substr(k - len) == s[y].substr(0, len)) return k - len;
}
return k;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(32);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
k = s[1].size();
Trie trie(k);
int sum = k;
for (int i = 1; i < n; i++) {
int cur = sum + k;
for (int len = 0; len <= k; len++) {
cur = min(cur, k - len + trie.query(s[i + 1].substr(0, len)));
}
trie.update(compute(i, i + 1));
trie.insert(s[i], cur);
sum += compute(i, i + 1);
}
trie.push(1);
cout << min(sum, trie.val[1]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int to[500100], ant[500100], adj[500100], z;
long long x[500100];
int rep[500100], pai[500100], lvl[500100], edp[500100];
int findset(int u) {
if (u == 0 || x[edp[u]] > 1) return u;
assert(u != pai[u]);
return rep[u] = findset(rep[pai[u]]);
}
void proc(int u) {
for (int i = adj[u]; ~i; i = ant[i]) {
int v = to[i];
if (v != pai[u]) {
pai[v] = u;
edp[v] = i;
lvl[v] = lvl[u] + 1;
proc(v);
}
}
}
long long proc(int u, int v, long long y) {
u = findset(u);
v = findset(v);
vector<long long> v1, v2;
int cnt = 0;
while (u != v && cnt < 70) {
if (lvl[u] > lvl[v]) {
v1.push_back(x[edp[u]]);
u = findset(pai[u]);
} else {
v2.push_back(x[edp[v]]);
v = findset(pai[v]);
}
cnt++;
}
if (cnt >= 70) return 0;
reverse(v2.begin(), v2.end());
for (int i = 0; i < v1.size(); i++) y /= v1[i];
for (int i = 0; i < v2.size(); i++) y /= v2[i];
return y;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
memset(adj, -1, sizeof(adj));
z = 0;
for (int i = 0; i < n - 1; i++) {
int a, b;
long long c;
scanf("%d%d", &a, &b);
a--, b--;
scanf("%lld", &c);
to[z] = b, x[z] = c, ant[z] = adj[a], adj[a] = z++;
to[z] = a, x[z] = c, ant[z] = adj[b], adj[b] = z++;
}
for (int i = 0; i < n; i++) rep[i] = i;
edp[0] = lvl[0] = pai[0] = 0;
proc(0);
for (int i = 0; i < m; i++) {
int t;
scanf("%d", &t);
if (t == 2) {
int a;
long long b;
scanf("%d%lld", &a, &b);
a--;
a <<= 1;
x[a] = x[a ^ 1] = b;
} else {
int a, b;
long long c;
scanf("%d%d", &a, &b);
a--, b--;
scanf("%lld", &c);
printf("%lld\n", proc(a, b, c));
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long int com(long long int n, long long int a) {
long long int result = 1;
if (n - a < a) a = n - a;
long long int cnt = 1;
for (long long int i = n - a + 1; i < n + 1; i++) {
result *= i;
result /= cnt;
cnt++;
}
return result;
}
void swap(int *xp, int *yp) {
int temp = *xp;
*xp = *yp;
*yp = temp;
}
void bubbleSort(int arr[], int n) {
int i, j;
for (i = 0; i < n - 1; i++)
for (j = 0; j < n - i - 1; j++)
if (arr[j] > arr[j + 1]) swap(&arr[j], &arr[j + 1]);
}
string to_upper(string &in) {
for (int i = 0; i < in.length(); i++)
if ('a' <= in[i] <= 'z') in[i] &= ~(1 << 5);
return in;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int test, temp = 0;
cin >> test;
while (test > 0) {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long int flag = 0;
for (long long int i = 0; i < n - 1; i++) {
if (abs(a[i] - a[i + 1]) > 1) {
flag = 1;
break;
}
}
if (flag)
cout << "NO";
else {
cout << "YES";
}
cout << "\n";
test--;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[300000];
int main() {
int n;
cin >> n;
int pos = 0;
int neg = 0;
int zerps = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
pos += a[i] > 0;
neg += a[i] < 0;
zerps += a[i] == 0;
}
n = n % 2 ? n / 2 + 1 : n / 2;
if (pos >= n) {
cout << "1";
} else if (neg >= n) {
cout << -1;
} else {
cout << 0;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int ML = 1e6 + 5;
const int MM = 1e5 + 5;
int n, m;
char s[ML];
struct node {
int opp, neg, res;
node() { opp = neg = res = 0; }
friend node operator+(const node &i, const node &j) {
node now;
int cur = min(i.opp, j.neg);
now.res = i.res + j.res + cur;
now.opp = i.opp + j.opp - cur;
now.neg = i.neg + j.neg - cur;
return now;
}
} tree[ML << 2];
void build(int p, int pl, int pr) {
if (pl == pr) {
tree[p].res = 0;
tree[p].opp = (s[pl] == '(');
tree[p].neg = (s[pl] == ')');
return;
}
int mid = (pl + pr) >> 1;
build(p << 1, pl, mid);
build(p << 1 | 1, mid + 1, pr);
tree[p] = tree[p << 1] + tree[p << 1 | 1];
}
node ask(int p, int pl, int pr, int ql, int qr) {
if (pl == ql && pr == qr) return tree[p];
int mid = (pl + pr) >> 1;
if (qr <= mid)
return ask(p << 1, pl, mid, ql, qr);
else if (ql > mid)
return ask(p << 1 | 1, mid + 1, pr, ql, qr);
else
return ask(p << 1, pl, mid, ql, mid) +
ask(p << 1 | 1, mid + 1, pr, mid + 1, qr);
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
build(1, 1, n);
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
int ql, qr;
scanf("%d%d", &ql, &qr);
printf("%d\n", ask(1, 1, n, ql, qr).res * 2);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Libm {
int x;
int y;
} s[4];
int main() {
Libm a, b, c;
cin >> a.x >> a.y >> b.x >> b.y >> c.x >> c.y;
int cnt = 0;
s[cnt].x = a.x - b.x + c.x;
s[cnt].y = a.y - b.y + c.y;
cnt++;
s[cnt].x = a.x + b.x - c.x;
s[cnt].y = a.y + b.y - c.y;
cnt++;
s[cnt].x = -a.x + b.x + c.x;
s[cnt].y = -a.y + b.y + c.y;
cnt++;
cout << cnt << endl;
for (int i = 0; i < cnt; i++) {
cout << s[i].x << " " << s[i].y << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double dp[3005 * 3005];
vector<int> v;
int main() {
int n;
cin >> n;
int x;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (v[i] > v[j]) {
cnt++;
}
}
}
dp[0] = 0;
dp[1] = 1.0;
for (int i = 2; i <= cnt; i++) {
dp[i] = 4 + dp[i - 2];
}
printf("%.9lf\n", dp[cnt]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int LG = 18, N = 1 << LG, Mod = 998244353;
inline int Power(int a, int b) {
int ret = 1;
for (; b; b >>= 1, a = 1LL * a * a % Mod)
if (b & 1) ret = 1LL * ret * a % Mod;
return (ret);
}
inline int Rev(int a, int k) {
int rt = 0;
for (; k; k--) rt = (rt << 1) | (a & 1), a >>= 1;
return (rt);
}
inline void NTT(vector<int> &F, bool inv = 0) {
int n = (int)F.size();
int k = __builtin_ctz(n);
for (int i = 0; i < n; i++)
if (i < Rev(i, k)) swap(F[i], F[Rev(i, k)]);
for (int len = 1; len < n; len <<= 1) {
int wn = Power(3, (Mod - 1) / (len << 1));
if (inv) wn = Power(wn, Mod - 2);
for (int i = 0; i < n; i += (len << 1))
for (int j = i, w = 1; j < i + len; j++) {
int a = 1LL * F[j + len] * w % Mod;
F[j + len] = F[j] - a;
F[j] += a;
if (F[j + len] < 0) F[j + len] += Mod;
if (F[j] >= Mod) F[j] -= Mod;
w = 1LL * w * wn % Mod;
}
}
if (inv)
for (int i = 0, rn = Power(n, Mod - 2); i < n; i++)
F[i] = 1LL * F[i] * rn % Mod;
}
inline vector<int> Multiply(vector<int> &A, vector<int> &B) {
int n = (int)A.size() + (int)B.size() - 1, k = 0;
while ((1 << k) < n) k++;
n = 1 << k;
while (A.size() < n) A.push_back(0);
while (B.size() < n) B.push_back(0);
NTT(A, 0);
NTT(B, 0);
for (int i = 0; i < n; i++) A[i] = 1LL * A[i] * B[i] % Mod;
NTT(A, 1);
return (A);
}
int main() {
int n;
map<int, int> C;
scanf("%d", &n);
for (int i = 1, a; i <= n; i++) scanf("%d", &a), C[a]++;
priority_queue<pair<int, vector<int> > > Pq;
for (auto X : C) {
vector<int> A(X.second + 1, 1);
Pq.push({-X.second - 1, A});
}
while (Pq.size() > 1) {
vector<int> A = Pq.top().second;
Pq.pop();
vector<int> B = Pq.top().second;
Pq.pop();
A = Multiply(A, B);
Pq.push({-(int)A.size(), A});
}
vector<int> A = Pq.top().second;
return !printf("%d\n", A[n / 2]);
}
| 9 |
#include <bits/stdc++.h>
int main(void) {
int h, r;
while (scanf("%d%d", &r, &h) != -1) {
int ans = 0;
int a = h % r;
int b = h / r;
int cnt = 0;
if (2 * a >= r) {
cnt = 2;
if (2 * a >= r * 1.732) {
cnt++;
}
} else {
cnt = 1;
}
ans = 2 * b + cnt;
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long fact[200005];
long long extgcd(long long a, long long b, long long& x, long long& y) {
long long d = a;
if (b != 0LL) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
long long mod_inverse(long long a, long long m) {
long long x, y;
extgcd(a, m, x, y);
return (m + x % m) % m;
}
long long mod_fact(long long n, long long p, long long& e) {
e = 0;
if (n == 0) return 1;
long long res = mod_fact(n / p, p, e);
e += n / p;
if (n / p % 2 != 0) {
return res * (p - fact[n % p]) % p;
}
return res * fact[n % p] % p;
}
long long mod_comb(long long n, long long k, long long p) {
if (n < 0 || k < 0 || n < k) return 0;
long long e1, e2, e3;
long long a1 = mod_fact(n, p, e1), a2 = mod_fact(k, p, e2),
a3 = mod_fact(n - k, p, e3);
if (e1 > e2 + e3) return 0;
return a1 * mod_inverse(a2 * a3 % p, p) % p;
}
long long mod_pow(long long x, long long n) {
long long ans = 1;
while (n > 0) {
if (n & 1) {
ans = ans * x % 998244353LL;
}
x = x * x % 998244353LL;
n >>= 1;
}
return ans;
}
int n;
long long k;
int h[200005];
int main(void) {
fact[0] = 1;
for (long long i = 1; i <= 200000; i++) {
fact[i] = fact[i - 1] * i % 998244353LL;
}
scanf("%d%lld", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
int cur = 0, nxt = 1;
long long po = 1;
int cnt = 0;
for (int i = 0; i < n; i++) {
int ans = h[i];
int cans = h[(i + 1) % n];
if (ans == cans) {
po = po * k % 998244353LL;
} else {
cnt++;
}
}
long long ans = 0;
long long v1 = 1;
for (int i = 0; i < cnt; i++) {
int rest = cnt - i;
long long v4 = mod_comb(cnt, i, 998244353LL);
long long sum = 0;
if (rest % 2 == 1) {
if (i == cnt) {
sum += v1 * mod_pow(2, rest - 1) % 998244353LL;
sum %= 998244353LL;
} else {
sum += v1 * mod_pow(2, rest - 1) % 998244353LL;
sum %= 998244353LL;
}
} else if (rest > 0) {
long long v3 = mod_pow(2, rest - 1);
long long v5 = mod_comb(rest - 1, rest / 2, 998244353LL);
v3 = (v3 - v5 + 998244353LL) % 998244353LL;
sum += v1 * v3 % 998244353LL;
sum %= 998244353LL;
}
sum = sum * v4 % 998244353LL;
ans += sum;
ans %= 998244353LL;
v1 = v1 * (k - 2LL) % 998244353LL;
}
ans = ans * po % 998244353LL;
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e6 + 3;
class node {
public:
long long v00, v01, v10, v11;
node() { v00 = v01 = v10 = v11 = 0; }
bool operator==(node &ot) {
bool ok = true;
if (v00 != ot.v00) ok = false;
if (v01 != ot.v01) ok = false;
if (v11 != ot.v11) ok = false;
if (v10 != ot.v10) ok = false;
return ok;
}
};
node INV;
node tree[800004];
long long n, m;
long long a[400004];
inline long long left(long long x) { return x << 1; }
inline long long right(long long x) { return (x << 1) + 1; }
void init(long long i, long long id) {
long long upp = a[i];
long long dd = a[i + n];
if (upp == 0)
tree[id].v00 = 0;
else
tree[id].v00 = inf;
if (dd == 0)
tree[id].v11 = 0;
else
tree[id].v11 = inf;
if (upp == 0 && dd == 0) {
tree[id].v01 = 1;
tree[id].v10 = 1;
} else {
tree[id].v01 = inf;
tree[id].v10 = inf;
}
}
node combines(node &lft, node &rgt) {
node ret;
ret.v00 = min(lft.v00 + rgt.v00, lft.v01 + rgt.v10) + 1;
if (ret.v00 > inf) ret.v00 = inf;
ret.v01 = min(lft.v01 + rgt.v11, lft.v00 + rgt.v01) + 1;
if (ret.v01 > inf) ret.v01 = inf;
ret.v10 = min(lft.v10 + rgt.v00, lft.v11 + rgt.v10) + 1;
if (ret.v10 > inf) ret.v10 = inf;
ret.v11 = min(lft.v11 + rgt.v11, lft.v10 + rgt.v01) + 1;
if (ret.v11 > inf) ret.v11 = inf;
return ret;
}
void build(long long id, long long l, long long r) {
if (l == r) {
init(l, id);
return;
}
long long mid = (l + r) >> 1;
build(left(id), l, mid);
build(right(id), mid + 1, r);
tree[id] = combines(tree[left(id)], tree[right(id)]);
}
node qry(long long id, long long x, long long y, long long l, long long r) {
if (r < x || l > y) return INV;
long long mid = (l + r) >> 1;
if (l >= x && r <= y) return tree[id];
node X = qry(left(id), x, y, l, mid);
node Y = qry(right(id), x, y, mid + 1, r);
if (X == INV) return Y;
if (Y == INV) return X;
return combines(X, Y);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
INV.v00 = inf + 29;
INV.v01 = inf + 61;
INV.v11 = inf + 37;
INV.v10 = inf + 101;
cin >> n >> m;
for (long long i = 0; i < n + n; i++) {
char x;
cin >> x;
a[i] = 0;
if (x != '.') a[i] = 1;
}
build(1, 0, n - 1);
long long q[2];
while (m--) {
cin >> q[0] >> q[1];
q[0]--;
q[1]--;
long long X = q[0];
long long Y = q[1];
long long actX = X % n;
long long actY = Y % n;
if (actX > actY) {
swap(actX, actY);
swap(q[0], q[1]);
swap(X, Y);
}
node Q = qry(1, actX, actY, 0, n - 1);
long long ans = 0;
if (X >= n && Y >= n) {
ans = Q.v11;
if (ans > n + n + 10) ans = -1;
cout << ans << "\n";
} else if (X >= n && Y < n) {
ans = Q.v10;
if (ans > n + n + 10) ans = -1;
cout << ans << "\n";
} else if (X < n && Y < n) {
ans = Q.v00;
if (ans > n + n + 10) ans = -1;
cout << ans << "\n";
} else {
ans = Q.v01;
if (ans > n + n + 10) ans = -1;
cout << ans << "\n";
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, z, x = -1000000000, a[100001], b[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = n; i >= 1; i--) {
b[i] = max(0LL, x - a[i] + 1);
x = max(a[i], x);
}
for (int i = 1; i <= n; i++) cout << b[i] << " ";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(long long int a, long long int b) { return a < b; }
int main() {
for (;;) {
long long int n, a[200000], i, j, k, min, mi, s = 1;
if (scanf("%lld", &n) == EOF) break;
for (i = 0; i < n; i++) scanf("%lld", &a[i]);
sort(a, a + n, cmp);
min = a[1] - a[0];
mi = 1;
for (i = 2; i < n; i++) {
k = a[i] - a[i - 1];
if (k < 0) k = -k;
if (k < min) {
min = k;
mi = i;
}
}
for (i = 1; i < n; i++) {
if (i == mi) continue;
k = a[i] - a[i - 1];
if (k < 0) k = -k;
if (k == min) s++;
}
printf("%lld %lld\n", min, s);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, const T& b) {
return a > b ? a = b, true : false;
}
template <class T>
bool umax(T& a, const T& b) {
return a < b ? a = b, true : false;
}
template <long long sz>
using tut = array<long long, sz>;
void usaco(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const long long N = 2e5 + 5;
const long long mod = (119 << 23) + 1;
const long long inf = LLONG_MAX;
const long double Pi = acos(-1);
void add(long long& a, long long b, long long mod = ::mod) {
a = (a + b) % mod;
}
void sub(long long& a, long long b, long long mod = ::mod) {
a = ((a - b) % mod + mod) % mod;
}
void mul(long long& a, long long b, long long mod = ::mod) {
a = (a * 1ll * b) % mod;
}
long long n, m, k, t, q, ans, res, a[N];
long long rr[N];
void solve(long long t_case) {
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
auto check2 = [&](long long b, long long a) -> long long {
return (a - 3ll * b * b + 3ll * b - 1);
};
auto check = [&](long long mm) -> bool {
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
long long l = 0, r = a[i];
while (l <= r) {
long long m = (l + r) >> 1;
if (check2(m, a[i]) >= mm)
l = m + 1;
else
r = m - 1;
}
rr[i] = l - 1;
cnt += rr[i];
}
return (cnt >= k);
};
long long l = -inf, r = inf;
while (l < r) {
long long m = (l + r + 1) >> 1;
if (check(m))
l = m;
else
r = m - 1;
}
check(l);
long long cnt = 0;
for (long long i = 1; i <= n; i++) cnt += rr[i];
cnt -= k;
for (long long i = 1; i <= n && cnt; i++) {
if (rr[i] && check2(rr[i], a[i]) == l) cnt--, rr[i]--;
}
for (long long i = 1; i <= n; i++) cout << rr[i] << " ";
cout << "\n";
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (0) {
long long t;
cin >> t;
for (long long t_case = 1; t_case <= t; t_case++) solve(t_case);
} else
solve(1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5010, M = 20010;
int n, m;
int min_stat[N];
long long cnt_stat[N];
long long ans;
long long dist(int a, int b) {
if (a <= b) {
return (long long)(b - a);
} else {
return (long long)(n - a + b);
}
}
int it[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
cnt_stat[a]++;
if (cnt_stat[a] == 1 || dist(a, min_stat[a]) > dist(a, b)) {
min_stat[a] = b;
}
}
for (int i = 1; i <= n; ++i) {
ans = 0;
for (int j = 1; j <= n; ++j) {
if (cnt_stat[j] > 0)
ans = max(ans, ((long long)cnt_stat[j] - 1) * (long long)n +
dist(i, j) + dist(j, min_stat[j]));
}
cout << ans << ' ';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[150][150], b[150][150];
int dir[4][2] = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
int main() {
int n, t;
while (scanf("%d %d", &n, &t) != EOF) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
a[75][75] = n;
int tag = 1;
while (tag) {
tag = 0;
memset(b, 0, sizeof(b));
for (int i = 0; i < 150; i++) {
for (int j = 0; j < 150; j++) {
if (a[i][j] >= 4) {
tag = 1;
for (int k = 0; k < 4; k++) {
b[i + dir[k][0]][j + dir[k][1]] += a[i][j] / 4;
}
b[i][j] += a[i][j] % 4;
} else {
b[i][j] += a[i][j];
}
}
}
if (tag) memcpy(a, b, sizeof(b));
}
while (t--) {
int x, y;
scanf("%d %d", &x, &y);
x += 75;
y += 75;
if (x < 150 && y < 150 && x >= 0 && y >= 0) {
printf("%d\n", a[x][y]);
} else {
puts("0");
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 998244353;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double pi = acosl(-1.), eps = 1e-9;
inline void sum(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
const int NN = 1000100;
char A[NN], L[NN], R[NN];
int n, ln, rn, B[NN];
void zval(const char *s, int len, int *z) {
z[0] = 0;
for (int b = 0, i = 1; i < len; i++) {
z[i] = max(min(z[i - b], z[b] + b - i), 0);
while (s[i + z[i]] == s[z[i]]) z[i]++;
if (i + z[i] > b + z[b]) b = i;
}
z[0] = len;
}
char zl[NN << 1], zr[NN << 1];
int zL[NN << 1], zR[NN << 1];
int main() {
scanf("%s %s %s", A + 1, L, R);
n = strlen(A + 1);
ln = strlen(L);
rn = strlen(R);
for (int i = 0; i < ln; i++) zl[i] = L[i];
zl[ln] = '*';
for (int i = ln + 1; i <= ln + n; i++) zl[i] = A[i - ln];
zval(zl, ln + n + 1, zL);
for (int i = 0; i < rn; i++) zr[i] = R[i];
zr[rn] = '*';
for (int i = rn + 1; i <= rn + n; i++) zr[i] = A[i - rn];
zval(zr, rn + n + 1, zR);
B[n + 1] = 1;
for (int i = n, st, ed; i; i--) {
B[i] = B[i + 1];
if (A[i] == '0') {
if (ln == 1 && L[0] == '0') {
st = ed = i + 1;
} else
continue;
} else {
st = i + ln;
if (st > n + 1) continue;
int p = zL[ln + i];
if (p < ln) {
if (A[i + p] < L[p]) st++;
}
if (st > n + 1) continue;
ed = i + rn;
if (ed <= n + 1) {
p = zR[rn + i];
if (p < rn) {
if (A[i + p] > R[p]) ed--;
}
} else
ed = n + 1;
if (ed < st) continue;
}
int d = B[st] - B[ed + 1];
if (d < 0) d += mod;
sum(B[i], d);
if (i == 1) {
cout << d << endl;
return 0;
}
}
puts("0");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 80;
int f[N][N][N][2], s[N][3];
int kn, vn, xn, pv[N], pk[N], px[N];
char ch[N];
int n;
void upd(int &x, int y) { x = min(x, y); }
int get(int d, int f, int v, int k, int x) {
int tot = 0, cnt[3];
cnt[0] = max(s[d][0] - v, 0);
cnt[1] = max(s[d][1] - k, 0);
cnt[2] = max(s[d][2] - x, 0);
for (register int i = (0); i <= (2); ++i)
if (i != f) tot += cnt[i];
return tot;
}
signed main() {
scanf("%d", &n);
scanf("%s", ch + 1);
bool flag = 0;
for (register int i = (1); i <= (n); ++i) {
s[i][0] = s[i - 1][0];
s[i][1] = s[i - 1][1];
s[i][2] = s[i - 1][2];
if (ch[i] == 'V')
s[i][0]++, pv[++vn] = i;
else if (ch[i] == 'K')
s[i][1]++, pk[++kn] = i;
else
s[i][2]++, px[++xn] = i;
if (ch[i] == 'K' && ch[i - 1] == 'V') flag = 1;
}
if (!flag) {
printf("0\n");
return 0;
}
memset(f, 0x3f, sizeof(f));
f[0][0][0][0] = 0;
for (register int v = (0); v <= (vn); ++v)
for (register int k = (0); k <= (kn); ++k)
for (register int x = (0); x <= (xn); ++x) {
if (v < vn)
upd(f[v + 1][k][x][1],
min(f[v][k][x][0], f[v][k][x][1]) + get(pv[v + 1], 0, v, k, x));
if (k < kn)
upd(f[v][k + 1][x][0], f[v][k][x][0] + get(pk[k + 1], 1, v, k, x));
if (x < xn)
upd(f[v][k][x + 1][0],
min(f[v][k][x][0], f[v][k][x][1]) + get(px[x + 1], 2, v, k, x));
}
int ans = min(f[vn][kn][xn][0], f[vn][kn][xn][1]);
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 102;
int n, m;
int arr[MAXN][MAXN];
vector<pair<pair<int, int>, pair<int, int>>> op;
void apply(int x, int y, int cx, int cy) {
for (int dx = 0; dx <= 1; ++dx)
for (int dy = 0; dy <= 1; ++dy) arr[x - dx][y - dy] ^= 1;
arr[cx][cy] ^= 1;
op.push_back({{x, y}, {cx, cy}});
}
void fix() {
int cnt = 0;
int cx0 = -1, cy0 = -1, cx1 = -1, cy1 = -1;
for (int i = 0; i <= 1; ++i)
for (int j = 0; j <= 1; ++j) {
if (arr[i][j] == 0) {
cx0 = i;
cy0 = j;
cnt++;
} else {
cx1 = i;
cy1 = j;
}
}
if (cnt == 4) return;
if (cnt == 1) apply(1, 1, cx0, cy0);
if (cnt == 2) {
apply(1, 1, cx1, cy1);
fix();
}
if (cnt == 3) {
apply(1, 1, cx0, cy0);
fix();
}
if (cnt == 0) {
apply(1, 1, cx1, cy1);
fix();
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
for (cin >> T; T; --T) {
op.clear();
cin >> n >> m;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
char c;
cin >> c;
arr[i][j] = (c == '1' ? 1 : 0);
}
for (int i = n - 1; i > 1; --i) {
for (int j = 1; j < m; ++j) {
if (arr[i][j] == 0 && arr[i][j - 1] == 0) continue;
int cx, cy;
if (arr[i][j] == 0) {
cx = i;
cy = j;
} else if (arr[i][j - 1] == 0) {
cx = i;
cy = j - 1;
} else {
cx = i - 1;
cy = j - 1;
}
apply(i, j, cx, cy);
}
}
for (int j = m - 1; j > 1; --j) {
if (arr[0][j] == 0 && arr[1][j] == 0) continue;
int cx, cy;
if (arr[0][j] == 0) {
cx = 0;
cy = j;
} else if (arr[1][j] == 0) {
cx = 1;
cy = j;
} else {
cx = 0;
cy = j - 1;
}
apply(1, j, cx, cy);
}
fix();
cout << op.size() << "\n";
for (auto o : op) {
int x, y, cx, cy;
tie(x, y) = o.first;
tie(cx, cy) = o.second;
for (int i = 0; i <= 1; ++i)
for (int j = 0; j <= 1; ++j) {
if (x - i == cx && y - j == cy) continue;
cout << x - i + 1 << " " << y - j + 1 << " ";
}
cout << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return (a ? gcd(b % a, a) : b);
}
long long int power(long long int a, long long int n) {
long long int p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long int power(long long int a, long long int n, long long int mod) {
long long int p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int l[n + 1];
for (int i = 0; i <= n - 1; ++i) cin >> l[i];
int i = 0;
while (l[i] == 0) i++;
if (i == n) {
cout << 0 << endl;
return 0;
}
i++;
long long int c = 1, t = 1;
while (i < n) {
while (l[i] == 0) {
i++;
t++;
}
if (i < n) {
c *= t;
}
t = 1;
i++;
}
cout << c << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int MAX_SIZE = 1000001;
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
long long int powermod(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int imod(long long int a, long long int m) {
return powermod(a, m - 2, m);
}
unsigned long long int aModM(string s, unsigned long long int mod) {
unsigned long long int number = 0;
for (unsigned long long int i = 0; i < s.length(); i++) {
number = (number * 10 + (s[i] - '0'));
number %= mod;
}
return number;
}
long long int gcd(long long int a, long long int b) {
if (a == 0 || b == 0) return a + b;
if (a > b)
return gcd(a % b, b);
else
return gcd(a, b % a);
}
vector<long long int> fact;
void factorial(long long int n) {
fact.push_back(1);
fact.push_back(1);
for (long long int i = 2; i <= n; i++)
fact.push_back((fact[i - 1] * i) % 1000000007);
}
struct Node {
long long int data;
Node *left;
Node *right;
};
Node *newNode(long long int data) {
Node *temp = new Node;
temp->data = data;
temp->right = temp->left = NULL;
return temp;
}
void printInorder(Node *node) {
if (node == NULL) return;
printInorder(node->left);
cout << node->data << " ";
printInorder(node->right);
}
void printLevelOrder(Node *root) {
if (root == NULL) return;
queue<Node *> q;
q.push(root);
long long int lvl = 1;
while (!q.empty()) {
long long int nodeCount = q.size();
while (nodeCount > 0) {
Node *node = q.front();
cout << node->data << " ";
q.pop();
if (node->left != NULL) q.push(node->left);
if (node->right != NULL) q.push(node->right);
nodeCount--;
}
lvl++;
cout << " ";
}
}
void myfun() {
factorial(1000);
long long int n, val, pos;
cin >> n >> val >> pos;
long long int left = 0;
long long int right = n;
long long int lcount = 0;
long long int rcount = 0;
while (left < right) {
long long int middle = (left + right) / 2;
if (middle == pos) {
left = middle + 1;
} else if (middle < pos) {
lcount++;
left = middle + 1;
} else {
rcount++;
right = middle;
}
}
long long int b = n - val;
long long int s = val - 1;
if (s >= lcount && b >= rcount) {
long long int total = fact[n - lcount - rcount - 1];
total = (total * imod(fact[b - rcount], 1000000007)) % 1000000007;
total = (total * imod(fact[s - lcount], 1000000007)) % 1000000007;
total = (total * fact[b]) % 1000000007;
total = (total * fact[s]) % 1000000007;
cout << total << "\n";
} else {
cout << 0 << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
while (t--) myfun();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long dx[] = {1, 0, -1, 0};
long long dy[] = {0, 1, 0, -1};
long long gcd(long long x, long long y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
long long expo(long long n, long long m, long long p) {
long long r = 1;
n = n % p;
while (m > 0) {
if (m % 2) r = (r * n) % p;
n = (n * n) % p;
m = m / 2;
}
return r % p;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long> z_function(string s) {
long long n = (long long)s.length();
vector<long long> z(n);
for (long long i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
long long s, x;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> s >> x;
long long aa = (s - x) / 2;
if ((s - x) % 2 == 1 || x > s) {
cout << 0 << '\n';
return 0;
}
long long ans = 0;
for (long long i = 0; i < 40; i++) {
if ((x & (1LL << i)) && ((aa & (1LL << i)) == 0)) {
ans++;
} else if ((x & (1LL << i)) && ((aa & (1LL << i)))) {
cout << "0" << '\n';
return 0;
}
}
ans = (1LL << ans);
if (s == x) ans -= 2;
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
bool cmp2(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first < b.first) return true;
if (a.first == b.first) {
if (a.second > b.second) {
return true;
}
}
return false;
}
bool cmp1(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first < b.first) return true;
if (a.first == b.first) {
if (a.second < b.second) {
return true;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long a, b, c, t, d, n, ans, e, i, x, temp, s, k, temp2, m, j;
cin >> t;
while (t--) {
cin >> n >> m;
vector<pair<long long, long long>> arr;
temp = n * m;
for (i = 0; i < temp; i++) {
cin >> x;
arr.push_back({x, i + 1});
}
sort(arr.begin(), arr.end());
vector<vector<pair<long long, long long>>> mat(n);
map<long long, pair<long long, long long>> mp;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
mat[i].push_back({arr[(i * m) + j].first, arr[(i * m) + j].second});
}
}
for (i = 0; i < m; i++) {
vector<pair<long long, long long>> temp2;
for (j = 0; j < n; j++) {
temp2.push_back({mat[j][i].first, mat[j][i].second});
}
sort(temp2.begin(), temp2.end(), cmp1);
for (j = 0; j < n; j++) {
mat[j][i] = temp2[j];
}
}
for (i = 0; i < n; i++) sort(mat[i].begin(), mat[i].end(), cmp2);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
mp[mat[i][j].second] = make_pair(i + 1, j + 1);
}
}
vector<set<long long>> v;
for (i = 0; i < n; i++) {
set<long long> ss;
ss.insert(0);
v.push_back(ss);
}
ans = 0;
pair<long long, long long> h;
for (auto k : mp) {
h = k.second;
auto l = v[h.first - 1].lower_bound(h.second);
if (l != v[h.first - 1].end()) {
j = distance(v[h.first - 1].begin(), l) - 1;
ans += j;
} else {
j = v[h.first - 1].size() - 1;
ans += j;
}
v[h.first - 1].insert(h.second);
}
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int x[300002], us[300002];
set<int> st;
vector<int> vec[300002], vec1[300002];
int main() {
int i, j, k, l, m, n, r;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> l >> r >> x[i];
vec[r].push_back(i);
vec1[l - 1].push_back(i);
}
for (i = n; i >= 1; i--) {
for (j = 0; j < vec[i].size(); j++) st.insert(vec[i][j]);
for (j = 0; j < vec1[i].size(); j++) st.erase(vec1[i][j]);
set<int>::iterator it = st.begin();
k = *it;
us[i] = x[k];
if (i == x[k]) {
for (std::set<int>::iterator it = st.begin(); it != st.end(); ++it) {
k = *it;
if (i != x[k]) {
us[i] = x[k];
break;
}
}
}
}
us[x[m]] = 0;
for (i = 1; i <= n; i++) cout << us[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using namespace std;
long long modu = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long a, b, x, y;
cin >> x >> y;
cin >> a >> b;
long long ans = 0;
ans += (max(x, y) - min(x, y)) * a;
if (2 * a < b) {
ans += 2 * min(x, y) * a;
} else {
ans += min(x, y) * b;
}
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
void debugarr(int* arr, int n) {
cout << "[";
for (int i = 0; i < n; i++) cout << arr[i] << " ";
cout << "]" << endl;
}
void debugvec(vector<int> arr) {
cout << "[";
for (int i = 0; i < ((int)(arr.size())); i++) cout << arr[i] << " ";
cout << "]" << endl;
}
int main() {
int n;
scanf("%d", &n);
long long sum[n];
vector<int> num;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
num.push_back(a);
if (i == 0)
sum[i] = a;
else
sum[i] = sum[i - 1] + a;
}
string str;
cin >> str;
long long ans[n];
memset(ans, 0, sizeof(ans));
ans[0] = (str[0] == '1' ? num[0] : 0);
for (int i = 1; i < ((int)(str.size())); i++) {
if (str[i] == '1')
ans[i] = ans[i - 1] + num[i];
else
ans[i] = ans[i - 1];
}
long long final = ans[n - 1];
for (int i = ((int)(str.size())) - 1; i >= 0; i--) {
if (str[i] == '1') {
final = ((final) > (ans[n - 1] - ans[i] + (i > 0 ? sum[i - 1] : 0))
? (final)
: (ans[n - 1] - ans[i] + (i > 0 ? sum[i - 1] : 0)));
}
}
cout << final << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> gr;
set<pair<int, int>> edges;
vector<int> used, ts;
bool cycle = false;
void dfs(int v) {
used[v] = 1;
for (int u : gr[v]) {
if (used[u] == 2) continue;
if (used[u] == 0)
dfs(u);
else
cycle = true;
}
used[v] = 2;
ts.push_back(v);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<vector<string>> v(n, vector<string>(k));
set<char> alpha;
for (int i = 0; i < n; i++) {
int ind;
cin >> ind;
for (int j = 0; j < k; j++) {
cin >> v[ind][j];
for (int h = 0; h < v[ind][j].size(); h++) alpha.insert(v[ind][j][h]);
}
}
gr.resize(26);
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
if (i == j && i == 0) continue;
int previ = i, prevj = j - 1;
if (prevj == -1) {
previ--;
prevj = k - 1;
}
int ind = 0;
while (ind < v[i][j].size() && ind < v[previ][prevj].size() &&
v[previ][prevj][ind] == v[i][j][ind])
ind++;
if (v[i][j].size() < v[previ][prevj].size() && ind == v[i][j].size()) {
cout << "IMPOSSIBLE";
return 0;
}
if (ind < v[i][j].size() && ind < v[previ][prevj].size() &&
edges.find({v[previ][prevj][ind] - 'a', v[i][j][ind] - 'a'}) ==
edges.end()) {
edges.insert({v[previ][prevj][ind] - 'a', v[i][j][ind] - 'a'});
gr[v[previ][prevj][ind] - 'a'].push_back(v[i][j][ind] - 'a');
}
}
}
used.resize(26);
for (int i = 0; i < 26; i++) {
if (!used[i]) dfs(i);
}
if (cycle) {
cout << "IMPOSSIBLE";
return 0;
}
reverse(ts.begin(), ts.end());
for (int i = 0; i < 26; i++) {
if (alpha.find(char('a' + ts[i])) != alpha.end()) cout << char('a' + ts[i]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> Ans;
int N, M, K;
struct Edge {
int u, v, w, id;
} e1[100005], e2[100005];
int M1, M2;
bool Comparew(Edge a, Edge b) {
if (a.w == b.w) {
if (a.u == 1 || a.v == 1)
return 1;
else
return 0;
} else {
if (a.w < b.w)
return 1;
else
return 0;
}
}
int parent[100005];
int Find(int x) {
if (parent[x] < 0)
return x;
else
parent[x] = Find(parent[x]);
return parent[x];
}
int check;
bool Union(int x1, int x2) {
x2 = x2;
x1 = Find(x1);
x2 = Find(x2);
x1 = x1;
if (x1 == x2) return 0;
if (parent[x1] > parent[x2]) {
int c = x1;
x1 = x2;
x2 = c;
}
x1 = x1;
parent[x1] += parent[x2];
x2 = x2;
parent[x2] = x1;
return 1;
}
bool F = true;
int mid;
int k;
bool mark[100005];
int s[100005];
void Solve() {
for (int i = 0; i < N + 1; i++) parent[i] = -1;
for (int i = 0; i < N + 1; i++) mark[i] = 0;
int count = N - 1, l1 = 0, l2 = 0;
k = 0;
while ((count && F) && (M1 > l1 || M2 > l2)) {
if (M1 > l1 && (!(l2 ^ M2) || e1[l1].w + mid < e2[l2].w) && F) {
if (Union(e1[l1].u, e1[l1].v)) {
count--;
F = true;
k++;
F = false;
mark[e1[l1].id] = 1;
F = true;
}
l1++;
} else if (M2 > l2 && (!(l1 ^ M1) || e1[l1].w + mid >= e2[l2].w)) {
if (Union(e2[l2].u, e2[l2].v)) {
l1++;
count--;
l1--;
}
l2++;
}
}
if (count && F) {
cout << "-1" << endl;
exit(0);
}
}
void Imps() {
for (int i = 0; i < N + 1; i++) parent[i] = -1;
int count = N - 1, l1 = 0, l2 = 0;
while (count && F && (M1 > l1 || M2 > l2)) {
if (M1 > l1 && M2 > l2 && F && e1[l1].w + mid == e2[l2].w && check && F &&
!mark[e1[l1].id]) {
if (Union(e1[l1].u, e1[l1].v)) {
l2++;
s[count--] = e1[l1].id;
l2--;
check--;
}
l1++;
} else if (F && M1 > l1 && (!(l2 ^ M2) || e1[l1].w + mid < e2[l2].w)) {
if (Union(e1[l1].u, e1[l1].v)) {
l2++;
s[count--] = e1[l1].id;
l2--;
}
l1++;
} else if (M2 > l2 && (l1 == M1 || e1[l1].w + mid >= e2[l2].w)) {
if (Union(e2[l2].u, e2[l2].v)) {
l1--;
s[count--] = e2[l2].id;
l1++;
}
l2++;
}
}
}
int main() {
scanf("%d%d%d", &N, &M, &K);
if (N == 1) {
if (K)
cout << "-1" << endl;
else
cout << "0" << endl;
return 0;
}
int chek = 0;
if (!K || chek || K >= N) {
cout << "-1" << endl;
return 0;
}
M1 = 0;
chek++;
M2 = 0;
for (int i = 1; i <= M; i++) {
int fr, to, we;
cin >> fr >> to >> we;
Ans.push_back(we);
if (fr > to) {
int temp = fr;
fr = to;
to = temp;
}
if (fr == 1 && F) {
e1[M1].u = fr;
e1[M1].v = to;
e1[M1].w = we;
e1[M1].id = i;
M1++;
} else {
e2[M2].u = fr;
e2[M2].v = to;
e2[M2].w = we;
e2[M2].id = i;
M2++;
}
}
sort(e1, e1 + M1, Comparew);
sort(e2, e2 + M2, Comparew);
int lef = -1e5 - 1;
int rit = 1e5 + 1;
while (lef < rit) {
mid = lef + rit >> 1;
Solve();
if (k <= K) {
lef++;
rit = mid;
lef--;
} else {
rit++;
lef = mid + 1;
rit--;
}
}
mid = lef;
if (F) {
check = 0;
}
Solve();
check = K - k;
Imps();
if (check && F && (lef == -1e5 - 1 || rit == 1e5 + 1)) {
cout << "-1" << endl;
return 0;
}
cout << N - 1 << endl;
for (int i = 1; i < N; i++) cout << s[i] << " ";
return 0;
}
| 8 |
#include <bits/stdc++.h>
const long long int mod = 1000000007;
const long long int AM = 2e5 + 5;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t;
cin >> t;
while (t--) {
long long int l, r;
cin >> l >> r;
long long int tmp = l;
for (__typeof(0) i = 0; i < 65; ++i) {
long long int x = tmp & (1LL << i);
if (!x) {
if (tmp + (1LL << i) <= r)
tmp += (1LL << i);
else
break;
}
}
cout << tmp << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
bool flg = true;
for (int i = 0; i < n - 1; i++) {
if (v[i] != v[i + 1]) {
flg = false;
break;
}
}
if (flg)
cout << n << "\n";
else
cout << 1 << "\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int findArea(int w, int h) {
int numW = floor(w / 2);
int stacked = numW * h;
if (w % 2 == 1) stacked += floor(h / 2);
return stacked;
}
int main() {
int m, n;
cin >> m >> n;
int mSIde = findArea(m, n), nSide = findArea(n, m);
int d = max(mSIde, nSide);
cout << d << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
void task() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
int left = 0;
int right = n + 1;
int last = 1;
for (int i = 0; i < k; ++i)
cout << (last = (i % 2 ? --right : ++left)) << ' ';
int d = k % 2 ? 1 : -1;
for (int i = last + d; i < right && left < i; i += d) cout << i << ' ';
}
int main() {
task();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[300010];
int cnt[300010];
int main() {
int q;
scanf("%d", &q);
while (q--) {
int a, b;
scanf("%d%d", &a, &b);
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) cnt[i] = 0;
int st = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '.')
st++;
else {
if (st) {
cnt[st]++;
}
st = 0;
}
}
if (s[n] == '.') cnt[st]++;
int tot = 0;
for (int i = b; i < a; i++) tot += cnt[i];
if (tot) {
puts("NO");
continue;
}
tot = 0;
for (int i = a; i <= n; i++) tot += cnt[i];
if (!tot) {
puts("NO");
continue;
}
tot = 0;
for (int i = 2 * b; i <= n; i++) tot += cnt[i];
if (tot >= 2) {
puts("NO");
continue;
}
if (!tot) {
for (int i = a; i <= n; i++) tot += cnt[i];
if (tot & 1)
puts("YES");
else
puts("NO");
continue;
}
int x;
for (int i = 2 * b; i <= n; i++) {
if (cnt[i]) x = i;
}
tot = 0;
for (int i = a; i < 2 * b; i++) tot += cnt[i];
int flag = 0;
for (int p = 0; p <= x - a; p++) {
int q = x - a - p;
if (p >= 2 * b || q >= 2 * b || (p < a && p >= b) || (q < a && q >= b))
continue;
int num = tot;
if (p >= a) num++;
if (q >= a) num++;
if (num % 2 == 0) flag = 1;
}
if (flag)
puts("YES");
else
puts("NO");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4000;
int n, m;
vector<int> G[maxn];
int dis[maxn][maxn];
int maxto[maxn][4];
int maxfrom[maxn][4];
void update(int d[][4], int v, int u, int len) {
if (d[v][1] < len) d[v][1] = len, d[v][3] = u;
if (d[v][1] > d[v][0]) swap(d[v][1], d[v][0]), swap(d[v][2], d[v][3]);
}
void bfs(int s) {
dis[s][s] = 0;
queue<int> Q;
Q.push(s);
while (!Q.empty()) {
int v = Q.front();
Q.pop();
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
if (dis[s][u] == -1) {
dis[s][u] = dis[s][v] + 1, Q.push(u);
update(maxto, s, u, dis[s][u]);
update(maxfrom, u, s, dis[s][u]);
}
}
}
}
int ans[4];
int maxdis = 0;
int main() {
memset(dis, -1, sizeof dis);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
}
for (int i = 1; i <= n; i++) bfs(i);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j || dis[i][j] == -1) continue;
for (int p1 = 2; p1 < 4; p1++) {
for (int p2 = 2; p2 < 4; p2++) {
int vf = maxfrom[i][p1];
int vt = maxto[j][p2];
int df = maxfrom[i][p1 - 2];
int dt = maxto[j][p2 - 2];
if (vf == i || vf == vt || vf == j || vt == i || vt == j || vf == 0 ||
vt == 0)
continue;
int d = dis[i][j] + df + dt;
if (d > maxdis) {
maxdis = d;
ans[0] = vf;
ans[1] = i;
ans[2] = j;
ans[3] = vt;
}
}
}
}
}
for (int i = 0; i < 4; i++) cout << ans[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 700012;
const int inf = 2e9;
int n, u, v;
vector<int> g[N];
int k, ans;
int best[N];
int len[N];
int st;
vector<int> order;
int par[N];
inline void dfs(int s) {
for (int v : order) {
int mx1 = 0, mx2 = -1e9;
for (int to : g[v]) {
if (to == par[v]) continue;
if (len[to] >= mx1)
mx2 = mx1, mx1 = len[to];
else if (len[to] >= mx2)
mx2 = len[to];
}
if (mx1 + mx2 + 1 >= st) {
len[v] = 0;
++ans;
} else {
len[v] = mx1 + 1;
}
}
}
int lvl[N];
inline void calc(int v, int p = 0) {
lvl[v] = lvl[p] + 1;
par[v] = p;
for (int to : g[v]) {
if (to == p) continue;
calc(to, v);
}
order.push_back(v);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n - 1; ++i) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
int root = 1;
const int K = 1000;
calc(root);
int kt = n;
for (int i = 1; i <= min(K, n); ++i) {
st = i;
ans = 0;
dfs(root);
best[i] = ans;
kt = min(kt, ans);
}
for (int i = 1; i <= kt + 1; ++i) {
int l = 1, r = (n + i - 1) / i + 1;
while (l + 1 < r) {
int m = (l + r) / 2;
ans = 0;
st = m;
dfs(root);
if (ans >= i)
l = m;
else
r = m;
}
best[l] = max(best[l], i);
}
for (int i = n; i >= 1; --i) {
best[i] = max(best[i], best[i + 1]);
}
cout << n << '\n';
for (int i = 2; i <= n; ++i) cout << best[i] << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:200000000")
const double EPS = 1E-9;
const int INF = 1000000000;
const long long INF64 = (long long)1E18;
const double PI = 3.1415926535897932384626433832795;
int n, m;
bool u[1100][1100];
double z[1100][1100];
double rec(int pos, int taken) {
if (taken == n || pos == m) return double(taken) / n;
if (u[pos][taken]) return z[pos][taken];
double p = (n - taken) / double(n * m - pos);
double res = rec(pos + 1, taken + 1) * p + rec(pos + 1, taken) * (1 - p);
u[pos][taken] = true;
return z[pos][taken] = res;
}
int main() {
cin >> n >> m;
double res = rec(1, 1);
printf("%.10lf\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
n = n / 2520;
cout << n << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char _;
inline long long powmod(long long x, long long n, long long _mod) {
long long res = 1;
while (n) {
if (n & 1) res = (res * x) % _mod;
x = (x * x) % _mod;
n >>= 1;
}
return res;
}
int n, m;
long double dis(pair<int, int> p, pair<int, int> q) {
return sqrt((long double)(p.first - q.first) * (p.first - q.first) +
(long double)(p.second - q.second) * (p.second - q.second));
}
bool inside(int x, int y) {
if (x < 0 or x > n or y < 0 or y > m) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
set<pair<int, int> > s;
s.insert(make_pair(0, 0));
if (inside(1, 0)) s.insert(make_pair(1, 0));
if (inside(0, 1)) s.insert(make_pair(0, 1));
s.insert(make_pair(n, m));
if (inside(n - 1, m)) s.insert(make_pair(n - 1, m));
if (inside(n, m - 1)) s.insert(make_pair(n, m - 1));
vector<pair<int, int> > v;
for (__typeof((s).begin()) itr = (s).begin(); itr != (s).end(); itr++)
v.push_back(*itr);
long double ans = 0;
pair<int, int> a, b, c, d;
do {
pair<int, int> p1 = v[0];
pair<int, int> p2 = v[1];
pair<int, int> p3 = v[2];
pair<int, int> p4 = v[3];
long double D = dis(p1, p2) + dis(p2, p3) + dis(p3, p4);
if ((D + 1e-9) > ans) {
ans = D;
a = p1;
b = p2;
c = p3;
d = p4;
}
} while (next_permutation((v).begin(), (v).end()));
if (n > 0 and m > 0) {
pair<int, int> p1 = make_pair(0, 0);
pair<int, int> p2 = make_pair(n, m);
pair<int, int> p3 = make_pair(n, 0);
pair<int, int> p4 = make_pair(0, m);
long double D = dis(p1, p2) + dis(p2, p3) + dis(p3, p4);
if ((D + 1e-9) > ans) {
ans = D;
a = p1;
b = p2;
c = p3;
d = p4;
}
swap(p3, p4);
D = dis(p1, p2) + dis(p2, p3) + dis(p3, p4);
if ((D + 1e-9) > ans) {
ans = D;
a = p1;
b = p2;
c = p3;
d = p4;
}
}
cout << a.first << ' ' << a.second << '\n';
cout << b.first << ' ' << b.second << '\n';
cout << c.first << ' ' << c.second << '\n';
cout << d.first << ' ' << d.second << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
t = 1;
while (t--) {
long long int n;
cin >> n;
vector<string> team;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
team.push_back(str);
}
unordered_map<string, int> ump;
for (int i = 0; i < n; i++) {
if (ump.find(team[i]) == ump.end()) {
ump.insert({team[i], 1});
} else {
ump[team[i]]++;
}
}
int mx = INT_MIN;
string ans;
for (auto &it : ump) {
if (it.second > mx) {
ans = it.first;
mx = it.second;
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
typedef long long LL;
const double INF = 1e100;
const int oo = ~0u >> 2;
const double pi = acos(-1.0);
const double EPS = 1e-8;
const int MAXN = 100033;
int n, a, b;
int cur = 1;
int s[133][133];
int main() {
scanf("%d%d%d", &n, &a, &b);
for (int i = (1), __ = (a); i <= __; ++i) {
if (i & 1)
for (int j = (1), __ = (b); j <= __; ++j) {
if (cur <= n) s[i][j] = cur++;
}
else
for (int j = (b), __ = (1); j >= __; --j) {
if (cur <= n) s[i][j] = cur++;
}
}
if (cur != n + 1) {
puts("-1");
return 0;
}
for (int i = (1), __ = (a); i <= __; ++i) {
for (int j = (1), __ = (b); j <= __; ++j) printf("%d ", s[i][j]);
puts("");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
struct node {
int l, r, sum;
node *ls, *rs;
node(int x, int y) {
l = x;
r = y;
sum = 0;
ls = nullptr;
rs = nullptr;
}
};
node *root[MAXN];
void cop(node *a, node *b) {
a->l = b->l;
a->r = b->r;
a->sum = b->sum;
a->ls = b->ls;
a->rs = b->rs;
}
void pac(node *curr, int co) {
if (curr->l == curr->r) {
curr->sum = 1;
return;
}
node *tmp = new node(0, 0);
int s = (curr->l + curr->r) / 2;
if (co <= s) {
if (curr->ls != nullptr)
cop(tmp, curr->ls);
else
tmp = new node(curr->l, s);
curr->ls = tmp;
pac(tmp, co);
} else {
if (curr->rs != nullptr)
cop(tmp, curr->rs);
else
tmp = new node(s + 1, curr->r);
curr->rs = tmp;
pac(tmp, co);
}
curr->sum = 0;
if (curr->ls != nullptr) curr->sum += curr->ls->sum;
if (curr->rs != nullptr) curr->sum += curr->rs->sum;
}
int daj(node *curr, int l, int r) {
if (curr->l == l && curr->r == r) return curr->sum;
int s = (curr->l + curr->r) / 2, x = 0;
if (l <= s && curr->ls != nullptr) x = daj(curr->ls, l, min(r, s));
if (r > s && curr->rs != nullptr) x += daj(curr->rs, max(s + 1, l), r);
return x;
}
int kwad(int a, int b, int c, int d) {
return daj(root[c], b, d) - daj(root[a - 1], b, d);
}
int main() {
int a, b, c, d, e, f, g, q, n;
node *curr;
long long p[9];
scanf("%d%d", &n, &q);
root[0] = new node(0, n + 1);
for (a = 1; a <= n; a++) {
scanf("%d", &b);
root[a] = new node(0, n + 1);
cop(root[a], root[a - 1]);
pac(root[a], b);
}
root[n + 1] = root[n];
while (q--) {
scanf("%d%d%d%d", &a, &b, &c, &d);
p[0] = kwad(1, d + 1, a - 1, n + 1);
p[1] = kwad(a, d + 1, c, n + 1);
p[2] = kwad(c + 1, d + 1, n + 1, n + 1);
p[3] = kwad(1, b, a - 1, d);
p[4] = kwad(a, b, c, d);
p[5] = kwad(c + 1, b, n + 1, d);
p[6] = kwad(1, 0, a - 1, b - 1);
p[7] = kwad(a, 0, c, b - 1);
p[8] = kwad(c + 1, 0, n + 1, b - 1);
printf("%lld\n", (p[0] + p[3]) * (p[4] + p[5] + p[7] + p[8]) +
p[1] * (p[3] + p[4] + p[5] + p[6] + p[7] + p[8]) +
p[2] * (p[3] + p[4] + p[6] + p[7]) +
p[4] * (p[5] + p[6] + p[7] + p[8]) +
p[4] * (p[4] - 1) / 2 + p[5] * (p[6] + p[7]));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1;
cin >> s2;
int two = 0, one = 0, ans = 0;
if (s1[0] == '0' && s2[0] == '0')
two++;
else if (s1[0] == '0' || s2[0] == '0')
one++;
for (int i = 1; i < s1.length(); i++) {
if (two != 0) {
if (s1[i] == '0') {
two = 0;
ans++;
if (s2[i] == '0') one++;
} else if (s2[i] == '0') {
two = 0;
ans++;
}
two = 0;
} else if (one != 0) {
if (s1[i] == '0' && s2[i] == '0') {
one = 0;
ans++;
} else if (s1[i] == '0' || s2[i] == '0')
one = 1;
else
one = 0;
} else {
if (s1[i] == '0' && s2[i] == '0') {
two++;
} else if (s1[i] == '0' || s2[i] == '0')
one++;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, m = 0, a = 1, b = 0, c = 0;
cin >> n >> m;
b = m;
for (int i = 0; i <= b; i += 2) {
cout << a << ' ' << a + m << ' ';
a++;
m -= 2;
if (m < 1) {
break;
}
c += 2;
}
if (m == 0) {
cout << a << ' ';
}
for (int i = b + 2; i <= n; i++) {
cout << i << ' ';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = (int)4e6 + 100;
const int INF = (int)1e9 + 7;
const long long LINF = (long long)1e18;
const double EPS = (double)1e-9;
int n, m;
int a[1555][1555];
long long p[1555][1555];
long long d[1555][1555];
long long ans = -LINF;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
scanf("%d", &a[i][j]);
p[i][j] = p[i][j - 1] + 1LL * a[i][j];
}
}
for (int i = 0; i <= n + 1; ++i) {
for (int j = 0; j <= m + 1; ++j) {
d[i][j] = -LINF;
}
}
for (int i = m; i >= 1; --i) {
d[1][i] = max(p[1][i], d[1][i + 1]);
}
for (int i = 2; i <= n; ++i) {
if (i % 2 == 0) {
for (int j = 1; j <= m; ++j) {
d[i][j] = max(d[i][j - 1], d[i - 1][j + 1] + p[i][j]);
}
} else {
for (int j = m; j >= 1; --j) {
d[i][j] = max(d[i][j + 1], d[i - 1][j - 1] + p[i][j]);
}
}
}
for (int i = 1; i <= m; ++i) {
ans = max(ans, d[n][i]);
}
printf("%I64d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <int N1, int N2>
using aii = array<array<int, N2>, N1>;
template <int N1>
using ai = array<int, N1>;
template <int N1>
using ac = array<char, N1>;
int main() {
uint64_t a;
int k;
cin >> a >> k;
ai<100> v;
uint64_t a1 = a;
int i = 0;
while (a1 != 0ULL) {
v[i++] = a1 % 10;
a1 = a1 / 10;
}
int n = i, ck = 0;
i = n - 1;
while ((i > 0) && (ck < k)) {
int max = i;
for (int j = i; j >= 0; j--)
if ((v[j] > v[max]) && (i - j <= k - ck)) max = j;
for (int j = max; j < i; j++) swap(v[j], v[j + 1]);
ck += i - max;
i--;
}
for (int i = 0; i < n; i++) cout << v[n - i - 1];
}
| 3 |
#include <bits/stdc++.h>
const int mod = 1000000007;
using LL = long long;
namespace tree {
struct edge {
int to, nxt;
} e[200005 << 1];
int head[200005], tot, n, a[200005], f[18][200005], dep[200005], idx,
dfn[200005];
void addedge(int x, int y) {
e[++tot] = (edge){y, head[x]};
head[x] = tot;
e[++tot] = (edge){x, head[y]};
head[y] = tot;
}
void dfs0(int x) {
dfn[x] = ++idx;
for (int i = 1; i < 18; i++) f[i][x] = f[i - 1][f[i - 1][x]];
for (int i = head[x]; i; i = e[i].nxt)
if (e[i].to != f[0][x])
f[0][e[i].to] = x, dep[e[i].to] = dep[x] + 1, dfs0(e[i].to);
}
int lca(int x, int y) {
if (dep[x] < dep[y]) std::swap(x, y);
for (int i = dep[x] - dep[y]; i; i &= i - 1) x = f[__builtin_ctz(i)][x];
for (int i = 17; i + 1; i--)
if (f[i][x] != f[i][y]) x = f[i][x], y = f[i][y];
return x == y ? x : f[0][x];
}
} // namespace tree
void up(int &x, int y) {
if ((x += y) >= mod) x -= mod;
}
namespace number {
int phi[200005], miu[200005], pr[200005], pt, F[200005], inv[200005],
sie[200005];
int pow(int x, int y) {
int ans = 1;
for (; y; y >>= 1, x = static_cast<LL>(x) * x % mod)
if (y & 1) ans = static_cast<LL>(ans) * x % mod;
return ans;
}
void sieve(int R) {
phi[1] = miu[1] = 1;
for (int i = 2; i <= R; i++) {
if (!sie[i]) phi[i] = i - 1, miu[i] = mod - 1, pr[++pt] = i;
for (int j = 1, t; j <= pt && (t = i * pr[j]) <= R; j++) {
sie[t] = 1;
if (i % pr[j] == 0) {
phi[t] = phi[i] * pr[j], miu[t] = 0;
break;
}
phi[t] = phi[i] * (pr[j] - 1), up(miu[t] = 0, mod - miu[i]);
}
}
inv[1] = 1;
for (int i = 2; i <= R; i++)
inv[i] = static_cast<LL>(inv[mod % i]) * (mod - mod / i) % mod;
for (int i = 1; i <= R; i++)
for (int j = i, t = 1; j <= R; j += i, t++)
up(F[j], static_cast<LL>(i) * inv[phi[i]] % mod * miu[t] % mod);
}
} // namespace number
namespace vtree {
int head[200005], tot, size[200005], val[200005], sum = 0, ans = 0;
struct edge {
int to, nxt, len;
} e[200005 << 1];
void addedge(int x, int y, int z) {
e[++tot] = (edge){y, head[x], z};
head[x] = tot;
e[++tot] = (edge){x, head[y], z};
head[y] = tot;
}
void addedge(int x, int y) {
addedge(x, y, std::abs(tree::dep[x] - tree::dep[y]));
}
int dfs0(int x, int f) {
size[x] = 0;
for (int i = head[x]; i; i = e[i].nxt)
if (e[i].to != f)
up(size[x], dfs0(e[i].to, x)),
up(ans, static_cast<LL>(size[e[i].to]) * (sum - size[e[i].to] + mod) %
mod * e[i].len * 2 % mod);
up(size[x], val[x]);
val[x] = 0;
head[x] = 0;
return size[x];
}
} // namespace vtree
int query[200005], ans, stack[200005], top, n, a[200005], map[200005], x, y;
int main() {
std::scanf("%d", &n);
for (int i = 1; i <= n; i++) std::scanf("%d", &a[i]), map[a[i]] = i;
for (int i = 1; i < n; i++) std::scanf("%d%d", &x, &y), tree::addedge(x, y);
number::sieve(n), tree::dfs0(1);
for (int i = 1; i <= n; i++) {
int tot = 0;
vtree::sum = vtree::ans = vtree::tot = 0;
for (int j = i; j <= n; j += i)
query[++tot] = map[j], up(vtree::sum, number::phi[j]),
vtree::val[map[j]] = number::phi[j];
std::sort(query + 1, query + tot + 1,
[](int i, int j) { return tree::dfn[i] < tree::dfn[j]; });
int rt = query[1];
for (int j = 2; j <= tot; j++) rt = tree::lca(rt, query[j]);
stack[top = 1] = rt;
for (int j = 1; j <= tot; j++) {
int lca = tree::lca(query[j], stack[top]);
while (tree::dep[lca] < tree::dep[stack[top - 1]])
vtree::addedge(stack[top], stack[top - 1]), --top;
if (lca != stack[top]) vtree::addedge(lca, stack[top--]);
if (stack[top] != lca) stack[++top] = lca;
if (stack[top] != query[j]) stack[++top] = query[j];
}
while (--top) vtree::addedge(stack[top + 1], stack[top]);
vtree::dfs0(rt, 0);
up(ans, static_cast<LL>(number::F[i]) * vtree::ans % mod);
}
std::printf("%d\n",
static_cast<LL>(ans) *
number::pow(static_cast<LL>(n) * (n - 1) % mod, mod - 2) %
mod);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int const N = 3 * 1e5 + 20;
int n, x, y, k, p, h[N], arr[N], p1, p2, ans;
long long t;
vector<int> adj[N];
void dfs(int v, int p = -1) {
h[v] = ~p ? h[p] + 1 : 0;
for (auto u : adj[v])
if (u != p) dfs(u, v);
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> p;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
x--, y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(0);
for (int i = 0; i < n; i++) arr[i] = h[i];
sort(arr, arr + n, greater<int>());
n--;
for (; p1 < n; p1++) {
if (p1 == p2) p2++;
for (; p2 < n && t + arr[p1] - arr[p2] <= p && p2 - p1 < k; p2++)
t += arr[p1] - arr[p2];
ans = max(ans, p2 - p1);
t -= 1LL * (p2 - p1 - 1) * (arr[p1] - arr[p1 + 1]);
}
return cout << ans, 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<string> x;
vector<pair<int, char>> s = {{0, 'A'}, {0, 'B'}, {0, 'C'}};
for (int i = 0; i < 3; i++) {
string temp;
cin >> temp;
if (temp == "A>B" || temp == "B<A") {
s[0].first++;
}
if (temp == "A>C" || temp == "C<A") {
s[0].first++;
}
if (temp == "B>A" || temp == "A<B") {
s[1].first++;
}
if (temp == "B>C" || temp == "C<B") {
s[1].first++;
}
if (temp == "C>A" || temp == "A<C") {
s[2].first++;
}
if (temp == "C>B" || temp == "B<C") {
s[2].first++;
}
}
sort(s.begin(), s.end());
if (s[0].first == s[1].first || s[1].first == s[2].first ||
s[2].first == s[0].first) {
cout << "Impossible";
} else {
for (int i = 0; i < 3; i++) {
cout << s[i].second;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
long *value = new long[n];
for (int k = 0; k < n; k++) {
scanf("%ld", value + k);
}
long output = 0, currentMax = -30000000;
for (int div = 1; div <= n / 3; div++) {
if (n % div != 0) {
continue;
}
for (int rem = 0; rem < div; rem++) {
output = 0;
for (int k = 0; k < n / div; k++) {
output += value[div * k + rem];
}
if (output > currentMax) {
currentMax = output;
}
}
}
printf("%ld\n", currentMax);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[200005], b[200005], i, j, x, y, r, s;
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
cin >> m;
for (i = 0; i < m; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + m);
x = 2 * n;
y = 2 * m;
r = 2 * n;
s = 2 * m;
for (i = n - 1, j = m - 1; i >= 0; i--) {
r++;
for (j; j >= 0 && b[j] >= a[i]; j--) s++;
if (r - s >= x - y) {
x = r;
y = s;
}
}
cout << x << ':' << y;
return 0;
}
| 4 |
#include <bits/stdc++.h>
double const EPS = 3e-8;
using namespace std;
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
const int NX = 30000 + 5;
int gem[NX], n, d, mx;
int vis[NX][1005], dp[NX][1005];
int DP(int cur, int l) {
if (cur > mx) return 0;
if (cur == mx) return gem[mx];
if (vis[cur][l]) return dp[cur][l];
vis[cur][l] = 1;
dp[cur][l] = gem[cur];
int a = 0, b = 0, c = 0;
if (l - 1 >= 1) a = DP(cur + l - 1, l - 1);
b = DP(cur + l, l);
c = DP(cur + l + 1, l + 1);
dp[cur][l] += max(a, max(b, c));
return dp[cur][l];
}
int DP2(int cur, int l) {
if (cur > mx) return 0;
if (cur == mx) return gem[mx];
int ans = gem[cur];
int a = 0, b = 0, c = 0;
if (l - 1 >= 1) a = DP(cur + l - 1, l - 1);
b = DP(cur + l, l);
c = DP(cur + l + 1, l + 1);
ans += max(a, max(b, c));
return ans;
}
int main() {
n = ({
int a;
read(a);
a;
}),
d = ({
int a;
read(a);
a;
});
mx = 0;
for (__typeof((n)-1) i = (0); i <= (n)-1; ++i) {
int x = ({
int a;
read(a);
a;
});
gem[x] += 1;
if (x > mx) mx = x;
}
if (d <= 1200)
printf("%d\n", DP(d, d));
else
printf("%d\n", DP2(d, d));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long max(long long a, long long b) { return ((a > b) ? a : b); }
inline long long min(long long a, long long b) { return ((a > b) ? b : a); }
inline long long gcd(long long a, long long b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
long long power(long long x, long long y) {
if (y == 0) return 1;
long long a = power(x, y / 2);
if (y % 2 == 0)
return a * a;
else
return x * a * a;
}
long long powermod(long long x, long long ex, long long md) {
long long ans = 1ll;
while (ex > 0) {
if (ex & 1ll) ans = (ans * x) % md;
ex >>= 1ll;
x = (x * x) % md;
}
return ans;
}
const long long inf = 1e18 + 9;
const long long mod = 1e9 + 7;
const long double PI = acos(-1);
const long double eps = 1e-9;
const long long N = 1e5 + 11;
long long n;
void solve() {
cin >> n;
for (long long i = 1; i <= n; i++) {
long long l = i, r = n * n - i + 1;
cout << l << " " << r << " ";
long long ct = 2;
while (ct < n) {
l += n;
r -= n;
cout << l << " " << r << " ";
ct += 2;
}
cout << "\n";
}
}
int main() {
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
cout << fixed << setprecision(20);
long long NTC = 1;
long long PTC = 0;
while (PTC++ < NTC) {
solve();
cout << "\n";
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int m, n;
cin >> m >> n;
int a[m];
for (int i = 0; i < m; i++) cin >> a[i];
int b[n];
for (int i = 0; i < n; i++) cin >> b[i];
unordered_set<int> s;
for (int i = 0; i < m; i++) s.insert(a[i]);
int flag = 1;
for (int i = 0; i < n; i++) {
if (s.find(b[i]) != s.end()) {
cout << "YES" << endl;
cout << 1 << " " << b[i] << endl;
flag = 0;
break;
}
}
if (flag == 1) cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
register T c = getchar();
x = 0;
int t = 0;
if (c == '-') t = 1, c = getchar();
for (; (c < 48 || c > 57); c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (t) x = -x;
}
int main() {
string s;
cin >> s;
long long l = s.length();
long long tot = pow(2, l);
long long ans = LLONG_MAX;
bool found = false;
for (int i = 1; i < tot; ++i) {
long long temp = 1 << (l - 1);
long long num = 0;
long long cnt = l;
bool f = true;
bool prev = false;
for (int j = 0; j < l; ++j) {
if (temp & i) {
num = num * 10 + (s[j] - '0');
--cnt;
if (f) {
if (s[j] == '0') {
prev = true;
}
f = false;
}
}
temp >>= 1;
}
if (prev) continue;
long long sq = sqrt(num);
if ((sq * sq) == num) {
ans = min(ans, cnt);
found = true;
}
}
if (found)
cout << ans;
else
cout << -1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int a[200010], b[200010], c[200010];
int l[200010], r[200010];
int t[200010 * 4], lazy[200010 * 4];
void range_upd(int node, int lo, int hi, int l, int r, int val) {
if (lo >= l and hi <= r) {
lazy[node] = val;
return;
}
if (lo > r or hi < l) return;
if (lazy[node]) {
lazy[node << 1] = lazy[node];
lazy[node << 1 | 1] = lazy[node];
lazy[node] = 0;
}
int md = (lo + hi) >> 1;
range_upd(node << 1, lo, md, l, r, val);
range_upd(node << 1 | 1, md + 1, hi, l, r, val);
}
int pt_query(int node, int lo, int hi, int in) {
if (lo == hi) {
t[node] = lazy[node];
lazy[node] = 0;
return t[node];
}
if (lazy[node]) {
lazy[node << 1] = lazy[node];
lazy[node << 1 | 1] = lazy[node];
lazy[node] = 0;
}
int md = (lo + hi) >> 1;
if (in <= md)
return pt_query(node << 1, lo, md, in);
else
return pt_query(node << 1 | 1, md + 1, hi, in);
}
set<pair<pair<int, int>, int> > sl, sr;
int main() {
int n, q, ae = 0;
cin >> n >> q;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (!a[i]) {
ae = i;
}
}
int mx = 0;
for (int i = 1; i <= n; ++i) {
if (l[a[i]])
r[a[i]] = i;
else
l[a[i]] = r[a[i]] = i;
mx = max(mx, a[i]);
}
for (int i = 1; i <= q; ++i) {
if (l[i] == 0) {
if (ae > 0) {
range_upd(1, 1, n, ae, ae, i);
continue;
} else if (mx > i) {
continue;
} else
return puts("NO"), 0;
}
int curl = l[i], curr = r[i];
auto rr = sr.lower_bound({{r[i], 1}, 1});
if (rr != sr.begin()) {
--rr;
if (rr->first.second > l[i] and rr->first.second < r[i])
return puts("NO"), 0;
}
sr.insert({{r[i], l[i]}, i});
auto ll = sl.lower_bound({{l[i], 1}, 1});
if (ll != sl.begin()) {
--ll;
if (ll->first.second < r[i] and ll->first.second > l[i])
return puts("NO"), 0;
}
sl.insert({{l[i], r[i]}, i});
range_upd(1, 1, n, l[i], r[i], i);
}
for (int i = 1; i <= n; ++i) {
b[i] = pt_query(1, 1, n, i);
if (c[i]) b[i] = c[i];
}
int pre = 0;
for (int i = 1; i <= n; ++i) {
if (b[i])
pre = b[i];
else
b[i] = pre;
}
pre = 0;
for (int i = n; i >= 1; --i) {
if (b[i])
pre = b[i];
else
b[i] = pre;
}
for (int i = 1; i <= n; ++i) {
if (a[i] != b[i] and a[i] != 0) return puts("NO"), 0;
if (b[i] == 0) b[i] = q;
}
puts("YES");
for (int i = 1; i <= n; ++i) {
cout << b[i] << ' ';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, m, a[100];
scanf("%d%d", &n, &d);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
scanf("%d", &m);
sort(a, a + n);
int ans = 0;
if (m <= n)
for (int i = 0; i < m; i++) ans += a[i];
else {
for (int i = 0; i < n; i++) ans += a[i];
ans -= d * (m - n);
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int src, dst;
int weight;
Edge(int src, int dst, int weight) : src(src), dst(dst), weight(weight) {}
};
bool operator<(const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight
: e.src != f.src ? e.src < f.src
: e.dst < f.dst;
}
const int MAXN = 100000;
int gcd(int a, int b) {
if (a != 0)
return gcd(b % a, a);
else
return b;
}
int gcd(int a, int b, int c) { return gcd(gcd(a, b), c); }
int main() {
int k;
cin >> k;
set<pair<int, int> > s;
int ans = 0;
for (int m = 2; m < 100; m++) {
for (int n = 1; n < m; n++) {
int a = m * m - n * n;
int b = 2 * m * n;
int c = m * m + n * n;
int g = gcd(a, b, c);
a /= g;
b /= g;
c /= g;
if (a > b) {
int x = a;
a = b;
b = x;
}
if (b <= k && c <= k) s.insert(make_pair(b, c));
}
}
for (__typeof((s).begin()) x = (s).begin(); x != (s).end(); ++x) {
int p = 1;
while (x->first * p <= k && x->second * p <= k) {
ans++;
p++;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 200005;
const long long int mod = 1e9 + 7;
long long int dp[200005][2][3];
long long int n;
char s[200005];
long long int A[N], B[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> s;
long long int i, j, k;
for (i = 1; i <= n; i++) {
A[i] = (s[i - 1] - '0');
}
for (i = 1; i <= n; i++) {
bool x = s[i - 1] - '0';
for (j = 0; j < 3; j++) {
for (k = 0; k < 2; k++) dp[i][k][j] = dp[i - 1][k][j];
}
dp[i][x][0] = max(dp[i][x][0], dp[i - 1][!x][0] + 1);
dp[i][x][1] = max(dp[i][x][1], dp[i - 1][!x][1] + 1);
dp[i][x][2] = max(dp[i][x][2], dp[i - 1][!x][2] + 1);
dp[i][!x][1] = max(dp[i][!x][1], dp[i][x][0]);
dp[i][x][1] = max(dp[i][x][1], dp[i][!x][0]);
dp[i][!x][2] = max(dp[i][!x][2], dp[i][x][1]);
dp[i][x][2] = max(dp[i][x][2], dp[i][!x][1]);
}
cout << max(dp[n][0][2], dp[n][1][2]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m, k;
int a[210000];
int main() {
cin >> t;
while (t--) {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> a[i];
if (k >= m - 1) k = m - 1;
int f = m - 1 - k;
int ans = -0x3f3f3f3f;
for (int i = 0; i <= k; i++) {
int l = i, r = n - 1 - k + i;
int mi = 0x3f3f3f3f;
for (int j = 0; j <= f; j++) {
mi = min(mi, max(a[l + j], a[r - f + j]));
}
ans = max(ans, mi);
}
cout << ans << endl;
continue;
}
return ~~(0 ^ 0 ^ 0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp[2][26];
char pt[500001][26], s[500001];
int main() {
int n, K, id;
scanf("%d %d %s", &n, &K, s);
int p = 0;
for (int i = 0; i < K; ++i) {
if (s[0] - 'A' == i)
dp[p][i] = 0;
else
dp[p][i] = 1;
pt[1][i] = -1;
}
for (int i = 2; i <= n; ++i) {
p = p ^ 1;
for (int j = 0; j < K; ++j) {
dp[p][j] = INT_MAX;
for (int k = 0; k < K; ++k) {
if (j != k) {
if (s[i - 1] - 'A' == j) {
if (dp[p][j] > dp[p ^ 1][k]) {
dp[p][j] = dp[p ^ 1][k];
id = k;
}
} else {
if (dp[p][j] > dp[p ^ 1][k] + 1) {
dp[p][j] = dp[p ^ 1][k] + 1;
id = k;
}
}
}
}
pt[i][j] = id;
}
}
int ans = INT_MAX;
for (int i = 0; i < K; ++i) {
if (ans > dp[p][i]) {
ans = dp[p][i];
id = i;
}
}
printf("%d\n", ans);
string res = "";
int l = n;
while (id != -1) {
res += char(id + 'A');
id = pt[l][id];
l--;
}
for (int i = n - 1; i >= 0; --i) {
putchar(res[i]);
}
return 0;
}
| 4 |
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
#include<stdio.h>
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<string.h>
#include<tuple>
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define NDEBUG
#define eprintf(...) do {} while (0)
#endif
#include<cassert>
using namespace std;
typedef long long LL;
typedef vector<int> VI;
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define EACH(i,c) for(__typeof((c).begin()) i=(c).begin(),i##_end=(c).end();i!=i##_end;++i)
template<class T> inline void amin(T &x, const T &y) { if (y<x) x=y; }
template<class T> inline void amax(T &x, const T &y) { if (x<y) x=y; }
#define rprintf(fmt, begin, end) do { const auto end_rp = (end); auto it_rp = (begin); for (bool sp_rp=0; it_rp!=end_rp; ++it_rp) { if (sp_rp) putchar(' '); else sp_rp = true; printf(fmt, *it_rp); } putchar('\n'); } while(0)
struct Matching2 { // for bipartite graph
static const int INF = 1<<29;
const VI* G;
VI matchM, matchW, dist;
int ans;
int SNK;
bool dfs(int v) {
if (v == SNK) return true;
EACH (e, G[v]) if (dist[matchW[*e]] == dist[v]+1 && dfs(matchW[*e])) {
matchM[v] = *e;
matchW[*e] = v;
return true;
}
dist[v] = INF;
return false;
}
Matching2(const VI G_[], int sizeM, int sizeW): G(G_), matchM(sizeM, -1), matchW(sizeW, sizeM), dist(sizeM+1), ans(0), SNK(sizeM) {
VI qu; qu.reserve(sizeM+1);
while (1) {
dist[SNK] = INF;
REP (i, sizeM) {
if (matchM[i] == -1) { dist[i] = 0; qu.push_back(i); }
else dist[i] = INF;
}
for (int i=0; i<(int)qu.size(); i++) {
int v = qu[i];
if (dist[v] < dist[SNK]) {
EACH (e, G[v]) if (dist[matchW[*e]] == INF) {
dist[matchW[*e]] = dist[v] + 1;
qu.push_back(matchW[*e]);
}
}
}
if (dist[SNK] == INF) break;
qu.clear();
REP (i, sizeM) if (matchM[i] == -1 && dfs(i)) ans++;
}
REP (i, sizeW) if (matchW[i] == SNK) matchW[i] = -1;
}
};
int N;
int M, K;
VI G[55];
vector<pair<int, int> > E;
bool in[55];
bool out[55];
LL R[55];
vector<pair<int, int> > B[55];
int calc() {
REP (i, N) G[i].clear();
EACH (e, E) {
if (!out[e->first] && !in[e->second]) {
G[e->first].push_back(e->second);
}
}
Matching2 X(G, N, N);
return N - X.ans;
}
LL X[55], Y[55];
void MAIN() {
scanf("%d%d%d", &N, &M, &K);
REP (i, M) {
int x, y;
scanf("%d%d", &x, &y);
x--; y--;
E.emplace_back(x, y);
}
for (int k=1; k<=K; k++) {
scanf("%lld%lld", X+k, Y+k);
}
int cur = calc();
for (int k=1; k<=K; k++) {
while (cur <= k) {
pair<int, int> p(0, 0);
REP (i, N) {
if (!in[i]) {
in[i] = true;
int tmp = calc();
if (cur < tmp) {
p = make_pair(i, -1);
cur = tmp;
goto OUT;
}
in[i] = false;
}
if (!out[i]) {
out[i] = true;
int tmp = calc();
if (cur < tmp) {
p = make_pair(i, 1);
cur = tmp;
goto OUT;
}
out[i] = false;
}
}
OUT:
;
B[k].push_back(p);
}
// eprintf("[%d] :", k);
// EACH (e, B[k]) eprintf("%d %d, ", e->first, e->second);
// eprintf("\n");
}
LL ans = -(1LL<<60);
using Tuple = tuple<int, int, int>;
vector<Tuple> best;
// non zero;
{
vector<Tuple> guess;
LL tmp = 0;
int min_y = 1;
for (int k=1; k<=K; k++) {
if (Y[min_y] > Y[k]) {
min_y = k;
}
tmp += X[k];
tmp -= Y[min_y] * (LL)B[k].size();
EACH (e, B[k]) {
guess.emplace_back(min_y, e->first, e->second);
}
}
if (ans < tmp) {
ans = tmp;
best = guess;
}
}
// zero;
for (int z=1; z<=K; z++) {
vector<Tuple> guess;
LL tmp = 0;
int min_y = 1;
memset(R, 0, sizeof R);
for (int k=1; k<=K; k++) {
if (Y[min_y] > Y[k]) {
min_y = k;
}
if (k < z) {
R[min_y] += Y[min_y] * (LL)B[k].size();
if (X[min_y] < R[min_y]) {
goto BAD;
}
tmp += X[k];
tmp -= Y[min_y] * (LL)B[k].size();
} else if (z == k) {
} else {
tmp += X[k];
}
EACH (e, B[k]) {
if (k < z) {
guess.emplace_back(min_y, e->first, e->second);
} else {
guess.emplace_back(z, e->first, e->second);
}
}
}
if (ans < tmp) {
ans = tmp;
best = guess;
}
BAD:
;
}
eprintf("SCORE = %lld\n", ans);
VI ANS;
for (int k=1, idx=0; k<=K; k++) {
while (idx < (int)best.size() && get<0>(best[idx]) <= k) {
int dummy, a, sgn;
tie(dummy, a, sgn) = best[idx];
ANS.push_back((a+1) * sgn);
idx++;
}
ANS.push_back(0);
}
printf("%d\n", (int)ANS.size());
rprintf("%d", ANS.begin(), ANS.end());
}
int main() {
int TC = 1;
// scanf("%d", &TC);
REP (tc, TC) MAIN();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long a, b, c, r;
cin >> a >> b >> c >> r;
long long ai = min(a, b);
long long bi = max(a, b);
a = ai;
b = bi;
long long start = c - r;
long long end = c + r;
if (start >= b || end <= a)
cout << b - a;
else if (start <= a && end >= b)
cout << "0";
else {
int ans = 0;
if (start - a > 0) ans += start - a;
if (b - end > 0)
ans += b - end;
else if (ans == 0)
ans += b - a;
cout << ans;
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum1 = 0, sum2 = 0, i = 0;
cin >> n;
while (true) {
i++;
sum1 += i;
sum2 += sum1;
if (sum2 > n) break;
}
cout << i - 1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void bad(string mes = "Impossible") {
cout << mes;
exit(0);
}
template <typename... T>
void shit(T&... x) {}
template <typename... T>
void dec(T&... x) {
shit(--x...);
}
template <typename... T>
void inc(T&... x) {
shit(++x...);
}
template <typename T>
string bin(T x, int st = 2) {
string ans = "";
while (x > 0) {
ans += char('0' + x % st);
x /= st;
}
reverse(ans.begin(), ans.end());
return ans.empty() ? "0" : ans;
}
template <typename T>
T input() {
T ans = 0, m = 1;
char c = ' ';
while (!((c >= '0' && c <= '9') || c == '-')) {
c = getchar();
}
if (c == '-') m = -1, c = getchar();
while (c >= '0' && c <= '9') {
ans = ans * 10 + (c - '0'), c = getchar();
}
return ans * m;
}
template <typename T>
void read(T& a) {
a = input<T>();
}
template <typename T>
void read(T& a, T& b) {
read(a), read(b);
}
template <typename T>
void read(T& a, T& b, T& c) {
read(a, b), read(c);
}
template <typename T>
void read(T& a, T& b, T& c, T& d) {
read(a, b), read(c, d);
}
const int inf = 1e9;
const double eps = 1e-9;
const int maxn = 3e5 + 15, base = 1e9 + 7;
const long long llinf = 2e18;
template <typename T>
T binpow(T n, T second) {
if (second <= 0) return 1LL;
if (second % 2 == 0) {
T b = binpow(n, second / 2);
return (1LL * b * b) % base;
} else {
return (1LL * binpow(n, second - 1) * n) % base;
}
}
int timeA[maxn], timeD[maxn];
vector<pair<int, int> > Query, tree[4 * maxn], convHull;
pair<int, int> line[maxn];
void add(int v, int tl, int tr, int l, int r, pair<int, int>& curL) {
if (l > r) return;
if (tl == l && tr == r) {
tree[v].push_back(curL);
return;
}
int tm = (tl + tr) >> 1;
add(v << 1, tl, tm, l, min(r, tm), curL);
add(v << 1 | 1, tm + 1, tr, max(l, tm + 1), r, curL);
}
pair<int, int>& Back() { return convHull.back(); }
pair<int, int>& afterB() { return convHull[convHull.size() - 2]; }
void build(int v, int tl, int tr) {
sort(tree[v].begin(), tree[v].end());
convHull.clear();
for (auto cur : tree[v]) {
while (convHull.size() > 0 && Back().first == cur.first)
convHull.pop_back();
while (convHull.size() > 1 && 1LL * (cur.first - afterB().first) *
(Back().second - afterB().second) <=
1LL * (cur.second - afterB().second) *
(Back().first - afterB().first))
convHull.pop_back();
convHull.push_back(cur);
}
tree[v].clear();
tree[v] = convHull;
if (tl == tr) {
return;
}
int tm = (tl + tr) >> 1;
build(v << 1, tl, tm);
build(v << 1 | 1, tm + 1, tr);
}
long long CHT_query(int v, int x) {
if (tree[v].empty()) return -1LL * llinf;
if (tree[v].size() == 1)
return 1LL * tree[v][0].first * x + tree[v][0].second;
int l = 0, r = tree[v].size() - 1;
while (r - l > 1) {
int m = (l + r) >> 1;
if (1LL * tree[v][m].first * x + tree[v][m].second >=
1LL * tree[v][m + 1].first * x + tree[v][m + 1].second)
r = m;
else
l = m;
}
return max(1LL * tree[v][l].first * x + tree[v][l].second,
1LL * tree[v][r].first * x + tree[v][r].second);
}
long long query(int v, int tl, int tr, int curTime, int x) {
if (tl == tr) {
return CHT_query(v, x);
}
int tm = (tl + tr) >> 1;
if (curTime <= tm)
return max(CHT_query(v, x), query(v << 1, tl, tm, curTime, x));
return max(CHT_query(v, x), query(v << 1 | 1, tm + 1, tr, curTime, x));
}
int main() {
int n;
read(n);
for (int i = 0; i < n; i++) timeA[i] = -1, timeD[i] = n - 1;
for (int i = 0; i < n; i++) {
int type;
read(type);
if (type == 1) {
int k, b;
read(k, b);
timeA[i] = i;
line[i] = {k, b};
}
if (type == 2) {
int pos;
read(pos);
pos--;
timeD[pos] = i - 1;
}
if (type == 3) {
int q;
read(q);
Query.push_back(make_pair(q, i));
}
}
for (int i = 0; i < n; i++)
if (timeA[i] != -1) {
add(1, 0, n, timeA[i], timeD[i], line[i]);
}
build(1, 0, n);
for (auto i : Query) {
int x = i.first, curTime = i.second;
long long res = query(1, 0, n, curTime, x);
if (res == -1LL * llinf)
puts("EMPTY SET");
else
printf("%I64d\n", res);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 510;
const int MOD = 998244353;
int a[N];
int b[N];
int dp[N][N];
void add_self(int& x, int y) {
if ((x += y) >= MOD) {
x -= MOD;
}
}
void sub_self(int& x, int y) {
if ((x -= y) < 0) {
x += MOD;
}
}
int add(int x, int y) {
return add_self(x, y), x;
}
int sub(int x, int y) {
return sub_self(x, y), x;
}
int mul(int x, int y) {
return (ll)x * y % MOD;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
char c;
scanf(" %c", &c);
if (c == '+') {
b[i] = 1;
scanf("%d", a + i);
}
}
int answer = 0;
for (int k = 0; k < n; k++) {
if (!b[k]) {
continue;
}
memset(dp, 0, sizeof(dp));
for (int j = 0; j <= n; j++) {
dp[n][j] = 1;
}
for (int i = n - 1; ~i; --i) {
for (int j = 0; j < n; j++) {
if (i == k) {
dp[i][j] = dp[i + 1][j];
} else {
dp[i][j] = dp[i + 1][j];
if (b[i]) {
add_self(dp[i][j], dp[i + 1][j + (pii(a[i], i) < pii(a[k], k))]);
} else if (i < k || j > 0) {
add_self(dp[i][j], dp[i + 1][max(0, j - 1)]);
}
}
}
}
add_self(answer, mul(a[k], dp[0][0]));
}
cout << answer << endl;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:500000000")
using namespace std;
int nextInt() {
int n;
scanf("%d", &n);
return n;
}
long long nextLong() {
long long n;
scanf("%lld", &n);
return n;
}
const double PI = acos(-1.0);
const double EPS = 1e-9;
const int INF = (int)2e9;
const int MAX_N = (int)1e5;
int a[MAX_N + 9];
bool isUsed[MAX_N + 9], isCanBeChanged[MAX_N + 9];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
if (a[i] > n || isUsed[a[i]]) isCanBeChanged[i] = true;
isUsed[a[i]] = true;
}
int curValue = 1;
for (int i = 0; i < n; ++i) {
if (isCanBeChanged[i]) {
while (isUsed[curValue]) ++curValue;
a[i] = curValue;
isUsed[curValue] = true;
}
}
for (int i = 0; i < n; ++i) printf("%d ", a[i]);
printf("\n");
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.