solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int m[N], f[N];
vector<int> e[2 * N];
void addedge(int a, int b) {
e[a].push_back(b);
e[b].push_back(a);
}
int color[2 * N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(color, -1, sizeof(color));
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> m[i] >> f[i];
addedge(m[i], f[i]);
}
for (int i = 1; i <= n; i++) {
addedge(i * 2 - 1, i * 2);
}
for (int i = 1; i <= 2 * n; i++) {
if (color[i] < 0) {
queue<int> q;
color[i] = 1;
q.push(i);
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int nxt : e[cur]) {
if (color[nxt] < 0) {
q.push(nxt);
color[nxt] = 3 - color[cur];
}
}
}
}
}
for (int i = 1; i <= n; i++) {
cout << color[m[i]] << ' ' << color[f[i]] << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long kpol = 0;
long long kotr = 1;
void one() {
cin >> n;
long long t;
int kol = 0;
for (int i = 0; i < n; i++) {
cin >> t;
if (t < 0) kol ^= 1;
if (kol)
kpol++;
else
kotr++;
}
}
int main() {
one();
cout << kpol * kotr << ' ' << kpol * (kpol - 1) / 2 + kotr * (kotr - 1) / 2;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
char a[200005], b[200005];
long long f[2][200005];
int solve() {
n = strlen(a);
if (strlen(b) != n) return 0;
bool same = (0 == strcmp(a, b));
if (0 == k) return same;
for (int i = 0; i < n; ++i) a[i + n] = a[i];
int cnt = 0;
for (int i = 1; i < n; ++i) {
bool ok = true;
for (int j = 0; ok && j < n; ++j)
if (a[i + j] != b[j]) ok = false;
cnt += ok;
}
if (1 == k) return cnt;
if (2 == n) return (1 == same + k % 2);
f[0][1] = cnt;
f[1][1] = n - 1 - cnt;
cnt += same;
for (int i = 2; i <= k; ++i) {
f[0][i] = (f[0][i - 1] * (cnt - 1) + f[1][i - 1] * cnt) % 1000000007;
f[1][i] =
(f[0][i - 1] * (n - cnt) + f[1][i - 1] * (n - 1 - cnt)) % 1000000007;
}
return (int)f[0][k];
}
int main() {
scanf("%s", a);
scanf("%s", b);
scanf("%d", &k);
printf("%d\n", solve());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(nullptr), ios::sync_with_stdio(false),
cout << fixed << setprecision(20);
};
} fast_ios_;
template <class T>
auto add = [](T a, T b) -> T { return a + b; };
template <class T>
auto f_max = [](T a, T b) -> T { return max(a, b); };
template <class T>
auto f_min = [](T a, T b) -> T { return min(a, b); };
template <class T>
using V = vector<T>;
using Vl = V<long long int>;
using VVl = V<Vl>;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < (int)v.size(); i++)
os << v[i] << (i + 1 != v.size() ? " " : "");
return os;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (T& in : v) is >> in;
return is;
}
template <class T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T& a, const T& b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long int ceil(long long int a, long long int b) { return (a + b - 1) / b; }
long long int digit(long long int a) { return (long long int)log10(a); }
long long int e_dist(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return abs(a.first - b.first) * abs(a.first - b.first) +
abs(a.second - b.second) * abs(a.second - b.second);
}
long long int m_dist(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return abs(a.first - b.first) + abs(a.second - b.second);
}
bool check_overflow(long long int a, long long int b, long long int limit) {
if (b == 0) return false;
return a > limit / b;
}
void Worshall_Floyd(VVl& g) {
for (long long int k = (0), k_end_ = (((long long int)(g).size()));
k < k_end_; ++k)
for (long long int i = (0), i_end_ = (((long long int)(g).size()));
i < i_end_; ++i)
for (long long int j = (0), j_end_ = (((long long int)(g).size()));
j < j_end_; ++j)
chmin(g[i][j], g[i][k] + g[k][j]);
}
const long long int MOD1000000007 = 1000000007, MOD998244353 = 998244353,
INF = 5e18;
long long int dx[8] = {1, 0, -1, 0, 1, -1, 1, -1},
dy[8] = {0, 1, 0, -1, -1, -1, 1, 1};
bool YN(bool flag) {
cout << (flag ? "YES" : "NO") << '\n';
return flag;
}
bool yn(bool flag) {
cout << (flag ? "Yes" : "No") << '\n';
return flag;
}
struct Edge {
long long int from, to;
long long int cost;
Edge() {}
Edge(long long int u, long long int v, long long int c) {
cost = c;
from = u;
to = v;
}
bool operator<(const Edge& e) const { return cost < e.cost; }
};
struct WeightedEdge {
long long int to;
long long int cost;
WeightedEdge(long long int v, long long int c = 1) {
to = v;
cost = c;
}
bool operator<(const WeightedEdge& e) const { return cost < e.cost; }
};
using WeightedGraph = V<V<WeightedEdge>>;
struct TmpFunc {
long long int x1;
long long int x2;
long long int y1;
long long int a;
long long int b;
long long int y2;
TmpFunc() {}
TmpFunc(Vl input) {
x1 = input[0];
x2 = input[1];
y1 = input[2];
a = input[3];
b = input[4];
y2 = input[5];
}
long long int get_val(long long int k) {
if (k <= x1)
return y1;
else if (k <= x2)
return a * k + b;
else
return y2;
}
};
const long long int FIX = 300;
const long long int MAX_X = 200100;
const long long int MOD = 1e9;
long long int N, Q;
int main() {
cin >> N;
VVl BucketSum1(N / FIX + 1, Vl(MAX_X + 1));
VVl BucketSum2(N / FIX + 1, Vl(MAX_X + 1));
V<TmpFunc> arr(N);
Vl _input(6);
for (long long int i = (0), i_end_ = (N); i < i_end_; ++i) {
cin >> _input;
arr[i] = TmpFunc(_input);
BucketSum1[i / FIX][arr[i].x1 + 1] += arr[i].a;
BucketSum1[i / FIX][arr[i].x2 + 1] -= arr[i].a;
BucketSum2[i / FIX][0] += arr[i].y1;
BucketSum2[i / FIX][arr[i].x1 + 1] -= arr[i].y1;
BucketSum2[i / FIX][arr[i].x1 + 1] += arr[i].b;
BucketSum2[i / FIX][arr[i].x2 + 1] -= arr[i].b;
BucketSum2[i / FIX][arr[i].x2 + 1] += arr[i].y2;
}
for (long long int i = (0), i_end_ = (N / FIX + 1); i < i_end_; ++i) {
for (long long int j = (0), j_end_ = (MAX_X); j < j_end_; ++j) {
BucketSum1[i][j + 1] += BucketSum1[i][j];
BucketSum2[i][j + 1] += BucketSum2[i][j];
}
}
long long int prv = 0;
cin >> Q;
for (long long int _ = (0), __end_ = (Q); _ < __end_; ++_) {
long long int l, r, x;
cin >> l >> r >> x;
l--;
long long int val = (prv + x) % MOD;
long long int pos = min(val, MAX_X);
long long int a_sum = 0, b_sum = 0, sum = 0;
if (r - l > 2 * FIX) {
for (long long int k = (l), k_end_ = (ceil(l, FIX) * FIX); k < k_end_;
++k) {
sum += arr[k].get_val(val);
}
for (long long int k = (r / FIX * FIX), k_end_ = (r); k < k_end_; ++k) {
sum += arr[k].get_val(val);
}
for (long long int k = (ceil(l, FIX)), k_end_ = (r / FIX); k < k_end_;
++k) {
a_sum += BucketSum1[k][pos];
b_sum += BucketSum2[k][pos];
}
} else {
for (long long int k = (l), k_end_ = (r); k < k_end_; ++k)
sum += arr[k].get_val(val);
}
sum += a_sum * val + b_sum;
prv = sum % MOD;
cout << sum << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (-1u) / 2;
const long long int INF2 = (-1ull) / 2;
int a, b, i, d[1011000], j, k, n, m, timer = 0, l, r, x, y;
int c[1011000], cnt = 0, fl = 0, a2, a3 = -1000000, ans = 0;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
j = 1;
k = n + 1;
a = 1;
while (a < n) {
if (a % 2 != 0) {
c[j] = a;
c[j + (n - a)] = a;
j++;
} else {
c[k] = a;
c[k + (n - a)] = a;
k++;
}
a++;
}
for (i = 1; i <= n * 2; i++) {
if (c[i] == 0) c[i] = n;
cout << c[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const double pi = 3.14159265;
long long mod = 1000000007;
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
{
long long to[51];
long long ba[51];
long long ar[2600];
long long x, y, p1, m1 = LONG_LONG_MIN, p2, m2 = m1;
cin >> x >> y;
for (int i = 0; i < x; i++) {
cin >> to[i];
}
for (int i = 0; i < y; i++) {
cin >> ba[i];
}
sort(ba, ba + y);
sort(to, to + x);
int r = 0;
int l;
for (int i = 0; i < x; i++) {
for (int e = 0; e < y; e++) {
if (to[i] * ba[e] > m1) {
m1 = to[i] * ba[e], l = to[i];
}
}
}
bool ww = 0;
for (int i = 0; i < x; i++) {
if (to[i] == l && ww == 0) {
ww = 1;
continue;
}
for (int e = 0; e < y; e++) {
if (to[i] * ba[e] > m2) m2 = to[i] * ba[e];
}
}
cout << m2 << endl;
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
int y, i, j, k, n, a = 0, b = 0, max, s[100050], x[100050];
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) scanf("%d", &s[i]);
for (j = 0; j < n; j++) scanf("%d", &x[j]);
for (i = 0; i < n; i++) {
if (x[i] == 1) {
a += s[i];
}
}
for (i = 0; i < k; i++) {
if (x[i] == 0) b = b + s[i];
}
max = b;
for (i = 1; i < n; i++) {
if (x[i - 1] == 0) b = b - s[i - 1];
if (x[i + k - 1] == 0 && i + k - 1 < n) b = b + s[i + k - 1];
if (max < b) max = b;
}
printf("%d\n", a + max);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long INF = 10000000000001;
int arr[110], n, m, k, p[110][110];
long long anw[110][110][110];
long long dp(int id, int prev, int g) {
if (id == n) return (g == k ? 0 : INF);
if (anw[id][prev][g] != -1) return anw[id][prev][g];
if (arr[id] != 0)
return (arr[id] == prev ? dp(id + 1, prev, g) : dp(id + 1, arr[id], g + 1));
long long w = INF;
for (int i = 0; i < m; i++)
w = min(w, dp(id + 1, i + 1, (prev == i + 1 ? g : g + 1)) + p[id][i]);
return anw[id][prev][g] = w;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &p[i][j]);
memset(anw, -1, sizeof(anw));
long long res = dp(0, 0, 0);
cout << (res >= INF ? -1 : res) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxv = 105;
int to[maxv];
bitset<maxv> vis;
int num[maxv];
int n;
int dfs(int x, int p) {
vis[x] = 1;
if (!vis[to[x]]) {
if (dfs(to[x], p)) {
num[x]++;
return 1;
}
} else {
if (to[x] == p) {
num[x]++;
return 1;
} else
return 0;
}
}
int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
to[i] = x;
}
for (int i = 1; i <= n; i++) {
vis.reset();
dfs(i, i);
}
long long res = 1;
for (int i = 1; i <= n; i++) {
int t = num[i] & 1 ? num[i] : num[i] / 2;
if (t == 0) {
cout << -1 << endl;
return 0;
}
res = t * res / gcd(t, res);
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int g[100001], dp[100001];
int a[50001][1000];
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 0; i <= n; i++) dp[i] = -1;
for (i = 2; i <= (n + 1) / 2; i++) {
int sum = i, f;
for (j = 0; j < 1000; j++) {
if (a[i][j] == 0) break;
}
g[i] = f = j;
for (j = i - 1; j > 0; j--) {
sum += j;
f ^= g[j];
if (sum > n) break;
if (f < 1000 && sum <= (n + 1) / 2) a[sum][f] = 1;
if (f == 0) dp[sum] = i - j + 1;
}
}
printf("%d\n", dp[n]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k, mt[205][205];
void make(int t) {
for (int i = 1; i <= t; i++) {
for (int j = 1; j <= t; j++) {
if (i != j) mt[i + n][j + n] = 1;
}
}
n += t;
}
int main() {
scanf("%d", &k);
int ok = 0, id = 0;
for (int i = 1;; i++) {
int v = i * (i - 1) * (i - 2) / 6;
if (v > k) break;
ok = v, id = i;
}
make(id);
k -= ok;
int tn = n;
while (k > 0) {
int ok = 0, id = 0;
for (int i = 1;; i++) {
int v = i * (i - 1) / 2;
if (v > k) break;
ok = v, id = i;
}
k -= ok;
n++;
for (int i = 1; i <= tn && id > 0; i++, id--) {
mt[i][n] = mt[n][i] = 1;
}
}
printf("%d\n", n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) printf("%d", mt[i][j]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template <class T>
ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++) o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
int main() {
int t, n;
cin >> t;
for (int r = 0; r < t; r++) {
cin >> n;
for (int i = 1; i <= n; i++) {
if (i == n)
cout << i << "\n";
else
cout << i << " ";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
struct Point {
long long x, y;
bool operator<(const Point &p) const {
if (x != p.x)
return x > p.x;
else
return y > p.y;
}
} pt[maxn];
int stk[maxn], stnum;
set<pair<long long, long long> > has;
bool check(Point a, Point b, Point c) {
return c.x * b.y * (b.x - a.x) * (a.y - c.y) <
b.x * c.y * (a.x - c.x) * (b.y - a.y);
}
bool check2(Point a, Point b, Point c) {
return c.x * a.y * (b.x - a.x) * (b.y - c.y) <
a.x * c.y * (b.x - c.x) * (b.y - a.y);
}
void convex(int n, int tn) {
int i, j;
stnum = 0;
for (i = 0; i < n; i++) {
while (stnum > 1 && check(pt[stk[stnum - 1]], pt[stk[stnum - 2]], pt[i]))
stnum--;
stk[stnum++] = i;
}
for (i = 0; i < stnum; i++) {
has.insert(make_pair(pt[stk[i]].x, pt[stk[i]].y));
}
}
long long a[maxn], b[maxn];
pair<long long, long long> node[maxn];
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%I64d %I64d", &a[i], &b[i]);
node[i] = make_pair(a[i], b[i]);
pt[i].x = a[i];
pt[i].y = b[i];
}
sort(pt, pt + n);
for (i = 0, j = 1; i < n; i++)
if (pt[j - 1].y < pt[i].y) pt[j++] = pt[i];
convex(j, n);
for (i = 0; i < n; i++) {
if (has.find(node[i]) != has.end()) printf("%d ", i + 1);
}
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e6 + 5, JYY = 1e9 + 7;
long long read() {
long long x = 0, y = 1;
char ch = getchar();
while (ch < '0' || ch > '9') y = (ch == '-') ? -1 : 1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * y;
}
long long qpow(long long x, long long y) {
long long res = 1;
for (; y; y >>= 1, x = x * x % JYY)
if (y & 1) res = res * x % JYY;
return res;
}
long long cnt[M];
void solve() {
long long n = read(), Ans = qpow(2, n - 1) - 1;
for (long long i = 1; i <= n; i++) {
long long x = read();
if (x != -1) cnt[x]++;
}
for (long long i = 1; i <= n; i++)
Ans = (Ans + 1 - qpow(2, cnt[i]) + JYY) % JYY;
printf("%lld\n", Ans);
}
signed main() { solve(); }
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int root[1 << 15];
int par[1 << 15];
int tmp[1 << 15];
int n, m;
bool a[1 << 15];
int getbit(int x, int i) { return (x >> i) & 1; }
int getpar(int u) { return (par[u] < 0) ? u : (par[u] = getpar(par[u])); }
bool join(int u, int v) {
u = getpar(u);
v = getpar(v);
if (u == v) return false;
if (par[u] > par[v]) swap(u, v);
par[u] += par[v];
par[v] = u;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
int ans = 0;
for (int i = 1; i <= n; i++) {
int cur = i & 1;
int pre = cur ^ 1;
for (int j = 0; j < m; j += 4) {
char c;
cin >> c;
int val = 0;
if (isdigit(c))
val = c - '0';
else
val = 10 + c - 'A';
for (int k = 0; k < 4; k++) {
a[(j + k) << 1 | cur] = getbit(val, 3 - k);
par[(j + k) << 1 | cur] = -1;
}
}
for (int j = 0; j < m; j++)
if (a[j << 1 | cur]) {
ans++;
if (j > 0 && a[(j - 1) << 1 | cur])
ans -= join(j << 1 | cur, (j - 1) << 1 | cur);
if (i > 1 && a[j << 1 | pre]) ans -= join(j << 1 | cur, j << 1 | pre);
}
if (i == 1) continue;
for (int j = 0; j < m; j++) {
tmp[j << 1 | cur] = getpar(j << 1 | cur);
}
memset(root, -1, sizeof(root));
for (int j = 0; j < m; j++) {
int p = tmp[j << 1 | cur];
if (root[p] < 0) {
par[j << 1 | cur] = -1;
root[p] = j << 1 | cur;
} else
par[j << 1 | cur] = root[p];
}
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e3 + 10;
const double eps = 1e-6;
int main() {
int n, i, l, l0, j, k, a[11][11];
char ch;
memset(a, 0, sizeof(a));
for (i = 1; i <= 10; i++)
for (j = 1; j <= 10; j++) {
cin >> ch;
if (ch == 'X') a[i][j] = 1;
if (ch == 'O') a[i][j] = 2;
}
for (i = 1; i <= 10; i++)
for (j = 1; j <= 6; j++) {
l = 0, l0 = 0;
for (k = j; k <= j + 4; k++) {
if (a[i][k] == 1)
l++;
else if (a[i][k] == 0)
l0++;
else
break;
}
if (l == 4 && l0 == 1) {
cout << "YES" << endl;
return 0;
}
}
for (i = 1; i <= 10; i++)
for (j = 1; j <= 6; j++) {
l = 0, l0 = 0;
for (k = j; k <= j + 4; k++) {
if (a[k][i] == 1)
l++;
else if (a[k][i] == 0)
l0++;
else
break;
}
if (l == 4 && l0 == 1) {
cout << "YES" << endl;
return 0;
}
}
for (i = 1; i <= 6; i++)
for (j = 1; j <= 6; j++) {
l = 0, l0 = 0;
for (k = 0; k <= 4; k++) {
if (a[i + k][j + k] == 1)
l++;
else if (a[i + k][j + k] == 0)
l0++;
else
break;
}
if (l == 4 && l0 == 1) {
cout << "YES" << endl;
return 0;
}
}
for (i = 5; i <= 10; i++)
for (j = 1; j <= 6; j++) {
l = 0, l0 = 0;
for (k = 0; k <= 4; k++) {
if (a[i - k][j + k] == 1)
l++;
else if (a[i - k][j + k] == 0)
l0++;
else
break;
}
if (l == 4 && l0 == 1) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, f = 0, s = 0;
char c;
cin >> n;
bool res = true;
for (int i = 0; i < n; ++i) {
cin >> c;
if (c != '4' && c != '7') {
res = false;
}
if (i < n / 2)
f += (c - '0');
else
s += (c - '0');
}
if (res && f != s) res = false;
if (res)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dcmp(double x, double y) {
return fabs(x - y) <= 1e-9 ? 0 : x < y ? -1 : 1;
}
const int MAX = 1e6 + 3;
int arr[MAX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int k, n;
cin >> k >> n;
if (k / n < 3) {
cout << -1 << "\n";
return 0;
} else {
int ptr = 1;
for (int i = 0; i < k; i += 2) {
arr[i] = ptr;
arr[i + 1] = ptr;
ptr++;
if (ptr == n + 1) break;
}
int mod = 1;
for (int i = 0; i < (int)(k); ++i) {
if (arr[i] == 0) {
if (mod == n + 1) mod = 1;
arr[i] = mod++;
}
cout << arr[i] << ' ';
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long s, n;
cin >> s >> n;
priority_queue<long long, vector<long long>, greater<long long>> pq;
long long k = 1;
while (s) {
long long dig = s % 10;
s /= 10;
while (n > 1 && dig) {
pq.push(k);
dig--, n--;
}
if (n == 1 && (s || dig)) {
pq.push(s * k * 10 + dig * k);
n--;
break;
}
k *= 10;
}
while (n) {
if (pq.top() == 1) {
cout << 1 << " ";
pq.pop();
} else {
long long num = pq.top();
pq.pop();
n++;
if (n > 10) {
for (long long i = 0; i < 10; i++) pq.push(num / 10);
n -= 10;
} else {
long long t = num / 10;
for (long long i = 0; i < n - 1; i++) pq.push(t), num -= t;
pq.push(num);
n = 0;
}
}
}
while (!pq.empty()) {
cout << pq.top() << " ";
pq.pop();
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1, i;
if (1) cin >> t;
for (i = 1; i <= t; i++) solve();
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int maxn = 2e5 + 7;
char S[maxn], T[maxn];
int Q, a, b, c, d;
int sumS[maxn], sumT[maxn];
int lastS[maxn], lastT[maxn];
int main() {
scanf(" %s %s %d", S, T, &Q);
for (int i = 0; S[i]; ++i) {
sumS[i + 1] = sumS[i] + (S[i] == 'C' || S[i] == 'B');
lastS[i + 1] = lastS[i];
if (S[i] == 'B' || S[i] == 'C') lastS[i + 1] = i + 1;
}
for (int i = 0; T[i]; ++i) {
sumT[i + 1] = sumT[i] + (T[i] == 'C' || T[i] == 'B');
lastT[i + 1] = lastT[i];
if (T[i] == 'B' || T[i] == 'C') lastT[i + 1] = i + 1;
}
while (Q--) {
scanf("%d%d%d%d", &a, &b, &c, &d);
int delta = sumT[d] - sumS[b] + sumS[a - 1] - sumT[c - 1];
int delta2 = b - max(a - 1, lastS[b]) - (d - max(c - 1, lastT[d]));
if (delta < 0 || delta % 2 != 0 || delta2 < 0 ||
delta2 == 0 && !(sumS[b] - sumS[a - 1]) && delta > 0) {
putchar('0');
continue;
}
if (delta2 == 0 || delta > 0 || delta2 % 3 == 0)
putchar('1');
else
putchar('0');
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long F[100];
int main() {
long long n, i, ret;
scanf("%lld", &n);
F[0] = 1;
F[1] = 2;
for (i = 2; i < 100; i++) F[i] = F[i - 1] + F[i - 2];
for (i = 85;; i--)
if (F[i] <= n) {
printf("%lld", i);
return 0;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int V[10010];
int ord[10010];
int bestord[10010];
int digit;
bool myf(const int& a, const int& b) {
int dist1 = abs(V[a] - digit);
int dist2 = abs(V[b] - digit);
if (dist1 < dist2) return true;
if (dist2 < dist1) return false;
int c = min(a, b);
if (V[c] < digit)
return b < a;
else
return a < b;
}
string do_word(int N, int K) {
string ans;
for (int i = 0; i < (N); i++) ans += (char)(V[i] + '0');
for (int j = 0; j < (K); j++) {
int i = ord[j];
ans[i] = (char)(digit + '0');
}
return ans;
}
int main() {
int N, K;
cin >> N >> K;
string num;
cin >> num;
for (int i = 0; i < (N); i++) V[i] = (int)(num[i] - '0');
int ans = 10 * N;
string bestword;
for (int digit2 = (0); digit2 <= (9); digit2++) {
digit = digit2;
int amt = 0;
for (int i = 0; i < (N); i++) ord[i] = i;
sort(ord, ord + N, myf);
for (int j = 0; j < (K); j++) {
int dist = abs(V[ord[j]] - digit);
amt += dist;
}
string newword = do_word(N, K);
if ((amt < ans) || (amt == ans && newword < bestword)) {
ans = amt;
bestword = newword;
}
}
cout << ans << endl << bestword << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool mini(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
bool maxi(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int N = 1e6 + 5;
const int oo = 1e9;
const long long ooo = 1e18;
const int mod = 1e9 + 7;
const long double pi = 3.14159265359;
vector<vector<int>> a, minpre, minsuf, maxpre, maxsuf;
vector<int> row[N];
int n, m;
char ans[N];
void solve() {
cin >> n >> m;
a.assign(n + 2, vector<int>(m + 2, 0));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
minpre = minsuf = maxpre = maxsuf = a;
for (int i = 1; i <= n; i++) {
for (int j = 2; j <= m; j++) {
maxi(maxpre[i][j], maxpre[i][j - 1]);
mini(minpre[i][j], minpre[i][j - 1]);
}
for (int j = m - 1; j >= 1; j--) {
maxi(maxsuf[i][j], maxsuf[i][j + 1]);
mini(minsuf[i][j], minsuf[i][j + 1]);
}
}
for (int k = 1; k < m; k++) {
vector<int> val;
multiset<int> red, blue;
for (int i = 1; i <= n; i++) {
ans[i] = 'R';
red.insert(maxsuf[i][k + 1]);
}
for (int i = 1; i <= n; i++) {
val.push_back(minpre[i][k] + 1);
val.push_back(maxpre[i][k] + 1);
}
sort((val).begin(), (val).end());
val.resize(unique((val).begin(), (val).end()) - val.begin());
for (int x : val) row[x].clear();
for (int i = 1; i <= n; i++) {
row[minpre[i][k] + 1].push_back(-i);
row[maxpre[i][k] + 1].push_back(i);
}
int cnt = n;
for (int x : val) {
for (int ind : row[x]) {
if (ind < 0) {
int i = -ind;
red.erase(red.find(maxsuf[i][k + 1]));
ans[i] = 0;
cnt--;
} else {
int i = ind;
blue.insert(minsuf[i][k + 1]);
ans[i] = 'B';
cnt++;
}
}
if (blue.size() && red.size() && cnt == n) {
if (*blue.begin() > *prev(red.end())) {
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << ans[i];
cout << " ";
cout << k << "\n";
return;
}
}
}
}
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a, b, k;
bool check(int p) {
int sq = sqrt(p);
for (int i = 2; i <= sq; i++)
if (p % i == 0) return false;
return true;
}
int solve(int n, int p) {
if (!check(p)) return 0;
int tmp = n / p, mn = min(n / p, p - 1);
for (int i = 2; i <= mn; i++) tmp -= solve(n / p, i);
return tmp;
}
int main() {
scanf("%d%d%d", &a, &b, &k);
printf("%d", solve(b, k) - solve(a - 1, k));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char c;
int x;
while (c = getchar(), c < '0' || c > '9')
;
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
return x;
}
int n, m, k, tot, fa[5005], vis[100005], l, r, mid, ans;
struct node {
int a, b, len, id;
} F[100005];
int cmp(node a, node b) {
if (a.len < b.len)
return 1;
else if (a.len == b.len) {
if (a.a == 1 || a.b == 1) return 1;
}
return 0;
}
int find(int x) {
if (fa[x] != x) fa[x] = find(fa[x]);
return fa[x];
}
void unionn(int x, int y) {
x = find(x);
y = find(y);
fa[y] = x;
}
int check(int x) {
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
if (F[i].a == 1 || F[i].b == 1) F[i].len += x;
}
sort(F + 1, F + 1 + m, cmp);
int p = 0, res = 0;
for (int i = 1; i <= m; i++) {
if (p == n - 1) break;
if ((F[i].a == 1 || F[i].b == 1) && res == k) continue;
if (find(F[i].a) != find(F[i].b)) {
unionn(F[i].a, F[i].b);
p++;
if (F[i].a == 1 || F[i].b == 1) res++;
}
}
for (int i = 1; i <= m; i++) {
if (F[i].a == 1 || F[i].b == 1) F[i].len -= x;
}
return res >= k;
}
int main() {
n = read();
m = read();
k = read();
for (int i = 1; i <= m; i++) {
F[i].a = read();
F[i].b = read();
F[i].len = read();
F[i].id = i;
}
l = -100000, r = 100000;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
l = mid + 1, ans = mid;
else
r = mid - 1;
}
for (int i = 1; i <= m; i++) {
if (F[i].a == 1 || F[i].b == 1) F[i].len += ans;
}
sort(F + 1, F + 1 + m, cmp);
int p = 0, res = 0;
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
if (p == n - 1) break;
if ((F[i].a == 1 || F[i].b == 1) && res == k) continue;
if (find(F[i].a) != find(F[i].b)) {
unionn(F[i].a, F[i].b);
p++;
vis[F[i].id] = 1;
if (F[i].a == 1 || F[i].b == 1) res++;
}
}
if (p < n - 1 || res != k) {
puts("-1");
} else {
printf("%d\n", n - 1);
for (int i = 1; i <= m; i++)
if (vis[i]) printf("%d ", i);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 100000;
const long long inf = 0x3f3f3f3f;
const double EPS = 1e-10;
const long long MOD = 1e9 + 7;
char s[100005];
vector<pair<long long, long long> > g[100005];
long long ans[100005], inv[100005], p25[100005];
long long quick_pow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ans;
}
long long Inv(long long a) { return quick_pow(a, MOD - 2); }
int main() {
long long q, ls, first, cmd, tot = 0;
scanf("%lld %s", &q, s);
ls = strlen(s);
while (q--) {
scanf("%lld", &cmd);
if (cmd == 1) {
scanf("%s", s);
ls = strlen(s);
} else {
long long n;
scanf("%lld", &n);
g[ls].push_back({n, ++tot});
}
}
p25[0] = 1;
for (long long i = 1; i <= MAX; ++i) {
p25[i] = p25[i - 1] * 25ll % MOD;
inv[i] = Inv(i);
}
for (long long first = 1; first <= MAX; ++first) {
if (g[first].size() == 0) continue;
sort(g[first].begin(), g[first].end());
long long top = g[first].size();
long long mx = g[first][top - 1].first;
long long C = 1, F = 0, now = 0;
while (g[first][now].first < first && now < top) {
long long th = g[first][now].second;
ans[th] = 0ll;
now++;
}
for (long long i = first; i <= mx; ++i) {
F = (C * p25[i - first] % MOD + F * 26 % MOD) % MOD;
C = C * i % MOD * inv[i - first + 1] % MOD;
while (g[first][now].first == i && now < top) {
long long th = g[first][now].second;
ans[th] = F;
now++;
}
}
}
for (int i = 1; i <= tot; ++i) {
printf("%lld\n", ans[i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
static void amin(T &x, U y) {
if (x > y) x = y;
}
int main() {
int n, so, x, cnt, t;
scanf("%d", &n);
so = n;
for (int i = 0; i < (20); i++) {
++so;
x = so < 0 ? -so : so;
while (x) {
t = x % 10;
if (t == 8) return printf("%d\n", so - n), 0;
x /= 10;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, L, a;
long long t, l;
vector<pair<long long, long long>> VI;
int main() {
ios::sync_with_stdio(false);
cin >> n >> L >> a;
if (n == 0) {
cout << L / a << endl;
return 0;
}
for (int i = 0; i < n; i++) {
cin >> t >> l;
VI.push_back(make_pair(t, l));
}
VI.push_back(make_pair(L, 0));
long long res = 0;
res += VI[0].first / a;
for (int i = 0; i < n; i++)
res += (VI[i + 1].first - VI[i].first - VI[i].second) / a;
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 12345;
const int maxQ = 1000 + 10;
bool mark[30][150];
char ch[maxQ];
int que;
int num[maxQ], mul[maxQ];
long long n;
int start = clock();
struct MAT {
int n, m;
vector<vector<int> > mat;
MAT() {}
MAT(int _n, int _m, bool h = false) {
n = _n;
m = _m;
mat = vector<vector<int> >(n, vector<int>(m, 0));
if (h)
for (int i = 0; i < n; i++) mat[i][i] = 1;
}
MAT operator*(const MAT &SEC) const {
MAT ret = MAT(n, SEC.m);
for (int i = 0; i < n; i++)
for (int j = 0; j < SEC.m; j++)
for (int k = 0; k < m; k++)
ret.mat[i][j] = (ret.mat[i][j] + mat[i][k] * SEC.mat[k][j]) % mod;
return ret;
}
MAT POWER(long long p) {
MAT ret = MAT(n, n, true);
MAT cur = *this;
while (p) {
if (p & 1) ret = ret * cur;
cur = cur * cur;
p >>= 1;
}
return ret;
}
};
int main() {
cin >> n >> que;
if (n == 0 || que == 0) {
cout << (n == 0) << endl;
return 0;
}
for (int o = 1; o <= que; o++) {
cin >> ch[o] >> num[o];
if (mark[ch[o] - 'A'][num[o]]) {
que--;
o--;
} else
mark[ch[o] - 'A'][num[o]] = true;
}
mul[que + 1] = 1;
for (int i = que; i > 0; i--) mul[i] = mul[i + 1] * num[i];
MAT comb = MAT(mul[1], mul[1]);
for (int i = 0; i < mul[1]; i++) {
int cur = i;
vector<int> Q;
for (int j = 1; j <= que; j++) {
Q.push_back(cur / mul[j + 1]);
cur -= Q.back() * mul[j + 1];
}
for (char j = 'A'; j <= 'Z'; j++) {
int temp = i;
bool bad = true;
for (int k = 1; k <= que; k++)
if (ch[k] == j) {
bad = false;
temp -= Q[k - 1] * mul[k + 1];
temp += ((Q[k - 1] + 1) % num[k]) * mul[k + 1];
}
if (!bad) comb.mat[temp][i]++;
}
}
MAT base = MAT(mul[1], 1);
base.mat[0][0] = 1;
MAT ans = comb.POWER(n) * base;
int ret = 0;
for (int i = 0; i < mul[1]; i++) {
int cur = i;
vector<int> Q;
for (int j = 1; j <= que; j++) {
Q.push_back(cur / mul[j + 1]);
cur -= Q.back() * mul[j + 1];
}
bool bad = false;
for (char j = 'A'; j <= 'Z'; j++) {
bool f1 = false;
bool f2 = false;
for (int k = 1; k <= que; k++)
if (ch[k] == j) {
f1 = true;
f2 |= (Q[k - 1] == 0);
}
if (f1 ^ f2) bad = true;
}
if (!bad) ret = (ret + ans.mat[i][0]) % mod;
}
cout << ret << endl;
cerr << endl
<< endl
<< fixed << setprecision(3)
<< "TIME : " << (clock() - start + 0.0) / CLOCKS_PER_SEC << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
string s[N];
int d[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= m; i++)
for (int j = 2; j <= n; j++)
if (s[j][i - 1] == 'X' && s[j - 1][i] == 'X') {
d[i] = 1;
continue;
}
for (int i = 1; i <= m; i++) d[i] += d[i - 1];
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
if (d[r - 1] - d[l - 1])
puts("NO");
else
puts("YES");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
double x, y;
Point() {}
Point(double _x, double _y) {
x = _x;
y = _y;
}
Point operator+(const Point& other) const {
return Point(x + other.x, y + other.y);
}
Point operator-(const Point& other) const {
return Point(x - other.x, y - other.y);
}
double operator^(const Point& other) const {
return x * other.y - y * other.x;
}
double operator*(const Point& other) const {
return x * other.x + y * other.y;
}
double operator~() const { return x * x + y * y; }
double distanceToSegment2(const Point s1, const Point s2) const {
Point c = *this;
if (((s2 - s1) * (c - s1)) <= 0.0 || ((s1 - s2) * (c - s2)) <= 0.0) {
return min(~(s1 - c), ~(s2 - c));
} else {
double area = (s2 - s1) ^ (c - s1);
return (area * area) / (~(s2 - s1));
}
}
};
struct Line {
double a, b, c;
Line() {}
Line(double _a, double _b, double _c) {
a = _a;
b = _b;
c = _c;
}
bool parallel(const Line& other) { return (a * other.b == other.a * b); }
Point intersect(const Line& other) {
if (this->parallel(other))
return Point(-HUGE_VAL, -HUGE_VAL);
else {
double det = a * other.b - other.a * b;
double x = (b * other.c - other.b * c) / det;
double y = (c * other.a - other.c * a) / det;
return Point(x, y);
}
}
Line perpendicular(Point p) { return Line(-b, a, b * p.x - a * p.y); }
};
const int MAXN = 2123;
int n;
Point v[MAXN];
int main() {
cin >> n;
double ans = HUGE_VAL;
for (int i = 0; i < n; ++i) scanf("%lf %lf", &v[i].x, &v[i].y);
for (int i = 0; i < n; ++i)
ans = min(ans, v[i].distanceToSegment2(v[(i - 1 + n) % n], v[(i + 1) % n]));
if (ans < 0) ans = 0;
cout << fixed << setprecision(12) << sqrt(ans) / 2.0 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, mod = 1e9 + 7;
string arr[8];
int dd[30][10][10], visited[30][10][10];
;
int dr[] = {0, 1, 1, 0, -1, -1, -1, 0, 1};
int dc[] = {0, 0, -1, -1, -1, 0, 1, 1, 1};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < 8; i++) cin >> arr[i];
memset(dd, 1, sizeof dd);
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
if (arr[i][j] == 'S')
for (int k = 0; k <= 8; k++) dd[k][i + k][j] = false;
queue<pair<int, pair<int, int> > > q;
q.push({0, {7, 0}});
while (!q.empty()) {
auto a = q.front();
q.pop();
int step = a.first, x = a.second.first, y = a.second.second;
if (x == 0 && y == 7) {
cout << "WIN";
return 0;
}
if (step > 20) continue;
if (!dd[step][x][y] || visited[step][x][y]) continue;
visited[step][x][y] = 1;
for (int i = 0; i <= 8; i++) {
int _x = x + dr[i], _y = y + dc[i];
if (_x < 0 || _x >= 8 || _y < 0 || _y >= 8) continue;
int f = dd[step][_x][_y];
if (f) q.push({step + 1, {_x, _y}});
}
}
cout << "LOSE";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
set<int> st;
for (int i = 0; i < 100000 + 5; i++) st.insert(i + 1);
int ms[100000 + 5];
int cnt[100000 + 5];
fill(cnt, cnt + 100000 + 5, 0);
for (int i = 0; i < n; i++) {
int tmp;
cin >> tmp;
if (st.count(tmp)) st.erase(tmp);
ms[i] = tmp;
cnt[tmp]++;
}
for (int i = 0; i < n; i++) {
if (cnt[ms[i]] > 1 || ms[i] > n) {
cnt[ms[i]]--;
ms[i] = *st.begin();
st.erase(st.begin());
}
cout << ms[i] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 5;
int n, m, f;
const int inf = 1e9;
struct node {
int to, cap, nxt;
} edge[maxn * maxn];
int ecnt = 0;
int q[maxn * maxn], l = 0, r = 0;
int head[maxn], level[maxn], iter[maxn];
int tot;
void init() {
for (int i = 0; i <= tot + 1; i++) head[i] = -1;
ecnt = 0;
}
void add(int from, int to, int cap) {
int& i = ecnt;
edge[i].to = to;
edge[i].cap = cap;
edge[i].nxt = head[from];
head[from] = i++;
edge[i].to = from;
edge[i].cap = 0;
edge[i].nxt = head[to];
head[to] = i++;
}
void bfs(int s) {
for (int i = 0; i <= tot + 1; i++) level[i] = -1;
level[s] = 0;
l = r = 0;
q[r++] = s;
int x;
while (l < r) {
x = q[l++];
for (int i = head[x]; i != -1; i = edge[i].nxt) {
node& e = edge[i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[x] + 1;
q[r++] = e.to;
}
}
}
}
int dfs(int v, int t, int f) {
if (v == t) return f;
for (int& i = iter[v]; i != -1; i = edge[i].nxt) {
node& e = edge[i];
if (e.cap > 0 && level[v] < level[e.to]) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
edge[i ^ 1].cap += d;
return d;
}
}
}
return 0;
}
long long maxFlow(int s, int t) {
long long flow = 0;
while (true) {
bfs(s);
if (level[t] < 0) return flow;
for (int i = 0; i <= tot + 1; i++) iter[i] = head[i];
int f;
while ((f = dfs(s, t, inf)) > 0) flow += f;
}
}
int main() {
scanf("%d%d", &n, &m);
int u, v, w;
long long sum = 0;
tot = n + m;
init();
int x;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
add(i, tot + 1, x);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
add(i + n, u, inf);
add(i + n, v, inf);
add(0, i + n, w);
sum += w;
}
printf("%lld\n", sum - maxFlow(0, tot + 1));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
default_random_engine generator;
const int MAXN = 2000;
vector<int> g[MAXN];
int s[MAXN];
map<pair<int, int>, int> mapa;
int good[MAXN];
int dfs(int v, int p = -1) {
s[v] = 1;
for (int u : g[v]) {
if (u != p) {
s[v] += dfs(u, v);
}
}
return s[v];
}
void dfs1(int v, int step, int &glob, int cur, int p = -1) {
for (int u : g[v]) {
if (p == -1) {
if (good[u]) {
glob += step;
mapa[{v, u}] = glob;
dfs1(u, step, glob, glob, v);
}
continue;
}
if (u == p) {
continue;
}
glob += step;
mapa[{v, u}] = glob - cur;
dfs1(u, step, glob, glob, v);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
g[v].push_back(u);
g[u].push_back(v);
}
dfs(0);
int cen = -1;
for (int i = 0; i < n; ++i) {
bool ok = (n - s[i] <= n / 2);
for (int u : g[i]) {
if (s[u] < s[i]) {
ok &= (s[u] <= n / 2);
}
}
if (ok) {
cen = i;
break;
}
}
assert(cen != -1);
dfs(cen);
vector<int> sum(2);
vector<vector<int>> arr(2);
vector<pair<int, int>> a;
for (int u : g[cen]) {
a.push_back({s[u], u});
}
sort((a).begin(), (a).end());
reverse((a).begin(), (a).end());
for (int i = 0; i < (int)(a).size(); ++i) {
int k = (sum[0] <= sum[1] ? 0 : 1);
sum[k] += a[i].first;
arr[k].push_back(a[i].second);
}
for (int u : arr[0]) {
good[u] = true;
}
int glob = 0;
dfs1(cen, 1, glob, 0);
for (int u : arr[0]) {
good[u] = false;
}
for (int u : arr[1]) {
good[u] = true;
}
int step = glob + 1;
glob = 0;
dfs1(cen, step, glob, 0);
for (auto el : mapa) {
cout << el.first.first + 1 << " " << el.first.second + 1 << " " << el.second
<< endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, c = 0;
cin >> n;
int a, f[7];
for (int j = 0; j < 7; j++) f[j] = 0;
for (int i = 0; i < n; i++) {
cin >> a;
for (int j = 0; j < 7; j++) {
if (a % (int)pow(10, 1) == 1) f[j]++;
a = a / 10;
}
}
for (int i = 0; i < 7; i++) c = max(c, f[i]);
cout << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
const int N = 1e5 + 5, M = 1e6 + 5;
int first[N], nex[M], to[M], w[M], num = 1;
int n, m, s, t, ans, sum1, sum2;
inline void add(int u, int v, int val) {
nex[++num] = first[u];
first[u] = num;
to[num] = v;
w[num] = val;
}
inline void Add(int u, int v, int val) {
add(u, v, val);
add(v, u, 0);
}
namespace ISAP {
int dep[N], gap[N];
void bfs() {
memset(dep, -1, sizeof(dep));
queue<int> q;
q.push(t);
dep[t] = 0;
gap[0] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = first[u]; i; i = nex[i]) {
int v = to[i];
if (!w[i] || dep[v] != -1) continue;
dep[v] = dep[u] + 1;
gap[dep[v]]++;
q.push(v);
}
}
}
int cur[N];
inline int dfs(int u, int in) {
int out = 0;
if (u == t) return in;
for (int i = cur[u]; i; i = nex[i]) {
cur[u] = i;
int v = to[i];
if (!w[i] || dep[v] != dep[u] - 1) continue;
int res = dfs(v, min(w[i], in - out));
w[i] -= res;
w[i ^ 1] += res;
out += res;
if (out == in) return out;
}
gap[dep[u]]--;
if (!gap[dep[u]]) dep[s] = n * m * 2 + 3;
dep[u]++;
gap[dep[u]]++;
return out;
}
void work() {
bfs();
while (dep[s] < n * m * 2 + 2) {
memcpy(cur, first, sizeof(first));
ans += dfs(s, 1e9);
}
}
} // namespace ISAP
bool vis[N], mp[202][202];
int main() {
n = read(), m = read();
s = 0, t = 2 * n * m + 1;
for (int i = 1; i <= n; ++i) {
string s;
getline(cin, s);
for (int j = 0; j < m; ++j)
if (s[j] == '#') mp[i][j + 1] = 1;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (!mp[i][j]) continue;
sum1++;
int y1 = (i - 1) * m + j, y2 = i * m + j, x2 = y1 + n * m, x1 = x2 - 1;
if (mp[i - 1][j] && !vis[y1]) sum2++, vis[y1] = 1, Add(s, y1, 1);
if (mp[i][j - 1] && !vis[x1]) sum2++, vis[x1] = 1, Add(x1, t, 1);
if (mp[i - 1][j]) {
if (mp[i][j + 1]) Add(y1, x2, 1);
if (mp[i][j - 1]) Add(y1, x1, 1);
}
if (mp[i + 1][j]) {
if (mp[i][j + 1]) Add(y2, x2, 1);
if (mp[i][j - 1]) Add(y2, x1, 1);
}
}
}
ISAP::work();
printf("%d", sum1 + ans - sum2);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long w, h, n, x;
char ty;
multiset<long long> pos[2], sz[2];
int main() {
scanf("%lld %lld %lld", &w, &h, &n);
pos[0].insert(0);
pos[0].insert(w);
sz[0].insert(w);
pos[1].insert(0);
pos[1].insert(h);
sz[1].insert(h);
for (int i = 0; i < n; i++) {
scanf(" %c %lld", &ty, &x);
ty = ty == 'H' ? 1 : 0;
multiset<long long>::iterator it2 = pos[ty].lower_bound(x), it = it2;
--it;
sz[ty].erase(sz[ty].find(*it2 - *it));
sz[ty].insert(*it2 - x);
sz[ty].insert(x - *it);
pos[ty].insert(x);
printf("%lld\n", *sz[0].rbegin() * *sz[1].rbegin());
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, t = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') t = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * t;
}
const int N = 3e5 + 5;
int n;
namespace Tree {
int rt, tot, Num, d[N], c[N][2], prt[N], w[N];
void Init(int x, int v) {
if (x) d[x] += v, w[x] += v;
}
void Pushdown(int x) {
if (!d[x]) return;
Init(c[x][0], d[x]), Init(c[x][1], d[x]), d[x] = 0;
}
void rot(int x, int &f) {
int y = prt[x], z = prt[y];
int l = (c[y][0] != x), r = l ^ 1;
if (y == f)
f = x;
else
c[z][c[z][0] != y] = x;
prt[y] = x, prt[x] = z, prt[c[x][r]] = y;
c[y][l] = c[x][r], c[x][r] = y;
}
void Splay(int x, int &f) {
while (x ^ f) {
int y = prt[x], z = prt[y];
if (y ^ f) Pushdown(z);
Pushdown(y), Pushdown(x);
if (y ^ f) {
if ((c[z][0] == y) ^ (c[y][0] == x))
rot(x, f);
else
rot(y, f);
}
rot(x, f);
}
}
int Pre(int v) {
int res = 0, x = rt;
while (x) {
Pushdown(x);
if (w[x] < v)
res = x, x = c[x][1];
else
x = c[x][0];
}
if (res) Splay(res, rt);
return res;
}
int Suf(int v) {
int res = 0, x = rt;
while (x) {
Pushdown(x);
if (w[x] > v)
res = x, x = c[x][0];
else
x = c[x][1];
}
if (res) Splay(res, rt);
return res;
}
void Insert(int v) {
int x = rt, f = 0;
if (!rt) {
w[rt = ++tot] = v;
return;
}
while (x) {
f = x, Pushdown(x);
x = (v < w[x]) ? c[x][0] : c[x][1];
}
c[f][v > w[f]] = ++tot;
prt[tot] = f, w[tot] = v, Splay(tot, rt);
}
void Delete(int x) {
Num++, Splay(x, rt), Pushdown(x);
if (!c[x][1]) {
prt[rt = c[x][0]] = 0;
return;
}
int y = c[x][1];
while (c[y][0]) y = c[y][0];
Splay(y, c[x][1]), Pushdown(y);
rt = y, prt[y] = 0, c[y][0] = c[x][0], prt[c[x][0]] = y;
}
void Print(int x) {
Pushdown(x);
if (c[x][0]) Print(c[x][0]);
cout << w[x] << " ";
if (c[x][1]) Print(c[x][1]);
}
void Update(int x, int y) {
int a = Pre(w[x]), b = Suf(w[y]);
if (!a && !b) return Init(rt, 1);
if (a && !b) return Splay(a, rt), Init(c[rt][1], 1);
if (!a && b) return Splay(b, rt), Init(c[rt][0], 1);
Splay(a, rt), Splay(b, c[rt][1]);
Init(c[c[rt][1]][0], 1);
}
} // namespace Tree
using namespace Tree;
int main() {
n = read(), Insert(0);
for (int i = 1; i <= n; i++) {
int l = read(), r = read();
int a = Suf(l - 1), b = Pre(r), c = Suf(r - 1);
if (a && b) Update(a, b);
Insert(l);
if (c) Delete(c);
}
cout << tot - Num - 1;
return 0;
}
| 10 |
#include <iostream>
#include <bits/stdc++.h>
#define test int t; cin >> t; while(t--)
using namespace std;
int main() {
test {
int n;
cin >> n;
int a[n];
set<int> s;
for(int i=0; i<n ;i++) {
cin >> a[i];
s.insert(a[i]);
}
int m=*min_element(a,a+n);
if(s.size()==1)
cout<<0<<endl;
else {
int c=0;
for(int i=0; i<n ;i++) {
if(a[i]!=m)
c++;
}
cout<<c<<endl;
}
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
vector<int>v;
string s;
int main()
{
ios::sync_with_stdio(false);
int t;
cin>>t;
while(t--)
{
int n,m;
cin>>n>>m;
cin>>s;
for(int i=0; i<m; i++)
{
v.clear();
for(int j=0; j<n; j++)
{
if(s[j]=='0')
{
if(j==0)
{
if(s[j]=='0' && s[j+1]=='1')
{
v.emplace_back(j);
}
}
else if(j==n-1)
{
if(s[j]=='0' && s[j-1]=='1')
{
v.emplace_back(j);
}
}
else
{
if(s[j-1]=='1' && s[j+1]=='1')
{
;
}
else if(s[j-1]=='0' && s[j+1]=='0')
{
;
}
else
{
v.emplace_back(j);
}
}
}
}
for(int j=0;j<v.size();j++)
{
int now=v[j];
s[now]='1';
}
//cout<<s<<endl;
if(v.size()==0)
{
break;
}
}
cout<<s<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e6 + 7;
const int Inf = 1e9 + 7;
int main() {
long long p, d;
while (~scanf(" %lld %lld", &p, &d)) {
long long dp = 1, Mod = 10;
long long cc = 0;
long long ans = p;
long long ss = 1LL;
for (; Mod <= p; Mod *= 10) {
if (p % Mod + 1 == Mod) continue;
if (p % Mod + 1 <= d) {
cc = p % Mod + 1;
} else
break;
dp++;
}
printf("%lld\n", p - cc);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int m, n;
cin >> m >> n;
if (m > n) {
m = m + n;
n = m - n;
m = m - n;
}
if (n >= 2 * m) {
cout << m;
} else {
cout << (n - m) + (2 * (2 * m - n)) / 3;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
string s;
cin >> s;
int n = s.size();
int result{0};
int one{0};
for (int j{n - 1}; j > 0; j--)
if (s[j] == '1')
one++;
else {
if (one == 0)
result++;
else {
s[j] = '1';
result += one + 1;
one = 0;
j++;
}
}
if (one != 0) result += one + 2;
cout << result;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string t, b, e;
int p;
vector<int> v1, v2;
int main() {
ios::sync_with_stdio(false);
cin >> t >> b >> e;
while (p = t.find(b, p) + 1) {
v1.push_back(p - 1);
}
p = 0;
while (p = t.find(e, p) + 1) {
v2.push_back(p - 1);
}
unordered_set<unsigned long long> ans;
for (int i : v1) {
int k = i;
unsigned long long code = 0;
for (int j : v2) {
if (i <= j && i + (int)b.length() <= j + (int)e.length()) {
while (k < j + (int)e.length()) {
code = code * 31 + t[k++];
}
ans.insert(code);
}
}
}
cout << ans.size() << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, c, x[112], ans;
int main(int argc, char const *argv[]) {
scanf("%d %d", &n, &c);
for (int i = 0; i < n; i++) scanf("%d", &x[i]);
for (int i = 0; i < n - 1; i++) {
ans = max(ans, x[i] - x[i + 1] - c);
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool palindrom(string s) {
bool c = true;
for (int i = 0; i < s.size() / 2; i++)
if (s[i] != s[s.size() - i - 1]) {
c = false;
break;
}
return c;
}
int main() {
string s;
char c;
int t;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> s;
bool check;
check = false;
if (palindrom(s)) {
for (int j = 0; j < s.size() / 2; j++) {
c = s[j];
s[j] = s[j + 1];
s[j + 1] = c;
if (palindrom(s) == false) {
check = true;
break;
}
}
if (check)
cout << s << endl;
else
cout << -1 << endl;
} else
cout << s << endl;
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx2")
using namespace std;
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
return {a.first + b.first, a.second + b.second};
}
pair<int, int>& operator+=(pair<int, int>& a, pair<int, int> b) {
return a.first += b.first, a.second += b.second, a;
}
template <typename Iter>
ostream& outIt(ostream& out, Iter b, Iter e) {
for (Iter i = b; i != e; i++) out << *i << " ";
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> v) {
return outIt(out << '[', (v).begin(), (v).end()) << ']';
}
template <typename T, size_t N>
ostream& operator<<(ostream& out, array<T, N> v) {
return outIt(out << '[', (v).begin(), (v).end()) << ']';
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
return out << '(' << p.first << ", " << p.second << ')';
}
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& p) {
return in >> p.first >> p.second;
}
vector<pair<int, int>> v;
vector<vector<int>> G;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
int time = clock();
srand(244131);
cin >> n >> m;
G.resize(n + 1);
for (auto& i : G) i.resize(n + 1);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
G[a][b] = 1, G[b][a] = -1;
}
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (!G[i][j]) G[i][j] = -1, G[j][i] = 1, v.push_back({i, j});
for (int t = 0; t < 100000; t++) {
random_shuffle((v).begin(), (v).end());
if (clock() - time >= CLOCKS_PER_SEC * 0.98) break;
for (auto p : v) {
int c = 0;
for (int i = 1; i <= n; i++)
if (G[p.first][i] == -G[p.second][i]) c += G[p.first][i];
G[p.first][p.second] =
-(G[p.second][p.first] = (c ? c >= 0 : rand() & 1) ? 1 : -1);
}
}
for (int i = 1; i <= n; i++, putchar('\n'))
for (int j = 1; j <= n; j++) putchar((G[i][j] == 1) + '0');
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
const long long inv2 = (998244353 + 1) / 2;
long long a[1000005], d, b[1000005], c[1000005], ans;
long long f[1000005], nf[1000005], inv[1000005];
int n, r, s;
long long pow_(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % 998244353;
x = x * x % 998244353;
y >>= 1;
}
return res;
}
long long C(long long x, long long y) {
return f[x] * nf[y] % 998244353 * nf[x - y] % 998244353;
}
long long calc(long long n, long long b, long long sum) {
if (sum < 0) return 0;
if (n == 0) return (sum == 0);
if (b == 0) return 0;
long long res = 0;
for (int i = 0; i <= min(n, sum / b); i++) {
if (i & 1)
(res -= C(n, i) * C(sum - i * b + n - 1, n - 1) % 998244353) %= 998244353;
else
(res += C(n, i) * C(sum - i * b + n - 1, n - 1)) %= 998244353;
}
return (res + 998244353) % 998244353;
}
int main() {
inv[1] = 1;
for (int i = 2; i < 1000005; i++)
inv[i] = 998244353 - (998244353 / i) * inv[998244353 % i] % 998244353;
f[0] = nf[0] = 1;
for (int i = 1; i < 1000005; i++)
f[i] = f[i - 1] * i % 998244353, nf[i] = nf[i - 1] * inv[i] % 998244353;
scanf("%d%d%d", &n, &s, &r);
if (s == 0) {
printf("%lld\n", inv[n]);
return 0;
}
for (int i = r; i <= s; i++) {
for (int j = 1; j <= n; j++) {
long long ret = calc(n - j, i, s - j * i) * C(n - 1, j - 1) % 998244353;
(ans += ret * inv[j]) %= 998244353;
}
}
ans = ans * pow_(calc(n, s + 1, s - r), 998244353 - 2) % 998244353;
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(int, char*[]) {
int counts[256] = {0};
int n = 0;
int distance = 0;
{
int c;
while ((c = getchar()) != EOF) {
if (c < 'a' || c > 'z') break;
counts[c]++;
if (counts[c] % 2)
distance++;
else
distance--;
n++;
}
}
char c1 = 'a';
char c2 = 'z';
while (c2 > c1) {
if (counts[c1] % 2) {
while (c2 > c1 && counts[c2] % 2 == 0) c2--;
counts[c1]++;
counts[c2]--;
}
c1++;
}
char odd_fix = 0;
for (char c = 'a'; c <= 'z'; ++c) {
if (counts[c] % 2) odd_fix = c;
for (int i = 0; i < counts[c] / 2; ++i) {
putchar(c);
}
}
if (odd_fix) putchar(odd_fix);
for (char c = 'z'; c >= 'a'; --c) {
for (int i = 0; i < counts[c] / 2; ++i) {
putchar(c);
}
}
putchar('\n');
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, pa[3333], rt[3333], dep[3333], dist[3333], len, pos[3333];
vector<int> g[3333], cycle;
bool used[3333], f, in_cycle[3333];
double ans, a, b, c, d;
void dfs(int i, int fa) {
used[i] = 1;
pa[i] = fa;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (to == fa) continue;
if (used[to]) {
if (f) continue;
f = 1;
int cur = i;
while (cur != to) {
cycle.push_back(cur);
cur = pa[cur];
}
cycle.push_back(cur);
continue;
}
dfs(to, i);
}
}
void precalc(int i, int fa, int root, int depth) {
rt[i] = root;
dep[i] = depth;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (to == fa || in_cycle[to]) continue;
precalc(to, i, root, depth + 1);
}
}
void proc(int i, int fa, int depth, int pt) {
dist[i] = depth;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (to == fa || (in_cycle[to] && to != pt)) continue;
proc(to, i, depth + 1, pt);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
x++;
y++;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
for (int i = 0; i < cycle.size(); i++) in_cycle[cycle[i]] = 1;
for (int i = 0; i < cycle.size(); i++) {
pos[cycle[i]] = i;
}
for (int i = 0; i < cycle.size(); i++) {
precalc(cycle[i], 0, cycle[i], 0);
}
len = cycle.size();
for (int i = 1; i <= n; i++) {
memset(dist, 0, sizeof(dist));
proc(i, 0, 0, rt[i]);
for (int j = 1; j <= n; j++) {
if (rt[i] == rt[j]) {
ans += 1.00 / (double)(dist[j] + 1);
} else {
c = (double)dep[i];
d = (double)dep[j];
a = (double)abs(pos[rt[i]] - pos[rt[j]]);
b = (double)(len - (int)a);
ans += (1.00 / (a + c + d + 1.00) + 1.00 / (b + c + d + 1.00) -
1.00 / (a + b + c + d));
}
}
}
printf("%.9lf\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int fa[6000000], n, m;
int get(int x) {
if (fa[x] == x) return x;
return fa[x] = get(fa[x]);
}
void merge(int a, int b) { fa[get(b)] = get(a); }
int main() {
for (int i = 0; i < 6000000; i++) fa[i] = i;
cin >> n >> m;
int MAX_C = n + m - 3;
for (int i = 2; i <= n - 1; i++) {
int x = i - 1, y = n - i + MAX_C;
merge(x, y);
}
for (int i = 2; i <= n - 1; i++) {
int x = m - 2 + i, y = n + m - i - 1 + MAX_C;
merge(x, y);
}
for (int i = 2; i <= m - 1; i++) {
int x = i - 1, y = n - 2 + i + MAX_C;
merge(x, y);
}
for (int i = 2; i <= m - 1; i++) {
int x = n - 2 + i, y = i - 1 + MAX_C;
merge(x, y);
}
int root = 0;
for (int i = 1; i <= 2 * MAX_C; i++)
if (get(i) == i) root++;
cout << root;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const int BLKSZ = 317;
int nowarn;
void noprint(...) {}
int n, c[MAXN], w[MAXN], q;
namespace Discrete {
int *a[MAXN], sz;
void init() { sz = 0; }
void add(int *p) { a[sz++] = p; }
bool cmp(int *a, int *b) { return *a < *b; }
void solve() {
sort(a, a + sz, cmp);
int last = *a[0], id = 1;
for (int i = 0; i < sz; ++i)
if (*a[i] == last)
*a[i] = id;
else
last = *a[i], *a[i] = ++id;
}
} // namespace Discrete
namespace Tree {
int head[MAXN], nxt[MAXN << 1], to[MAXN << 1], m;
void init() {
m = 0;
memset(head, -1, sizeof(head));
}
void adde(int u, int v) {
to[m] = v, nxt[m] = head[u], head[u] = m++;
to[m] = u, nxt[m] = head[v], head[v] = m++;
}
} // namespace Tree
namespace Block {
int dfn[MAXN], dfn_cnt, blkno[MAXN], blkcnt;
stack<int> stk;
int dfs(int u, int fa) {
using namespace Tree;
dfn[u] = ++dfn_cnt;
int sz = 0;
for (int i = head[u]; ~i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
sz += dfs(v, u);
if (sz >= BLKSZ) {
++blkcnt;
for (; sz; --sz, stk.pop()) {
int o = stk.top();
blkno[o] = blkcnt;
}
}
}
++sz, stk.push(u);
return sz;
}
void solve() {
dfn_cnt = blkcnt = 0;
dfs(1, 0);
while (!stk.empty()) {
int u = stk.top();
stk.pop();
blkno[u] = blkcnt;
}
}
} // namespace Block
struct Query {
int u, v, idx;
Query() {}
Query(int u, int v, int idx) : u(u), v(v), idx(idx) {}
bool operator<(const Query &rhs) const {
using Block::blkno;
using Block::dfn;
if (blkno[u] == blkno[rhs.u])
return dfn[v] < dfn[rhs.v];
else
return blkno[u] < blkno[rhs.u];
}
};
Query qy[MAXN];
namespace LCA {
int dfn[MAXN], dfn_cnt, sz[MAXN], top[MAXN], son[MAXN], dep[MAXN], pa[MAXN];
void dfs1(int u, int fa, int d) {
using namespace Tree;
pa[u] = fa, dep[u] = d, sz[u] = 1, son[u] = 0;
for (int i = head[u]; ~i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
dfs1(v, u, d + 1);
sz[u] += sz[v];
if (sz[v] > sz[son[u]]) son[u] = v;
}
}
void dfs2(int u, int tp) {
using namespace Tree;
dfn[u] = ++dfn_cnt, top[u] = tp;
if (son[u]) dfs2(son[u], tp);
for (int i = head[u]; ~i; i = nxt[i]) {
int v = to[i];
if (v == pa[u] || v == son[u]) continue;
dfs2(v, v);
}
}
void solve() {
dfn_cnt = 0;
dfs1(1, 0, 1);
dfs2(1, 1);
}
int lca(int u, int v) {
noprint("lca(%d %d) = ", u, v);
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
u = pa[top[u]];
}
int ans = dep[u] < dep[v] ? u : v;
noprint("%d\n", ans);
return ans;
}
} // namespace LCA
long long ans[MAXN], now;
int cnt[MAXN][2], vis[MAXN];
void flip(int x) {
if (vis[x]) {
now -= cnt[w[x]][!c[x]];
--cnt[w[x]][c[x]];
vis[x] = 0;
} else {
now += cnt[w[x]][!c[x]];
++cnt[w[x]][c[x]];
vis[x] = 1;
}
}
void move(int u, int v) {
using LCA::lca;
using LCA::pa;
int w = lca(u, v);
while (u != w) flip(u), u = pa[u];
while (v != w) flip(v), v = pa[v];
}
void solve() {
using LCA::lca;
LCA::solve();
now = 0;
memset(vis, 0, sizeof(vis));
memset(cnt, 0, sizeof(cnt));
int u = 1, v = 1;
for (int i = 0; i < q; ++i) {
int uu = qy[i].u, vv = qy[i].v, idx = qy[i].idx;
noprint("uu = %d, vv = %d\n", uu, vv);
move(u, uu), move(v, vv), flip(lca(uu, vv));
ans[idx] = now, flip(lca(uu, vv));
u = uu, v = vv;
}
}
int main() {
nowarn = scanf("%d", &n);
for (int i = 1; i <= n; ++i) nowarn = scanf("%d", c + i);
Discrete::init();
for (int i = 1; i <= n; ++i) {
nowarn = scanf("%d", w + i);
Discrete::add(w + i);
}
Discrete::solve();
Tree::init();
for (int i = 0; i < n - 1; ++i) {
int u, v;
nowarn = scanf("%d%d", &u, &v);
Tree::adde(u, v);
}
nowarn = scanf("%d", &q);
for (int i = 0; i < q; ++i) {
int u, v;
nowarn = scanf("%d%d", &u, &v);
if (u > v) swap(u, v);
qy[i] = Query(u, v, i);
}
Block::solve();
sort(qy, qy + q);
solve();
for (int i = 0; i < q; ++i) printf("%lld\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long x[200005];
map<long long, long long> mapa;
int main() {
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> x[i];
sort(x + 1, x + 1 + n);
for (long long i = 1; i <= n; i++) mapa[x[i]] = 1;
x[0] = 1e12;
x[n + 1] = 1e12;
queue<tuple<long long, long long, long long> > q;
for (long long i = 1; i <= n; i++) {
long long pos = x[i];
long long esq = pos - 1;
long long dir = pos + 1;
if (mapa[esq] == 0) {
q.push(tuple<long long, long long, long long>(i - 1, esq, i));
mapa[esq] = 1;
}
if (mapa[dir] == 0) {
q.push(tuple<long long, long long, long long>(i, dir, i + 1));
mapa[dir] = 1;
}
}
long long res = 0;
vector<long long> aux;
while (!q.empty() and m) {
long long a, pos, b;
tie(a, pos, b) = q.front();
q.pop();
aux.push_back(pos);
m--;
res += min(abs(x[a] - pos), abs(x[b] - pos));
long long esq = pos - 1, dir = pos + 1;
if (mapa[esq] == 0) {
mapa[esq] = 1;
q.push(tuple<long long, long long, long long>(a, esq, b));
}
if (mapa[dir] == 0) {
mapa[dir] = 1;
q.push(tuple<long long, long long, long long>(a, dir, b));
}
}
cout << res << endl;
for (long long u : aux) cout << u << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, c = 0;
cin >> n >> k;
int a[n], i = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
}
i = 0;
while (a[i] <= k && i < n) {
c++;
i++;
}
int j = n - 1;
while (a[j] <= k && j > i - 1) {
c++;
j--;
}
cout << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long calc(long long x) { return x * (x - 1) / 2; }
int main() {
long long int n, m;
cin >> n >> m;
cout << (m - n % m) * calc(n / m) + (n % m) * calc(n / m + 1) << ' '
<< calc(n - m + 1) << ' ' << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<long long, long long> cost;
void update(long long u, long long v, long long w) {
if (u > v) {
cost[u] += w;
update(u / 2, v, w);
} else if (v > u) {
cost[v] += w;
update(u, v / 2, w);
} else
return;
}
long long get(long long u, long long v) {
if (u == v) return 0;
if (u > v) {
if (cost.find(u) != cost.end())
return cost[u] + get(u / 2, v);
else
return get(u / 2, v);
} else {
if (cost.find(v) != cost.end())
return cost[v] + get(u, v / 2);
else
return get(u, v / 2);
}
}
int main() {
ios::sync_with_stdio(false);
int q;
scanf("%d", &q);
while (q--) {
int type;
scanf("%d", &type);
if (type == 1) {
long long u, v, w;
scanf("%lld %lld %lld", &u, &v, &w);
update(u, v, w);
} else {
long long u, v;
scanf("%lld %lld", &u, &v);
printf("%lld\n", get(u, v));
}
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define X first
#define Y second
#define sz(a) (int)a.size()
#define ll long long
#define int long long
signed main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
bool flag = 1;
vector <pair <int, int> > x(n);
vector <int> ve(n + 1), c(n + 1);
vector <int> suffmax(n + 2), seq0, seq1;
for(int i = 0; i < n; i++)
{
int a, b;
cin >> a >> b;
int cost = 0;
if(a > b)
{
swap(a, b);
cost = 1;
}
if(a <= n)
{
ve[a] = b;
c[a] = cost;
}
else
{
flag = 0;
}
}
if(!flag)
{
cout << -1;
return 0;
}
suffmax[n + 1] = -1;
for(int i = n; i >= 1; i--)
{
suffmax[i] = max(suffmax[i + 1], ve[i]);
}
int prefmin = INT_MAX;
int cost0 = 0, cost1 = 0, ans = 0;
for(int i = 1; i <= n; i++)
{
prefmin = min(prefmin, ve[i]);
if(seq0.empty() || ve[seq0.back()] > ve[i])
{
seq0.push_back(i);
cost0 += c[i];
}
else if(seq1.empty() || ve[seq1.back()] > ve[i])
{
seq1.push_back(i);
cost1 += c[i];
}
else
{
cout << -1 << "\n";
return 0;
}
if(prefmin > suffmax[i + 1])
{
int s0 = (int)seq0.size();
int s1 = (int)seq1.size();
ans += min(cost0 + s1 - cost1, s0 + cost1 - cost0);
cost0 = cost1 = 0;
seq0.clear();
seq1.clear();
}
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
string s;
int mod[N], a, b;
int main() {
ios::sync_with_stdio(0);
cin >> s >> a >> b;
int t = 1;
for (int i = int(s.length()) - 1; i >= 0; --i) {
mod[i] = (mod[i + 1] + t * (s[i] - '0')) % b;
t = (t * 10) % b;
}
int now = 0;
for (int i = 0; i < int(s.length()) - 1; ++i) {
now = (now * 10 + (s[i] - '0')) % a;
if (now == 0 && s[i + 1] != '0' && mod[i + 1] == 0) {
cout << "YES\n" << s.substr(0, i + 1) << '\n' << s.substr(i + 1) << '\n';
return 0;
}
}
cout << "NO\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int powermod(int base, int pw, int modulo) {
int ans = 1;
while (pw) {
if (pw & 1) {
ans = (1LL * base * ans) % modulo;
}
base = (1LL * base * base) % modulo;
pw >>= 1;
}
return ans;
}
inline void debug(long double n) {
cout << n << ' ';
cout << "\n";
}
inline void debug(string s, long double n) {
cout << s << ": ";
cout << n << ' ';
cout << "\n";
}
inline void debug(string s) {
cout << s << " ";
cout << "\n";
}
void print_array(int* a, int n) {
for (int i = 0; i < n; i++) {
cout << a[i] << ' ';
}
cout << '\n';
}
void print_array(unsigned int* a, int n) {
for (int i = 0; i < n; i++) {
cout << a[i] << ' ';
}
cout << '\n';
}
void print_array(long long int* a, int n) {
for (int i = 0; i < n; i++) {
cout << a[i] << ' ';
}
cout << '\n';
}
void print_array(unsigned long long int* a, int n) {
for (int i = 0; i < n; i++) {
cout << a[i] << ' ';
}
cout << '\n';
}
void print_array(float* a, int n) {
for (int i = 0; i < n; i++) {
cout << a[i] << ' ';
}
cout << '\n';
}
void print_array(double* a, int n) {
for (int i = 0; i < n; i++) {
cout << a[i] << ' ';
}
cout << '\n';
}
void print_array(long double* a, int n) {
for (int i = 0; i < n; i++) {
cout << a[i] << ' ';
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(20);
int n, m;
cin >> n >> m;
char grid[n][m], grid2[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> grid[i][j];
grid2[i][j] = '.';
}
}
for (int i = 1; i < n - 1; i++) {
for (int j = 1; j < m - 1; j++) {
if (grid[i - 1][j - 1] == '#' && grid[i - 1][j] == '#' &&
grid[i - 1][j + 1] == '#' && grid[i][j - 1] == '#' &&
grid[i][j + 1] == '#' && grid[i + 1][j - 1] == '#' &&
grid[i + 1][j] == '#' && grid[i + 1][j + 1] == '#') {
grid2[i - 1][j - 1] = '#';
grid2[i - 1][j] = '#';
grid2[i - 1][j + 1] = '#';
grid2[i][j - 1] = '#';
grid2[i][j + 1] = '#';
grid2[i + 1][j - 1] = '#';
grid2[i + 1][j] = '#';
grid2[i + 1][j + 1] = '#';
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] != grid2[i][j]) {
cout << "NO";
return 0;
}
}
}
cout << "YES";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bitset<3000> b[3000];
struct {
double x, y;
} a[3000];
struct edg {
int x, y;
double z;
} f[5000010];
int n, m, i, j;
double dist(int i, int j) {
return (a[i].x - a[j].x) * (a[i].x - a[j].x) +
(a[i].y - a[j].y) * (a[i].y - a[j].y);
}
bool operator<(edg a, edg b) { return a.z < b.z; }
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> a[i].x >> a[i].y;
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++)
f[++m].x = i, f[m].y = j, f[m].z = sqrt(dist(i, j)) / 2;
sort(f + 1, f + m + 1);
for (i = m; i; i--) {
if ((b[f[i].x] & b[f[i].y]) != 0) break;
b[f[i].x][f[i].y] = 1;
b[f[i].y][f[i].x] = 1;
}
cout << setprecision(10) << fixed << f[i].z << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline void Boost() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int NMAX = 2e5 + 10;
const int mod = 998244353;
int n, k;
pair<int, int> v[NMAX];
vector<int> work;
bool cmp(pair<int, int> &X, pair<int, int> &Y) { return X.first > Y.first; }
int main() {
Boost();
int i, j;
long long sum = 0;
long long ans = 1;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> v[i].first;
v[i].second = i;
}
sort(v + 1, v + n + 1, cmp);
for (i = 1; i <= k; i++) {
work.push_back(v[i].second);
sum += v[i].first;
}
cout << sum << " ";
sort(work.begin(), work.end());
for (i = 1; i < work.size(); i++)
ans = (1LL * ans * (work[i] - work[i - 1] + mod) % mod) % mod;
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
int num[maxn], n, ans[maxn];
vector<int> ve[2];
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
ve[0].push_back(1e9);
ve[1].push_back(-1);
}
int put() {
for (int i = 1; i <= n; i++) {
if ((num[i] > *ve[1].rbegin() && num[i] < *ve[0].rbegin())) {
if (num[i + 1] > num[i]) {
ve[1].push_back(num[i]);
ans[i] = 0;
} else {
ve[0].push_back(num[i]);
ans[i] = 1;
}
} else if (num[i] < *ve[0].rbegin()) {
ans[i] = 1;
ve[0].push_back(num[i]);
} else if (num[i] > *ve[1].rbegin()) {
ans[i] = 0;
ve[1].push_back(num[i]);
} else {
return 0;
}
}
return 1;
}
void Print() {
puts("YES");
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
}
int main() {
init();
int flag = put();
if (!flag) {
puts("NO");
return 0;
}
Print();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool judge(int mid) {
int an = n - (mid / 2 - mid / 6);
int bn = m - (mid / 3 - mid / 6);
int s = mid / 6;
if (an > 0) s -= an;
if (bn > 0) s -= bn;
return s >= 0;
}
int main() {
scanf("%d%d", &n, &m);
int l = 0, r = 5000000;
while (l < r) {
int mid = (l + r) >> 1;
if (judge(mid))
r = mid;
else
l = mid + 1;
}
printf("%d\n", l);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void new_s(const string &&tmp, string &s1) {
for (int i = 0; i < (int)tmp.size(); ++i) {
if (isalpha(tmp[i])) {
s1 += char(tolower(tmp[i]));
}
}
}
bool check_s(const vector<string> &v, const string &tmp) {
string tmp2 = "";
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (i == j) continue;
for (int k = 0; k < 3; ++k) {
if (k == j || k == i) continue;
tmp2 = v[i] + v[j] + v[k];
if (tmp == tmp2) return 1;
}
}
}
return 0;
}
signed main() {
string s1, s2, s3, tmp, s;
vector<string> v;
v.resize(3);
cin >> tmp;
new_s(move(tmp), v[0]);
cin >> tmp;
new_s(move(tmp), v[1]);
cin >> tmp;
new_s(move(tmp), v[2]);
int n;
cin >> n;
while (n--) {
cin >> tmp;
new_s(move(tmp), s);
if (false) cerr << s << '\n';
if (check_s(v, s))
cout << "ACC\n";
else
cout << "WA\n";
s = "";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long bl = 1000000000LL;
long long x, y, a1, a2, b1, b2, i, j, k;
int cmp(long long a, long long b, long long c, long long d) {
long long a1, a2, a3, b1, b2, b3, x, y, p, q;
x = a / bl;
y = a % bl;
p = d / bl;
q = d % bl;
a1 = x * p;
a2 = x * q + y * p;
a3 = y * q;
x = b / bl;
y = b % bl;
p = c / bl;
q = c % bl;
b1 = x * p;
b2 = x * q + y * p;
b3 = y * q;
a2 += a3 / bl;
a3 %= bl;
b2 += b3 / bl;
b3 %= bl;
a1 += a2 / bl;
a2 %= bl;
b1 += b2 / bl;
b2 %= bl;
if (a1 > b1) return 1;
if (a1 < b1) return -1;
if (bl * a2 + a3 > bl * b2 + b3) return 1;
if (bl * a2 + a3 < bl * b2 + b3) return -1;
return 0;
}
long long gcd(long long a, long long b) {
long long r;
do {
r = a % b;
a = b;
b = r;
} while (r);
return a;
}
long long bs1(long long a, long long b, long long c, long long d) {
long long l = 1, r = max(x, y), m;
if (c) r = min(r, (x - a) / c);
if (d) r = min(r, (y - b) / d);
while (l < r - 1) {
m = (l + r) >> 1;
if (cmp(a + m * c, b + m * d, x, y) <= 0)
r = m;
else
l = m + 1;
}
return (cmp(a + l * c, b + l * d, x, y) <= 0) ? l : r;
}
long long bs2(long long a, long long b, long long c, long long d) {
long long l = 1, r = max(x, y), m;
if (c) r = min(r, (x - a) / c);
if (d) r = min(r, (y - b) / d);
while (l < r - 1) {
m = (l + r) >> 1;
if (cmp(a + m * c, b + m * d, x, y) >= 0)
r = m;
else
l = m + 1;
}
return (cmp(a + l * c, b + l * d, x, y) >= 0) ? l : r;
}
int main() {
cin >> x >> y;
if (gcd(x, y) > 1) {
puts("Impossible");
return 0;
}
a2 = b1 = 1;
a1 = b2 = 0;
while (a1 + b1 != x || a2 + b2 != y) {
if (cmp(x, y, a1 + b1, a2 + b2) == 1) {
k = bs2(a1 + b1, a2 + b2, b1, b2);
a1 += k * b1;
a2 += k * b2;
cout << k << "A";
} else {
k = bs1(a1 + b1, a2 + b2, a1, a2);
b1 += k * a1;
b2 += k * a2;
cout << k << "B";
}
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char a[n], b[n];
for (int i = 0; i < n; i++) {
char c;
cin >> c;
a[i] = c;
cin >> c;
b[i] = c;
}
int o = 20;
string g = "RGBYW12345";
for (int i = 0; i < 1024; i++) {
string d = "";
int k = 0;
for (int j = 0; j < 10; j++) {
if ((i & (1 << j)) > 0) {
d += g[j];
k++;
}
}
int f = 0;
for (int x = 0; x < n; x++) {
for (int y = 0; y < n; y++) {
if (x != y) {
int l = d.find(a[x]), m = d.find(a[y]), l1 = d.find(b[x]),
m1 = d.find(b[y]);
if (l < 0 || l >= d.size()) l = -1;
if (m < 0 || m >= d.size()) m = -1;
if (l1 < 0 || l1 >= d.size()) l1 = -1;
if (m1 < 0 || m1 >= d.size()) m1 = -1;
if (a[x] != a[y] && b[x] != b[y]) {
if (l == -1 && m == -1 && l1 == -1 && m1 == -1) {
f = 1;
break;
}
} else if (a[x] == a[y] && b[x] != b[y]) {
if (l1 == -1 && m1 == -1) {
f = 1;
break;
}
} else if (a[x] != a[y] && b[x] == b[y]) {
if (l == -1 && m == -1) {
f = 1;
break;
}
}
}
}
if (f == 1) break;
}
if (f == 0) o = min(o, k);
}
cout << o;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, f, g;
char c;
set<int> d, e;
cin >> a >> b;
for (f = 0; f < a; f++) {
for (g = 0; g < b; g++) {
cin >> c;
if (c == 'S') {
d.insert(f);
e.insert(g);
}
}
}
cout << a * b - d.size() * e.size();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
node *left, *right;
int size;
int key, mx;
};
int pos[100110];
struct SplayTree {
int cnt, top, count;
node *root, *null, *stack[100110 * 2], nodes[100110 * 2];
node *newnode(int c) {
node *res;
if (top)
res = stack[--top];
else
res = nodes + (++cnt);
res->left = res->right = null;
res->size = 1;
res->mx = res->key = c;
return res;
}
void pushup(node *x) {
if (x == null) return;
x->size = x->left->size + x->right->size + 1;
x->mx = max(x->key, max(x->left->mx, x->right->mx));
}
void init() {
top = cnt = 0;
count = 0;
null = &nodes[++cnt];
null->size = 0;
null->left = null->right = null;
null->mx = -0x3f3f3f3f;
root = newnode(0);
root->right = newnode(0);
}
void rightrotate(node *&x) {
node *y = x->left;
x->left = y->right;
y->right = x;
pushup(x);
x = y;
}
void leftrotate(node *&x) {
node *y = x->right;
x->right = y->left;
y->left = x;
pushup(x);
x = y;
}
void leftlink(node *&t, node *&l) {
node *temp = t;
t = t->right;
temp->right = l;
l = temp;
}
void rightlink(node *&t, node *&r) {
node *temp = t;
t = t->left;
temp->left = r;
r = temp;
}
void leftfinish(node *l, node *p) {
while (1) {
node *temp = l;
l = l->right;
temp->right = p;
pushup(temp);
p = temp;
if (temp == null) break;
}
}
void rightfinish(node *r, node *p) {
while (1) {
node *temp = r;
r = r->left;
temp->left = p;
pushup(temp);
p = temp;
if (temp == null) break;
}
}
void splay(node *&t, int k) {
node *l = null, *r = null;
null->left = null->right = null;
while (k != t->left->size + 1) {
if (k <= t->left->size) {
if (k == t->left->left->size + 1)
rightlink(t, r);
else if (k <= t->left->left->size) {
rightrotate(t);
rightlink(t, r);
} else {
k -= t->left->left->size + 1;
rightlink(t, r);
leftlink(t, l);
}
} else {
k -= t->left->size + 1;
if (k == t->right->left->size + 1)
leftlink(t, l);
else if (k > t->right->left->size + 1) {
k -= t->right->left->size + 1;
leftrotate(t);
leftlink(t, l);
} else {
leftlink(t, l);
rightlink(t, r);
}
}
}
leftfinish(l, t->left);
rightfinish(r, t->right);
t->left = null->right;
t->right = null->left;
pushup(t);
}
void insert(int pos, int v) {
splay(root, pos + 1);
splay(root->right, 1);
(root->right->left) = newnode(v);
pushup(root->right);
pushup(root);
count++;
}
int find(int v) {
splay(root, 1);
splay(root->right, count + 1);
return find((root->right->left), v);
}
int find(node *r, int v) {
if (r == null) return 0;
if (r->right->mx > v) return r->left->size + find(r->right, v) + 1;
if (r->key > v) return r->left->size + 1;
if (r->left->mx > v) return find(r->left, v);
return 0;
}
void visit() {
splay(root, 1);
splay(root->right, count + 1);
visit((root->right->left));
}
void visit(node *r) {
if (r == null) return;
visit(r->left);
printf("%d ", pos[r->key]);
visit(r->right);
}
} st;
int n, a, c;
int main() {
scanf("%d", &n);
st.init();
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a, &c);
pos[a] = i;
int p = st.find(a);
p = max(p, i - c - 1);
st.insert(p, a);
}
st.visit();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans *= a;
b >>= 1;
a *= a;
}
return ans;
}
long long qpow(long long a, long long b, long long mod) {
long long ans = 1;
a %= mod;
while (b) {
if (b & 1) (ans *= a) %= mod;
b >>= 1;
(a *= a) %= mod;
}
return ans % mod;
}
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (ch < 48 || ch > 57) {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= 48 && ch <= 57)
s = (s << 1) + (s << 3) + (ch ^ 48), ch = getchar();
return s * w;
}
const int mod = 1e9 + 7;
const int N = 1e5 + 7;
int nums[20];
long long dp[20][20];
long long dfs(int pos, int pre, bool limit) {
if (pos == 0) return 1;
if (!limit && dp[pos][pre] != -1) return dp[pos][pre];
int maxnum = limit ? nums[pos] : 9;
long long sum = 0;
for (int i = 0; i <= maxnum; i++) {
if (pre == 4 && i == 9) continue;
sum += dfs(pos - 1, i, limit && i == maxnum);
}
if (!limit) dp[pos][pre] = sum;
return sum;
}
long long solve(long long n) {
int pos = 0;
while (n) {
nums[++pos] = n % 10;
n /= 10;
}
memset(dp, -1, sizeof(dp));
return dfs(pos, 0, true);
}
string s;
int main() {
int t;
cin >> t;
while (t--) {
int a = 0, b = 0, c = 0;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'B')
b++;
else
a++;
}
if (a == b)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
long long int n, m, i, j, k, a[200009], q = 0;
scanf("%lld", &n);
for (i = 0; i < n; i++) scanf("%lld", &a[i]);
m = 0;
j = 0;
for (i = 0; i < n; i++) {
if (a[i] > m) {
m = a[i];
j = i;
}
}
for (i = j - 1; i >= 0; i--) {
if (a[i] > a[i + 1]) {
q = 1;
break;
}
}
for (i = j + 1; i < n; i++) {
if (a[i] > a[i - 1]) {
q = 1;
break;
}
}
if (q == 1)
printf("NO\n");
else
printf("YES\n");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
int board[4][n];
for (int i = 0; i < (4); i++) {
for (int j = 0; j < (n); j++) {
scanf("%d", &board[i][j]);
board[i][j]--;
}
}
vector<pair<int, pair<int, int>>> moves;
bool flag = true;
while (flag && k > 0) {
flag = false;
for (int i = 0; i < (n); i++) {
if (board[0][i] != -1 && board[0][i] == board[1][i]) {
moves.push_back({board[0][i] + 1, {1, i + 1}});
board[1][i] = -1;
k--;
flag = true;
}
if (board[3][i] != -1 && board[3][i] == board[2][i]) {
moves.push_back({board[3][i] + 1, {4, i + 1}});
board[2][i] = -1;
k--;
flag = true;
}
}
if (board[1][0] == -1 && board[2][0] != -1) {
moves.push_back({board[2][0] + 1, {2, 1}});
board[1][0] = board[2][0];
board[2][0] = -1;
flag = true;
} else {
for (int i = 1; i < (n); i++) {
if (board[1][i - 1] != -1 && board[1][i] == -1) {
moves.push_back({board[1][i - 1] + 1, {2, i + 1}});
board[1][i] = board[1][i - 1];
board[1][i - 1] = -1;
flag = true;
break;
}
}
if (!flag) {
if (board[1][n - 1] != -1 && board[2][n - 1] == -1) {
moves.push_back({board[1][n - 1] + 1, {3, n}});
board[2][n - 1] = board[1][n - 1];
board[1][n - 1] = -1;
flag = true;
} else {
for (int i = n - 2; i >= 0; i--) {
if (board[2][i + 1] != -1 && board[2][i] == -1) {
moves.push_back({board[2][i + 1] + 1, {3, i + 1}});
board[2][i] = board[2][i + 1];
board[2][i + 1] = -1;
flag = true;
break;
}
}
}
}
}
}
if (k > 0)
printf("%d\n", -1);
else {
printf("%d\n", (int)moves.size());
for (pair<int, pair<int, int>> pp : moves) {
printf("%d %d %d\n", pp.first, pp.second.first, pp.second.second);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
typedef unsigned int UI;
typedef long int LI;
typedef unsigned long int ULI;
typedef long long int LL;
typedef unsigned long long int ULL;
const LL MOD = 1e9 + 7;
inline int scanInt() {
int n = 0;
char ch = getchar();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
n = (n << 1) + (n << 3) + (int)(ch - '0');
ch = getchar();
}
return n * sign;
}
inline LL scanLong() {
LL n = 0;
char ch = getchar();
LL sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
n = (n << 1) + (n << 3) + (LL)(ch - '0');
ch = getchar();
}
return n * sign;
}
int main() {
LL n = scanLong();
;
LL As[n], Bs[n], Cs[n];
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
As[i] = scanLong();
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
Bs[i] = scanLong();
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
Cs[i] = As[i] - Bs[i];
vector<LL> neg, pos;
LL zeros = 0;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
if (Cs[i] < 0)
neg.push_back(Cs[i]);
else if (Cs[i] > 0)
pos.push_back(Cs[i]);
else
zeros++;
}
LL poscnt = pos.size();
LL ans = 0;
ans += (poscnt * (poscnt - 1) / 2);
ans += (poscnt * zeros);
sort(pos.begin(), pos.end());
for (__typeof(neg.end()) it = (neg.begin()) - ((neg.begin()) > (neg.end()));
it != (neg.end()) - ((neg.begin()) > (neg.end()));
it += 1 - 2 * ((neg.begin()) > (neg.end()))) {
LL num = *it;
LL index = upper_bound(pos.begin(), pos.end(), abs(num)) - pos.begin();
ans += (poscnt - index);
}
printf("%lld ", ans);
printf("\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 0x7fffffff;
const int N = 1e6 + 10;
int G[105][105];
int T[105][105];
void TurnOver(int n, int m, int v) {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
T[i][j] += v;
}
}
}
int main() {
int n, m;
char c[555];
scanf("%d%d", &n, &m);
memset(T, 0, sizeof(T));
for (int i = 0; i < n; i++) {
scanf("%s", c);
for (int j = 0; j < m; j++) {
if (c[j] == 'B')
G[i][j] = -1;
else
G[i][j] = 1;
}
}
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (T[i][j] != G[i][j]) {
TurnOver(i, j, G[i][j] - T[i][j]);
ans++;
}
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
const long double pi = acos(-1);
string s;
int cntAB[100100];
int cntBA[100100];
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout << fixed;
cout.tie(0);
cin.tie(0);
cin >> s;
int N = int(s.size());
s = " " + s;
for (int(i) = 1, j123 = N; (i) <= j123; (i)++) {
if (i + 1 <= N) {
if (s[i] == 'A' && s[i + 1] == 'B') cntAB[i] = 1;
if (s[i] == 'B' && s[i + 1] == 'A') cntBA[i] = 1;
}
}
for (int(i) = 1, j123 = N; (i) <= j123; (i)++) cntBA[i] += cntBA[i - 1];
int any = 0;
for (int(i) = 1, j123 = N; (i) <= j123; (i)++)
if (cntAB[i] == 1) {
if (i + 2 <= N && cntBA[N] - cntBA[i + 1] >= 1) any = 1;
if (i - 2 >= 1 && cntBA[i - 2] >= 1) any = 1;
}
if (any)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (1LL << 45LL);
const long long MAXLL = 9223372036854775807LL;
const unsigned long long MAXULL = 18446744073709551615LLU;
const long long MOD = 1000000007;
const long double DELTA = 0.000000001L;
inline long long fmm(long long a, long long b, long long m = MOD) {
long long r = 0;
a %= m;
b %= m;
while (b > 0) {
if (b & 1) {
r += a;
r %= m;
}
a += a;
a %= m;
b >>= 1;
}
return r % m;
}
inline long long fme(long long a, long long b, long long m = MOD) {
long long r = 1;
a %= m;
while (b > 0) {
if (b & 1) {
r *= a;
r %= m;
}
a *= a;
a %= m;
b >>= 1;
}
return r % m;
}
inline long long sfme(long long a, long long b, long long m = MOD) {
long long r = 1;
a %= m;
while (b > 0) {
if (b & 1) r = fmm(r, a, m);
a = fmm(a, a, m);
b >>= 1;
}
return r % m;
}
std::vector<long long> primes;
long long primsiz;
std::vector<long long> fact;
std::vector<long long> invfact;
inline void sieve(long long n) {
long long i, j;
std::vector<bool> a(n);
a[0] = true;
a[1] = true;
for (i = 2; i * i < n; ++i) {
if (!a[i]) {
for (j = i * i; j < n; j += i) {
a[j] = true;
}
}
}
for (i = 2; i < n; ++i)
if (!a[i]) primes.push_back(i);
primsiz = primes.size();
}
inline void sieve() {
long long n = 1010000, i, j, k = 0;
std::vector<bool> a(n);
primes.resize(79252);
a[0] = a[1] = true;
for (i = 2; (j = (i << 1)) < n; ++i) a[j] = true;
for (i = 3; i * i < n; i += 2) {
if (!a[i]) {
k = (i << 1);
for (j = i * i; j < n; j += k) a[j] = true;
}
}
k = 0;
for (i = 2; i < n; ++i)
if (!a[i]) primes[k++] = i;
primsiz = k;
}
inline bool isPrimeSmall(unsigned long long n) {
if (((!(n & 1)) && n != 2) || (n < 2) || (n % 3 == 0 && n != 3)) return false;
for (unsigned long long k = 1; 36 * k * k - 12 * k < n; ++k)
if ((n % (6 * k + 1) == 0) || (n % (6 * k - 1) == 0)) return false;
return true;
}
bool _p(unsigned long long a, unsigned long long n) {
unsigned long long t, u, i, p, c = 0;
u = n / 2, t = 1;
while (!(u & 1)) {
u /= 2;
++t;
}
p = fme(a, u, n);
for (i = 1; i <= t; ++i) {
c = (p * p) % n;
if ((c == 1) && (p != 1) && (p != n - 1)) return 1;
p = c;
}
if (c != 1) return 1;
return 0;
}
inline bool isPrime(unsigned long long n) {
if (((!(n & 1)) && n != 2) || (n < 2) || (n % 3 == 0 && n != 3)) return 0;
if (n < 1373653) {
for (unsigned long long k = 1; (((36 * k * k) - (12 * k)) < n); ++k)
if ((n % (6 * k + 1) == 0) || (n % (6 * k - 1) == 0)) return 0;
return 1;
}
if (n < 9080191) {
if (_p(31, n) || _p(73, n)) return 0;
return 1;
}
if (_p(2, n) || _p(7, n) || _p(61, n)) return 0;
return 1;
}
unsigned long long nCk(long long n, long long k, unsigned long long m = MOD) {
if (k < 0 || k > n || n < 0) return 0;
if (k == 0 || k == n) return 1;
if (fact.size() >= (unsigned long long)n && isPrime(m)) {
return (((fact[n] * invfact[k]) % m) * invfact[n - k]) % m;
}
unsigned long long i = 0, j = 0, a = 1;
k = ((k) < (n - k) ? (k) : (n - k));
for (; i < (unsigned long long)k; ++i) {
a = (a * (n - i)) % m;
while (j < (unsigned long long)k && (a % (j + 1) == 0)) {
a = a / (j + 1);
++j;
}
}
while (j < (unsigned long long)k) {
a = a / (j + 1);
++j;
}
return a % m;
}
void nCkInit(unsigned long long m = MOD) {
long long i, mx = 1010000;
fact.resize(mx + 1);
invfact.resize(mx + 1);
fact[0] = 1;
for (i = 1; i <= mx; ++i) {
fact[i] = (i * fact[i - 1]) % m;
}
invfact[mx] = fme(fact[mx], m - 2, m);
for (i = mx - 1; i >= 0; --i) {
invfact[i] = (invfact[i + 1] * (i + 1)) % m;
}
}
template <class T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return;
}
long long x1, y1;
extGCD(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
}
inline void get(long long &x) {
int n = 0;
x = 0;
char c = getchar_unlocked();
if (c == '-') n = 1;
while (c < '0' || c > '9') {
c = getchar_unlocked();
if (c == '-') n = 1;
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar_unlocked();
}
if (n) x = -x;
}
inline int get(char *p) {
char c = getchar_unlocked();
int i = 0;
while (c != '\n' && c != '\0' && c != ' ' && c != '\r' && c != EOF) {
p[i++] = c;
c = getchar_unlocked();
}
p[i] = '\0';
return i;
}
inline void put(long long a) {
int n = (a < 0 ? 1 : 0);
if (n) a = -a;
char b[20];
int i = 0;
do {
b[i++] = a % 10 + '0';
a /= 10;
} while (a);
if (n) putchar_unlocked('-');
i--;
while (i >= 0) putchar_unlocked(b[i--]);
putchar_unlocked(' ');
}
inline void putln(long long a) {
int n = (a < 0 ? 1 : 0);
if (n) a = -a;
char b[20];
int i = 0;
do {
b[i++] = a % 10 + '0';
a /= 10;
} while (a);
if (n) putchar_unlocked('-');
i--;
while (i >= 0) putchar_unlocked(b[i--]);
putchar_unlocked('\n');
}
const int K = 3;
std::vector<std::vector<long long> > mul(std::vector<std::vector<long long> > a,
std::vector<std::vector<long long> > b,
unsigned long long m = MOD) {
std::vector<std::vector<long long> > c(K, std::vector<long long>(K));
for (long long ii = 0; ii < (K); ++ii)
for (long long jj = 0; jj < (K); ++jj)
for (long long kk = 0; kk < (K); ++kk)
c[ii][jj] = (c[ii][jj] + a[ii][kk] * b[kk][jj]) % m;
return c;
}
std::vector<std::vector<long long> > fme(std::vector<std::vector<long long> > a,
unsigned long long n,
unsigned long long m = MOD) {
if (n == 1) return a;
if (n & 1) return mul(a, fme(a, n - 1, m), m);
std::vector<std::vector<long long> > x = fme(a, n / 2, m);
return mul(x, x, m);
}
long long n;
double a[100100];
bool solve1() {
bool pt = false, okay = true;
double m = (a[1] - a[0]), px = -1, py = -1;
for (long long i = 2; i < n; ++i) {
if ((((double)(a[i] - a[0])) / i) != m) {
if (pt) {
if (((a[i] - py) / (i - px)) != m) okay = false;
} else {
pt = true;
px = i;
py = a[i];
}
}
}
return (okay && pt);
}
bool solve2() {
bool okay = true;
if (((a[2] - a[0])) == (2 * (a[1] - a[0]))) okay = false;
double m = (a[2] - a[0]) / 2;
for (long long i = 2; i < n; ++i) {
if ((((a[i] - a[0]) / (i)) != m) && (((a[i] - a[1]) / (i - 1)) != m))
okay = false;
}
return okay;
}
bool solve3() {
bool okay = true;
if (((a[2] - a[0])) == (2 * (a[1] - a[0]))) okay = false;
double m = (a[2] - a[1]);
for (long long i = 2; i < n; ++i) {
if ((((a[i] - a[0]) / (i)) != m) && (((a[i] - a[1]) / (i - 1)) != m))
okay = false;
}
return okay;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
long long t = 0, m = 0, maxx = 0, minn = 0, curr = 0, k = 0, num = 0, siz = 0,
n1 = 0, n2 = 0, n3 = 0, n4 = 0, ind = 0;
long long root = 0, sum = 0, diff = 0, q = 0, choice = 0, d = 0, len = 0,
begg = 0, endd = 0, pos = 0, cnt = 0, lo = 0, hi = 0, mid = 0,
ans = 0;
bool flag = false;
std::string s1, s2, s3, str;
char ch, ch1, ch2, ch3, *ptr;
double dub = 0;
cin >> n;
for (long long i = 0; i < (n); ++i) cin >> a[i];
if (solve1() || solve2() || solve3())
cout << "Yes";
else
cout << "No";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const long long int INFLL = 1e18 + 10;
const long double EPS = 1e-8;
const long double EPSLD = 1e-14;
const long long int MOD = 1e9 + 7;
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
class Primes : public vector<int> {
public:
Primes(int max_n) {
vector<bool> isp(max_n, true);
for (int i = (2); i < (int)(max_n); i++) {
if (isp[i]) {
emplace_back(i);
for (int j = i * 2; j < max_n; j += i) isp[j] = false;
}
}
}
};
int k;
vector<int> v;
Primes ps(5010);
int s = 0;
int cnt[5010];
bool test() {
for (int i = (0); i < (int)(s); i++) cnt[i] = 0;
for (int i = (0); i < (int)(k); i++)
for (int j = (0); j < (int)(s); j++)
if (v[i] % ps[j] == 0) cnt[j]++;
for (int j = (0); j < (int)(s); j++)
if (cnt[j] * 2 < k) return false;
return true;
}
int main() {
scanf("%d", &k);
int limit = k * k * 2;
v.emplace_back(1);
for (auto &w : ps) {
int cur_size = v.size();
if (cur_size >= k) break;
for (int i = (0); i < (int)(cur_size); i++) {
int a = w;
while (a * v[i] <= limit) {
v.emplace_back(a * v[i]);
a *= w;
}
}
}
reverse((v).begin(), (v).end());
for (int i = (0); i < (int)(k); i++)
printf("%d%c", v[i], i == k - 1 ? '\n' : ' ');
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void boost() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = 1e6;
const long long inf = 1e9 + 7;
const long double PI = acos(-1);
long long bin_pow(long long x, long long y) {
long long res = 1, base = x;
while (y) {
if (y & 1) {
res *= base;
res %= inf;
}
base *= base;
base %= inf;
y /= 2;
}
return res;
}
int n;
int mx, pos, d;
int deep[N];
int up[N][21];
bool upper(int v, int u) { return deep[v] < deep[u]; }
int lca(int v, int u) {
if (!upper(v, u)) {
swap(v, u);
}
int mask = deep[u] - deep[v];
for (int i = 20; i >= 0; i--) {
if (mask & (1 << i)) {
u = up[u][i];
}
}
if (v == u) {
return v;
}
for (int i = 20; i >= 0; i--) {
if (up[v][i] != up[u][i]) {
v = up[v][i];
u = up[u][i];
}
}
return up[v][0];
}
int main() {
boost();
cin >> n;
deep[1] = 0;
up[1][0] = 1;
for (int i = 1; i < 21; i++) {
up[1][i] = 1;
}
for (int i = 2; i <= n; i++) {
int x;
cin >> x;
up[i][0] = x;
for (int j = 1; j < 21; j++) {
up[i][j] = up[up[i][j - 1]][j - 1];
}
deep[i] = deep[x] + 1;
if (deep[i] > mx) {
d++;
mx = deep[i];
pos = i;
} else {
int y = lca(pos, i);
d = max(d, deep[i] + mx - 2 * deep[y]);
}
cout << d << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
constexpr int INF = 2e9;
struct UnionFind {
vector<int> data;
int __size;
UnionFind(int sz) {
data.assign(sz, -1);
__size = sz;
}
bool unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return (false);
if (data[x] > data[y]) swap(x, y);
__size--;
data[x] += data[y];
data[y] = x;
return (true);
}
int find(int k) {
if (data[k] < 0) return (k);
return (data[k] = find(data[k]));
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int k) { return (-data[find(k)]); }
int union_count() { return (__size); }
};
int main() {
int n, m;
cin >> n >> m;
vector<UnionFind> uf(m, UnionFind(n));
for (int i = 0; i < m; i++) {
int u, v, c;
cin >> u >> v >> c;
u--;
v--;
c--;
uf[c].unite(u, v);
}
int q;
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
u--;
v--;
int res = 0;
for (int i = 0; i < m; i++) {
res += uf[i].same(u, v);
}
cout << res << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
int t;
cin >> t;
while (t--) {
cin >> n;
int a[n];
bool odd = false;
bool eve = false;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (!(a[i] & 1))
eve = true;
else
odd = true;
}
if (!eve && !(n & 1) || !odd)
cout << "NO";
else
cout << "YES";
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const double eps = 1e-10;
using namespace std;
int n, i, j, k, m, q, r, b;
int f[155], dp[155][155], a[155];
double ways[155][155], maxW;
long long C[155][155];
int maximal, pas;
int main() {
scanf("%d", &n);
for (int i = 0; i < 10; i++) cin >> a[i];
for (i = 0; i < n + 1; i++) C[0][i] = 1;
for (int i = 0; i <= n; i++) {
for (int j = 1; j <= i; j++) {
C[j][i] = (C[j][i - 1] + C[j - 1][i - 1]) % 1000000007;
}
}
for (int i = 0; i <= n; i++) {
for (int j = 9; j >= 0; j--) {
if (j == 0) {
for (int x = a[0]; x <= 101; x++) {
if (i >= x)
dp[i][j] = (dp[i][j] + dp[i - x][1] * C[x][i - 1]) % 1000000007;
}
} else if (j < 9) {
for (int x = a[j]; x <= 100; x++) {
dp[i][j] = (dp[i][j] + dp[i - x][j + 1] * C[x][i]) % 1000000007;
}
} else {
if (i >= a[9]) dp[i][9] = 1;
}
}
}
while (n--) pas = (pas + dp[n + 1][0]) % 1000000007;
cout << pas << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const int inf = 0x3f3f3f3f;
int prefix[N << 1];
int main(void) {
ios::sync_with_stdio(false), cin.tie(0);
int n;
string s;
cin >> n >> s;
int mn = inf, p = 0;
for (int i = 0; i < n; ++i) {
prefix[i + 1] = prefix[i];
if (s[i] == '(')
prefix[i + 1]++;
else
prefix[i + 1]--;
if (prefix[i + 1] < mn) mn = prefix[i + 1], p = i + 1;
prefix[n + i + 1] = prefix[i + 1];
}
if (prefix[n] != 0) return cout << 0 << endl << "1 1" << endl, 0;
int cnt = 0;
for (int i = p; i <= p + n; ++i) {
prefix[i] -= mn;
if (prefix[i] == 0) cnt++;
}
cnt--;
int zerob = p + 1, oneb = p + 2;
int num1 = 0, num2 = 0, ans = cnt, l = 1, r = 1;
for (int i = p + 1; i <= p + n; ++i) {
if (prefix[i] == 1) {
if (ans < cnt + num2) {
ans = cnt + num2;
l = oneb, r = i;
}
num2 = 0, oneb = i + 1;
num1++;
} else if (prefix[i] == 2) {
num2++;
} else if (prefix[i] == 0) {
if (ans < num1) {
ans = num1;
l = zerob, r = i;
}
num1 = 0, zerob = i + 1;
}
}
if (l > n) l -= n;
if (r > n) r -= n;
cout << ans << endl << l << ' ' << r << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct node {
int x, y, X, Y;
} a[1010], q1[1010], q2[1010];
bool cmpx(node a, node b) { return a.x < b.x; }
bool cmpy(node a, node b) { return a.y < b.y; }
void solve(int l, int r) {
int k = -1;
if (l == r) return;
sort(a + l, a + r + 1, cmpx);
int Max = a[l].X;
for (int i = l + 1; i <= r; i++) {
if (Max <= a[i].x) {
k = i;
break;
}
Max = max(Max, a[i].X);
}
if (k != -1) {
solve(l, k - 1);
solve(k, r);
return;
}
sort(a + l, a + r + 1, cmpy);
Max = a[l].Y;
for (int i = l + 1; i <= r; i++) {
if (Max <= a[i].y) {
k = i;
break;
}
Max = max(Max, a[i].Y);
}
if (k != -1) {
solve(l, k - 1);
solve(k, r);
return;
}
printf("NO");
exit(0);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d %d %d %d", &a[i].x, &a[i].y, &a[i].X, &a[i].Y);
solve(1, n);
printf("YES");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e3 + 100, MOD = 1e9 + 7, INF = 1e15, SQ = 350, LOG = 20;
int x1, x2, z, t, y2, maxi, maxi2, mini, ptr, a[N], b[N], p, q, k, sum1, sum2,
dp[N];
long long ans, x, y, n, m;
vector<long long> v, v2;
int main() {
cin >> n >> m;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
v.push_back(i);
v.push_back(n / i);
}
}
for (long long i = 1; i * i <= m; i++) {
if (m % i == 0) {
v2.push_back(i);
v2.push_back(m / i);
}
}
sort(v.begin(), v.end());
sort(v2.begin(), v2.end());
x = n + m;
ans = INF;
for (long long i = 1; i * i <= x; i++) {
if (x % i == 0) {
y = x / i;
int b = 0, e = v.size(), mid = 0;
while (e - b > 1) {
mid = e + b >> 1;
if (v[mid] > i) {
e = mid;
} else {
b = mid;
}
}
if (v[b] <= i && (n / v[b]) <= y) {
ans = min(ans, (i + i + y + y));
}
b = 0, e = v2.size(), mid = 0;
while (e - b > 1) {
mid = e + b >> 1;
if (v2[mid] > i) {
e = mid;
} else {
b = mid;
}
}
if (v2[b] <= i && (m / v2[b]) <= y) {
ans = min(ans, (i + i + y + y));
}
}
}
cout << ans;
}
| 6 |
#include<bits/stdc++.h>
#define int long long
#define mem(x) memset(x,0,sizeof(x))
#define mod 1000000007
using namespace std;
int read(){
int s = 0,w = 1;
char ch = getchar();
while(ch < '0' || ch > '9'){if(ch == '-')w = -1;ch = getchar();}
while(ch >= '0' && ch <= '9')s = s * 10 + ch - '0',ch = getchar();
return s * w;
}
int t;
int n,m;
void solve(){
n = read(),m = read();
int s = 1;
for(int i = 1;i <= m;i ++){
s *= n;
s %= mod;
}
cout<<s<<endl;
}
signed main(){
cin>>t;
while(t --)solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize(3)
#pragma GCC optimize("O3")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
int n, m, Q;
double sy, l[200100], r[200100], sum[200100], zl, zr, x, y, ans;
struct Node {
double x, y;
} bj[2][200100], tmp, L, R;
inline bool lef(Node u, Node v, Node w) {
if (u.x == v.x) return w.x < u.x;
double t;
t = v.x - (v.x - u.x) * (v.y - w.y) / (v.y - u.y);
return w.x < t;
}
inline double ask(int u) {
double p, q;
if (bj[0][u].x == x)
p = x;
else {
p = x - (x - bj[0][u].x) * (y - sy) / y;
}
if (bj[1][u].x == x)
q = x;
else {
q = x - (x - bj[1][u].x) * (y - sy) / y;
}
return max((double)0, min(q, zr) - max(p, zl));
}
int main() {
int i, j, p, q, mid, a, b;
cin >> sy >> zl >> zr >> n;
L.y = R.y = sy, L.x = zl, R.x = zr;
for (i = 1; i <= n; i++) {
scanf("%lf%lf", &l[i], &r[i]);
sum[i] = sum[i - 1] + r[i] - l[i];
bj[0][i].y = 0, bj[0][i].x = l[i];
bj[1][i].y = 0, bj[1][i].x = r[i];
}
cin >> m;
for (i = 1; i <= m; i++) {
scanf("%lf%lf", &x, &y);
ans = 0;
tmp.x = x, tmp.y = y;
for (p = 1, q = n; p < q;) {
mid = ((p + q) >> 1);
if (lef(tmp, bj[0][mid], L))
q = mid;
else
p = mid + 1;
}
a = p - 1;
for (p = 1, q = n; p < q;) {
mid = ((p + q) >> 1);
if (!lef(tmp, bj[1][mid], R))
p = mid + 1;
else
q = mid;
}
b = p;
printf("%.10f\n", ask(a) + ask(b) * (a != b) +
max((double)0, sum[b - 1] - sum[a]) * (y - sy) / y);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, z, a, b;
int main() {
cin >> a >> b >> x >> y >> z;
long long aa = 2ll * x + 1ll * y;
long long bb = 1ll * y + 3ll * z;
printf("%lld\n", max(0ll, aa - a) + max(0ll, bb - b));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 1;
long long dp[1001][11];
long long pri[] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
long long mxpow[] = {0, 59, 37, 25, 21, 17, 16, 14, 14, 13, 12};
long long Pow[11][60];
void Put() {
for (int i = 0; i <= 1000; ++i)
for (int j = 0; j <= 10; ++j) dp[i][j] = inf;
for (int i = 1; i <= 10; ++i) {
Pow[i][0] = 1;
for (int j = 1; j <= mxpow[i]; ++j) {
Pow[i][j] = Pow[i][j - 1] * pri[i];
}
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
Put();
int n;
cin >> n;
for (int i = 0; i <= 10; ++i) dp[1][i] = 1;
for (int i = 2; i <= n; ++i) {
for (int j = 1; j <= 10; ++j) {
for (int k = 0; k <= mxpow[j]; ++k) {
if (i % (k + 1) == 0 && dp[i / (k + 1)][j - 1] <= inf / Pow[j][k])
dp[i][j] = min(dp[i][j], dp[i / (k + 1)][j - 1] * Pow[j][k]);
}
}
}
cout << dp[n][10];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int x[103], y[103], vis[104];
vector<int> a[104];
void add(int i, int j) {
a[i].push_back(j);
a[j].push_back(i);
}
bool bl = true;
void dfs(int i, int k) {
vis[i] = k;
if (k == 1)
k = 2;
else
k = 1;
for (int j = 0; j < a[i].size(); j++) {
int ver = a[i][j];
if (vis[ver] == 0)
dfs(ver, k);
else if (vis[ver] != k)
bl = false;
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
if (x[i] > y[i]) swap(x[i], y[i]);
}
for (int i = 1; i <= m; i++) {
for (int j = i + 1; j <= m; j++) {
if (x[i] > x[j] && x[i] < y[j] && y[i] > y[j])
add(i, j);
else if (x[i] < x[j] && y[i] > x[j] && y[i] < y[j])
add(i, j);
}
}
for (int i = 1; i <= m; i++) {
if (vis[i] == 0) dfs(i, 1);
}
if (bl) {
for (int i = 1; i <= m; i++)
if (vis[i] == 1)
cout << "o";
else
cout << "i";
cout << '\n';
} else
cout << "Impossible" << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long calc(long long n) {
if (n < 10) {
return n;
}
long long ans = n / 10 + 9;
long long l = n % 10;
while (n > 9) {
n = n / 10;
}
if (n > l) {
ans--;
}
return ans;
}
int main() {
long long l, r;
cin >> l >> r;
cout << calc(r) - calc(l - 1);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void past_code();
int main() {
int q, x, y, c = 0, l = 0, ans = 100000;
string s, t = "RGB";
cin >> q;
while (q--) {
ans = 1000000;
l = 0, c = 0;
cin >> x >> y;
cin >> s;
for (int i = y - 1; i < s.length(); i++) {
for (int j = i - y + 1; j <= i; j++) {
if (s[j] != t[c % 3]) {
l++;
c++;
} else
c++;
}
ans = min(ans, l);
l = 0;
c = 1;
for (int j = i - y + 1; j <= i; j++) {
if (s[j] != t[c % 3]) {
l++;
c++;
} else
c++;
}
ans = min(ans, l);
l = 0;
c = 2;
for (int j = i - y + 1; j <= i; j++) {
if (s[j] != t[c % 3]) {
l++;
c++;
} else
c++;
}
ans = min(ans, l);
l = 0;
c = 0;
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::max;
using std::min;
using std::vector;
int main() {
const int DAY = 86400;
int n, k;
cin >> n >> k;
vector<int> t(n), d(n);
vector<int> f(n + 5, 0);
for (int i = 0; i < n; ++i) {
cin >> t[i] >> d[i];
--t[i];
}
t.push_back(DAY);
d.push_back(1);
int ans = 0;
for (int j = 0; j <= n; ++j) {
ans = max(ans, t[j] - f[k]);
for (int i = k; i > 0; --i) {
f[i] = min(f[i - 1], max(f[i], t[j]) + d[j]);
if (f[i] > DAY) f[i] = DAY;
}
f[0] = max(f[0], t[j]) + d[j];
if (f[0] > DAY) f[0] = DAY;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct item {
int w, v, t;
};
bool operator<(item a, item b) {
if (a.t != b.t) return a.t < b.t;
return (a.w == b.w) ? (a.v < b.v) : (a.w < b.w);
}
struct query {
int t, w, number;
};
bool operator<(query a, query b) { return a.t < b.t; }
int get() {
char c;
while (c = getchar(), (c < '0' || c > '9') && (c != '-'))
;
bool flag = (c == '-');
if (flag) c = getchar();
int x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + c - 48;
c = getchar();
}
return flag ? -x : x;
}
void output(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
int len = 0, data[10];
while (x) {
data[len++] = x % 10;
x /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
putchar('\n');
}
const int maxn = 4000;
const int maxm = 4000;
const int maxq = 20000;
item a[maxn];
query q[maxq];
int f[maxn + 1][maxm + 1], g[maxn + 1][maxm + 1];
int ans[maxq];
int main() {
int n = get(), m = get();
for (int i = 0; i < n; i++) {
a[i].w = get();
a[i].v = get();
a[i].t = get();
}
sort(a, a + n);
int total = get();
for (int i = 0; i < total; i++) {
q[i].t = get();
q[i].w = get();
q[i].number = i;
}
sort(q, q + total);
for (int l = 0, r = 0; l < total; l = r) {
int W = 0;
while (r < total && q[r].t - q[l].t < m) W = max(W, q[r++].w);
item tmp = {-1, -1, q[l].t};
int p0 = lower_bound(a, a + n, tmp) - a, q0 = p0;
int p1 = upper_bound(a, a + n, tmp) - a - 1, q1 = p1;
for (int i = 0; i <= W; i++) f[0][i] = 0;
while (q0 < n && a[q0].t < q[l].t + m) {
int t = q0 - p0;
for (int i = 0; i <= W; i++) {
f[t + 1][i] = f[t][i];
if (i >= a[q0].w)
f[t + 1][i] = max(f[t + 1][i], f[t][i - a[q0].w] + a[q0].v);
}
q0++;
}
for (int i = 0; i <= W; i++) g[0][i] = 0;
while (q1 >= 0 && a[q1].t > q[l].t - m) {
int t = p1 - q1;
for (int i = 0; i <= W; i++) {
g[t + 1][i] = g[t][i];
if (i >= a[q1].w)
g[t + 1][i] = max(g[t + 1][i], g[t][i - a[q1].w] + a[q1].v);
}
q1--;
}
for (int i = l; i < r; i++) {
int r0 = p0, r1 = p1;
while (r0 < n && a[r0].t <= q[i].t) r0++;
while (r1 >= 0 && a[r1].t > q[i].t - m) r1--;
int best = 0;
for (int j = 0; j <= q[i].w; j++)
best = max(best, f[r0 - p0][j] + g[p1 - r1][q[i].w - j]);
ans[q[i].number] = best;
}
}
for (int i = 0; i < total; i++) output(ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
vector<int> g[N];
int a[N];
int ans1[N];
int ans2[N];
vector<int> divroot;
map<int, int> divcnt;
inline int gcd(int a, int b) {
while (b != 0) {
int r = a % b;
a = b;
b = r;
}
return a;
}
void dfs(int u, int p) {
ans1[u] = (p == -1) ? 0 : gcd(a[u], ans1[p]);
for (int v : g[u]) {
if (v == p) continue;
dfs(v, u);
}
}
void dfs2(int u, int p, int depth) {
for (int div : divroot) {
if (a[u] % div == 0) divcnt[div]++;
}
ans2[u] = 1;
for (int div : divroot) {
if (divcnt[div] >= depth - 1) ans2[u] = div;
}
for (int v : g[u]) {
if (v == p) continue;
dfs2(v, u, depth + 1);
}
for (int div : divroot) {
if (a[u] % div == 0) divcnt[div]--;
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= a[0]; ++i) {
if (a[0] % i == 0) divroot.push_back(i);
}
dfs(0, -1);
dfs2(0, -1, 1);
for (int i = 0; i < n; ++i) {
cout << max(ans1[i], ans2[i]) << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, dfn[200005], low[200005], ibcc[200005], dfncnt, bcccnt;
vector<pair<int, int>> g[200005];
vector<int> ng[200005];
int st[200005], stcnt;
void getbcc(int x, int pe) {
dfn[x] = low[x] = ++dfncnt;
st[stcnt++] = x;
for (pair<int, int> &e : g[x])
if (!dfn[e.first]) {
getbcc(e.first, e.second);
low[x] = min(low[x], low[e.first]);
} else if (e.second != pe) {
low[x] = min(low[x], dfn[e.first]);
}
if (dfn[x] == low[x]) {
ibcc[x] = ++bcccnt;
int y;
while ((y = st[--stcnt]) != x) {
ibcc[y] = bcccnt;
}
}
}
int dep[200005];
int fa[200005][18];
bool vis[200005];
void dfs4lca(int x, int p, int cd) {
vis[x] = 1;
fa[x][0] = p;
dep[x] = cd;
for (int &y : ng[x])
if (y != p) {
dfs4lca(y, x, cd + 1);
}
}
void init4lca() {
for (int i = 1; i <= bcccnt; i++)
if (!vis[i]) dfs4lca(i, -1, 0);
for (int j = 0; j < 17; j++) {
for (int i = 1; i <= bcccnt; i++) {
if (fa[i][j] == -1)
fa[i][j + 1] = -1;
else
fa[i][j + 1] = fa[fa[i][j]][j];
}
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 17; i >= 0; i--) {
if (fa[x][i] != -1 && dep[fa[x][i]] >= dep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 17; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int up[200005], down[200005];
void calc(int x, int p) {
vis[x] = 1;
for (int &y : ng[x])
if (y != p) {
calc(y, x);
up[x] += up[y];
down[x] += down[y];
}
if (up[x] && down[x]) {
puts("No");
exit(0);
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].emplace_back(b, i);
g[b].emplace_back(a, i);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) getbcc(i, -1);
for (int x = 1; x <= n; x++) {
for (pair<int, int> &e : g[x]) {
if (ibcc[x] != ibcc[e.first]) {
ng[ibcc[x]].emplace_back(ibcc[e.first]);
}
}
}
init4lca();
memset(vis, 0, sizeof(vis));
while (q--) {
int u, v, anc;
scanf("%d%d", &u, &v);
u = ibcc[u];
v = ibcc[v];
if (u == v) continue;
anc = lca(u, v);
up[u]++;
up[anc]--;
down[v]++;
down[anc]--;
}
for (int i = 1; i <= bcccnt; i++)
if (!vis[i]) calc(i, -1);
puts("Yes");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
int p1[200005];
int p2[200005];
int pos1, pos2;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", p1 + i);
for (int i = 0; i < n; ++i) scanf("%d", p2 + i);
for (pos2 = 0; pos2 < n; pos2++)
if (p1[pos1] == p2[pos2]) pos1++;
printf("%d", n - pos1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double F[150000], P[150000];
double Fmn[150000], Fmx[150000], Fans[150000];
int p[150000];
int main() {
int n, m, C;
scanf("%d %d %d", &n, &m, &C);
int x[n];
for (int i = 0; i < n; ++i) scanf("%d", &x[i]);
for (int i = 1; i < n; ++i) scanf("%d", &p[i]);
P[0] = 0;
for (int i = 1; i < n; ++i) P[i] = P[i - 1] + p[i] / 100.0;
for (int i = 0; i < n; ++i) F[i] = x[i] / 2.0 - C * P[i];
int sz = (int)floor(sqrt(n));
for (int i = 0; sz * i < n; i++) {
Fmn[i] = F[sz * i];
Fmx[i] = F[sz * i];
Fans[i] = 0;
double mn = F[sz * i];
for (int j = 0; j < sz && sz * i + j < n; ++j) {
Fmn[i] = min(Fmn[i], F[sz * i + j]);
Fmx[i] = max(Fmx[i], F[sz * i + j]);
mn = min(mn, F[sz * i + j]);
Fans[i] = max(Fans[i], F[sz * i + j] - mn);
}
}
double ans = 0;
for (int i = 0, xa, xb; i < m; ++i) {
scanf("%d %d", &xa, &xb);
--xa;
--xb;
double aux = 0;
int l = (xa + sz - 1) / sz, r = xb / sz;
if (l <= r) {
for (int j = l; j < r; ++j) aux = max(aux, Fans[j]);
int x1 = min(sz * l, xb);
double mn = F[xa];
for (int j = xa; j < x1; ++j) {
mn = min(mn, F[j]);
aux = max(aux, F[j] - mn);
}
for (int j = l; j < r; ++j) {
aux = max(aux, Fmx[j] - mn);
mn = min(mn, Fmn[j]);
}
int x2 = max(sz * r, xa);
for (int j = x2; j <= xb; ++j) {
mn = min(mn, F[j]);
aux = max(aux, F[j] - mn);
}
} else {
double mn = F[xa];
for (int j = xa; j <= xb; ++j) {
mn = min(mn, F[j]);
aux = max(aux, F[j] - mn);
}
}
ans += aux;
}
printf("%.8f\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100000 + 10;
int n, k;
double F[2][800];
void solve() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
int p = i % 2, c = p ^ 1;
memset(F[p], 0, sizeof(F[p]));
for (int j = 1; j <= 800; j++) {
F[p][j] =
1.0 / (double)k *
((double)j / (double)(j + 1) * (F[c][j] + (double)(j + 1) / 2.0) +
1.0 / (double)(j + 1) * (F[c][j + 1] + (double)j)) +
(double)(k - 1) / k * F[c][j];
}
}
double ans = F[n % 2][1] * (double)k;
printf("%.9f\n", ans);
}
int main() {
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100;
int n;
int m;
bool visited[maxn][maxn];
int unvisited_row(int c) {
for (int r = 0; r < n; ++r)
if (!visited[r][c]) return r;
return -1;
}
int unvisited_col(int r) {
for (int c = 0; c < m; ++c)
if (!visited[r][c]) return c;
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int r, c;
scanf("%d%d", &n, &m);
scanf("%d%d", &r, &c);
--r;
--c;
int cnt = 0;
visited[r][c] = true;
while (true) {
printf("%d %d\n", r + 1, c + 1);
++cnt;
if (int r2 = unvisited_row(c); r2 != -1) {
r = r2;
} else if (int c2 = unvisited_col(r); c2 != -1) {
c = c2;
} else {
break;
}
visited[r][c] = true;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<string> oo;
vector<int> pp;
priority_queue<int, vector<int>, greater<int> > hh;
int n, i, x;
scanf("%d", &n);
char s[100010];
int cnt = 0;
for (i = 0; i < n; i++) {
scanf("%s", s);
if (strcmp(s, "insert") == 0) {
scanf("%d", &x);
hh.push(x);
oo.push_back("insert");
pp.push_back(x);
cnt++;
} else if (strcmp(s, "getMin") == 0) {
scanf("%d", &x);
if (hh.empty()) {
hh.push(x);
oo.push_back("insert");
pp.push_back(x);
cnt++;
oo.push_back("getMin");
pp.push_back(x);
cnt++;
continue;
}
int rr = hh.top();
if (rr == x) {
oo.push_back("getMin");
pp.push_back(x);
cnt++;
} else {
if (rr > x) {
hh.push(x);
oo.push_back("insert");
pp.push_back(x);
cnt++;
oo.push_back("getMin");
pp.push_back(x);
cnt++;
} else {
while (!hh.empty() && rr < x) {
hh.pop();
oo.push_back("removeMin");
cnt++;
rr = hh.top();
}
if (hh.empty()) {
hh.push(x);
oo.push_back("insert");
pp.push_back(x);
cnt++;
oo.push_back("getMin");
pp.push_back(x);
cnt++;
continue;
}
if (rr == x) {
oo.push_back("getMin");
pp.push_back(x);
cnt++;
} else {
hh.push(x);
oo.push_back("insert");
pp.push_back(x);
cnt++;
oo.push_back("getMin");
pp.push_back(x);
cnt++;
}
}
}
} else {
if (hh.empty()) {
oo.push_back("insert");
pp.push_back(x);
cnt++;
oo.push_back("removeMin");
cnt++;
} else {
hh.pop();
oo.push_back("removeMin");
cnt++;
}
}
}
cout << cnt << endl;
int jj = 0;
for (i = 0; i < oo.size(); i++) {
cout << oo[i];
if (oo[i] == "insert" || oo[i] == "getMin") {
printf(" %d", pp[jj]);
jj++;
}
printf("\n");
}
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.