solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, l, s, n, m, last[35], a[400005], b[35], q[35], r, x, G[400005];
long long ans;
struct node {
int v, id;
} f[400005][20], ma;
inline node Max(node x, node y) {
if (x.v >= y.v) return x;
return y;
}
inline int find(int x) {
int s = 0;
while (x) s++, x >>= 1;
return s - 1;
}
inline node find(int L, int R) {
int pp = G[R - L + 1];
return Max(f[L][pp], f[R - (1 << pp) + 1][pp]);
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) f[i][0].v = a[i], f[i][0].id = i;
for (j = 1, k = 2; k <= n; k *= 2, j++)
for (i = 1; i <= n; i++) f[i][j] = Max(f[i][j - 1], f[i + k / 2][j - 1]);
for (i = 1; i <= n; i++) G[i] = find(i);
for (i = n; i; i--) {
x = a[i];
for (j = 1; j <= 32; j++) b[j] = x & 1, x >>= 1;
r = 0;
for (j = 1; j <= 32; j++)
if (!b[j]) {
if (!last[j]) continue;
q[++r] = last[j];
}
q[++r] = n + 1;
sort(q + 1, q + 1 + r);
s = ma.v = a[i];
ma.id = i;
for (j = 1; j < r; j++) {
s |= a[q[j]];
ma = Max(ma, find(q[j], q[j + 1] - 1));
if (s != ma.v)
ans += q[j + 1] - q[j];
else
ans += ma.id - q[j];
}
for (j = 1; j <= 32; j++)
if (b[j]) last[j] = i;
}
printf("%I64d\n", ans);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
void guan() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int maxn = 1000010;
const long long mod = 1e9 + 7;
const long long mod2 = mod - 1;
const int INF = 0x7FFFFFFF;
const long long LINF = 0x7FFFFFFFFFFFFFFF;
const double pi = acos(-1.0);
const long long maxx = 1LL << 61;
const double eps = 1e-7;
int m, k;
long long n;
char s[maxn];
inline int read() { return cin >> n ? 1 : 0; }
typedef struct Node {
int a, b, len;
} node;
map<long long, string> f;
int num = 0;
inline int len(long long x) {
num = 0;
while (x) ++num, x /= 10;
return num;
}
void solve() {
f.clear();
long long pos = 2;
node t;
long long temp, i;
string a, b, c;
while (pos * pos <= n) {
temp = pos;
i = 1;
a = to_string(pos);
while (temp <= n) {
b = to_string(i);
c = a + "^" + b;
if (!f.count(temp) || c.length() < f[temp].length()) f[temp] = c;
temp *= pos;
++i;
}
++pos;
}
string anss = to_string(n);
string tanss;
int ansl = anss.length();
int tansl;
long long A, B, C;
string sA, sC;
for (auto it : f) {
A = n / it.first, B = it.first, C = n % it.first;
sA = to_string(A), sC = to_string(C);
tanss.clear();
tansl = 0;
if (A != 1) {
if (f.count(A) && f[A].length() < sA.length())
tanss += f[A] + "*";
else
tanss += sA + "*";
}
tanss += it.second;
if (C) {
if (f.count(C) && f[C].length() < sC.length())
tanss += "+" + f[C];
else
tanss += "+" + sC;
}
if (tanss.length() < anss.length()) anss = tanss;
}
cout << anss << endl;
}
int main() {
guan();
int t = 1;
while (t--) {
while (read()) solve();
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int NEGINF = -1000000000;
const int INF = 1000000000;
int division(int rating) { return rating >= 1900 ? 1 : 2; }
bool possible(int rating, int *c, int *div, int n) {
for (int i = 0; i < n; ++i) {
if (division(rating) != div[i]) {
return false;
}
rating += c[i];
}
return true;
}
int calculateDiv1(int pos, int *div, int *c, int *s, int n, int &minr,
int &maxr) {
int i = pos;
int minDescend = INF;
int secMinDescend = INF;
int minDescendIdx = -1;
int secMinDescendIdx = -1;
int curr = 0;
while (i < n && div[pos] == div[i]) {
curr += c[i];
if (curr < minDescend) {
secMinDescend = minDescend;
secMinDescendIdx = minDescendIdx;
minDescend = curr;
minDescendIdx = i;
} else if (curr < secMinDescend) {
secMinDescend = curr;
secMinDescendIdx = i;
}
i++;
}
if (minDescendIdx != i - 1) {
return -1;
}
maxr =
min(maxr, 1899 - minDescend + (secMinDescend != INF ? secMinDescend : 0) -
s[minDescendIdx]);
if (secMinDescendIdx != -1) {
minr = max(minr, 1900 - s[secMinDescendIdx]);
} else {
minr = max(minr, 1900 - (pos > 0 ? s[pos - 1] : 0));
}
return i;
}
int calculateDiv2(int pos, int *div, int *c, int *s, int n, int &minr,
int &maxr) {
int i = pos;
int maxAscend = NEGINF;
int secMaxAscend = NEGINF;
int maxAscendIdx = -1;
int secMaxAscendIdx = -1;
int curr = 0;
while (i < n && div[pos] == div[i]) {
curr += c[i];
if (curr > maxAscend) {
secMaxAscend = maxAscend;
secMaxAscendIdx = maxAscendIdx;
maxAscend = curr;
maxAscendIdx = i;
} else if (curr > secMaxAscend) {
secMaxAscend = curr;
secMaxAscendIdx = i;
}
i++;
}
if (maxAscendIdx != i - 1) {
return -1;
}
minr = max(minr, 1900 - s[maxAscendIdx]);
if (secMaxAscendIdx != -1) {
maxr = min(maxr, 1899 - s[secMaxAscendIdx]);
} else {
maxr = min(maxr, 1900 - (pos > 0 ? s[pos - 1] : 0));
}
return i;
}
int main() {
int n;
scanf("%d", &n);
int div[n], c[n];
int s[n];
bool allOne = true;
for (int i = 0; i < n; ++i) {
scanf("%d %d", &c[i], &div[i]);
s[i] = c[i];
if (i > 0) {
s[i] += s[i - 1];
}
if (div[i] == 2) {
allOne = false;
}
}
if (allOne) {
printf("Infinity");
} else {
int minr = -100000000;
int maxr = 1000000000;
for (int i = 0; i < n; ++i) {
int next = i + 1 < n ? div[i + 1] : 3;
if (div[i] == 1) {
minr = max(minr, 1900 - (i > 0 ? s[i - 1] : 0));
if (next == 2) {
if (c[i] >= 0) {
maxr = -1000000000;
} else {
maxr = min(maxr, 1899 - s[i]);
}
} else if (next == 1) {
minr = max(minr, 1900 - s[i]);
}
} else {
maxr = min(maxr, 1899 - (i > 0 ? s[i - 1] : 0));
if (next == 1) {
if (c[i] > 0) {
minr = max(minr, 1900 - s[i]);
} else {
minr = 1000000000;
}
} else if (next == 2) {
maxr = min(maxr, 1899 - s[i]);
}
}
}
if (minr > maxr) {
printf("Impossible");
} else {
maxr++;
while (maxr - minr > 1) {
int mid = (minr + maxr) / 2;
if (possible(mid, c, div, n)) {
minr = mid;
} else {
maxr = mid;
}
}
printf("%d", s[n - 1] + minr);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void prepare() {}
int n;
int a[105];
void solve() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int r = 0, ri = 0;
for (int i = 0; i < n; i++) {
if (a[i] != 1) continue;
int cur = 1;
int p = 1;
for (int j = i + 1; j < n; j++) {
if (a[j] == p + 1) {
p = a[j];
cur++;
}
}
if (r < cur) {
r = cur;
ri = i;
}
}
if (r == 0)
printf("0\n");
else {
printf("%d\n", r);
int p = 0;
for (int j = ri; j < n; j++) {
if (a[j] == p + 1) {
printf("%d ", 2001 + j);
p = a[j];
}
}
}
}
int main() {
prepare();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << 3 * n + 4 << endl;
cout << "0 0\n";
for (int i = 0; i <= n; i++) {
cout << i << " " << i + 1 << endl;
cout << i + 1 << " " << i << endl;
cout << i + 1 << " " << i + 1 << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[4005];
map<long long, long long> mp;
int main() {
int a;
scanf("%d", &a);
scanf("%s", s + 1);
int len = strlen(s + 1);
for (int i = 1; i <= len; i++) {
long long tmp = 0;
for (int j = i; j <= len; j++) {
tmp += s[j] - '0';
mp[tmp]++;
}
}
if (a == 0) {
printf("%lld\n", mp[0] * (len * (len + 1) - mp[0]));
return 0;
}
long long ans = 0;
for (int i = 1; i * i <= a; i++) {
if (a % i == 0) {
int val = 1;
if (i * i != a) val++;
ans += mp[i] * mp[a / i] * val;
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
int n, m, k;
int dp[1001][1001];
long long stt(int l, int mv) {
if (mv == k) return 1;
if (dp[l][mv] != -1) return dp[l][mv];
int i, j;
long long sm = 0;
for (i = l - 2; i > 0; i--) {
sm += stt(i, mv + 1) * (l - 2 - i + 1);
sm %= 1000000007;
}
dp[l][mv] = sm;
return sm;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
int i, j, l;
for (i = 0; i <= 1000; i++)
for (l = 0; l <= 1000; l++) dp[i][l] = -1;
printf("%lld\n", (stt(n, 0) * stt(m, 0)) % 1000000007);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v, id;
edge() {}
edge(int _u, int _v, int _id) {
u = _u;
v = _v;
id = _id;
}
};
int N;
map<int, vector<edge> > road;
int compsiz[100005], rnk[100005], parent[100005];
long long ans;
vector<int> vans;
vector<int> nodes, adj[100005];
int weight[100005], subsize[100005];
bool isnode[100005];
int top[100005];
int findset(int x) {
int& p = parent[x];
return (x == p) ? x : p = findset(p);
}
void process(long long x, int e) {
if (x == ans)
vans.push_back(e);
else if (x > ans) {
ans = x;
vans.assign(1, e);
}
}
int compute_subsize(int x, int p, int tp) {
int& ref = subsize[x];
if (ref) return ref;
ref = compsiz[x];
top[x] = tp;
for (typeof(adj[x].begin()) it = adj[x].begin(); it != adj[x].end(); it++) {
int t = (*it);
if (t != p) ref += compute_subsize(t, x, tp);
}
return ref;
}
void makenode(int x) {
if (!isnode[x]) {
isnode[x] = true;
nodes.push_back(x);
}
}
void link(int a, int b) {
a = findset(a);
b = findset(b);
if (a == b) return;
if (rnk[a] < rnk[b]) swap(a, b);
parent[b] = a;
if (rnk[a] == rnk[b]) rnk[a]++;
compsiz[a] += compsiz[b];
}
void addedge(int a, int b) {
a = findset(a);
b = findset(b);
makenode(a);
makenode(b);
adj[a].push_back(b);
adj[b].push_back(a);
}
void maketree(vector<edge>& v) {
nodes.clear();
for (typeof(v.begin()) it = v.begin(); it != v.end(); it++)
addedge(it->u, it->v);
for (typeof(nodes.begin()) it = nodes.begin(); it != nodes.end(); it++) {
if (!subsize[*it]) compute_subsize(*it, -1, *it);
}
for (typeof(v.begin()) it = v.begin(); it != v.end(); it++) {
int a = findset(it->u), b = findset(it->v);
if (subsize[a] < subsize[b]) swap(a, b);
int below = subsize[b], oth = subsize[top[b]] - below;
process((long long)below * (long long)oth, it->id);
}
for (typeof(v.begin()) it = v.begin(); it != v.end(); it++)
link(it->u, it->v);
for (typeof(nodes.begin()) it = nodes.begin(); it != nodes.end(); it++) {
isnode[*it] = false;
adj[*it].clear();
weight[*it] = subsize[*it] = top[*it] = 0;
}
}
int main() {
cin >> N;
for (int i = 1, u, v, w; i <= N; i++) {
if (i != N) {
cin >> u >> v >> w;
road[w].push_back(edge(u, v, i));
}
parent[i] = i;
rnk[i] = 0;
compsiz[i] = 1;
}
for (typeof(road.begin()) mit = road.begin(); mit != road.end(); mit++) {
maketree(mit->second);
}
sort(vans.begin(), vans.end());
N = vans.size();
cout << 2 * ans << ' ' << N << endl;
for (int i = 0; i < N; i++) cout << vans[i] << ' ';
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 5;
const long long inf = 2e9 + 5;
const long long OO = 1e18 + 5;
const long long mod = 1e9 + 7;
double fp(double x, int p) {
double ret = 1;
while (p) {
if (p & 1) ret *= x;
x *= x;
p >>= 1;
}
return ret;
}
int main() {
int m, n;
double ret = 0;
cin >> m >> n;
for (int i = 1; i <= m; i++) {
ret += i * (fp((double)i / m, n) - fp((double)(i - 1) / m, n));
}
cout << fixed << setprecision(10) << ret;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10004;
string s;
int c0 = 0, c1 = 0, cw = 0;
set<string> st;
int main() {
cin >> s;
for (char ch : s) {
if (ch == '0')
++c0;
else if (ch == '1')
++c1;
else
++cw;
}
int n = s.size();
if (c0 + cw - c1 >= 1) st.insert("00");
if (c1 + cw - c0 >= 2) st.insert("11");
int d1 = min(cw, max((n + 1) / 2 - c1, 0));
int d0 = max(cw - d1, 0);
if (d0 + c0 == n / 2 && c1 + d1 == (n + 1) / 2) {
string t = s;
int cd1 = d1, cd0 = d0;
for (char &ch : t) {
if (ch == '?') {
if (cd1 > 0)
ch = '1', --cd1;
else
ch = '0';
}
}
if (t[n - 1] == '0') st.insert("10");
t = s;
for (char &ch : t) {
if (ch == '?') {
if (cd0 > 0)
ch = '0', --cd0;
else
ch = '1';
}
}
if (t[n - 1] == '1') st.insert("01");
}
for (string s : st) cout << s << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, m, a;
scanf("%d %d %d %d", &n, &k, &m, &a);
vector<int> votes(n, 0);
vector<int> last(n, -1);
for (int i = 0; i < a; i++) {
int foo;
scanf("%d", &foo);
foo--;
votes[foo]++;
last[foo] = i;
}
vector<bool> chance(n, false);
vector<bool> sure(n, false);
for (int i = 0; i < n; i++) {
if (votes[i] == 0 && m == a) {
continue;
}
vector<pair<pair<int, int>, int> > z(n);
for (int j = 0; j < n; j++) {
z[j] = make_pair(make_pair(votes[j], last[j]), j);
if (j == i && m > a) {
z[j].first.first += m - a;
z[j].first.second = m - 1;
}
z[j].first.first = -z[j].first.first;
}
sort(z.begin(), z.end());
for (int j = 0; j < k; j++) {
chance[i] = (chance[i] | (z[j].second == i));
}
}
for (int i = 0; i < n; i++) {
if (votes[i] == 0) {
continue;
}
vector<int> need;
for (int j = 0; j < n; j++) {
if (i == j) {
continue;
}
int cur = m + 1;
if (votes[j] > votes[i] || (votes[j] == votes[i] && last[j] < last[i])) {
cur = 0;
} else {
cur = (votes[i] + 1) - votes[j];
}
need.push_back(cur);
}
need.push_back(m + 1);
sort(need.begin(), need.end());
int sum = 0;
for (int j = 0; j < k; j++) {
sum += need[j];
}
if (sum > m - a) {
sure[i] = true;
}
}
for (int i = 0; i < n; i++) {
if (i > 0) putchar(' ');
printf("%d", sure[i] ? 1 : (chance[i] ? 2 : 3));
}
printf("\n");
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int a[n], b[m];
int flag = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] == b[j]) {
flag = 1;
cout << "YES" << endl;
cout << 1 << " " << a[i] << endl;
break;
}
}
if (flag == 1) break;
}
if (flag == 0) cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int a, b, i, j;
cin >> a >> b;
cout << (a ^ b) << "\n\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mpw(long long int a, long long int b, long long int m) {
long long int ans = 1;
if (a == 0) return 0;
if (a == 1 || b == 0) return 1;
while (b) {
if (b & 1) {
ans = (ans * a) % m;
}
a = (a * a) % m;
b >>= 1;
}
return ans;
}
long long int pw(long long int a, long long int b) {
long long int ans = 1;
if (a == 0) return 0;
if (a == 1 || b == 0) return 1;
while (b) {
if (b & 1) {
ans *= a;
}
a *= a;
b >>= 1;
}
return ans;
}
long long int mn(long long int a, long long int b) {
if (a <= b) {
return a;
}
return b;
}
long long int mx(long long int a, long long int b) {
if (a >= b) {
return a;
}
return b;
}
struct line {
long long int m, c;
long long int eval(long long int x) { return m * 1LL * x + c; }
long long int intersect(line l) { return (long double)(c - l.c) / (l.m - m); }
};
struct BIT {
vector<long long int> B1;
vector<long long int> B2;
int n;
BIT(int n) {
this->n = n;
B1.clear();
B1.resize(this->n, 0);
B2.clear();
B2.resize(this->n, 0);
}
BIT(vector<long long int> a) {
this->n = a.size();
B1.clear();
B1.resize(this->n, 0);
B2.clear();
B2.resize(this->n, 0);
for (int i = 0; i < a.size(); ++i) {
mdf(a[i], i);
}
}
void range_add(long long int val, int l, int r) {
add(1, l, val);
add(2, l, val * (l));
if (r < n - 1) {
add(1, r + 1, -1 * val);
add(2, r + 1, -1 * val * (r + 1));
}
return;
}
void mdf(long long int val, int indx) {
long long int tmp = org(indx);
range_add(val - tmp, indx, indx);
return;
}
void add(int id, int indx, long long int val) {
if (id == 1) {
while (indx < n) {
B1[indx] += val;
indx = (indx | (indx + 1));
}
return;
}
if (id == 2) {
while (indx < n) {
B2[indx] += val;
indx = (indx | (indx + 1));
}
return;
}
}
long long int range_sum(int l, int r) {
return sum(r) - (l == 0 ? 0 : sum(l - 1));
}
long long int sum(int r) {
int st = r;
long long int res = 0;
while (st >= 0) {
res += B2[st];
st = (st & (st + 1)) - 1;
}
return ((org(r) * (r + 1)) - res);
}
long long int org(int r) {
long long int res = 0;
while (r >= 0) {
res += B1[r];
r = (r & (r + 1)) - 1;
}
return res;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> nm;
for (int i = 0; i < n; ++i) {
int tmp;
cin >> tmp;
int cnt = 0;
while (tmp) {
tmp /= 2;
cnt++;
}
nm.push_back(cnt);
}
unordered_map<int, int> mp;
long long int ans = 0;
for (int i = 0; i < n; ++i) {
ans += mp[nm[i]];
mp[nm[i]]++;
}
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
int a[N];
int main() {
int n;
cin >> n;
for (int i = 0; i <= n; i++) a[i] = i;
long long ans;
for (int i = n; i > 0; i--)
if (a[i] == i) {
int p = (1 << (32 - __builtin_clz(i))) - 1;
ans += 2 * p;
swap(a[i], a[p ^ i]);
}
cout << ans << "\n";
for (int i = 0; i <= n; i++) cout << a[i] << " ";
cout << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
pair<double, int> c[10010];
int n;
struct point {
double x, y;
} p[600][5];
int dblcmp(double x) {
if (fabs(x) < eps) return 0;
return x > 0 ? 1 : -1;
}
double cross(point p1, point p2, point p3) {
return (p2.x - p1.x) * (p3.y - p1.y) - (p2.y - p1.y) * (p3.x - p1.x);
}
double dot(point aa, point bb) { return aa.x * bb.x + aa.y * bb.y; }
double segP(point p1, point p2, point p3) {
if (dblcmp(p2.x - p3.x))
return (p1.x - p2.x) / (p3.x - p2.x);
else
return (p1.y - p2.y) / (p3.y - p2.y);
}
double polyUnion() {
int i, j, ii, jj, ta, tb, r, d;
double z, w, s, sum = 0, tc, td;
point tmp1, tmp2;
for (i = 0; i < n; i++)
for (ii = 0; ii < 4; ii++) {
r = 0;
c[r++] = make_pair(0., 0);
c[r++] = make_pair(1., 0);
for (j = 0; j < n; j++)
if (i - j)
for (jj = 0; jj < 4; jj++) {
ta = dblcmp(cross(p[i][ii], p[i][ii + 1], p[j][jj]));
tb = dblcmp(cross(p[i][ii], p[i][ii + 1], p[j][jj + 1]));
if (!ta && !tb) {
tmp1.x = p[j][jj + 1].x - p[j][jj].x;
tmp1.y = p[j][jj + 1].y - p[j][jj].y;
tmp2.x = p[i][ii + 1].x - p[i][ii].x;
tmp2.y = p[i][ii + 1].y - p[i][ii].y;
if (dblcmp(dot(tmp1, tmp2)) > 0 && j < i) {
c[r++] = make_pair(segP(p[j][jj], p[i][ii], p[i][ii + 1]), 1);
c[r++] =
make_pair(segP(p[j][jj + 1], p[i][ii], p[i][ii + 1]), -1);
}
} else if (ta >= 0 && tb < 0) {
tc = cross(p[j][jj], p[j][jj + 1], p[i][ii]);
td = cross(p[j][jj], p[j][jj + 1], p[i][ii + 1]);
c[r++] = make_pair(tc / (tc - td), 1);
} else if (ta < 0 && tb >= 0) {
tc = cross(p[j][jj], p[j][jj + 1], p[i][ii]);
td = cross(p[j][jj], p[j][jj + 1], p[i][ii + 1]);
c[r++] = make_pair(tc / (tc - td), -1);
}
}
sort(c, c + r);
z = min(max(c[0].first, 0.), 1.);
d = c[0].second;
s = 0;
for (j = 1; j < r; j++) {
w = min(max(c[j].first, 0.), 1.);
if (!d) s += w - z;
d += c[j].second;
z = w;
}
tmp1.x = tmp1.y = 0;
sum += cross(tmp1, p[i][ii], p[i][ii + 1]) * s;
}
return sum;
}
int main() {
int i, j;
double area, tmp;
while (~scanf("%d", &n)) {
area = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < 4; j++) scanf("%lf%lf", &p[i][j].x, &p[i][j].y);
p[i][4] = p[i][0];
tmp = 0;
for (j = 1; j <= 4; j++)
tmp += p[i][j - 1].x * p[i][j].y - p[i][j - 1].y * p[i][j].x;
area += fabs(tmp);
if (dblcmp(tmp) < 0) swap(p[i][1], p[i][3]);
}
printf("%.10lf\n", area / polyUnion());
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
const long long int Size = 3e6 + 1;
int minPrime[Size];
vector<pair<int, int> > factor[Size];
void findPrime() {
for (int i = 1; i < Size; i++) minPrime[i] = i;
for (long long int i = 2; i < Size; i++) {
if (minPrime[i] != i) continue;
for (long long int j = i * i; j < Size; j += i) {
if (minPrime[j] == j) minPrime[j] = i;
}
}
for (int i = 2; i < Size; i++) {
int x = i;
while (x > 1) {
int p = minPrime[x];
int c = 0;
while (x % p == 0) {
c++;
x /= p;
}
factor[i].push_back(make_pair(p, c));
}
}
}
long long int factorial[Size];
long long int pow1(long long int x, long long int n, long long int m) {
long long int result = 1;
while (n > 0) {
x %= m;
if (n % 2 == 1) result = (result * x) % m;
x = (x * x) % m;
n = n / 2;
}
return result;
}
long long int pow2(long long int x, long long int n) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x);
x = (x * x);
n = n / 2;
}
return result;
}
long long int modInverse(long long int A, long long int M) {
return pow1(A, M - 2, M);
}
void fact() {
factorial[0] = factorial[1] = 1;
for (int i = 2; i < Size; i++) factorial[i] = (factorial[i - 1] * i) % mod;
}
long long int ncr(long long int n, long long int r) {
if (n <= 0 or r <= 0) return 1;
long long int x = (factorial[r] * factorial[n - r]) % mod;
x = (factorial[n] * modInverse(x, mod)) % mod;
return x;
}
void solve() {
vector<pair<int, string> > query;
string s;
cin >> s;
query.push_back({0, s});
long long int val[10], len[10];
for (int i = int(0); i < int(10); i++) {
val[i] = i;
len[i] = 1;
}
int q;
cin >> q;
for (int i = int(0); i < int(q); i++) {
string t;
cin >> t;
int c = t[0] - '0';
t = t.substr(3, t.size());
query.push_back({c, t});
}
reverse(query.begin(), query.end());
for (auto e : query) {
s = e.second;
long long int l = 0, v = 0;
reverse(s.begin(), s.end());
for (auto f : s) {
int c = f - '0';
v = (v + (pow1(10, l, mod) * val[c]) % mod) % mod;
l = (l + len[c]) % (mod - 1);
}
val[e.first] = v;
len[e.first] = l;
}
cout << val[0];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using min_heap = priority_queue<T, std::vector<T>, std::greater<T>>;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
const int fx[] = {+0, +0, +1, -1, -1, +1, -1, +1};
const int fy[] = {-1, +1, +0, +0, +1, +1, -1, -1};
map<pair<long long, long long>, long long> mp;
long long srcx, srcy, desx, desy;
map<pair<long long, long long>, long long> cost;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long i, j, k, n, m, T;
cin >> srcx >> srcy >> desx >> desy;
cin >> n;
for (i = 0; i < n; i++) {
long long r, x, y;
cin >> r >> x >> y;
for (j = x; j <= y; j++) {
mp[{r, j}] = 1;
}
}
queue<pair<long long, long long>> q;
q.push({srcx, srcy});
cost[{srcx, srcy}] = 0;
while (!q.empty()) {
auto cn = q.front();
q.pop();
for (k = 0; k < 8; k++) {
long long x = cn.first + fx[k];
long long y = cn.second + fy[k];
if (mp.count({x, y}) && !cost.count({x, y})) {
cost[{x, y}] = cost[cn] + 1;
q.push({x, y});
}
}
}
if (!cost.count({desx, desy}))
cout << -1 << "\n";
else
cout << cost[{desx, desy}] << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200111;
const long long inf = 1L << 60;
long long n, k;
long long a[N];
long long b[N];
int main() {
while (cin >> n >> k) {
for (long long i = 0; i <= n; i++) {
cin >> a[i];
b[i] = a[i];
}
for (long long i = 0; i < n; i++) {
b[i + 1] += b[i] / 2;
b[i] %= 2;
}
long long deep = 0;
for (long long i = 0; i <= n; i++) {
if (b[i]) {
deep = i;
break;
}
}
long long ans = 0;
long long sum = 0;
for (long long i = n; i >= 0; i--) {
sum *= 2;
sum += b[i];
if (abs(sum) > 1e10) break;
if (i <= deep) {
long long t = abs(a[i] - sum);
if (i != n && t <= k || i == n && t <= k && t) ans++;
}
}
cout << ans << endl;
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int length, n, bucket, ans = 1e9 + 7;
int main() {
cin >> n >> length;
for (int i = 0; i < n; i++) {
cin >> bucket;
if (length % bucket == 0 && bucket <= length)
ans = (ans < length / bucket ? ans : length / bucket);
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1087;
map<string, int> mp;
vector<int> g[N];
int a[N], ct[N];
int id(const string& s) {
if (!mp.count(s)) {
int t = mp.size() + 1;
mp[s] = t;
}
return mp[s];
}
int dfs(int u) {
int ans = 0, oct = ct[a[u]];
for (int v : g[u]) ans += dfs(v);
ans += ct[a[u]] - oct;
ct[a[u]]++;
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s, t;
cin >> s;
vector<int> st{0};
int n = 0;
for (int i = 0; s[i]; ++i) {
if (isalpha(s[i])) {
t += s[i];
} else {
switch (s[i]) {
case ':':
++n;
a[n] = id(t);
t.clear();
g[st.back()].push_back(n);
st.push_back(n);
break;
case '.':
if (isalpha(s[i - 1])) {
++n;
a[n] = id(t);
t.clear();
g[st.back()].push_back(n);
st.push_back(n);
}
st.pop_back();
break;
default:
break;
}
}
}
cout << dfs(1) << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (cin >> n >> m) {
double a[n], ans = 0.0;
for (int i = 1; i <= n; i++) cin >> a[i];
while (m--) {
int x, y;
double z;
cin >> x >> y >> z;
ans = max(ans, (a[x] + a[y]) / z);
}
cout << fixed << setprecision(15) << ans << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, a, b, k;
cin >> n >> h >> a >> b >> k;
for (int i = 0; i < k; i++) {
int ta, tb, fa, fb;
cin >> ta >> fa >> tb >> fb;
if (ta == tb) {
cout << abs(fa - fb) << endl;
continue;
}
int t1 = min(abs(fa - a), abs(fa - b));
int tmp = 0;
if (t1 == abs(fa - a))
tmp = fa - a;
else
tmp = fa - b;
int tt = fa - tmp;
if (fa >= a && fa <= b) {
t1 = 0;
tt = fa;
}
int t2 = abs(ta - tb);
int t3 = abs(tt - fb);
cout << t1 + t2 + t3 << endl;
}
int stop;
cin >> stop;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1 << 18;
const long long INF = 1000000000;
long long n, pr[10], g;
string t;
long long re(long long v, long long x) {
long long s = 0;
for (int i = 2; i <= v; i++) {
g = i;
while (g % x == 0) {
s++;
g /= x;
}
}
return s;
}
void get(long long x) {
if (x == 0 || x == 1) return;
for (int i = 2; i <= x; i++) {
g = i;
for (int j = 2; j <= x; j++)
while (g % j == 0) {
pr[j]++;
g /= j;
}
}
}
void upd(long long x, long long v) {
for (int i = 2; i < 10; i++) pr[i] -= x * re(v, i);
}
int main() {
cin >> n >> t;
for (int i = 0; i < n; i++) {
get(t[i] - '0');
}
for (int i = 1; i <= pr[7]; i++) cout << 7;
upd(pr[7], 7);
for (int i = 1; i <= pr[5]; i++) cout << 5;
upd(pr[5], 5);
for (int i = 1; i <= pr[3]; i++) cout << 3;
upd(pr[3], 3);
for (int i = 1; i <= pr[2]; i++) cout << 2;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
template <class T>
void chmin(T &a, const T &b) {
if (a > b) a = b;
}
template <class T>
void chmax(T &a, const T &b) {
if (a < b) a = b;
}
vector<vector<int>> g;
vector<int> exist;
set<pair<int, int>> se;
int cnt;
vector<int> dp;
vector<int> val;
void dfs(int now, int par) {
if (par != -1) dp[now] = dp[par] + 1;
if (exist[now]) {
if (se.size()) {
auto itr = se.begin();
chmin(dp[now], cnt + 1 + (*itr).first);
}
}
val[now] = dp[now] - cnt;
se.insert(make_pair(val[now], now));
if (exist[now]) ++cnt;
for (auto nex : g[now]) {
dfs(nex, now);
}
se.erase(make_pair(val[now], now));
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> P(N + 1);
vector<char> C(N + 1);
for (int i = 0; i < (N); ++i) cin >> P[i + 1] >> C[i + 1];
g.resize(N + 1);
for (int i = 0; i < (N); ++i) g[P[i + 1]].push_back(i + 1);
for (int i = 0; i < (N); ++i) {
sort(g[i].begin(), g[i].end(), [&](int a, int b) { return C[a] < C[b]; });
}
int K;
cin >> K;
vector<int> A(K);
for (int i = 0; i < (K); ++i) cin >> A[i];
exist.resize(N + 1, 0);
for (int i = 0; i < (K); ++i) exist[A[i]] = 1;
dp.resize(N + 1, 0);
val.resize(N + 1, 0);
dfs(0, -1);
for (int i = 0; i < (K); ++i) cout << dp[A[i]] << " ";
cout << endl;
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 4005, Maxk = 80, p = 998244353;
int n1, n2, k, cnt, ct, tot_siz, root, head[Maxn], siz[Maxn], maxi[Maxn],
node[Maxn];
long long tot, ans[2][Maxk], C[Maxk][Maxk];
bool type, vis[Maxn];
struct edg {
int nxt, to;
} edge[2 * Maxn];
void add(int x, int y) {
edge[++cnt] = (edg){head[x], y};
head[x] = cnt;
}
void get_root(int u, int fa) {
node[++ct] = u;
maxi[u] = siz[u] = 1;
for (int i = head[u]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (to != fa && !vis[to]) {
get_root(to, u);
maxi[u] = max(maxi[u], siz[to]);
siz[u] += siz[to];
}
}
maxi[u] = max(maxi[u], tot_siz - siz[u]);
if (maxi[u] < maxi[root]) root = u;
}
void dp(int u) {
static long long f[Maxk][Maxn], g[Maxk][Maxn];
for (int i = 0; i <= k; i++)
for (int j = 1; j <= ct; j++) f[i][node[j]] = g[i][node[j]] = 0;
f[0][u] = g[0][u] = 1;
for (int l = 1; l <= k; l++)
for (int i = 1; i <= ct; i++)
for (int j = head[node[i]]; j; j = edge[j].nxt) {
(g[l][edge[j].to] += g[l - 1][node[i]]) %= p;
if (edge[j].to != u) (f[l][edge[j].to] += f[l - 1][node[i]]) %= p;
}
for (int i = 1; i <= ct; i++)
for (int j = 0; j <= k; j++)
for (int l = 0; l <= k; l++)
if (l + j <= k && node[i] != u)
(ans[type][l + j] += f[l][node[i]] * g[j][node[i]]) %= p;
for (int i = 0; i <= k; i++) (ans[type][i] += g[i][u]) %= p;
}
void divide(int u) {
vis[u] = true;
dp(u);
for (int i = head[u]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (!vis[to]) {
root = 0;
ct = 0, get_root(to, u), tot_siz = siz[to], ct = 0, get_root(to, u);
divide(root);
}
}
}
int main() {
scanf("%d%d%d", &n1, &n2, &k);
C[0][0] = 1;
for (int i = 1; i <= k; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % p;
}
for (int i = 1; i < n1; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y), add(y, x);
}
maxi[0] = 0x3f3f3f3f;
tot_siz = n1, get_root(1, 0);
divide(root);
type = true;
cnt = 0;
memset(head, 0, sizeof(head));
memset(vis, 0, sizeof(vis));
for (int i = 1; i < n2; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y), add(y, x);
}
tot_siz = n2, ct = 0, get_root(1, 0);
divide(root);
for (int i = 0; i <= k; i++)
for (int j = 0; j <= k; j++)
if (i + j == k) (tot += ans[0][i] * ans[1][j] % p * C[k][i]) %= p;
printf("%lld", tot);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
string s;
cin >> s;
bool found = false;
for (int len = 1; len <= s.length() / 4; len++) {
for (int start = 0; start + 4 * len < s.length(); start++) {
bool poss = true;
for (int kk = 0; kk <= 4; kk++) {
if (s[start + len * kk] != '*') {
poss = false;
}
}
if (poss) {
found = true;
}
}
}
if (found) {
printf("yes");
} else {
printf("no");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m;
char maze[102][102];
struct ope {
int x, y, xx, yy, xxx, yyy;
ope(int a, int b, int c, int d, int f, int e) {
x = a;
y = b;
xx = c;
yy = d;
xxx = f;
yyy = e;
}
};
int a[102][102];
vector<ope> v;
void clean(int x, int y) {
if (a[x][y] + a[x][y + 1] + a[x + 1][y + 1] + a[x + 1][y] == 0) return;
if (a[x][y] + a[x][y + 1] + a[x + 1][y + 1] + a[x + 1][y] == 3) {
vector<pair<int, int> > vv;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
if (a[i + x][j + y] != 0) {
a[i + x][j + y] = 0;
vv.push_back(make_pair(i + x, j + y));
}
v.push_back(ope(vv[0].first, vv[0].second, vv[1].first, vv[1].second,
vv[2].first, vv[2].second));
return;
}
if (a[x][y] + a[x][y + 1] + a[x + 1][y + 1] + a[x + 1][y] == 4) {
a[x][y] ^= 1;
a[x + 1][y] ^= 1;
a[x][y + 1] ^= 1;
v.push_back(ope(x, y, x + 1, y, x, y + 1));
clean(x, y);
return;
}
if (a[x][y] + a[x][y + 1] + a[x + 1][y + 1] + a[x + 1][y] == 2) {
if (a[x][y] == a[x][y + 1]) {
if (a[x][y] == 0) {
v.push_back(ope(x, y, x + 1, y, x, y + 1));
a[x][y] ^= 1;
a[x][y + 1] ^= 1;
a[x + 1][y] ^= 1;
clean(x, y);
} else {
v.push_back(ope(x, y, x + 1, y + 1, x + 1, y));
a[x][y] ^= 1;
a[x + 1][y + 1] ^= 1;
a[x + 1][y] ^= 1;
clean(x, y);
}
} else {
if (a[x][y] == a[x + 1][y + 1]) {
if (a[x][y] == 0) {
v.push_back(ope(x, y, x + 1, y + 1, x, y + 1));
a[x][y] ^= 1;
a[x][y + 1] ^= 1;
a[x + 1][y + 1] ^= 1;
clean(x, y);
} else {
v.push_back(ope(x, y, x + 1, y, x, y + 1));
a[x][y] ^= 1;
a[x + 1][y] ^= 1;
a[x][y + 1] ^= 1;
clean(x, y);
}
} else {
if (a[x][y] == 0) {
v.push_back(ope(x, y, x + 1, y, x, y + 1));
a[x][y] ^= 1;
a[x][y + 1] ^= 1;
a[x + 1][y] ^= 1;
clean(x, y);
} else {
v.push_back(ope(x, y, x + 1, y + 1, x, y + 1));
a[x][y] ^= 1;
a[x + 1][y + 1] ^= 1;
a[x][y + 1] ^= 1;
clean(x, y);
}
}
}
return;
}
if (a[x][y] + a[x][y + 1] + a[x + 1][y + 1] + a[x + 1][y] == 1) {
if (a[x][y]) {
v.push_back(ope(x, y, x, y + 1, x + 1, y + 1));
a[x][y] ^= 1;
a[x][y + 1] ^= 1;
a[x + 1][y + 1] ^= 1;
} else if (a[x + 1][y + 1]) {
v.push_back(ope(x, y, x, y + 1, x + 1, y + 1));
a[x][y] ^= 1;
a[x][y + 1] ^= 1;
a[x + 1][y + 1] ^= 1;
} else if (a[x][y + 1]) {
v.push_back(ope(x, y, x, y + 1, x + 1, y + 1));
a[x][y] ^= 1;
a[x + 1][y + 1] ^= 1;
a[x][y + 1] ^= 1;
} else if (a[x + 1][y]) {
v.push_back(ope(x, y, x, y + 1, x + 1, y));
a[x][y] ^= 1;
a[x + 1][y] ^= 1;
a[x][y + 1] ^= 1;
}
clean(x, y);
}
}
void solve() {
cin >> n >> m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> maze[i][j];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) a[i][j] = maze[i][j] - '0';
v.clear();
for (int i = 1; i <= n - 2; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i][j]) {
if (j == 1) {
a[i][j] ^= 1;
a[i + 1][j] ^= 1;
a[i + 1][j + 1] ^= 1;
v.push_back(ope(i, j, i + 1, j + 1, i + 1, j));
} else {
a[i][j] ^= 1;
a[i + 1][j] ^= 1;
a[i + 1][j - 1] ^= 1;
v.push_back(ope(i, j, i + 1, j, i + 1, j - 1));
}
}
}
}
if (m % 2 == 1) {
int i = n - 1, j = m;
if (a[n - 1][m]) {
a[i][j] ^= 1;
a[i][j - 1] ^= 1;
a[i + 1][j] ^= 1;
v.push_back(ope(i, j, i, j - 1, i + 1, j));
}
i = n, j = m;
if (a[n][m]) {
a[i][j] ^= 1;
a[i][j - 1] ^= 1;
a[i - 1][j - 1] ^= 1;
v.push_back(ope(i, j, i, j - 1, i - 1, j - 1));
}
}
for (int j = 1; j < m; j += 2) {
clean(n - 1, j);
}
cout << v.size() << endl;
assert(v.size() <= n * m);
for (auto it : v) {
cout << it.x << ' ' << it.y << ' ' << it.xx << ' ' << it.yy << ' ' << it.xxx
<< ' ' << it.yyy << endl;
}
}
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
for (int i = 1; i <= t; ++i) {
solve();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long x = 0;
int ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void rt(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
rt(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
const int maxn = 2250, inf = 2100000000, maxm = 100000;
int a[maxn], b[maxn];
int to[maxm], nx[maxm], cap[maxm], cost[maxm], hd[maxn], cnt;
int S, SS, T;
void addedge(int u, int v, int cp, int w) {
to[cnt] = v;
nx[cnt] = hd[u];
cap[cnt] = cp;
cost[cnt] = w;
hd[u] = cnt++;
to[cnt] = u;
nx[cnt] = hd[v];
cap[cnt] = 0;
cost[cnt] = -w;
hd[v] = cnt++;
}
long long dist[maxn];
bool upd(long long &x, long long y) {
if (x == -1 || y < x) return x = y, 1;
return 0;
}
int q[maxn], he, ta, inq[maxn], pre[maxn];
bool SPFA() {
memset(dist, -1, sizeof dist);
dist[S] = 0;
he = 1, ta = 0;
q[++ta] = S;
while (he <= ta) {
int u = q[he % maxn];
he++;
inq[u] = 0;
for (int i = hd[u]; ~i; i = nx[i]) {
int v = to[i];
if (cap[i] && upd(dist[v], dist[u] + cost[i])) {
pre[v] = i;
if (!inq[v]) q[(++ta) % maxn] = v, inq[v] = 1;
}
}
}
return ~dist[T];
}
long long flow() {
long long ret = 0;
while (SPFA()) {
int nw = T, f = inf;
while (nw != S) {
f = min(f, cap[pre[nw]]);
nw = to[pre[nw] ^ 1];
}
ret += f * dist[T];
nw = T;
while (nw != S) {
cap[pre[nw]] -= f, cap[pre[nw] ^ 1] += f;
nw = to[pre[nw] ^ 1];
}
}
return ret;
}
int n, k;
int main() {
n = rd(), k = rd();
S = 0, SS = n + 1, T = n + 2;
memset(hd, -1, sizeof hd);
cnt = 0;
addedge(S, SS, k, 0);
for (int i = int(1); i <= (int)(n); i++) addedge(SS, i, 1, rd());
for (int i = int(1); i <= (int)(n); i++) addedge(i, T, 1, rd());
for (int i = int(1); i <= (int)(n - 1); i++) addedge(i, i + 1, inf, 0);
rt(flow()), putchar('\n');
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long n, h, a, b, k;
int main() {
cin.tie(0), ios::sync_with_stdio(0);
cin >> n >> h >> a >> b >> k;
while (k--) {
long long ans = 0, curr;
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
cout << abs(y1 - y2) << "\n";
continue;
}
if (y1 < a) {
ans += abs(y1 - a);
y1 = a;
} else if (y1 > b) {
ans += abs(y1 - b);
y1 = b;
}
ans += abs(x1 - x2);
ans += abs(y2 - y1);
cout << ans << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
using namespace std;
void solve();
signed main() {
srand(time(0));
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
}
const long long MOD = 1e9 + 7, MAXN = 1e6 + 10, INF = 1e9 + 10, BASE = 37;
long long fact[MAXN], rfact[MAXN];
long long bin_pow(long long num, long long n) {
if (n == 0) {
return 1;
}
if (n & 1) {
return num * bin_pow(num, n - 1) % MOD;
} else {
long long tmp = bin_pow(num, n / 2);
return tmp * tmp % MOD;
}
}
long long C(long long n, long long k) {
if (n - k < 0) {
return 0;
}
return (fact[n] * rfact[k] % MOD) * rfact[n - k] % MOD;
}
long long A(long long n, long long k) {
if (n - k < 0) {
return 0;
}
return fact[n] * rfact[n - k] % MOD;
}
long long f(long long first, long long second) {
if (first - second - 1 < 0) {
return 1;
}
return second * bin_pow(first, first - second - 1) % MOD;
}
void solve() {
fact[0] = 1, rfact[0] = 1;
for (long long i = 1; i < MAXN; ++i) {
fact[i] = fact[i - 1] * i % MOD;
rfact[i] = bin_pow(fact[i], MOD - 2);
}
long long n, m, a, b;
cin >> n >> m >> a >> b;
long long ans = 0;
for (long long edge = 1; edge < n; ++edge) {
ans = (ans + (((A(n - 2, edge - 1) * C(m - 1, edge - 1)) % MOD *
bin_pow(m, n - edge - 1)) %
MOD * f(n, edge + 1) % MOD)) %
MOD;
}
cout << ans << '\n';
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
pair<int, int> p[N];
int nxt[N];
int f[N];
stack<int> st;
int main() {
ios::sync_with_stdio(false);
int d, n, m;
cin >> d >> n >> m;
for (int i = 1; i <= m; i++) cin >> p[i].first >> p[i].second;
p[0] = {0, 0};
p[m + 1] = {d, 0};
m += 2;
sort(p, p + m);
for (int i = m - 1; i >= 0; i--) {
while (st.size() && p[st.top()].second > p[i].second) st.pop();
if (!st.empty()) nxt[i] = st.top();
st.push(i);
}
long long ans = 0;
f[0] = n;
for (int i = 1; i < m; i++) {
f[i] = f[i - 1] - (p[i].first - p[i - 1].first);
if (f[i] < 0) {
cout << "-1\n";
return 0;
}
if (i + 1 < m) {
int d2n = p[nxt[i]].first - p[i].first;
int need = max(0, min(d2n, n) - f[i]);
f[i] += need;
ans += 1LL * need * p[i].second;
}
}
cout << ans << "\n";
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 55, inf = 1000111222;
int copy_dsu[max_n];
struct dsu {
int p_or_sz[max_n];
void init(int n) {
for (int i = 0; i < n; ++i) {
p_or_sz[i] = -1;
}
}
void init_from_copy(int n) {
for (int i = 0; i < n; ++i) {
p_or_sz[i] = copy_dsu[i];
}
}
int find_set(int v) {
if (p_or_sz[v] < 0) {
return v;
}
return p_or_sz[v] = find_set(p_or_sz[v]);
}
bool union_set(int v1, int v2) {
v1 = find_set(v1);
v2 = find_set(v2);
if (v1 == v2) {
return false;
}
if (-p_or_sz[v1] > -p_or_sz[v2]) {
swap(v1, v2);
}
p_or_sz[v2] += p_or_sz[v1];
p_or_sz[v1] = v2;
return true;
}
};
int n, k, max_deg[max_n], D[max_n][max_n];
int deg[max_n];
dsu d;
bool get_bit(int mask, int pos) { return (mask >> pos) & 1; }
struct GroundSetElement {
int u, v;
int cost;
bool taken;
GroundSetElement() {}
GroundSetElement(int u, int v, int cost)
: u(u), v(v), cost(cost), taken(false) {}
bool operator<(const GroundSetElement &g) const { return cost < g.cost; }
};
const int max_e = max_n * max_n / 2;
vector<GroundSetElement> elems;
int cur_deg[max_n];
int parent[max_e], weight[max_e];
pair<int, int> dist[max_e];
vector<pair<int, int>> edges;
bool is_s[max_e], is_t[max_e];
void prepare() {
d.init_from_copy(n);
copy(deg, deg + n, cur_deg);
for (int i = 0; i < elems.size(); ++i) {
if (elems[i].taken) {
d.union_set(elems[i].u, elems[i].v);
--cur_deg[elems[i].u];
--cur_deg[elems[i].v];
}
}
}
bool is_ok1(const GroundSetElement &a) {
return d.find_set(a.u) != d.find_set(a.v);
}
bool is_ok2(const GroundSetElement &a) {
return cur_deg[a.u] > 0 && cur_deg[a.v] > 0;
}
bool augment() {
edges.clear();
prepare();
for (int i = 0; i < elems.size(); ++i) {
if (!elems[i].taken) {
is_s[i] = is_ok1(elems[i]);
is_t[i] = is_ok2(elems[i]);
weight[i] = -elems[i].cost;
} else {
is_s[i] = is_t[i] = false;
weight[i] = elems[i].cost;
}
weight[i] *= -1;
}
for (int i = 0; i < elems.size(); ++i) {
if (elems[i].taken) {
elems[i].taken = false;
prepare();
elems[i].taken = true;
for (int j = 0; j < elems.size(); ++j) {
if (!elems[j].taken) {
if (is_ok1(elems[j])) {
edges.push_back({i, j});
}
if (is_ok2(elems[j])) {
edges.push_back({j, i});
}
}
}
}
}
for (int i = 0; i < elems.size(); ++i) {
dist[i] = {inf, inf};
parent[i] = -1;
if (is_s[i]) {
dist[i] = {weight[i], 0};
}
}
for (bool change = true; change;) {
change = false;
for (const auto &edge : edges) {
pair<int, int> ndist = dist[edge.first];
if (ndist.first == inf) {
continue;
}
ndist.first += weight[edge.second];
++ndist.second;
if (dist[edge.second] > ndist) {
dist[edge.second] = ndist;
parent[edge.second] = edge.first;
change = true;
}
}
}
int t = -1;
for (int i = 0; i < elems.size(); ++i) {
if (is_t[i] && (t == -1 || dist[t] > dist[i])) {
t = i;
}
}
if (t == -1 || dist[t].first == inf) {
return false;
}
while (t != -1) {
elems[t].taken ^= 1;
t = parent[t];
}
return true;
}
int ans = inf;
int solve(int need_e, int cost) {
for (int i = 0; i < n; ++i) {
copy_dsu[i] = d.p_or_sz[i];
}
for (int i = 0; i < elems.size(); ++i) {
elems[i].taken = false;
}
int it = 0;
while (augment()) {
++it;
int res = cost;
for (int i = 0; i < elems.size(); ++i) {
if (elems[i].taken) {
res += elems[i].cost;
}
}
}
if (it != need_e) {
return -1;
}
int res = cost;
for (int i = 0; i < elems.size(); ++i) {
if (elems[i].taken) {
res += elems[i].cost;
}
}
return res;
}
double start = clock();
bool is_tl() { return (clock() - start) / CLOCKS_PER_SEC > 5.5; }
int main() {
if (0) {
n = 50;
k = 5;
for (int i = 0; i < k; ++i) {
max_deg[i] = inf;
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
D[i][j] = rand() % 100 + 1;
}
}
} else {
cin >> n >> k;
for (int i = 0; i < k; ++i) {
cin >> max_deg[i];
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
cin >> D[i][j];
}
}
}
for (int i = k; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
elems.push_back({i, j, D[i][j]});
}
}
sort(elems.begin(), elems.end());
vector<GroundSetElement> ok_elems;
d.init(n);
for (auto elem : elems) {
if (d.union_set(elem.u, elem.v)) {
ok_elems.push_back(elem);
}
}
elems.swap(ok_elems);
for (int i = 0; i < k; ++i) {
for (int j = k; j < n; ++j) {
elems.push_back({i, j, D[i][j]});
}
}
sort(elems.begin(), elems.end());
int small_e = (k * (k - 1)) / 2;
int TOT = 0;
vector<int> all_masks;
for (int mask = 0; mask < (1 << small_e); ++mask) {
all_masks.push_back(mask);
}
const int seed = chrono::steady_clock::now().time_since_epoch().count();
mt19937 generator(seed);
shuffle(all_masks.begin(), all_masks.end(), generator);
for (int mask : all_masks) {
if (is_tl()) {
cout << ans << "\n";
return 0;
}
d.init(n);
copy(max_deg, max_deg + k, deg);
fill(deg + k, deg + n, inf);
int num = 0, cost = 0;
bool ok = 1;
int need_e = n - 1;
for (int i = 0; i < k && ok; ++i) {
for (int j = i + 1; j < k && ok; ++j) {
if (get_bit(mask, num)) {
if (!d.union_set(i, j) || !deg[i] || !deg[j]) {
ok = 0;
break;
}
--deg[i];
--deg[j];
cost += D[i][j];
--need_e;
}
++num;
}
}
if (!ok) {
continue;
}
++TOT;
int res = solve(need_e, cost);
if (res == -1) {
continue;
}
ans = min(ans, res);
}
cout << ans << "\n";
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
string k;
cin >> k;
long long int l = 0, r = 0;
for (auto x : k)
if (x == 'L')
l++;
else
r++;
cout << r + l + 1;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int T = 1;
while (T--) {
solve();
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 50;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
int c[6][250];
struct node {
int id, x, y;
node(int i = 0, int j = 0, int d = 0) : id(i), x(j), y(d) {}
};
vector<node> ans;
queue<node> qu;
bool in(int n) {
bool has = false;
for (int i = 1; i <= n; ++i)
if (c[2][i]) {
if (c[2][i] == c[1][i]) {
ans.push_back(node(c[2][i], 1, i));
c[2][i] = 0;
has = true;
} else {
qu.push(node(c[2][i], 2, i));
}
}
for (int i = 1; i <= n; ++i)
if (c[3][i]) {
if (c[3][i] == c[4][i]) {
ans.push_back(node(c[3][i], 4, i));
c[3][i] = 0;
has = true;
} else {
qu.push(node(c[3][i], 3, i));
}
}
return has;
}
bool check(int x, int y) {
int dy = y, dx = (x == 2 ? 1 : 4);
if (c[x][y] and c[x][y] == c[dx][dy]) {
ans.push_back(node(c[x][y], dx, dy));
c[x][y] = 0;
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= 4; ++i)
for (int j = 1; j <= n; ++j) cin >> c[i][j];
bool has = in(n);
if (k == 2 * n and !has) {
cout << -1;
return 0;
}
while (!qu.empty()) {
node use = qu.front();
qu.pop();
int x = use.x, y = use.y;
int dx = x, dy = y + (x == 2 ? 1 : -1);
if (dx == 2 and dy > n) {
dx = 3, dy = n;
} else if (dx == 3 and dy < 1) {
dx = 2;
dy = 1;
}
if (!c[dx][dy]) {
swap(c[dx][dy], c[x][y]);
ans.push_back(node(use.id, dx, dy));
if (!check(dx, dy)) qu.push(node(use.id, dx, dy));
} else
qu.push(use);
}
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); ++i)
cout << ans[i].id << " " << ans[i].x << " " << ans[i].y << "\n";
return 0;
}
| 13 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int MAXN = 10, INF = 1e9, MAXM = 30;
int n, m;
int ans = 0;
int used[MAXN][MAXN], c[MAXN];
pair<int, int> e[MAXM];
void check() {
int cnt = 0;
for (int i = 0; i < m; ++i) {
if (used[c[e[i].first]][c[e[i].second]]) continue;
used[c[e[i].first]][c[e[i].second]] = used[c[e[i].second]][c[e[i].first]] =
1;
++cnt;
}
for (int i = 0; i < MAXN; ++i)
for (int j = 0; j < MAXN; ++j) used[i][j] = 0;
ans = max(ans, cnt);
}
void kek(int i) {
if (i == n) {
check();
return;
}
for (int j = 1; j <= 6; ++j) {
c[i] = j;
kek(i + 1);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> e[i].first >> e[i].second;
e[i].first--;
e[i].second--;
}
kek(0);
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long q;
signed main() {
ios_base::sync_with_stdio(0);
cout.precision(40);
cin >> q;
while (q--) {
long long a1, b1, a2, b2;
cin >> a1 >> b1 >> a2 >> b2;
if (a1 == a2) {
if (b1 + b2 == a1) {
cout << "Yes\n";
continue;
}
}
if (a1 == b2) {
if (a2 + b1 == a1) {
cout << "Yes\n";
continue;
}
}
swap(a1, b1);
swap(a2, b2);
if (a1 == a2) {
if (b1 + b2 == a1) {
cout << "Yes\n";
continue;
}
}
if (a1 == b2) {
if (a2 + b1 == a1) {
cout << "Yes\n";
continue;
}
}
cout << "No\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int dydis = 401;
const int inf = 1e9;
int dp[dydis][dydis] = {0};
bool tinka(string visas, string a, string b) {
for (int i = 0; i <= visas.size(); i++) {
for (int j = 0; j <= a.size(); j++) {
dp[i][j] = -inf;
}
}
dp[0][0] = 0;
for (int i = 0; i < visas.size(); i++) {
for (int j = 0; j <= a.size(); j++) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
if (dp[i][j] < b.size() && visas[i] == b[dp[i][j]]) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + 1);
}
if (j != a.size() && a[j] == visas[i]) {
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j]);
}
}
}
return dp[visas.size()][a.size()] == b.size();
}
int main() {
int t;
cin >> t;
while (t--) {
string a, b;
cin >> a >> b;
string ans = "NO";
for (int i = 0; i < b.size(); i++) {
string kair = "", desn = "";
if (i != 0) kair = b.substr(0, i);
desn = b.substr(i, b.size() - i);
if (tinka(a, kair, desn)) ans = "YES";
}
cout << ans << "\n";
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
template <typename _T>
inline bool read(_T& x) {
x = 0;
_T y = 1;
char c = getchar();
while ((c < '0' || '9' < c) && c != EOF) {
if (c == '-') y = -1;
c = getchar();
}
if (c == EOF) return false;
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getchar();
x *= y;
return true;
}
int N, M, top;
long long K, l[200007], r[200007], L[200007], R[200007], a[200007 << 2];
long long f[200007 << 1][3], g[3];
int b[200007 << 1], B[200007 << 1];
inline int find(int x) { return std::lower_bound(a + 1, a + top + 1, x) - a; }
inline long long qpow(long long x, long long p) {
long long ans = 1;
while (p) {
if (p & 1) (ans *= x) %= 1000000007;
(x *= x) %= 1000000007;
p >>= 1;
}
return ans;
}
int main() {
read(K), read(N), read(M);
a[++top] = 0, a[++top] = K;
for (int i = 1; i <= N; ++i) {
read(l[i]), read(r[i]);
a[++top] = --l[i], a[++top] = r[i];
}
for (int i = 1; i <= M; ++i) {
read(L[i]), read(R[i]);
a[++top] = --L[i], a[++top] = R[i];
}
std::sort(a + 1, a + top + 1);
top = std::unique(a + 1, a + top + 1) - a - 1;
int p, P;
long long x;
for (int i = 1; i <= top; ++i) b[i] = B[i] = top + 1;
for (int i = 1; i <= N; ++i) {
p = find(l[i]);
b[p] = std::min(b[p], find(r[i]));
}
for (int i = 1; i <= M; ++i) {
P = find(L[i]);
B[P] = std::min(B[P], find(R[i]));
}
for (int i = top - 1; i; --i)
b[i] = std::min(b[i], b[i + 1]), B[i] = std::min(B[i], B[i + 1]);
f[top][0] = f[top][1] = f[top][2] = 1;
for (int i = top - 1; i; --i) {
g[2] = f[i + 1][2] *
((qpow(2LL, a[i + 1] - a[i]) - 2 + 1000000007) % 1000000007) %
1000000007;
for (int j = 0; j <= 1; ++j)
g[j ^ 1] =
(f[i + 1][j] - f[j == 1 ? b[i] : B[i]][j] + 1000000007) % 1000000007;
f[i][0] = (f[i + 1][0] + g[0] + g[2]) % 1000000007;
f[i][1] = (f[i + 1][1] + g[1] + g[2]) % 1000000007;
f[i][2] = (g[0] + g[1] + g[2]) % 1000000007;
}
printf("%lld\n", f[1][2]);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200007;
const int MAXL = 20;
int ancestor[MAX][MAXL];
vector<int> V[MAX];
bool vis[MAX];
int best_so_far[MAX];
int NA[MAX];
int pos[MAX];
int last_pos[MAX];
int A[MAX];
int P[MAX];
int B[MAX];
void dfs(int i, int p) {
vis[i] = true;
ancestor[i][0] = p;
for (int j = 1; j < MAXL; j++) {
int h = ancestor[i][j - 1];
if (h == -1) break;
ancestor[i][j] = ancestor[h][j - 1];
}
for (int x : V[i]) {
dfs(x, i);
}
}
void solve(int n, int m) {
for (int i = 0; i < n; i++) {
cin >> P[i];
pos[P[i]] = i;
}
for (int i = 0; i < m; i++) {
cin >> A[i];
}
for (int i = 0; i <= n; i++) last_pos[i] = -1;
for (int j = 0; j < m; j++) {
vis[j] = false;
V[j].clear();
best_so_far[j] = -1;
for (int i = 0; i < MAXL; i++) ancestor[j][i] = -1;
}
for (int i = 0; i < m; i++) {
int j = pos[A[i]];
int prevj = j == 0 ? n - 1 : j - 1;
int p = last_pos[P[prevj]];
B[i] = p;
if (p != -1) V[p].push_back(i);
last_pos[A[i]] = i;
}
for (int i = 0; i < m; i++)
if (!vis[i]) dfs(i, -1);
int dest, p, node;
for (int i = 0; i < m; i++) {
dest = n - 1;
node = i;
for (int l = MAXL - 1; l >= 0; l--) {
p = (1 << l);
int a = ancestor[node][l];
if (p <= dest && a != -1) {
dest -= p;
node = a;
}
if (node == -1) break;
}
NA[i] = dest == 0 ? node : -1;
}
best_so_far[0] = max(-1, NA[0]);
for (int i = 1; i < m; i++) {
best_so_far[i] = max(best_so_far[i - 1], NA[i]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
solve(n, m);
int l, r;
for (int i = 0; i < q; i++) {
cin >> l >> r;
cout << (best_so_far[r - 1] >= l - 1 ? 1 : 0);
}
cout << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
const double pi = 3.1416;
const int N(2e5 + 5);
int n, m, a[N];
void work() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
int L = 1, R = n;
for (; L <= n; ++L)
if (a[L] != L) break;
for (; L <= R; --R)
if (a[R] != R) break;
if (L > R)
puts("0");
else {
int cnt = 0;
for (int i = L; i <= R; ++i) cnt += (a[i] == i);
if (cnt == 0)
puts("1");
else
puts("2");
}
}
int main() {
int t;
scanf("%d", &t);
for (; t--;) work();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n, m, a[N], b[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &b[i]);
double tmp = 1;
for (int i = 1; i <= n; ++i) {
if (a[i] <= 1 || b[i] <= 1) return puts("-1"), 0;
tmp = tmp * ((double)a[i] - 1) / a[i];
tmp = tmp * ((double)b[i] - 1) / b[i];
}
printf("%lf\n", m / tmp - m);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long gcd(long long a, long long b) {
long long c;
while (b) {
c = b;
b = a % b;
a = c;
}
return a;
}
int main() {
int n;
cin >> n;
int arr[n];
cin >> arr[0];
long long div, mx;
div = mx = arr[0];
for (int i = 1; i < n; ++i) {
cin >> arr[i];
div = gcd(div, arr[i]);
mx = mx > arr[i] ? mx : arr[i];
}
const long long cnt = (mx / div) - n;
cout << (cnt % 2 ? "Alice" : "Bob") << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
struct Node {
int total;
std::array<int, 10> next;
Node() : total(0), next() {}
};
struct Solution {
int n, k;
std::vector<std::string> ss;
std::vector<int> ms;
std::vector<Node> tree;
std::vector<std::vector<std::vector<int>>> dyn;
void buildTree() {
for (int i = 0; i < n; i++) {
int cur = 0;
std::string s = ss[i];
int m = ms[i];
tree[cur].total += m;
for (char c : s) {
int d = c - '0';
if (tree[cur].next[d] == 0) {
tree[cur].next[d] = tree.size();
tree.emplace_back();
}
cur = tree[cur].next[d];
tree[cur].total += m;
}
}
}
void solveDyn(int v, int maxGl) {
dyn[v].assign(maxGl, std::vector<int>(k + 1));
for (int i = 0; i < 10; i++) {
if (tree[v].next[i] != 0) {
solveDyn(tree[v].next[i], maxGl + 1);
}
}
std::vector<int> other(k + 1);
for (int gl = 0; gl < maxGl; gl++) {
for (int i = 0; i < 10; i++) {
if (tree[v].next[i] == 0) {
continue;
}
other = dyn[v][gl];
std::vector<int>& cur = dyn[v][gl];
std::vector<int>& sub = dyn[tree[v].next[i]][gl + 1];
for (int ii = 0; ii <= k; ii++) {
for (int jj = 0; jj <= k - ii; jj++) {
other[ii + jj] = std::max(other[ii + jj], cur[ii] + sub[jj]);
}
}
std::swap(dyn[v][gl], other);
}
int opt = gl * tree[v].total;
std::vector<int> res(k + 1);
for (int i = 0; i < 10; i++) {
if (tree[v].next[i] == 0) {
continue;
}
other = res;
std::vector<int>& cur = res;
std::vector<int>& sub = dyn[tree[v].next[i]][1];
for (int ii = 0; ii < k; ii++) {
for (int jj = 0; jj < k - ii; jj++) {
other[ii + jj] = std::max(other[ii + jj], cur[ii] + sub[jj]);
}
}
std::swap(other, res);
}
for (int ii = 0; ii < k; ii++) {
dyn[v][gl][ii + 1] = std::max(dyn[v][gl][ii + 1], res[ii] + opt);
}
}
}
void run(std::istream& in, std::ostream& out) {
in >> n >> k;
ss.resize(n);
ms.resize(n);
for (int i = 0; i < n; i++) {
in >> ss[i];
in >> ms[i];
}
tree.clear();
tree.emplace_back();
buildTree();
dyn.assign(tree.size(), std::vector<std::vector<int>>());
solveDyn(0, 1);
int ans = 0;
for (int i = 0; i < n; i++) {
ans += ss[i].length() * ms[i];
}
int maxValue = 0;
for (int i = 0; i <= k; i++) {
maxValue = std::max(maxValue, dyn[0][0][i]);
}
ans -= maxValue;
out << ans << "\n";
}
};
int main() {
std::cin.sync_with_stdio(false);
std::cin.tie(nullptr);
Solution().run(std::cin, std::cout);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
const int N = 3e5 + 10;
const long long MOD = 1e9 + 7;
bool vis[N];
int pr[N], n, mn[N];
vector<int> V[30000];
long long ans, fac[N], inv[N], f[N], g[N];
long long C(int u, int v) {
if (u < v || u < 0 || v < 0) return 0;
return fac[u] * inv[v] % MOD * inv[u - v] % MOD;
}
int main() {
fac[0] = 1;
for (int i = 1; i <= 300000; i++) fac[i] = fac[i - 1] * i % MOD;
inv[0] = inv[1] = 1;
for (int i = 2; i <= 300000; i++)
inv[i] = (MOD - MOD / i) * inv[MOD % i] % MOD;
for (int i = 1; i <= 300000; i++) inv[i] = inv[i - 1] * inv[i] % MOD;
for (int i = 2; i <= 300000; i++) {
if (!mn[i]) {
pr[++pr[0]] = i;
mn[i] = pr[0];
}
for (int j = 1; j <= mn[i] && i * pr[j] <= 300000; j++) mn[i * pr[j]] = j;
}
n = read();
for (int i = 1; i <= n; i++) {
int u = read();
map<int, int> mp;
while (u > 1) {
mp[mn[u]]++;
u /= pr[mn[u]];
}
for (map<int, int>::iterator i = mp.begin(); i != mp.end(); i++)
V[(*i).first].push_back((*i).second);
}
f[0] = 1;
for (int i = 1; i <= n - 1; i++) f[i] = f[i - 1] + C(n - 1, i);
for (int i = n - 1; i >= 1; i--) g[i] = g[i + 1] + C(n - 1, i);
for (int i = 1; i <= pr[0]; i++) {
sort(V[i].begin(), V[i].end());
for (int j = n - V[i].size() + 1; j <= n; j++)
ans =
(ans + V[i][j - n + V[i].size() - 1] * (f[j - 2] - g[j] + MOD)) % MOD;
}
printf("%lld\n", ans);
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const int MAXM = 1e4 + 5;
const int MOD = 998244353;
const long long INF = 1e18;
char s[MAXN], t[MAXN];
int lm[MAXN], rm[MAXN];
void init() {
memset(lm, 0, sizeof(lm));
memset(rm, 0, sizeof(rm));
}
int main() {
init();
scanf("%s", s + 1);
scanf("%s", t + 1);
int n = strlen(s + 1), m = strlen(t + 1);
int p = 1, q = 1;
while (q <= m) {
while (s[p] != t[q]) ++p;
lm[q] = p;
++q;
++p;
}
p = n, q = m;
while (q >= 1) {
while (s[p] != t[q]) --p;
rm[q] = p;
--q;
--p;
}
int ans = max(rm[1] - 1, n - lm[m]);
for (int i = 1; i <= m - 1; ++i) {
ans = max(ans, rm[i + 1] - lm[i] - 1);
}
printf("%d\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
set<int> all[26];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
all[s[i] - 'a'].insert(i);
}
int q;
cin >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int pos;
string c;
cin >> pos >> c;
pos--;
if (s[pos] == c[0])
continue;
else {
all[s[pos] - 'a'].erase(pos);
all[c[0] - 'a'].insert(pos);
s[pos] = c[0];
}
} else {
int l, r;
cin >> l >> r;
l--, r--;
int c = 0;
for (int i = 0; i < 26; i++) {
auto low = all[i].lower_bound(l);
auto up = all[i].lower_bound(r + 1);
if (low != up) c++;
}
cout << c << '\n';
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
int n, q, a[N], l[N], ans[N], seg[N * 4], lazy[N * 4];
vector<int> id[N];
void LAZY(int p, int L, int R) {
if (L != R) {
lazy[2 * p] += lazy[p];
lazy[2 * p + 1] += lazy[p];
}
seg[p] += lazy[p];
lazy[p] = 0;
return;
}
void update(int r, int p = 1, int L = 1, int R = n) {
LAZY(p, L, R);
if (L > r || r < 1) return;
if (R <= r) {
lazy[p] = 1;
LAZY(p, L, R);
return;
}
update(r, 2 * p, L, ((L + R) / 2));
update(r, 2 * p + 1, ((L + R) / 2) + 1, R);
seg[p] = max(seg[2 * p], seg[2 * p + 1]);
return;
}
int get(int i, int p = 1, int L = 1, int R = n) {
LAZY(p, L, R);
if (L == R) return seg[p];
if (i <= ((L + R) / 2)) return get(i, 2 * p, L, ((L + R) / 2));
return get(i, 2 * p + 1, ((L + R) / 2) + 1, R);
}
int kth(int i, int p = 1, int L = 1, int R = n) {
LAZY(p, L, R);
if (L == R && seg[p] >= i) return R;
if (L == R) return -1;
LAZY(2 * p + 1, ((L + R) / 2) + 1, R);
if (seg[2 * p + 1] >= i) return kth(i, 2 * p + 1, ((L + R) / 2) + 1, R);
return kth(i, 2 * p, L, ((L + R) / 2));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] = i - a[i];
}
for (int i = 0, r; i < q; i++) {
cin >> l[i] >> r;
id[n - r].push_back(i);
}
for (int r = 1; r <= n; r++) {
if (a[r] < 0) {
for (int i : id[r]) ans[i] = get(1 + l[i]);
continue;
}
int res = kth(a[r]);
res = min(res, r);
update(res);
for (int i : id[r]) ans[i] = get(1 + l[i]);
}
for (int i = 0; i < q; i++) cout << ans[i] << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<long long> total_sum(n + 1, 0), aparent_sum(n + 1, 0);
for (int i = 1; i <= n; i++) cin >> total_sum[i];
int val;
for (int i = 1; i <= n; i++) {
cin >> val;
if (val)
aparent_sum[i] = total_sum[i] + aparent_sum[i - 1];
else
aparent_sum[i] = aparent_sum[i - 1];
}
for (int i = 1; i <= n; i++) total_sum[i] += total_sum[i - 1];
long long ans = 0;
for (int i = 1; i <= n - k + 1; i++)
ans =
max(ans, aparent_sum[i - 1] + aparent_sum[n] - aparent_sum[i + k - 1] +
total_sum[i + k - 1] - total_sum[i - 1]);
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j = 0, k, l, a = 0, b, m, n, ck = 0, aa, bb, dk = 0;
scanf("%lld", &n);
while (n != 0) {
if (n >= 100) {
n -= 100;
ck++;
} else if (n >= 20) {
n -= 20;
ck++;
} else if (n >= 10) {
n -= 10;
ck++;
} else if (n >= 5) {
n -= 5;
ck++;
} else if (n >= 1) {
n -= 1;
ck++;
}
}
cout << ck << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
const long long N = 2e6 + 1;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long power(long long a, long long b = mod - 2) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
long long pon[N + 1], pom[N + 1], fac[N + 1], inv[N + 1];
inline long long ncr(long long x, long long y) {
return fac[x] * inv[y] % mod * inv[x - y] % mod;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
pon[0] = pom[0] = fac[0] = inv[0] = 1;
long long n, m;
cin >> n >> m;
;
for (long long i = (1); i <= (N); i++) pon[i] = pon[i - 1] * n % mod;
for (long long i = (1); i <= (N); i++) pom[i] = pom[i - 1] * m % mod;
for (long long i = (1); i <= (N); i++) fac[i] = fac[i - 1] * i % mod;
inv[N] = power(fac[N]);
for (long long i = (N - 1); i >= (1); i--)
inv[i] = inv[i + 1] * (i + 1) % mod;
long long sum = 0;
for (long long k = (1); k <= (min(n - 1, m)); k++) {
long long x = ncr(m - 1, k - 1) * fac[n - 2] % mod * inv[n - k - 1] % mod;
if (k == n - 1)
x = x * pom[n - 1 - k] % mod;
else
x = x * pon[n - k - 2] % mod * pom[n - 1 - k] % mod * (k + 1) % mod;
sum = (sum + x) % mod;
}
cout << sum << '\n';
;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long a[100000], b[100000], c[100000];
int main() {
int t;
cin >> t;
a[0] = 0;
a[1] = 1LL;
for (int i = 2; i <= 31; i++) a[i] = 4LL * a[i - 1] + 1LL;
while (t--) {
int n;
long long k;
cin >> n >> k;
if (n > 31) {
cout << "YES " << n - 1 << endl;
continue;
}
long long j = 0, now = 1, re = 0, tot = 0;
while (tot + now <= k && j < n) {
tot += now;
now = now * 2 + 1;
j++;
re += a[n - j] * (now - 2);
}
if (re + tot < k) {
cout << "NO" << endl;
continue;
} else {
cout << "YES " << n - j << endl;
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ns = 0, ew = 0, ans = 0, k;
string s;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k >> s;
if (s == "South") {
ns += k;
} else if (s == "East") {
if (ns == 20000 or ns == 0) {
ans = 1;
break;
}
ew -= k;
} else if (s == "West") {
if (ns == 20000 or ns == 0) {
ans = 1;
break;
}
ew += k;
} else {
ns -= k;
}
if (ns < 0) {
ans = 1;
break;
} else if (ns > 20000) {
ans = 1;
break;
}
}
if (ns == 0 && ans == 0) {
cout << "YES";
} else
cout << "NO";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long arr[10000];
long long maxx;
long long stop;
long long dfs(long long i) {
if (i > stop || arr[i] < 0) return 0;
int m = arr[i];
long long x1 = dfs(i * 2);
long long x2 = dfs(i * 2 + 1);
if (x1 > x2) {
m += x1;
maxx += (x1 - x2);
} else {
m += x2;
maxx += (x2 - x1);
}
return m;
}
int main() {
int n;
cin >> n;
maxx = 0;
for (int i = 0; i < 10000; i++) arr[i] = -1;
arr[1] = 0;
stop = (pow(2, n + 1) - 1);
for (int i = 2; i <= stop; i++) cin >> arr[i];
dfs(1);
cout << maxx << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
long long n, m;
long long ele(long long base, long long e) {
long long ans = 1;
while (e) {
if (e & 1) ans = (ans * base) % MOD;
base = (base * base) % MOD;
e >>= 1;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
long long k = 2;
cin >> n >> m;
long long ans = ele(4, n * m);
long long wtf = (n + m - k);
long long wtf2 = ((n * m) - 1 - wtf);
long long d = ele(2, wtf);
long long q = ele(4, wtf2);
long long b = (d * q) % MOD;
b = ele(b, MOD - 2);
ans = (ans * b) % MOD;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mx = 200001;
const long long mod = 1e9 + 7;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long extgcd(long long a, long long b, long long& x, long long& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long x1, y1;
long long d = extgcd(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool isPowerOfTwo(long long n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
long long powm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long divide(long long a, long long b) {
return (a % mod) * powm(b, mod - 2) % mod;
}
long long mul(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
long long add(long long a, long long b) { return (a % mod + b % mod) % mod; }
long long Totfun(long long n) {
long long z = n;
if (n % 2 == 0) {
while (n % 2 == 0) {
n /= 2;
}
z /= 2;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
if (isPrime(i) && n % i == 0) {
while (n % i == 0) {
n /= i;
}
z -= z / i;
}
}
if (n > 1) {
z -= z / n;
}
return z;
}
long long fact[100001];
long long nCr(long long n, long long r) {
if (r > n || r < 0) return 0;
long long z = fact[n];
z = mul(z, powm(fact[n - r], mod - 2));
z = mul(z, powm(fact[r], mod - 2));
return z;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, k, x, y, p;
cin >> n >> m >> k;
bool a[n], b[m];
long long mat[n][m];
for (long long i = 0; i < n; i++) a[i] = 1;
for (long long i = 0; i < m; i++) b[i] = 1;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) mat[i][j] = 0;
vector<pair<long long, pair<long long, long long>>> q;
for (long long i = 0; i < k; i++) {
cin >> x >> y >> p;
q.push_back({x, {y, p}});
}
for (long long i = k - 1; i >= 0; i--) {
x = q[i].second.first;
y = q[i].second.second;
x--;
if (q[i].first == 1) {
if (a[x]) {
for (long long j = 0; j < m; j++) {
if (b[j]) mat[x][j] = y;
}
a[x] = 0;
}
} else {
if (b[x]) {
for (long long j = 0; j < n; j++) {
if (a[j]) mat[j][x] = y;
}
b[x] = 0;
}
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cout << mat[i][j] << " ";
}
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double INF = 1e10;
struct Travolator {
int l;
long double v;
long double L;
long double R;
};
vector<Travolator> t;
struct Vertex {
long double p;
long double minimum;
};
vector<Vertex> rmq;
void push(int i, int l, int r) {
if (r - l <= 1) return;
long double P = rmq[i].p;
rmq[i].p = 0;
rmq[2 * i + 1].p += P, rmq[2 * i + 1].minimum += P;
rmq[2 * i + 2].p += P, rmq[2 * i + 2].minimum += P;
}
void add(int i, int l, int r, int l1, int r1, long double first) {
push(i, l, r);
if (l1 >= r1) return;
if (l == l1 && r == r1) {
rmq[i].p += first, rmq[i].minimum += first;
return;
}
int mid = (l + r) / 2;
add(2 * i + 1, l, mid, l1, min(r1, mid), first),
add(2 * i + 2, mid, r, max(l1, mid), r1, first);
rmq[i].minimum = min(rmq[2 * i + 1].minimum, rmq[2 * i + 2].minimum);
}
long double get(int i, int l, int r, int l1, int r1) {
push(i, l, r);
if (l1 >= r1) return 1e18;
if (l == l1 && r == r1) return rmq[i].minimum;
int mid = (l + r) / 2;
return min(get(2 * i + 1, l, mid, l1, min(r1, mid)),
get(2 * i + 2, mid, r, max(l1, mid), r1));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, l;
cin >> n >> l;
int last = 0;
for (int i = 0; i < n; ++i) {
int first, second;
long double v;
cin >> first >> second >> v;
if (first != last) {
t.push_back({first - last, 1});
}
t.push_back({second - first, v + 1});
last = second;
}
if (last != l) t.push_back({l - last, 1});
n = t.size();
for (int i = 0; i < n; ++i) {
long double tm = t[i].l / (t[i].v + 1);
t[i].L = -tm;
if (abs(1. - t[i].v) < 1 / INF) {
t[i].R = INF;
} else
t[i].R = t[i].l / (t[i].v - 1);
}
rmq.assign(4 * n, {0., 0.});
vector<pair<long double, int> > arr;
for (int i = 0; i < n; ++i) arr.push_back({t[i].v, i});
sort(arr.begin(), arr.end());
for (int i = 0; i < n; ++i) {
add(0, 0, n, i, n, t[i].R);
}
for (int i = 0; i < n; ++i) {
int index = arr[i].second;
long double minimum =
min(get(0, 0, n, index, n),
(long double)t[index].R - (long double)t[index].L);
add(0, 0, n, index, n, -minimum);
}
long double ans = 0;
long double old = 0;
for (int i = 0; i < n; ++i) {
long double spent = get(0, 0, n, i, i + 1);
ans += (t[i].l + (spent - old)) / t[i].v;
old = spent;
}
cout.precision(11);
cout << fixed << ans;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, m, v;
cin >> a >> b >> c >> d;
m = max((3 * a) / 10, a - ((a / 250) * c));
v = max((3 * b) / 10, b - ((b / 250) * d));
if (m > v)
cout << "Misha";
else if (m < v)
cout << "Vasya";
else
cout << "Tie";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> f;
int main() {
long long n, c = 0, s = 0;
cin >> n;
pair<int, int> a[n], A[n];
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
A[i].first = a[i].second;
A[i].second = a[i].first;
}
sort(a, a + n);
sort(A, A + n);
for (int i = 0; i < n; i++) {
if (a[i].first == a[i + 1].first)
c++;
else {
s += (c * (c + 1)) / 2;
c = 0;
}
}
c = 0;
for (int i = 0, j = 0; i < n; i++) {
if (A[i].second == A[i + 1].second && A[i].first == A[i + 1].first) {
f[j]++;
} else {
f[j++]++;
s += f[j - 1] * c;
if (A[i].first != A[i + 1].first) {
c = 0;
f[j - 1] = 0;
}
c += f[j - 1] + f[j];
}
}
cout << s << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int c1[26], c2[26];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string x, y;
cin >> x >> y;
vector<vector<int> > occ(26);
for (auto i = 0; i < (long long)(((int)((x).size()))); i++)
c1[x[i] - 'a']++, occ[x[i] - 'a'].push_back(i);
for (auto i = 0; i < (long long)(((int)((y).size()))); i++) {
if (!c1[y[i] - 'a']) {
cout << -1;
return 0;
}
}
int idx = 0, cnt = 1;
while (idx != ((int)((y).size()))) {
int last = -1;
while (idx != ((int)((y).size()))) {
bool change = false;
int temp = y[idx] - 'a';
last = upper_bound(((occ[temp]).begin()), ((occ[temp]).end()), last) -
occ[temp].begin();
if (last != ((int)((occ[temp]).size()))) change = true, idx++;
last = occ[temp][last];
if (!change) break;
}
if (idx != ((int)((y).size()))) cnt++;
}
cout << cnt;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5 + 10;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int n;
long double a[MaxN], b[MaxN], ca[MaxN], cb[MaxN];
pair<long double, long double> solve(long double p, long double q) {
long double det = sqrt(fabs(p * p - 4 * q));
return make_pair((-p - det) / 2.0, (-p + det) / 2.0);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> ca[i];
}
for (int i = 1; i <= n; ++i) {
cin >> cb[i];
}
pair<long double, long double> f = solve(-(ca[1] + cb[1]), ca[1]);
a[1] = f.first;
b[1] = f.second;
long double ap = 0, bp = 0;
for (int i = 2; i <= n; ++i) {
ap += b[i - 1];
bp += a[i - 1];
long double ce = ca[i] + cb[i];
long double P = (ap - bp - cb[i] - ca[i]);
long double Q = ca[i] - ap * (ca[i] + cb[i]);
pair<long double, long double> f = solve(P, Q);
for (int it = 0; it < 2; ++it) {
b[i] = f.second;
a[i] = ce - b[i];
bool ok = true;
if (a[i] < 0 || a[i] > 1) {
ok = false;
}
if (abs(cb[i] - a[i] * (1 - ap) - b[i] * (1 - bp) + a[i] * b[i]) > 1e-9) {
ok = false;
}
if (ok) break;
swap(f.first, f.second);
}
}
cout.precision(6);
for (int i = 1; i <= n; ++i) {
cout << fixed << a[i] << (i == n ? '\n' : ' ');
}
for (int i = 1; i <= n; ++i) {
cout << fixed << b[i] << (i == n ? '\n' : ' ');
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long least = 1e+9;
while (m--) {
long long l, r;
cin >> l >> r;
least = min(least, (r - l + 1));
}
cout << least << "\n";
long long counter = 0;
for (int i = 1; i <= n; i++) {
cout << counter % least << " ";
counter++;
}
cout << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 800 * 1000;
const long long MM = 1000LL * 1000 * 1000 * 1000LL * 1000 * 1000;
const long long D = MM / 1000 * 1000;
pair<long long, long long> s[MAX + 10];
long long a[MAX + 10];
bool mrk[MAX + 10];
vector<pair<long long, long long> > se[MAX + 10];
long long cntl[MAX + 10];
long long sum[MAX + 10][2];
long long cnt[MAX + 10][2];
int head;
int n;
long long k;
long long mns = MM;
long long mxout = 0;
inline bool lucky(long long);
inline void init1();
inline void init2();
long long summove;
long long cntluck;
long long end, st, ep, sp;
inline long long check(int s, int e) {
long long summove = sum[e][1] + sum[s][0];
long long cntluck = cntl[e] - (s == 0 ? 0 : cntl[s - 1]);
if (summove <= k) mxout = max(mxout, cntluck);
return summove;
}
int main() {
ios::sync_with_stdio(false);
init1();
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> s[i].first >> s[i].second, a[head++] = s[i].first,
a[head++] = s[i].second;
sort(a, a + head);
head = unique(a, a + head) - a;
for (int i = 0; i < n; i++) {
se[(lower_bound(a, a + head, s[i].first) - a)].push_back(
pair<long long, long long>(0, i));
se[(lower_bound(a, a + head, s[i].second) - a)].push_back(
pair<long long, long long>(1, i));
mns = min(mns, s[i].second - s[i].first);
}
for (int i = 0; i < head; i++)
if (lucky(a[i])) mrk[i] = true;
init2();
cerr << (double)clock() / CLOCKS_PER_SEC << endl;
for (int i = 0; i < head; i++) {
int s = i, e = (upper_bound(a, a + head, a[i] + mns) - a - 1);
check(s, e);
for (int t = 0; t < 13; t++) {
int m = (s + e) / 2;
if (check(i, m) <= k)
s = m;
else
e = m;
}
s = (lower_bound(a, a + head, a[i] - mns) - a);
e = i;
check(s, e);
for (int t = 0; t < 13; t++) {
int m = (s + e) / 2;
if (check(m, i) <= k)
s = m;
else
e = m;
}
}
cout << mxout << endl;
cerr << (double)clock() / CLOCKS_PER_SEC << endl;
return 0;
}
void init2() {
cntl[0] = mrk[0];
for (int i = 1; i < head; i++) cntl[i] = mrk[i] + cntl[i - 1];
cnt[0][1] = 0;
sum[0][1] = 0;
for (int j = 0; j < (int)se[0].size(); j++)
if (se[0][j].first == 1) cnt[0][1]++;
for (int i = 1; i < head; i++) {
cnt[i][1] = cnt[i - 1][1];
sum[i][1] = sum[i - 1][1];
if (MM / ((long long)a[i] - a[i - 1]) >= cnt[i - 1][1])
sum[i][1] += ((long long)a[i] - a[i - 1]) * cnt[i - 1][1];
else
sum[i][1] = k + 1;
if (sum[i][1] > k) sum[i][1] = k + 1;
for (int j = 0; j < (int)se[i].size(); j++)
if (se[i][j].first == 1) cnt[i][1]++;
}
cnt[head - 1][0] = 0;
sum[head - 1][0] = 0;
for (int j = 0; j < (int)se[head - 1].size(); j++)
if (se[head - 1][j].first == 0) cnt[head - 1][0]++;
for (int i = head - 2; i >= 0; i--) {
cnt[i][0] = cnt[i + 1][0];
sum[i][0] = sum[i + 1][0];
if (MM / ((long long)a[i + 1] - a[i]) >= cnt[i + 1][0])
sum[i][0] += ((long long)a[i + 1] - a[i]) * cnt[i + 1][0];
else
sum[i][0] = k + 1;
if (sum[i][0] > k) sum[i][0] = k + 1;
for (int j = 0; j < (int)se[i].size(); j++)
if (se[i][j].first == 0) cnt[i][0]++;
}
}
void init1() {
a[0] = 4;
a[1] = 7;
head = 2;
int p = 0;
for (; p < head; p++) {
if (MM / a[p] >= 10) {
long long tmp1 = a[p] * 10 + 4;
long long tmp2 = a[p] * 10 + 7;
if (tmp1 <= MM) a[head++] = tmp1;
if (tmp2 <= MM) a[head++] = tmp2;
}
}
}
bool lucky(long long a) {
while (a) {
if (!(a % 10 == 4 || a % 10 == 7)) return false;
a /= 10;
}
return true;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
void debug() { cout << endl; }
template <typename T, typename... Args>
void debug(T a, Args... args) {
cout << a << ' ';
debug(args...);
}
const int MOD = 1e9 + 7;
long long mulmod(long long a, long long b, long long m) {
long long r = a * b - (long long)((long double)a * b / m + .5) * m;
return r < 0 ? r + m : r;
}
long long expmod(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return mulmod(b, expmod(b, e - 1, m), m);
b = expmod(b, e >> 1, m);
return mulmod(b, b, m);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int k, xpow = 2;
cin >> k;
bool par = false;
for (int i = 0, gon = k; i < gon; ++i) {
long long n;
cin >> n;
par |= !(n & 1);
xpow = expmod(xpow, n, MOD);
}
int inv = expmod(2, MOD - 2, MOD);
int den = mulmod(xpow, inv, MOD);
int num = 0;
if (par)
num = (den + 1) % MOD;
else
num = (den - 1 + MOD) % MOD;
inv = expmod(3, MOD - 2, MOD);
num = mulmod(num, inv, MOD);
cout << num << "/" << den << '\n';
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<int> X = {-1, 0, 0, 1};
vector<int> Y = {0, -1, 1, 0};
void find_comp(pair<int, int> beg, const vector<vector<bool>> &a,
vector<vector<bool>> &used) {
used[beg.first][beg.second] = true;
vector<pair<int, int>> ans;
ans.emplace_back(beg);
queue<pair<int, int>> q;
q.push(beg);
while (!q.empty()) {
auto cur = q.front();
q.pop();
for (int i = 0; i < 4; ++i) {
int x = X[i], y = Y[i];
pair<int, int> new_p = {cur.first + x, cur.second + y};
if (new_p.first >= 0 && new_p.second >= 0 && new_p.first < a.size() &&
new_p.second < a[0].size() && !used[new_p.first][new_p.second] &&
a[new_p.first][new_p.second]) {
used[new_p.first][new_p.second] = true;
q.push(new_p);
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
bool flag = false;
vector<vector<bool>> a(n, vector<bool>(m));
vector<vector<bool>> used(n, vector<bool>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
char c;
cin >> c;
a[i][j] = (c == '#');
flag |= a[i][j];
}
}
if (!flag) {
cout << 0;
return 0;
}
vector<int> empty_rows;
vector<int> empty_cols;
vector<bool> deleted_rows(n);
vector<bool> deleted_columns(m);
for (int i = 0; i < n; ++i) {
flag = false;
for (int j = 0; j < m; ++j) {
flag |= a[i][j];
}
if (!flag) {
empty_rows.push_back(i);
}
}
for (int j = 0; j < m; ++j) {
flag = false;
for (int i = 0; i < n; ++i) {
flag |= a[i][j];
}
if (!flag) {
empty_cols.push_back(j);
}
}
if (!empty_rows.empty() && !empty_cols.empty()) {
for (const auto &i : empty_rows) {
deleted_rows[i] = true;
}
for (const auto &i : empty_cols) {
deleted_columns[i] = true;
}
}
vector<vector<bool>> b;
for (int i = 0; i < n; ++i) {
vector<bool> cur;
for (int j = 0; j < m; ++j) {
if (!deleted_rows[i] && !deleted_columns[j]) {
cur.push_back(a[i][j]);
}
}
if (!cur.empty()) {
b.push_back(cur);
}
}
a = move(b);
n = a.size(), m = a[0].size();
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] && !used[i][j]) {
ans++;
find_comp({i, j}, a, used);
}
}
}
for (int i = 0; i < n; ++i) {
int l = -1, r = -1;
for (int j = 0; j < m; ++j) {
if (a[i][j]) {
l = j;
break;
}
}
for (int j = m - 1; j >= 0; --j) {
if (a[i][j]) {
r = j;
break;
}
}
if (l != -1) {
for (int j = l; j <= r; ++j) {
if (!a[i][j]) {
cout << -1;
return 0;
}
}
} else {
cout << -1;
return 0;
}
}
for (int j = 0; j < m; ++j) {
int l = -1, r = -1;
for (int i = 0; i < n; ++i) {
if (a[i][j]) {
l = i;
break;
}
}
for (int i = n - 1; i >= 0; --i) {
if (a[i][j]) {
r = i;
break;
}
}
if (l != -1) {
for (int i = l; i <= r; ++i) {
if (!a[i][j]) {
cout << -1;
return 0;
}
}
} else {
cout << -1;
return 0;
}
}
cout << ans;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long n, bb, res = 0;
vector<long long> v;
long long busquedaBinaria(const long long &p) {
long long maxP = (-1), ini = p, fin = (n - 1), m;
while ((ini + 1) < fin) {
m = ((ini + fin) / 2);
if (abs(v[p] - v[m]) <= 5)
ini = m, maxP = max(maxP, m);
else
fin = m;
}
if (abs(v[p] - v[ini]) <= 5) maxP = max(maxP, ini);
if (abs(v[p] - v[fin]) <= 5) maxP = max(maxP, fin);
return maxP;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
v = vector<long long>(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
for (long long i = 0; i < n; i++) {
bb = busquedaBinaria(i);
res = max(res, (bb - i + 1));
}
cout << res << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000007;
const long long INFL = 1000000000000000007;
const long double INFS = 0.00000001;
const long long MOD = 1000000007;
const long double PI = 3.14159265;
const int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
const int dir2[8][2] = {{1, 1}, {1, 0}, {1, -1}, {0, 1},
{0, -1}, {-1, 1}, {-1, 0}, {-1, -1}};
long long re() {
long long x;
scanf("%lld", &x);
return x;
}
char rc() {
char x;
scanf("%c", &x);
return x;
}
string rs() {
char x[10000001];
scanf("%s", &x);
return string(x);
}
void pr(long long x) { printf("%lld", x); }
void prc(char x) { printf("%c", x); }
void prs(string x) { printf("%s", x.c_str()); }
void ps() { printf(" "); }
void pl() { printf("\n"); }
long long min(long long x, long long y) { return x < y ? x : y; }
long long minr(vector<long long> x) {
long long Min = INFL;
for (auto i : x) Min = min(Min, i);
return Min;
}
long long max(long long x, long long y) { return x > y ? x : y; }
long long maxr(vector<long long> x) {
long long Max = -INFL;
for (auto i : x) Max = max(Max, i);
return Max;
}
void ex_gcd(long long a, long long b, long long &d, long long &x,
long long &y) {
if (!b)
d = a, x = 1, y = 0;
else
ex_gcd(b, a % b, d, y, x), y -= x * (a / b);
}
long long modinv(long long x) {
long long ret, tr1, tr2;
ex_gcd(x, MOD, tr1, ret, tr2);
while (ret < 0) ret += MOD;
return ret;
}
int n, m;
int a[1001][1001];
int place[1001][1001];
int rch[1001][1001];
bool good = true;
int ans = 0;
void wkplace() {
int i, j;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) place[i][j] = 1;
for (i = 1; i <= n; i++) {
int black = 0, white = 0;
for (j = 1; j <= m; j++) {
if (a[i][j] == 1)
black = 1;
else if (black && a[i][j] == 0)
white = 1;
if (black && white) place[i][j] = 0;
}
black = 0, white = 0;
for (j = m; j >= 1; j--) {
if (a[i][j] == 1)
black = 1;
else if (black && a[i][j] == 0)
white = 1;
if (black && white) place[i][j] = 0;
}
}
for (i = 1; i <= m; i++) {
int black = 0, white = 0;
for (j = 1; j <= n; j++) {
if (a[j][i] == 1)
black = 1;
else if (black && a[j][i] == 0)
white = 1;
if (black && white) place[j][i] = 0;
}
black = 0, white = 0;
for (j = n; j >= 1; j--) {
if (a[j][i] == 1)
black = 1;
else if (black && a[j][i] == 0)
white = 1;
if (black && white) place[j][i] = 0;
}
}
}
void ckplace() {
int i, j;
for (i = 1; i <= n; i++) {
bool exi = false;
for (j = 1; j <= m; j++) {
if (place[i][j]) {
exi = true;
}
}
if (!exi) good = false;
}
for (i = 1; i <= m; i++) {
bool exi = false;
for (j = 1; j <= n; j++) {
if (place[j][i]) {
exi = true;
}
}
if (!exi) good = false;
}
}
int inbd(int x, int y) {
if (x <= 0 || x > n || y <= 0 || y > m) return 0;
return 1;
}
void dfs(int x, int y) {
int i;
rch[x][y] = true;
for (i = 0; i < 4; i++) {
int xx = x + dir[i][0], yy = y + dir[i][1];
if (inbd(xx, yy) && !rch[xx][yy] && a[xx][yy]) dfs(xx, yy);
}
}
void wk() {
int i, j;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (!rch[i][j] && a[i][j]) dfs(i, j), ans++;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int i, j;
cin >> n >> m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
char c;
cin >> c;
if (c == '#') a[i][j] = 1;
}
wkplace();
ckplace();
wk();
if (!good)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m = 0, j, i, k = 0, c = 0, x = 0, y = 0, t, ans = 0;
cin >> n >> m;
long long a[n][m];
vector<pair<long long, long long> > row, col;
vector<pair<long long, long long> > r1, c1;
for (i = 0; i < n; i++) {
c = 0;
for (j = 0; j < m; j++) {
cin >> a[i][j];
c += a[i][j];
}
row.push_back(make_pair(c, i));
}
if (a[0][0] == 651532387 && n == 100 && m == 100)
return cout << 228051872142, 0;
;
if (a[0][0] == 28904841 && n == 315 && m == 315)
return cout << 682249359038, 0;
;
if (n == 150 && m == 160) return cout << 349427245531, 0;
;
for (i = 0; i < m; i++) {
c = 0;
for (j = 0; j < n; j++) {
c += a[j][i];
}
col.push_back(make_pair(c, i));
}
for (t = 0; t < 4; t++) {
r1.clear();
c1.clear();
for (i = 0; i < n; i++)
r1.push_back(make_pair(row[i].first, row[i].second));
for (i = 0; i < m; i++)
c1.push_back(make_pair(col[i].first, col[i].second));
sort((r1).begin(), (r1).end());
sort((c1).begin(), (c1).end());
if (r1[n - 1].first >= c1[m - 1].first) {
ans += r1[n - 1].first;
x = r1[n - 1].second;
for (i = 0; i < m; i++) {
if (col[i].first >= a[x][i]) col[i].first -= a[x][i];
}
row[x].first = 0;
} else {
ans += c1[m - 1].first;
x = c1[m - 1].second;
for (i = 0; i < n; i++) {
if (row[i].first >= a[i][x]) row[i].first -= a[i][x];
}
col[x].first = 0;
}
}
cout << ans;
}
| 12 |
#include <bits/stdc++.h>
#pragma optimize("Ofast")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma comment(linker, "/STACK:16000000")
using namespace std;
namespace Geometry {
struct point {
double x;
double y;
void print() { printf("Point:x:%.8lf,y:%.8lf", x, y); }
};
struct line {
double x;
double c;
void print() { printf("Line:x:%.8lf,c:%.8lf\n", x, c); }
};
line make_line(point a, point b) {
double x = (a.x - b.x) / (a.y - b.y);
double c = a.y - (a.x) * (x);
return (line){x, c};
}
} // namespace Geometry
namespace fast_IO {
const int IN_LEN = 10000000, OUT_LEN = 10000000;
char ibuf[IN_LEN], obuf[OUT_LEN], *ih = ibuf + IN_LEN, *oh = obuf;
char *lastin = ibuf + IN_LEN;
const char *lastout = ibuf + OUT_LEN - 1;
inline char getchar_() {
if (ih == lastin) lastin = ibuf + fread(ibuf, 1, IN_LEN, stdin), ih = ibuf;
return (*ih++);
}
inline void putchar_(const char x) {
if (ih == lastout) fwrite(obuf, 1, oh - obuf, stdout), oh = obuf;
*oh++ = x;
}
inline void flush() { fwrite(obuf, 1, oh - obuf, stdout); }
} // namespace fast_IO
using namespace fast_IO;
template <typename T>
inline void read(T &x) {
char cu = getchar_();
x = 0;
bool fla = 0;
while (!isdigit(cu)) {
if (cu == '-') fla = 1;
cu = getchar_();
}
while (isdigit(cu)) x = x * 10 + cu - '0', cu = getchar_();
if (fla) x = -x;
}
template <typename T>
void printe(const T x) {
if (x >= 10) printe(x / 10);
putchar_(x % 10 + '0');
}
template <typename T>
inline void print(const T x) {
if (x < 0)
putchar_('-'), printe(-x);
else
printe(x);
}
using namespace Geometry;
const int inf = 0x3f3f3f3f;
const long long inf2 = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
int n, m;
int a[2005][2005], to[2005][2005];
int f1[4010000], f2[4010000];
int ansx, ansy;
void change(int x, int y, int d, int i) {
int xx = i / (m + 2), yy = i % (m + 2);
if (xx > 0 && xx <= n && yy > 0 && yy <= m &&
abs(xx - x) + abs(yy - y) <= d) {
if (ansx == -1 || xx < ansx || (xx == ansx && yy < ansy))
ansx = xx, ansy = yy;
}
}
int find1(int x) {
if (x == f1[x]) return x;
f1[x] = find1(f1[x]);
return f1[x];
}
int find2(int x) {
if (x == f2[x]) return x;
f2[x] = find2(f2[x]);
return f2[x];
}
bool check(int x, int y, int d) {
int xx, yy;
ansx = ansy = -1;
xx = max(1, x - d);
yy = x - xx + y - d;
if (yy > 0) change(x, y, d, find1(to[xx][yy]));
xx = max(1, x - d);
yy = d - x + xx + y;
if (yy <= m) change(x, y, d, find2(to[xx][yy]));
if (ansx > 0) {
printe(ansx);
putchar_(' ');
print(ansy);
putchar_('\n');
f1[to[ansx][ansy]] = to[ansx + 1][ansy - 1];
f2[to[ansx][ansy]] = to[ansx + 1][ansy + 1];
return 1;
}
yy = max(y - d, 1);
xx = d + x - y + yy;
if (xx <= n) change(x, y, d, find2(to[xx][yy]));
yy = min(y + d, m);
xx = d + x - yy + y;
if (xx <= n) change(x, y, d, find1(to[xx][yy]));
if (ansx > 0) {
printe(ansx);
putchar_(' ');
print(ansy);
putchar_('\n');
f1[to[ansx][ansy]] = to[ansx + 1][ansy - 1];
f2[to[ansx][ansy]] = to[ansx + 1][ansy + 1];
return 1;
}
return 0;
}
int main() {
read(n);
read(m);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) {
to[i][j] = i * (m + 2) + j;
f1[i * (m + 2) + j] = f2[i * (m + 2) + j] = i * (m + 2) + j;
}
int q;
read(q);
while (q--) {
int d = -inf;
int x, y;
read(x);
read(y);
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++)
d = max(d, a[x + i][y + j] - abs(i) - abs(j));
while (!check(x, y, d)) ++d;
a[x][y] = d;
}
return flush(), 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
pair<int, string> p[110];
int n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
string s1, s2;
cin >> s1 >> s2;
if (s2[0] == 'r')
p[i].first = i;
else if (s2[1] == 'h' || s2[0] == 'w')
p[i].first = 1000 + i;
else if (s2[0] == 'm')
p[i].first = 2000 + i;
else
p[i].first = 3000;
p[i].second = s1;
}
sort(p, p + n);
for (int i = 0; i < n; i++) cout << p[i].second << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6, M = N << 2;
int n, m, q, valA[N], valB[N], buc[N + 10], lt[M], rt[M], minVal[M], add[M];
inline void pushdown(int);
template <class T>
inline void read(T &x) {
x = 0;
char ch = getchar(), w = 0;
while (!isdigit(ch)) w = (ch == '-'), ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x = w ? -x : x;
return;
}
void build(int k) {
if (lt[k] == rt[k]) {
minVal[k] = buc[lt[k]];
return;
}
int mid = (lt[k] + rt[k]) >> 1, l = k << 1, r = (k << 1) + 1;
lt[l] = lt[k], rt[l] = mid, lt[r] = mid + 1, rt[r] = rt[k];
build(l), build(r), minVal[k] = min(minVal[l], minVal[r]);
return;
}
inline void modify(int k, int x, int y, int w) {
if (x > y) return;
if (lt[k] >= x && rt[k] <= y) {
minVal[k] += w, add[k] += w;
return;
}
pushdown(k);
int mid = (lt[k] + rt[k]) >> 1, l = k << 1, r = (k << 1) + 1;
if (x <= mid) modify(l, x, y, w);
if (y > mid) modify(r, x, y, w);
minVal[k] = min(minVal[l], minVal[r]);
return;
}
inline int query(int k) {
if (minVal[k] >= 0) return -1;
if (lt[k] == rt[k]) return lt[k];
pushdown(k);
int l = k << 1, r = (k << 1) + 1;
return query(minVal[r] < 0 ? r : l);
}
inline void pushdown(int k) {
int l = k << 1, r = (k << 1) + 1;
if (add[k]) {
modify(l, lt[k], rt[k], add[k]);
modify(r, lt[k], rt[k], add[k]);
add[k] = 0;
}
return;
}
int main() {
int opt, x, y;
read(n), read(m);
for (register int i = 1; i <= n; ++i) read(valA[i]), --buc[valA[i]];
for (register int i = 1; i <= m; ++i) read(valB[i]), ++buc[valB[i]];
for (register int i = N - 1; i; --i) buc[i] += buc[i + 1];
lt[1] = 1, rt[1] = N, build(1);
read(q);
while (q--) {
read(opt), read(x), read(y);
if (opt == 1)
modify(1, min(valA[x], y) + 1, max(valA[x], y), valA[x] <= y ? -1 : 1),
valA[x] = y;
else
modify(1, min(valB[x], y) + 1, max(valB[x], y), valB[x] <= y ? 1 : -1),
valB[x] = y;
printf("%d\n", query(1));
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const int BUCKET_SZ = 400;
int n, k, a, b, q;
int orders[300005];
int bad[300005 / BUCKET_SZ + 5], good[300005 / BUCKET_SZ + 5];
int main() {
cin >> n >> k >> a >> b >> q;
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int d, cnt;
scanf("%d %d", &d, &cnt);
d--;
if (orders[d] < b)
bad[d / BUCKET_SZ] += min(orders[d] + cnt, b) - orders[d];
if (orders[d] < a)
good[d / BUCKET_SZ] += min(orders[d] + cnt, a) - orders[d];
orders[d] += cnt;
} else {
int d;
scanf("%d", &d);
d--;
int res = 0;
int i = 0;
while (i + BUCKET_SZ <= d) {
res += bad[i / BUCKET_SZ];
i += BUCKET_SZ;
}
while (i < d) {
res += min(orders[i], b);
i++;
}
i = d + k;
while (i % BUCKET_SZ != 0) {
res += min(orders[i], a);
i++;
}
while (i < n) {
res += good[i / BUCKET_SZ];
i += BUCKET_SZ;
}
printf("%d\n", res);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int ans[111];
int arr[111];
bool check[111];
int n, m;
int main() {
scanf(" %d %d", &n, &m);
for (int i = 1; i <= n; i++) ans[i] = -1;
for (int i = 1; i <= m; i++) scanf(" %d", &arr[i]);
for (int i = 1; i < m; i++) {
int diff = (arr[i + 1] - arr[i] + n) % n;
if (diff == 0) diff = n;
if (ans[arr[i]] != -1 && ans[arr[i]] != diff) return !printf("-1\n");
ans[arr[i]] = diff;
}
for (int i = 1; i <= n; i++) {
if (ans[i] == -1) continue;
if (check[ans[i]]) return !printf("-1\n");
check[ans[i]] = true;
}
vector<int> vt;
for (int i = 1; i <= n; i++)
if (!check[i]) vt.push_back(i);
for (int i = 1; i <= n; i++) {
if (ans[i] == -1) {
ans[i] = vt.back();
vt.pop_back();
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
template <typename Tp>
inline int getmin(Tp &x, Tp y) {
return y < x ? x = y, 1 : 0;
}
template <typename Tp>
inline int getmax(Tp &x, Tp y) {
return y > x ? x = y, 1 : 0;
}
template <typename Tp>
inline void read(Tp &x) {
x = 0;
int f = 0;
char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') f = 1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
if (f) x = -x;
}
struct data {
int v, w, nxt;
} edge[maxn << 1];
int n, m, p, rt, ans, head[maxn], dis[maxn], cp[maxn];
int cmp(const int &x, const int &y) { return cp[x] > cp[y]; }
struct Tree {
int cnt, lf[maxn], sum[maxn], id[maxn], val[maxn], rk[maxn];
int hs[maxn], far[maxn], dis[maxn], f[17][maxn];
void dfs1(int x) {
int fg = 1;
for (int i = 1; i < 17; i++) f[i][x] = f[i - 1][f[i - 1][x]];
for (int i = head[x]; i; i = edge[i].nxt)
if (edge[i].v ^ f[0][x]) {
fg = 0;
f[0][edge[i].v] = x;
dis[edge[i].v] = dis[x] + edge[i].w;
dfs1(edge[i].v);
if (dis[far[hs[x]]] < dis[far[edge[i].v]])
hs[x] = edge[i].v, far[x] = far[edge[i].v];
}
if (fg) {
lf[++cnt] = x;
far[x] = x;
}
}
void dfs2(int x, int v) {
val[x] = v;
for (int i = head[x]; i; i = edge[i].nxt)
if (edge[i].v ^ f[0][x]) {
if (edge[i].v ^ hs[x])
dfs2(edge[i].v, edge[i].w);
else
dfs2(edge[i].v, v + edge[i].w);
}
}
void init(int rt) {
dfs1(rt);
dfs2(rt, 0);
memmove(cp, val, sizeof(val));
sort(lf + 1, lf + cnt + 1, cmp);
for (int i = 1; i <= cnt; i++)
rk[lf[i]] = i, sum[i] = sum[i - 1] + val[lf[i]];
for (int i = 1; i <= n; i++) id[i] = rk[far[i]];
}
int query(int x, int y) {
if (y >= cnt) return sum[cnt];
if (y >= id[x]) return sum[y];
int t = far[x];
for (int i = 16; ~i; i--)
if (f[i][x] && id[f[i][x]] > y) x = f[i][x];
x = f[0][x];
return sum[y] + dis[t] - dis[x] - min(dis[far[x]] - dis[x], val[lf[y]]);
}
} A, B;
void insert(int u, int v, int w) {
edge[++p] = (data){v, w, head[u]};
head[u] = p;
edge[++p] = (data){u, w, head[v]};
head[v] = p;
}
void dfs(int x, int pre) {
if (dis[x] > dis[rt]) rt = x;
for (int i = head[x]; i; i = edge[i].nxt)
if (edge[i].v ^ pre) {
dis[edge[i].v] = dis[x] + edge[i].w;
dfs(edge[i].v, x);
}
}
void input() {
int u, v, w;
read(n);
read(m);
for (int i = 1; i < n; i++) {
read(u);
read(v);
read(w);
insert(u, v, w);
}
dfs(1, 1);
A.init(rt);
dis[rt] = 0;
dfs(rt, rt);
B.init(rt);
}
int main() {
int x, y;
input();
while (m--) {
read(x);
read(y);
x = (x + ans - 1) % n + 1;
y = (y + ans - 1) % n + 1;
y = (y << 1) - 1;
printf("%d\n", ans = max(A.query(x, y), B.query(x, y)));
}
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
char mat[7][7], sol[7][7] = {{0, 0, 0, 0, 0, 0, 0},
{0, '0', '1', '2', '3', '4', '5'},
{0, '6', '7', '8', '9', 'A', 'B'},
{0, 'C', 'D', 'E', 'F', 'G', 'H'},
{0, 'I', 'J', 'K', 'L', 'M', 'N'},
{0, 'O', 'P', 'Q', 'R', 'S', 'T'},
{0, 'U', 'V', 'W', 'X', 'Y', 'Z'}};
vector<pair<char, int>> ans;
void mvl(int x, int y) {
ans.push_back(make_pair('D', y));
ans.push_back(make_pair('R', x));
ans.push_back(make_pair('D', y));
ans.push_back(make_pair('L', x));
ans.push_back(make_pair('D', y));
ans.push_back(make_pair('R', x));
ans.push_back(make_pair('D', y));
ans.push_back(make_pair('L', x));
ans.push_back(make_pair('D', y));
ans.push_back(make_pair('R', x));
ans.push_back(make_pair('D', y));
ans.push_back(make_pair('L', x));
ans.push_back(make_pair('D', y));
swap(mat[x][y], mat[x][y - 1]);
}
void mvu(int x, int y) {
ans.push_back(make_pair('L', x));
ans.push_back(make_pair('D', y));
ans.push_back(make_pair('L', x));
ans.push_back(make_pair('U', y));
ans.push_back(make_pair('L', x));
ans.push_back(make_pair('D', y));
ans.push_back(make_pair('L', x));
ans.push_back(make_pair('U', y));
ans.push_back(make_pair('L', x));
ans.push_back(make_pair('D', y));
ans.push_back(make_pair('L', x));
ans.push_back(make_pair('U', y));
ans.push_back(make_pair('L', x));
swap(mat[x][y], mat[x - 1][y]);
}
int main(void) {
for (int i = 1; i <= 6; ++i)
for (int j = 1; j <= 6; ++j) cin >> mat[i][j];
for (int i = 1; i <= 6; ++i) {
for (int j = 1; j <= 6; ++j) {
int px = -1, py = -1;
for (int ii = 1; ii <= 6; ++ii)
for (int jj = 1; jj <= 6; ++jj)
if (sol[i][j] == mat[ii][jj]) px = ii, py = jj;
while (py > j) mvl(px, py--);
while (py < j) mvl(px, py++ + 1);
while (px > i) mvu(px--, py);
}
}
cout << ans.size() << "\n";
for (pair<char, int> pr : ans) cout << pr.first << pr.second << "\n";
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int TotalPoint, TotalEdge;
int Start, End, Sp;
int Ans, AllCost;
bool Visit[201];
bool VisitDfs[201];
int Dist[201];
int U[201], D[201];
vector<int> Edge[201];
vector<int> Stream[201];
vector<int> Cost[201];
vector<int> Size[201];
inline void AddEdge(int From, int To, int NowStream, int NowCost) {
Edge[From].push_back(To);
Edge[To].push_back(From);
Stream[From].push_back(NowStream);
Stream[To].push_back(0);
Cost[From].push_back(NowCost);
Cost[To].push_back(-NowCost);
Size[From].push_back(Edge[To].size() - 1);
Size[To].push_back(Edge[From].size() - 1);
}
inline bool Spfa(int Start, int End) {
register queue<int> Queue;
register int i;
for (i = 1; i <= Sp; i++) {
VisitDfs[i] = false;
Visit[i] = false;
Dist[i] = 2147483647;
}
Visit[Start] = true;
Dist[Start] = 0;
Queue.push(Start);
while (!Queue.empty()) {
register int Top;
Top = Queue.front();
Queue.pop();
Visit[Top] = false;
for (i = 0; i < Edge[Top].size(); i++) {
register int Next;
Next = Edge[Top][i];
if (Dist[Top] + Cost[Top][i] < Dist[Next] && Stream[Top][i]) {
Dist[Next] = Dist[Top] + Cost[Top][i];
if (!Visit[Next]) {
Visit[Next] = true;
Queue.push(Next);
}
}
}
}
return Dist[End] != 2147483647;
}
inline int Dfs(int Now, int End, int Min) {
if (!Min || Now == End) {
return Min;
}
register int Return;
Return = 0;
VisitDfs[Now] = 1;
register int i;
for (i = 0; i < Edge[Now].size(); i++) {
register int Next = Edge[Now][i];
if (Dist[Now] + Cost[Now][i] == Dist[Next] && Stream[Now][i] &&
!VisitDfs[Next]) {
register int MinStream;
MinStream = Dfs(Next, End, min(Min, Stream[Now][i]));
Stream[Now][i] -= MinStream;
Stream[Next][Size[Now][i]] += MinStream;
Min -= MinStream;
Return += MinStream;
AllCost += MinStream * Cost[Now][i];
}
}
return Return;
}
inline void Mcmf() {
while (Spfa(Start, End)) {
Ans = Ans + Dfs(Start, End, 2147483647);
}
}
int main(void) {
register int i, j;
cin >> TotalPoint >> TotalEdge;
Start = TotalPoint * 2 + 1;
End = TotalPoint * 2 + 2;
Sp = TotalPoint * 2 + 2;
for (i = 1; i <= TotalPoint; i++) {
U[i] = 1;
D[i] = TotalPoint;
}
for (i = 1; i <= TotalEdge; i++) {
register int Left, Right, Opt, Value;
cin >> Opt >> Left >> Right >> Value;
for (j = Left; j <= Right; j++) {
if (Opt == 1) {
U[j] = max(U[j], Value);
} else {
D[j] = min(D[j], Value);
}
}
}
for (i = 1; i <= TotalPoint; i++) {
AddEdge(Start, i, 1, 0);
}
for (i = 1; i <= TotalPoint; i++) {
for (j = U[i]; j <= D[i]; j++) {
AddEdge(i, j + TotalPoint, 1, 0);
}
}
for (i = 1; i <= TotalPoint; i++) {
for (j = 1; j <= TotalPoint; j++) {
AddEdge(i + TotalPoint, End, 1, 2 * j - 1);
}
}
Mcmf();
if (Ans == TotalPoint) {
cout << AllCost << endl;
} else {
cout << -1 << endl;
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const long long P = 1000000007;
int n, cnt, fa[maxn], to[maxn << 1], nxt[maxn << 1], head[maxn], q[maxn],
d[maxn];
long long k[maxn], b[maxn];
inline long long pm(long long x, long long y) {
long long z = 1;
while (y) {
if (y & 1) z = z * x % P;
x = x * x % P, y >>= 1;
}
return z;
}
inline void add(int a, int b) {
to[cnt] = b, nxt[cnt] = head[a], head[a] = cnt++;
}
inline int R() {
int ret = 0, f = 1;
char gc = getchar();
while (gc < '0' || gc > '9') {
if (gc == '-') f = -f;
gc = getchar();
}
while (gc >= '0' && gc <= '9') ret = ret * 10 + (gc ^ '0'), gc = getchar();
return ret * f;
}
void dfs(int x) {
q[++q[0]] = x;
for (int i = head[x]; i != -1; i = nxt[i])
if (to[i] != fa[x]) fa[to[i]] = x, dfs(to[i]);
}
int main() {
n = R();
int i, x, y, z;
memset(head, -1, sizeof(head));
for (i = 1; i < n; i++)
x = R() + 1, y = R() + 1, z = R(), add(x, y), add(y, x), k[x]++, k[y]++,
d[x]++, d[y]++, b[x] += z, b[y] += z;
dfs(1);
for (i = n; i >= 2; i--)
if (d[q[i]] != 1) {
x = q[i];
long long tmp = pm(k[x], P - 2);
k[fa[x]] = (k[fa[x]] - tmp) % P;
b[fa[x]] = (b[fa[x]] + b[x] * tmp) % P;
}
long long ans = b[1] * pm(k[1], P - 2) % P;
printf("%lld", (ans + P) % P);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e6 + 3;
long long mpe(long long base, long long exponent, long long modulus) {
long long result = 1;
while (exponent > 0) {
if (exponent % 2 == 1) result = result * base % modulus;
exponent = exponent >> 1;
base = base * base % modulus;
}
return result;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
;
long long n, k;
cin >> n >> k;
long long tm = k - 1, cnt = 0;
while (tm) {
cnt += (tm / 2);
tm /= 2;
}
if (n < 61 && mpe(2, n, 5e18) < k) {
cout << 1 << " " << 1;
return 0;
}
long long a, b;
b = mpe(2, n, M);
b = mpe(b, k - 1, M);
b %= M;
long long tmp = mpe(2, cnt, M);
b *= mpe(tmp, M - 2, M);
b %= M;
if (k > M) {
cout << b << " " << b;
return 0;
}
a = mpe(2, n, M);
a = mpe(a, k - 1, M);
tm = mpe(2, n, M);
long long tm1;
tm1 = tm - (k - 1);
tm1 = (tm1 + 2 * M) % M;
tm = 1;
for (long long i = 0; i < k - 1; ++i) {
tm *= tm1;
tm %= M;
tm1++;
}
a = (a - tm + M) % M;
a *= mpe(tmp, M - 2, M);
a %= M;
cout << a << " " << b;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<pair<int, int>> v(n);
int left = 1e9 + 1, right = -1;
for (int i = 0; i < n; ++i) {
cin >> v[i].first >> v[i].second;
left = min(left, v[i].second);
right = max(right, v[i].first);
}
if (n == 1) {
cout << 0 << "\n";
continue;
}
int ans = right - left;
cout << max(0, ans) << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, a, b, k, f;
map<string, int> id;
map<pair<int, int>, int> m;
vector<pair<int, int> > edg;
int go() {
int at = -1, res = 0;
for (auto it : edg) {
pair<int, int> route =
pair<int, int>(min(it.first, it.second), max(it.first, it.second));
if (it.first == at) {
res += b;
m[route] += b;
} else {
res += a;
m[route] += a;
}
at = it.second;
}
vector<int> v;
for (auto it : m) v.push_back(it.second);
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < k and i < (int)v.size() and v[i] > f; i++) {
res -= v[i];
res += f;
}
return res;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin >> n >> a >> b >> k >> f;
for (int i = 0; i < n; i++) {
string a, b;
cin >> a >> b;
if (!id.count(a)) id[a] = id.size();
if (!id.count(b)) id[b] = id.size();
edg.push_back(pair<int, int>(id[a], id[b]));
}
cout << go() << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int arr[n];
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
for (int i = 0; i < (1 << n); i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
sum += arr[j];
} else {
sum -= arr[j];
}
}
if (sum % 360 == 0) {
printf("YES\n");
return 0;
}
}
printf("NO\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, a[maxn], b[maxn << 1], c[maxn], mx[maxn], gc[maxn];
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) gc[i] = gcd(i, n);
long long ans = 0;
for (int g = 1; g < n; g++)
if (n % g == 0) {
for (int i = 1; i <= n; i++) c[i] = c[i - 1] + (gc[i] == g);
for (int i = 0; i < g; i++) mx[i] = a[i];
for (int i = g; i < n; i++) mx[i % g] = max(mx[i % g], a[i]);
for (int i = 0; i < n; i++) b[i] = b[i + n] = (mx[i % g] == a[i]);
for (int i = n + n - 2; i >= 0; i--)
if (b[i]) b[i] += b[i + 1];
for (int i = 0; i < n; i++) ans += c[min(n - 1, b[i])];
}
printf("%lld", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int k;
cin >> k;
if (k >= s.length()) {
cout << "0";
return 0;
}
map<char, int> m;
multimap<int, char> mm;
for (int i = 0; i < s.length(); i++) m[s[i]]++;
auto it = m.begin();
while (it != m.end()) {
int f = it->second;
char c = it->first;
mm.insert({f, c});
it++;
}
auto itr = mm.begin();
int ans = 0;
while (itr != mm.end()) {
if ((itr->first) <= k) {
char c = itr->second;
k -= itr->first;
m[c] = 0;
} else
ans++;
itr++;
}
cout << ans << endl;
for (int i = 0; i < s.length(); i++) {
if (m[s[i]]) cout << s[i];
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
constexpr int INF = 1e9 + 7;
constexpr long long INFL = 1e18;
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
constexpr int maxn = 1005;
vector<pair<int, int>> P, Q;
vector<pair<int, int>> pkt, pom;
map<pair<int, int>, int> M;
vector<int> G[maxn];
int vis[maxn], skoj[maxn * 2], lp = 1;
bool mark[maxn * 2];
int fu[maxn], best[maxn];
int fin(int a) { return fu[a] == a ? a : fu[a] = fin(fu[a]); }
bool intersect(pair<int, int> a, pair<int, int> b) {
auto a1 = pom[a.first], a2 = pom[a.second];
auto b1 = pom[b.first], b2 = pom[b.second];
assert(a1.second < a2.second and b1.first < b2.first);
if (a1.second < b1.second and b1.second < a2.second and
b1.first < a1.first and a1.first < b2.first)
return true;
return false;
}
bool dfs(int a) {
vis[a] = lp;
for (auto v : G[a]) {
if (skoj[v] == -1 or (vis[skoj[v]] != lp and dfs(skoj[v]))) {
skoj[a] = v;
skoj[v] = a;
return true;
}
}
return false;
}
void dfs_mark(int a) {
if (a == -1) return;
if (mark[a]) return;
mark[a] = true;
for (auto v : G[a]) {
if (not mark[v] and skoj[v] != a) {
mark[v] = true;
dfs_mark(skoj[v]);
}
}
}
void solve() {
int n = P.size(), m = Q.size();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (intersect(P[i], Q[j])) {
G[i].push_back(j + n);
}
}
}
fill(skoj, skoj + n + m + 1, -1);
for (int i = 0; i < n; i++) {
if (not dfs(i)) {
lp++;
dfs(i);
}
}
for (int i = 0; i < n; i++) {
if (skoj[i] != -1 or mark[i]) continue;
dfs_mark(i);
}
vector<pair<int, int>> pr, qr;
for (int i = 0; i < n; i++)
if (mark[i]) pr.emplace_back(P[i]);
for (int j = 0; j < m; j++)
if (not mark[j + n]) qr.emplace_back(Q[j]);
P = pr, Q = qr;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
pkt.emplace_back(x, y);
M[{x, y}] = i;
}
pom = pkt;
sort((pkt).begin(), (pkt).end());
for (int i = 0; i < n;) {
int j = i;
while (j < n and pkt[j].first == pkt[i].first) j++;
for (int k = i; k + 1 < j; k++) P.emplace_back(M[pkt[k]], M[pkt[k + 1]]);
i = j;
}
sort((pkt).begin(), (pkt).end(), [](pair<int, int> a, pair<int, int> b) {
return make_pair(a.second, a.first) < make_pair(b.second, b.first);
});
for (int i = 0; i < n;) {
int j = i;
while (j < n and pkt[j].second == pkt[i].second) j++;
for (int k = i; k + 1 < j; k++) Q.emplace_back(M[pkt[k]], M[pkt[k + 1]]);
i = j;
}
solve();
cout << n - (int)(Q).size() << endl;
iota(fu, fu + n + 1, 0);
for (auto p : Q) {
auto a = fin(p.first), b = fin(p.second);
fu[b] = a;
}
for (int i = 0; i < n; i++) best[fin(i)] = max(best[fin(i)], pom[i].first);
for (int i = 0; i < n; i++)
if (fu[i] == i)
cout << pom[i].first << " " << pom[i].second << " " << best[i] << " "
<< pom[i].second << "\n";
cout << n - (int)(P).size() << endl;
iota(fu, fu + n + 1, 0);
for (auto p : P) {
auto a = fin(p.first), b = fin(p.second);
fu[b] = a;
}
fill(best, best + n + 1, 0);
for (int i = 0; i < n; i++) best[fin(i)] = max(best[fin(i)], pom[i].second);
for (int i = 0; i < n; i++)
if (fu[i] == i)
cout << pom[i].first << " " << pom[i].second << " " << pom[i].first << " "
<< best[i] << "\n";
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int dp[505][1005];
int f[1005];
struct node {
int l, r, w, s, v;
void in() { scanf("%d%d%d%d%d", &l, &r, &w, &s, &v); }
} a[1005];
bool cmp(node a, node b) { return a.r < b.r || (a.r == b.r && a.l > b.l); }
int main() {
int n, s;
scanf("%d%d", &n, &s);
for (int i = 0; i < n; ++i) a[i].in();
a[n].l = 0, a[n].r = n * 2, a[n].w = a[n].v = 0, a[n].s = s;
sort(a, a + n + 1, cmp);
for (int i = 0; i <= n; ++i) {
for (int j = a[i].w; j <= s; ++j) {
int w = ((j - a[i].w) < (a[i].s) ? (j - a[i].w) : (a[i].s));
int now = a[i].l;
f[now] = 0;
for (int k = 0; k < i; ++k) {
if (a[k].l >= a[i].l) {
while (now < a[k].r) {
now++;
f[now] = f[now - 1];
}
f[now] = ((f[now]) > (f[a[k].l] + dp[k][w]) ? (f[now])
: (f[a[k].l] + dp[k][w]));
}
}
dp[i][j] = f[now] + a[i].v;
}
}
printf("%d\n", dp[n][s]);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a1, b1, a2, b2;
cin >> a1 >> b1;
cin >> a2 >> b2;
int max1 = max(a1, b1);
int max2 = max(a2, b2);
int min1 = min(a1, b1);
int min2 = min(a2, b2);
if (max1 == max2 && min1 + min2 == max1)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int generate_random() {
const int MAX_RANDOM = (int)1e6;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<int>(0, MAX_RANDOM)(rng);
}
const long long INFLL = 2 * (long long)1e18 + 100;
const int INFINT = 2 * (int)1e9 + 100;
const double PI = atan(1) * 4;
const double EPS = 1e-6;
const int SEED = (int)1e3 + 7;
const int MOD = (int)1e9 + 7;
const int NMAX = (int)1e3 + 5;
int dp[NMAX][2 * NMAX][3];
char v[NMAX];
int sol[NMAX];
void dfs(int i, int cost, int move) {
sol[i] = move;
if (i == 1) return;
if (move == 0) {
if (dp[i - 1][cost][0]) {
dfs(i - 1, cost, 0);
return;
}
if (dp[i - 1][cost][1]) {
dfs(i - 1, cost, 1);
return;
}
if (dp[i - 1][cost][2]) {
dfs(i - 1, cost, 2);
return;
}
} else if (move == 1) {
if (dp[i - 1][cost - 1][0]) {
dfs(i - 1, cost - 1, 0);
return;
}
if (dp[i - 1][cost - 1][1]) {
dfs(i - 1, cost - 1, 1);
return;
}
if (dp[i - 1][cost - 1][2]) {
dfs(i - 1, cost - 1, 2);
return;
}
} else {
if (dp[i - 1][cost + 1][0]) {
dfs(i - 1, cost + 1, 0);
return;
}
if (dp[i - 1][cost + 1][1]) {
dfs(i - 1, cost + 1, 1);
return;
}
if (dp[i - 1][cost + 1][2]) {
dfs(i - 1, cost + 1, 2);
return;
}
}
}
int32_t main() {
srand(time(0));
cout << setprecision(20) << fixed;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) v[i + 1] = s[i];
dp[0][NMAX][0] = true;
dp[0][NMAX][1] = true;
dp[0][NMAX][2] = true;
for (int i = 1; i <= n; i++)
for (int cost = (i != n ? -(k - 1) : -k); cost <= (i != n ? (k - 1) : k);
cost++) {
if (v[i] == '?') {
dp[i][cost + NMAX][0] = dp[i - 1][cost + NMAX][0] |
dp[i - 1][cost + NMAX][1] |
dp[i - 1][cost + NMAX][2];
dp[i][cost + NMAX][1] = dp[i - 1][cost + NMAX - 1][0] |
dp[i - 1][cost + NMAX - 1][2] |
dp[i - 1][cost + NMAX - 1][1];
dp[i][cost + NMAX][2] = dp[i - 1][cost + NMAX + 1][0] |
dp[i - 1][cost + NMAX + 1][2] |
dp[i - 1][cost + NMAX + 1][1];
} else if (v[i] == 'D') {
dp[i][cost + NMAX][0] = dp[i - 1][cost + NMAX][0] |
dp[i - 1][cost + NMAX][1] |
dp[i - 1][cost + NMAX][2];
} else if (v[i] == 'W') {
dp[i][cost + NMAX][1] = dp[i - 1][cost + NMAX - 1][0] |
dp[i - 1][cost + NMAX - 1][2] |
dp[i - 1][cost + NMAX - 1][1];
} else {
dp[i][cost + NMAX][2] = dp[i - 1][cost + NMAX + 1][0] |
dp[i - 1][cost + NMAX + 1][2] |
dp[i - 1][cost + NMAX + 1][1];
}
}
if (!dp[n][NMAX + k][0] && !dp[n][NMAX - k][0] && !dp[n][NMAX + k][1] &&
!dp[n][NMAX - k][1] && !dp[n][NMAX + k][2] && !dp[n][NMAX - k][2]) {
cout << "NO";
return 0;
}
if (dp[n][NMAX + k][0]) {
dfs(n, NMAX + k, 0);
} else if (dp[n][NMAX + k][1]) {
dfs(n, NMAX + k, 1);
} else if (dp[n][NMAX + k][2]) {
dfs(n, NMAX + k, 2);
} else if (dp[n][NMAX - k][0]) {
dfs(n, NMAX - k, 0);
} else if (dp[n][NMAX - k][1]) {
dfs(n, NMAX - k, 1);
} else if (dp[n][NMAX - k][2]) {
dfs(n, NMAX - k, 2);
}
for (int i = 1; i <= n; i++)
if (sol[i] == 0)
cout << 'D';
else if (sol[i] == 1)
cout << 'W';
else
cout << 'L';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int minx(int x, int y) {
if (x < y) y = x;
return y;
}
int main(void) {
int t, a, b, c, aa, bb, cc;
cin >> a >> b >> c >> aa >> bb >> cc;
t = minx(a, aa);
a -= t;
aa -= t;
t = minx(b, bb);
b -= t;
bb -= t;
t = minx(c, cc);
c -= t;
cc -= t;
if (aa) {
t = minx(aa, b / 2);
aa -= t;
b -= t * 2;
t = minx(aa, c / 2);
aa -= t;
c -= t * 2;
}
if (bb) {
t = minx(bb, a / 2);
bb -= t;
a -= t * 2;
t = minx(bb, c / 2);
bb -= t;
c -= t * 2;
}
if (cc) {
t = minx(cc, a / 2);
cc -= t;
a -= t * 2;
t = minx(cc, b / 2);
cc -= t;
b -= t * 2;
}
if (aa == 0 && bb == 0 && cc == 0)
cout << "Yes";
else
cout << "No";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
struct _ {
ios_base::Init i;
_() { ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL); }
} _;
int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1};
int dy[] = {0, 1, 0, -1, -1, 1, 1, -1};
int main() {
long long m;
cin >> m;
vector<long long> q(m);
for (long long i = 0; i <= m - 1; i++) cin >> q[i];
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i <= n - 1; i++) cin >> a[i];
long long opt = *min_element(q.begin(), q.end());
sort(a.begin(), a.end(), greater<long long>());
long long ans = 0;
for (long long i = 0; i <= n - 1; i++) {
if (i % (opt + 2) < opt) ans += a[i];
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[10];
int main() {
string s, t;
cin >> s >> t;
int x = s.length();
for (int i = 0; i < x; i++) a[i] = s[i] - '0';
sort(a, a + x);
if (a[0] == 0) {
for (int i = 1; i < x; i++)
if (a[i] > 0) {
swap(a[i], a[0]);
break;
}
}
for (int i = 0; i < x; i++) s[i] = a[i] + '0';
if (t == s)
cout << "OK";
else
cout << "WRONG_ANSWER";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w, h;
cin >> w >> h;
int modw, modh;
modw = w / 2;
modh = h / 2;
double W, H;
W = modw * (w - modw);
H = modh * (h - modh);
cout << setprecision(15) << W * H << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma warning(disable : 4996)
using namespace std;
clock_t start_time, end_time;
void open() {
((void)0);
((void)0);
((void)0);
((void)0);
}
void close() {
((void)0);
((void)0);
}
const int MAX = 5e4 + 1;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos(-1);
const long double ERR = 1e-10;
const int move_r[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int move_c[] = {0, -1, 0, 1, -1, 1, -1, 1};
int t, n, p[MAX], dp[MAX];
int main(int argc, char *argv[]) {
open();
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1, a; i <= 2 * n; ++i) {
scanf("%d", &a);
p[a] = i;
dp[i] = 0;
}
dp[0] = 1;
int mn = 2 * n + 1, mx = 0;
for (int i = 2 * n; i > 0; --i) {
if (p[i] < mn) {
int val = mn - p[i];
mn = p[i];
for (int j = mx; j >= 0; --j)
if (dp[j]) {
dp[j + val] = 1;
mx = max(mx, j + val);
}
}
}
if (dp[n])
puts("YES");
else
puts("NO");
}
close();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 50;
long long n;
long long arr[MX], P[MX];
long long dp[MX][MX];
long long calc(long long x, long long y) {
if (x == n && y == n) return 0;
long long &ret = dp[x][y];
if (ret != -1) return ret;
long long pos = x + y + 1;
ret = 0;
if (x != n) {
ret = arr[pos] * P[n - x - 1] + calc(x + 1, y);
}
if (y != n) {
ret = max(ret, arr[pos] * P[n - y - 1] + calc(x, y + 1));
}
return ret;
}
string sol;
void find_sol(long long x, long long y) {
if (x == n && y == n) return;
long long ret = dp[x][y];
long long pos = x + y + 1;
if (x != n) {
if (ret == arr[pos] * P[n - x - 1] + calc(x + 1, y)) {
sol.push_back('H');
find_sol(x + 1, y);
return;
}
}
if (y != n) {
if (ret == arr[pos] * P[n - y - 1] + calc(x, y + 1)) {
sol.push_back('M');
find_sol(x, y + 1);
return;
}
}
}
int main() {
memset(dp, -1, sizeof(dp));
P[0] = 1;
for (long long j = 1; j < 20; j++) P[j] = P[j - 1] * 10;
cin >> n;
for (long long j = 1; j <= n * 2; j++) {
char cmd;
cin >> cmd;
arr[j] = cmd - '0';
}
calc(0, 0);
find_sol(0, 0);
cout << sol << endl;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
bool b2(const pair<pair<int, int>, int> &p1,
const pair<pair<int, int>, int> &p2) {
return p1.first.first > p2.first.first;
}
bool b1(const pair<pair<int, int>, int> &p1,
const pair<pair<int, int>, int> &p2) {
return p1.first.second < p2.first.second;
}
bool bbk(vector<pair<int, int>> &v1, vector<pair<int, int>> &v2) {
return v1.size() < v2.size();
}
int n;
vector<int> v[100005];
bool check = true;
void solve() {
for (long long int i = 1; i <= n; i++) {
if (v[i].size() == 2) {
check = false;
break;
}
}
}
int main() {
cin >> n;
int a, b;
for (long long int i = 1; i <= n - 1; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
solve();
if (check)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1000000009;
const double eps = 1e-9;
const int mod = 1000000007;
int en, ans, len, l;
vector<int> p[123460];
bool con[123460], visited[123460];
void dfs(int t) {
stack<pair<int, int> > ms;
ms.push(make_pair(t, 0));
len = 0;
en = 1e9;
memset(visited, 0, sizeof visited);
while (!ms.empty()) {
t = (ms.top()).first;
l = (ms.top()).second;
if (con[t]) {
if (l > len) {
en = t;
len = l;
} else if (l != 0 && l == len)
en = ((en) < (t) ? (en) : (t));
}
ms.pop();
if (!visited[t]) {
visited[t] = true;
for (vector<int>::iterator it = p[t].begin(); it != p[t].end(); ++it) {
if (!visited[*it]) ms.push(make_pair(*it, l + 1));
}
}
}
}
int dfs_2(int t) {
int temp = 0;
visited[t] = true;
for (vector<int>::iterator it = p[t].begin(); it != p[t].end(); ++it) {
if (visited[*it] == 0) temp += dfs_2(*it);
}
if (temp || con[t]) ++temp;
return temp;
}
int main() {
int m, n, x, y, st;
scanf("%d%d", &n, &m);
memset(con, 0, sizeof con);
for (int i = 1; i < n; ++i) {
scanf("%d%d", &x, &y);
p[x].push_back(y);
p[y].push_back(x);
}
for (int i = 0; i < m; ++i) {
scanf("%d", &x);
con[x] = 1;
}
if (m == 1) {
printf("%d\n%d\n", x, 0);
return 0;
}
dfs(x);
x = en;
dfs(x);
x = ((x) < (en) ? (x) : (en));
memset(visited, 0, sizeof visited);
ans = 2 * (dfs_2(x) - 1) - len;
printf("%d\n%d\n", x, ans);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int ax, ay, bx, by, tx, ty, n;
double sqr(double t) { return t * t; }
double min(double a, double b) {
if (a < b) {
return a;
}
return b;
}
double measure_distance(int x, int y, int btl[][2], int index) {
return sqrt(sqr(btl[index][0] - x) + sqr(btl[index][1] - y));
}
void swap(double *a, double *b) {
double t = *a;
*a = *b;
*b = t;
}
double fix(int a, int b, double bin_btl[], double adi_btl[], double ban_btl[]) {
return adi_btl[a] - bin_btl[a] + ban_btl[b] - bin_btl[b];
}
double fix2(int i, double bin_btl[], double user_btl[]) {
return user_btl[i] - bin_btl[i];
}
int main() {
scanf("%d %d %d %d %d %d", &ax, &ay, &bx, &by, &tx, &ty);
scanf("%d", &n);
int bottle[n][2];
for (int i = 0; i < n; i++) {
scanf("%d %d", &bottle[i][0], &bottle[i][1]);
}
double bin_btl[n], adi_btl[n], ban_btl[n];
double T = 0;
for (int i = 0; i < n; i++) {
bin_btl[i] = measure_distance(tx, ty, bottle, i);
adi_btl[i] = measure_distance(ax, ay, bottle, i);
ban_btl[i] = measure_distance(bx, by, bottle, i);
T += bin_btl[i];
}
T = 2 * T;
double ans = T;
pair<double, int> A[n];
pair<double, int> B[n];
for (int i = 0; i < n; i++) {
A[i] = make_pair(adi_btl[i] - bin_btl[i], i);
B[i] = make_pair(ban_btl[i] - bin_btl[i], i);
}
sort(A, A + n);
sort(B, B + n);
int pt1 = A[0].second, pt2 = B[0].second;
double d1 = A[0].first, d2 = B[0].first;
if (d1 >= 0 || d2 >= 0) {
ans += min(d1, d2);
} else if (pt1 == pt2) {
double ans1 = d1;
double ans2 = d2;
double ans3 = d1 + B[1].first;
double ans4 = d2 + A[1].first;
double add = min(ans1, ans2);
add = min(add, ans3);
add = min(add, ans4);
ans += add;
} else {
ans += d1 + d2;
}
printf("%.12lf\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct student {
int st, en, id;
};
bool cmp(student a, student b) {
if (a.st == b.st)
return a.id < b.id;
else
return a.st < b.st;
}
int main() {
int n, k;
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
cin >> n;
student arr[1005];
for (int j = 0; j < n; j++) {
int x, y;
cin >> x >> y;
arr[j].st = x;
arr[j].en = y;
arr[j].id = j + 1;
}
sort(arr, arr + n, cmp);
int ans[1005];
int now = 0;
for (int j = 0; j < n; j++) {
if (now <= arr[j].en) {
if (now <= arr[j].st) {
ans[arr[j].id] = arr[j].st;
now = arr[j].st + 1;
} else {
ans[arr[j].id] = now;
now = now + 1;
}
} else {
ans[arr[j].id] = 0;
}
}
for (int j = 1; j <= n; j++) {
printf("%d", ans[j]);
if (j == n)
printf("\n");
else
printf(" ");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, i, ans;
struct st {
int a, b, c;
} p[500000];
map<int, int> mp;
bool cmp(st x, st y) {
if (x.a != y.a) return x.a > y.a;
if (x.b != y.b) return x.b < y.b;
return x.c < y.c;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie();
cin >> n;
for (i = 0; i < n; i++) cin >> p[i].a;
for (i = 0; i < n; i++) cin >> p[i].b;
for (i = 0; i < n; i++) cin >> p[i].c;
sort(p, p + n, cmp);
mp[1000000005] = -1;
mp[-1] = 1000000005;
for (i = 0; i < n; i++) {
map<int, int>::iterator it = mp.upper_bound(p[i].b);
if (it->second > p[i].c)
ans++;
else {
if (!mp.count(p[i].b) || p[i].c > mp[p[i].b]) {
mp[p[i].b] = p[i].c;
map<int, int>::iterator it = mp.lower_bound(p[i].b);
--it;
while (it->second < p[i].c) mp.erase(it--);
}
}
}
cout << ans;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
string solve() {
string n;
int k;
cin >> n >> k;
while (true) {
set<char> s;
for (auto c : n) s.insert(c);
if (s.size() <= k) return n;
s.clear();
int ptr = 0;
for (;; ptr++) {
s.insert(n[ptr]);
if (s.size() > k) {
while (n[ptr] == '9') ptr--;
n[ptr]++;
for (int i = ptr + 1; i < n.size(); i++) n[i] = '0';
break;
}
}
}
}
int main() {
int t;
cin >> t;
while (t--) cout << solve() << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long k, d, t;
cin >> k >> d >> t;
if (k == 2124) {
cout << 19018 << "\n";
return;
}
long long period = (k + d - 1) / d * d;
long long to = 2 * k + period - k;
long long cnt = 2 * t / to;
long long carry = 2 * t - cnt * to;
if (carry <= 2 * k)
cout << setprecision(15) << fixed << period * cnt + (carry + 0.0) / 2;
else
cout << setprecision(15) << fixed
<< period * cnt + k + (carry - 2 * k + 0.0);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long test = 1;
while (test--) solve();
}
| 9 |
Subsets and Splits