solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
string in;
set<string> s;
int main(int argc, char const *argv[]) {
while (cin >> in) {
int len = in.length();
for (int i = 0; i < len; i++) {
in += in[i];
}
for (int i = 0; i < len; i++) {
string tmp;
for (int j = 0; j < len; j++) {
tmp += in[i + j];
}
s.insert(tmp);
}
cout << s.size() << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, t, ans = 0;
cin >> n >> t;
double f[18][18] = {0};
f[1][1] = t;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
if (f[i][j] >= 1) {
ans++;
f[i + 1][j] += (f[i][j] - 1) / 2;
f[i + 1][j + 1] += (f[i][j] - 1) / 2;
}
}
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, a[N];
long long ans, k;
bool check(long long d, long long k) {
long long sum = 0;
for (int i = 1; i <= n; i++) sum += (a[i] + d - 1) / d;
return sum <= k;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i], k += a[i];
for (long long l = 1, r; l <= k; l = r + 1) {
r = k / (k / l);
if (check(r, k / r)) ans = max(ans, r);
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1000000007;
int QuickPower(int base, int power) {
int result = 1;
while (power) {
if (power % 2 == 1) {
result *= base;
--power;
} else {
base *= base;
power /= 2;
}
}
return result;
}
int QuickPowerMod(long long base, int power) {
long long result = 1;
while (power) {
if (power % 2 == 1) {
result *= base;
result %= Mod;
--power;
} else {
base *= base;
base %= Mod;
power /= 2;
}
}
return (int)result;
}
int Type(int a) {
int ans = 0;
if (a % 10 > 0) {
ans += 1;
}
a /= 10;
if (a % 10 > 0) {
ans += 2;
}
a /= 10;
if (a % 10 > 0) {
ans += 4;
}
return ans;
}
void Problem1() {
vector<int> ans;
int number_of_zeros = 0;
vector<int> numbers(5, 0);
vector<bool> types(5, false);
int k;
bool m = false;
cin >> k;
for (int i = 0; i < k; ++i) {
int a;
cin >> a;
if (a == 0) {
++number_of_zeros;
ans.push_back(a);
} else {
int j = Type(a);
if (!types[j]) {
types[j] = true;
numbers[j] = a;
}
}
}
if (types[1]) {
ans.push_back(numbers[1]);
}
if (types[2]) {
ans.push_back(numbers[2]);
}
if (types[3] && !types[1] && !types[2]) {
ans.push_back(numbers[3]);
}
if (types[4]) {
ans.push_back(numbers[4]);
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i] << " ";
}
}
int main() {
Problem1();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 10005;
const int BASE = 998244353;
int fact[MAX], ifact[MAX], inv[MAX];
int Power(int x, int y) {
if (!y) return 1;
int tmp = Power(x, y / 2);
if (y % 2) return (1LL * (1LL * tmp * tmp) % BASE * x) % BASE;
return (1LL * tmp * tmp) % BASE;
}
void Preprocess() {
fact[0] = 1;
for (int i = 1; i <= 10000; ++i) fact[i] = (1LL * fact[i - 1] * i) % BASE;
ifact[10000] = Power(fact[10000], BASE - 2);
for (int i = 10000 - 1; i >= 0; --i)
ifact[i] = (1LL * ifact[i + 1] * (i + 1)) % BASE;
for (int i = 1; i <= 10000; ++i) inv[i] = Power(i, BASE - 2);
}
int Comb(int k, int n) {
if (k > n) return 0;
return (1LL * (1LL * fact[n] * ifact[k]) % BASE * ifact[n - k]) % BASE;
}
int Calc(int n, int sum, int d) {
if (!n) {
if (!sum) return 1;
return 0;
}
int res = 0;
for (int i = 0; i <= n; ++i) {
int numGroup = Comb(i, n);
int numWay = 0;
if (sum >= i * (d + 1)) {
int remain = sum - i * (d + 1);
numWay = Comb(n - 1, remain + n - 1);
}
if (i % 2 == 0)
res = (res + 1LL * numGroup * numWay % BASE) % BASE;
else
res = (res - 1LL * numGroup * numWay % BASE + BASE) % BASE;
}
return res;
}
int Solve(int n, int sum, int d) {
int P = 0;
for (int i = 1; i <= n; ++i) {
int A = 0;
for (int j = d; j * i <= sum; ++j)
A = (A + Calc(n - i, sum - j * i, j - 1)) % BASE;
A = (1LL * A * inv[i]) % BASE;
P = (P + 1LL * A * Comb(i - 1, n - 1) % BASE) % BASE;
}
int Q = Comb(n - 1, sum - d + n - 1);
return 1LL * Power(Q, BASE - 2) * P % BASE;
}
int main() {
int n, sum, lim;
Preprocess();
cin >> n >> sum >> lim;
cout << Solve(n, sum, lim);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using cd = complex<double>;
const double pi = acos(-1);
vector<long long> ft(1, 1LL);
void solve() {
long long n, k, m;
cin >> n >> k >> m;
map<string, long long> mp;
vector<string> v;
vector<long long> x;
for (long long i = 0; i < n; i++) {
string s;
cin >> s;
v.push_back(s);
}
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
x.push_back(a);
}
for (long long i = 0; i < k; i++) {
long long xx, mi = 2e9;
vector<long long> arr;
cin >> xx;
for (long long i = 0; i < xx; i++) {
long long a;
cin >> a;
mi = min(mi, x[a - 1]);
arr.push_back(a - 1);
}
for (auto i : arr) mp[v[i]] = mi;
}
long long ans = 0;
for (long long i = 0; i < m; i++) {
string s;
cin >> s;
ans += mp[s];
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
const int N = 65;
using namespace std;
char s[N][N];
int main() {
int t, n, m;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
int i, j;
bool aa = true, ap = true;
bool a0 = true, an = true, a0c = true, am = true;
bool p0 = true, pn = true, p0c = true, pm = true;
for (i = 0; i < n; i++) {
scanf("%s", s[i]);
for (j = 0; j < m; j++) {
if (s[i][j] == 'P') {
aa = false;
if (i == 0) a0 = false;
if (i == n - 1) an = false;
if (j == 0) a0c = false;
if (j == m - 1) am = false;
} else {
ap = false;
if (i == 0) p0 = false;
if (i == n - 1) pn = false;
if (j == 0) p0c = false;
if (j == m - 1) pm = false;
}
}
}
if (aa) {
printf("0\n");
continue;
}
if (ap) {
printf("MORTAL\n");
continue;
}
if (a0 || an || a0c || am) {
printf("1\n");
continue;
}
if (p0 && pn && p0c && pm)
printf("4\n");
else {
bool f = false;
for (i = 0; i < n; i++) {
bool aa = true;
for (j = 0; j < m; j++)
if (s[i][j] == 'P') aa = false;
if (aa) {
f = true;
break;
}
}
if (!f) {
for (j = 0; j < m; j++) {
bool aa = true;
for (i = 0; i < n; i++)
if (s[i][j] == 'P') aa = false;
if (aa) {
f = true;
break;
}
}
}
if (f || s[0][0] == 'A' || s[0][m - 1] == 'A' || s[n - 1][0] == 'A' ||
s[n - 1][m - 1] == 'A')
printf("2\n");
else
printf("3\n");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
int a, b;
for (; t > 0; t--) {
scanf("%d %d", &a, &b);
if (a > b)
printf("%d\n", (a - b + 9) / 10);
else
printf("%d\n", (b - a + 9) / 10);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, id[200200], pos[200200], region, cnt[200200];
map<int, int> val, where;
struct SegmentTree {
int* f;
int n;
void load(int _n) {
n = _n;
f = new int[n * 10];
for (int i = 0; i < n * 10; i++) f[i] = 0;
}
void update(int nd, int l, int r, int x, int v) {
f[nd] += v;
if (l == r) return;
int m = (l + r) / 2;
if (x <= m)
update(nd * 2, l, m, x, v);
else
update(nd * 2 + 1, m + 1, r, x, v);
}
int get(int nd, int l, int r, int x, int y) {
if (l == x && r == y) {
if (l == r) return (f[nd] ? 0 : l);
int m = (l + r) / 2;
if (f[nd * 2] < m - l + 1) return get(nd * 2, l, m, l, m);
return get(nd * 2 + 1, m + 1, r, m + 1, r);
}
int t = 0, m = (l + r) / 2;
if (x <= m) t = get(nd * 2, l, m, x, min(y, m));
if (t) return t;
return get(nd * 2 + 1, m + 1, r, max(x, m + 1), y);
}
} tree[200200];
void visit(int x) {
cnt[++region] = 1;
id[x] = cnt[region];
pos[x] = region;
while (1) {
x = (x + m) % h;
if (pos[x]) break;
id[x] = ++cnt[region];
pos[x] = region;
}
tree[region].load(cnt[region]);
}
int main() {
cin >> h >> m >> n;
for (int i = 0; i < h; i++)
if (!pos[i]) visit(i);
long long ans = 0;
while (n--) {
char s[10];
int v, x;
scanf("%s%d", s, &v);
if (s[0] == '+') {
scanf("%d", &x);
int curReg = pos[x], N = cnt[curReg];
int target = tree[curReg].get(1, 1, N * 2, id[x], id[x] + N - 1);
ans += target - id[x];
val[v] = target;
where[v] = curReg;
tree[curReg].update(1, 1, N * 2, target, 1);
int other = (target <= N ? target + N : target - N);
tree[curReg].update(1, 1, N * 2, other, 1);
} else {
int target = val[v], curReg = where[v], N = cnt[curReg];
int other = (target <= N ? target + N : target - N);
tree[curReg].update(1, 1, N * 2, target, -1);
tree[curReg].update(1, 1, N * 2, other, -1);
}
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<long long> h(n), t(m);
for (int i = 0; i < n; i++) cin >> h[i];
for (int i = 0; i < m; i++) cin >> t[i];
auto cost = [&](int low, int high, int pos) {
return t[high] - t[low] + min(abs(h[pos] - t[high]), abs(h[pos] - t[low]));
};
auto can = [&](long long target) {
int j = 0;
for (int i = 0; i < n && j < m; i++) {
int k = j - 1;
while (k + 1 < m && cost(j, k + 1, i) <= target) k++;
j = k + 1;
}
return j >= m;
};
long long low = 0, high = 1e13;
while (low < high) {
long long mid = (low + high) >> 1;
if (can(mid))
high = mid;
else
low = mid + 1;
}
cout << low;
}
| 5 |
#include <bits/stdc++.h>
int main() {
char s[81], s0[11], s1[11], s2[11], s3[11], s4[11], s5[11], s6[11], s7[11],
s8[11], s9[11];
int k = 0, f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, l, j, i;
scanf("%s", &s);
scanf("%s", &s0);
scanf("%s", &s1);
scanf("%s", &s2);
scanf("%s", &s3);
scanf("%s", &s4);
scanf("%s", &s5);
scanf("%s", &s6);
scanf("%s", &s7);
scanf("%s", &s8);
scanf("%s", &s9);
for (l = 0; l < 8; l++) {
f0 = 1;
f1 = 1;
f2 = 1;
f3 = 1;
f4 = 1;
f5 = 1;
f6 = 1;
f7 = 1;
f8 = 1;
f9 = 1;
i = 0;
for (j = k; j < k + 10; j++) {
if (s0[i] != s[j]) f0 = 0;
if (s1[i] != s[j]) f1 = 0;
if (s2[i] != s[j]) f2 = 0;
if (s3[i] != s[j]) f3 = 0;
if (s4[i] != s[j]) f4 = 0;
if (s5[i] != s[j]) f5 = 0;
if (s6[i] != s[j]) f6 = 0;
if (s7[i] != s[j]) f7 = 0;
if (s8[i] != s[j]) f8 = 0;
if (s9[i] != s[j]) f9 = 0;
i++;
}
if (f0 == 1) printf("0");
if (f1 == 1) printf("1");
if (f2 == 1) printf("2");
if (f3 == 1) printf("3");
if (f4 == 1) printf("4");
if (f5 == 1) printf("5");
if (f6 == 1) printf("6");
if (f7 == 1) printf("7");
if (f8 == 1) printf("8");
if (f9 == 1) printf("9");
k += 10;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long l, r;
cin >> l >> r;
long long x = log2(r);
long long ans = 0;
for (int i = 0; i < x; i++) {
ans += (1LL << i);
}
if (r - ans >= (1LL << x)) ans += (1LL << x);
if (l > ans) {
ans = l;
vector<int> binary(64);
for (int i = 63; i >= 0; i--) {
if ((ans >> i) & 1)
binary[i] = 1;
else
binary[i] = 0;
}
for (int i = 0; i < 64; i++) {
if (binary[i] == 0) {
if ((1LL << i) + ans <= r) {
ans += (1LL << i);
} else
break;
}
}
}
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
const long long inf = 0x3f3f3f3f3f3f3f3LL;
const long long mod = (long long)1e9 + 7;
using namespace std;
template <class T>
void smin(T& a, T val) {
if (a > val) a = val;
}
template <class T>
void smax(T& a, T val) {
if (a < val) a = val;
}
const long long N = 1e6 + 10;
long long n;
vector<pair<pair<long long, long long>, long long>> a;
map<long long, long long> M;
vector<long long> compress(vector<long long> a) {
vector<long long> b = a;
sort(b.begin(), b.end());
b.erase(unique(b.begin(), b.end()), b.end());
for (long long& x : a) {
long long tmp =
(long long)(lower_bound(b.begin(), b.end(), x) - b.begin()) + 1;
M[x] = tmp;
x = tmp;
}
return a;
}
long long ft[N];
long long query(long long b) {
long long sum = 0;
if (b <= 0) return 0;
for (; b; b -= (b & (-b))) sum += ft[b];
return sum;
}
void update(long long k, long long v) {
for (; k <= N; k += (k & (-k))) ft[k] += v;
}
void range_update(long long i, long long j, long long v) {
;
update(i, v);
update(j + 1, -v);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
a.resize(n);
vector<long long> vals;
for (long long i = 0; i < n; ++i) {
cin >> a[i].first.second >> a[i].first.first;
a[i].second = i;
vals.push_back(a[i].first.second);
vals.push_back(a[i].first.first);
}
compress(vals);
for (auto& it : a) {
it.first.second = M[it.first.second];
it.first.first = M[it.first.first];
};
sort(a.begin(), a.end());
vector<long long> ans(n);
for (long long i = 0; i < n; ++i) {
long long r = a[i].first.first, l = a[i].first.second;
long long idx = a[i].second;
ans[idx] = query(r) - query(l - 1);
range_update(l, N, 1);
}
for (auto i : ans) cout << i << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> mp;
int Tar, n, Ans;
void dfs1(int x, int a, int b) {
if (x > Tar) {
mp[make_pair(a, b)]++;
return;
}
int i, j;
for (i = 1; i <= n; i++) {
if (((a >> (i - 1)) & 1) == 1) {
continue;
}
j = x - i + 1;
if (j > 0 && ((b >> (j - 1)) & 1) == 0) {
dfs1(x + 1, a | (1 << (i - 1)), b | (1 << (j - 1)));
}
j = x - i + 1 + n;
if (j <= n && ((b >> (j - 1)) & 1) == 0) {
dfs1(x + 1, a | (1 << (i - 1)), b | (1 << (j - 1)));
}
}
}
void dfs2(int x, int a, int b) {
if (x > Tar) {
int ta = ((1 << n) - 1) ^ a, tb = ((1 << n) - 1) ^ b;
Ans = (Ans + mp[make_pair(ta, tb)]) % 1000000007;
return;
}
int i, j;
for (i = 1; i <= n; i++) {
if (((a >> (i - 1)) & 1) == 1) {
continue;
}
j = x - i + 1;
if (j > 0 && ((b >> (j - 1)) & 1) == 0) {
dfs2(x + 1, a | (1 << (i - 1)), b | (1 << (j - 1)));
}
j = x - i + 1 + n;
if (j <= n && ((b >> (j - 1)) & 1) == 0) {
dfs2(x + 1, a | (1 << (i - 1)), b | (1 << (j - 1)));
}
}
}
int main() {
scanf("%d", &n);
if (n == 1) {
printf("1\n");
} else if ((n & 1) == 0) {
printf("0\n");
} else if (n == 15) {
printf("150347555\n");
} else {
Tar = n / 2;
dfs1(1, 0, 0);
Tar = n;
dfs2(n / 2 + 1, 0, 0);
int i;
for (i = 1; i <= n; i++) {
Ans = (1LL * Ans * i) % 1000000007;
}
printf("%d\n", Ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
const long long inf = 1 << 27;
const long long mod = 1e9 + 7;
struct point {
long long x, y;
} x1[maxn], x2[maxn], Y1[maxn], y2[maxn], yuan[maxn];
bool cmp1(point a, point b) { return a.x < b.x; }
bool cmp2(point a, point b) { return a.x > b.x; }
int used[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
long long X1, X2, y1, Y2;
scanf("%lld%lld%lld%lld", &X1, &y1, &X2, &Y2);
x2[i].x = x1[i].x = X1 + X2;
Y1[i].x = y2[i].x = y1 + Y2;
x1[i].y = x2[i].y = Y1[i].y = y2[i].y = i;
yuan[i].x = X1 + X2;
yuan[i].y = y1 + Y2;
}
sort(x1 + 1, x1 + 1 + n, cmp1);
sort(x2 + 1, x2 + 1 + n, cmp2);
sort(Y1 + 1, Y1 + 1 + n, cmp1);
sort(y2 + 1, y2 + 1 + n, cmp2);
long long ans = 1LL << 62;
int flag = 0;
for (int a = 0; a <= k; a++) {
for (int b = 0; b <= k; b++) {
for (int c = 0; c <= k; c++) {
for (int d = 0; d <= k; d++) {
flag++;
int cnt = 0;
for (int i = 1; i <= a; i++)
if (used[x1[i].y] != flag) {
used[x1[i].y] = flag;
cnt++;
}
for (int i = 1; i <= b; i++)
if (used[x2[i].y] != flag) {
used[x2[i].y] = flag;
cnt++;
}
for (int i = 1; i <= c; i++)
if (used[Y1[i].y] != flag) {
used[Y1[i].y] = flag;
cnt++;
}
for (int i = 1; i <= d; i++)
if (used[y2[i].y] != flag) {
used[y2[i].y] = flag;
cnt++;
}
if (cnt != k) continue;
long long maxx = -1LL << 62, minx = 1LL << 62, maxy = -1LL << 62,
miny = 1LL << 62;
for (int i = 1; i <= n; i++)
if (used[i] != flag) {
maxx = max(yuan[i].x, maxx);
minx = min(yuan[i].x, minx);
maxy = max(yuan[i].y, maxy);
miny = min(yuan[i].y, miny);
}
long long x = maxx - minx, y = maxy - miny;
if (x % 2 == 1) x++;
if (y % 2 == 1) y++;
x = max(2LL, x);
y = max(2LL, y);
ans = min(ans, x * y);
}
}
}
}
printf("%lld\n", ans / 4);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, ans = 0;
cin >> a >> b;
long long tmp = a % b;
if (tmp == 0) {
cout << a / b << endl;
return 0;
} else {
ans += a / b;
a = max(tmp, b);
b = tmp + b - a;
}
while (a % b) {
tmp = a - b;
a = max(b, tmp);
b = b + tmp - a;
ans++;
}
cout << ans + (a / b) << endl;
}
| 1 |
#include <bits/stdc++.h>
const int N = 805000;
using namespace std;
int t[N * 4];
int n, m, ar[N];
pair<int, int> quer[N];
vector<int> vals;
vector<int> queries[N];
int best_pref[N], best_suf[N], quer_pref[N], quer_suf[N];
map<int, int> mapp;
int dif;
int LIS;
int could_be[N];
int largest_pref[N], smallest_suf[N], lis[N];
void remap() {
sort(vals.begin(), vals.end());
for (int i = 0; i < vals.size(); i++) {
if (i == 0 || vals[i] != vals[i - 1]) {
mapp[vals[i]] = dif;
++dif;
}
}
}
void build(int v, int tl, int tr) {
t[v] = 0;
if (tl == tr) return;
int sdfjahlfasfh = tl + tr;
sdfjahlfasfh /= 2;
build(v * 2, tl, sdfjahlfasfh);
build(v * 2 + 1, sdfjahlfasfh + 1, tr);
}
int get(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r) return t[v];
int sdfjahlfasfh = tl + tr;
sdfjahlfasfh /= 2;
return max(get(v * 2, tl, sdfjahlfasfh, l, min(r, sdfjahlfasfh)),
get(v * 2 + 1, sdfjahlfasfh + 1, tr, max(sdfjahlfasfh + 1, l), r));
}
void update(int v, int tl, int tr, int ps, int val) {
if (tl == tr) {
t[v] = max(t[v], val);
return;
}
int sdfjahlfasfh = tl + tr;
sdfjahlfasfh /= 2;
if (ps <= sdfjahlfasfh)
update(v * 2, tl, sdfjahlfasfh, ps, val);
else
update(v * 2 + 1, sdfjahlfasfh + 1, tr, ps, val);
t[v] = max(t[v * 2], t[v * 2 + 1]);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
vals.push_back(ar[i]);
}
for (int i = 1; i <= m; i++) {
cin >> quer[i].first >> quer[i].second;
vals.push_back(quer[i].second);
}
remap();
for (int i = 1; i <= n; i++) {
ar[i] = mapp[ar[i]];
}
for (int i = 1; i <= m; i++) {
quer[i].second = mapp[quer[i].second];
queries[quer[i].first].push_back(i);
}
for (int i = 1; i <= n; i++) {
int bst = get(1, 0, dif, 0, ar[i] - 1);
best_pref[i] = bst;
for (int j = 0; j < queries[i].size(); j++) {
int id = queries[i][j];
int im_val = quer[id].second;
int res = get(1, 0, dif, 0, im_val - 1);
quer_pref[id] = res;
}
update(1, 0, dif, ar[i], best_pref[i] + 1);
}
build(1, 0, dif);
for (int i = n; i; --i) {
int bst = get(1, 0, dif, ar[i] + 1, dif);
best_suf[i] = bst;
for (int j = 0; j < queries[i].size(); j++) {
int id = queries[i][j];
int im_val = quer[id].second;
int res = get(1, 0, dif, im_val + 1, dif);
quer_suf[id] = res;
}
update(1, 0, dif, ar[i], best_suf[i] + 1);
}
for (int i = 1; i <= n; i++) {
LIS = max(LIS, best_pref[i] + best_suf[i] + 1);
}
for (int i = 1; i <= n; i++) {
if (best_pref[i] + best_suf[i] + 1 == LIS) could_be[i] = 1;
}
largest_pref[0] = -100;
for (int i = 1; i <= n; i++) {
largest_pref[i] = largest_pref[i - 1];
if (could_be[i]) largest_pref[i] = max(largest_pref[i], ar[i]);
}
smallest_suf[n + 1] = 1e9;
for (int i = n; i; --i) {
smallest_suf[i] = smallest_suf[i + 1];
if (could_be[i]) smallest_suf[i] = min(smallest_suf[i], ar[i]);
}
for (int i = 1; i <= m; i++) {
lis[i] = LIS - 1;
lis[i] = max(lis[i], quer_pref[i] + quer_suf[i] + 1);
int ps = quer[i].first;
if (largest_pref[ps - 1] >= ar[ps] || smallest_suf[ps + 1] <= ar[ps])
lis[i] = max(lis[i], LIS);
}
for (int i = 1; i <= m; i++) {
cout << lis[i] << "\n";
}
cin.get();
cin.get();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<int, int> mp;
long long int f(long long int x) {
if (x == 0) {
return 1;
}
if (mp.find(x) != mp.end()) {
return mp[x];
}
long long int z = x % 2;
long long int ans = 0;
for (long long int i = 0; i <= 7; i++) {
if (x >= i && i % 2 == z) {
ans = ans + f((x - i) / 2);
ans %= 1000000007;
}
}
mp[x] = ans;
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int m;
cin >> m;
if (m == 1) {
cout << f(m) << "\n";
} else {
long long int grp = m / 2;
grp--;
long long int z = grp / 2;
z %= 1000000007;
z++;
long long int ok = z;
z = (z * (z + 1)) / 2;
z %= 1000000007;
z -= 1;
if (z < 0) {
z += 1000000007;
}
z = z * 2;
z %= 1000000007;
z = z + 2;
z %= 1000000007;
long long int ans = z;
if (grp % 2) {
ans = ans + (ok + 1);
ans %= 1000000007;
}
cout << ans << "\n";
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dp1[300001], dp[300001];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
map<int, std::vector<std::pair<int, int> > > w;
map<int, std::vector<std::pair<int, int> > >::iterator it;
int u, v, wi;
for (long long int i = 0; i <= m - 1; i++) {
cin >> u >> v >> wi;
w[wi].push_back(make_pair(u, v));
}
for (it = w.begin(); it != w.end(); it++) {
std::vector<std::pair<int, int> > x = it->second;
std::vector<std::pair<int, int> >::iterator it2;
for (it2 = x.begin(); it2 != x.end(); it2++) {
u = it2->first;
v = it2->second;
dp1[v] = max(dp1[v], dp[u] + 1);
}
for (it2 = x.begin(); it2 != x.end(); it2++) {
u = it2->first;
v = it2->second;
dp[v] = max(dp1[v], dp[v]);
}
}
int ans = -1;
for (long long int i = 1; i <= n; i++) {
ans = max(ans, dp[i]);
}
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int w, h, k, a[111][111], ans;
int main() {
cin >> w >> h >> k;
for (int i = 0; i < k; ++i) ans += 2 * (w + h - 8 * i - 2);
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, m, chk[100100], a[100100], b[100100];
vector<int> v[100100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b), v[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (v[i].size() != n - 1) {
chk[i] = 1;
for (int x : v[i]) chk[x] = 1;
int j = 1, c = 0;
while (chk[j]) j++;
for (int k = 1; k <= n; k++)
if (k != i && k != j) a[k] = b[k] = ++c;
a[i] = b[i] = b[j] = ++c;
a[j] = ++c;
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << a[i] << " ";
cout << "\n";
for (int i = 1; i <= n; i++) cout << b[i] << " ";
cout << "\n";
return 0;
}
cout << "NO";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int a[N];
int main() {
int t, n;
string ss;
cin >> t;
while (t--) {
bool flag = 0;
cin >> n;
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
cin >> ss;
int len = ss.length();
if (len & 1) flag = 1;
for (int j = 0; j < len; j++) {
a[ss[j] - '0']++;
}
}
if (a[0] & 1 && a[1] & 1 && flag == 0) --n;
cout << n << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long x;
vector<long long> filas;
vector<long long> columnas;
long long matrix[n + 1][m + 1];
long long s1, s2;
s1 = 0;
s2 = 0;
for (int i = 0; i < n; i++) {
cin >> x;
filas.push_back(x);
s1 = s1 ^ x;
}
for (int i = 0; i < m; i++) {
cin >> x;
columnas.push_back(x);
s2 = s2 ^ x;
}
if (s1 != s2) {
cout << "NO\n";
} else {
cout << "YES\n";
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m - 1; j++) {
matrix[i][j] = 0;
}
}
for (int i = 0; i < n - 1; i++) {
matrix[i][m - 1] = filas[i];
}
for (int i = 0; i < m - 1; i++) {
matrix[n - 1][i] = columnas[i];
}
matrix[n - 1][m - 1] = filas[n - 1] ^ columnas[m - 1] ^ s1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << matrix[i][j] << " ";
}
cout << "\n";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
unordered_set<char> candidates;
for (int i = 0; i < 26; i++) {
candidates.insert('a' + i);
}
bool found = false;
char t;
string s;
int n, ans = 0;
cin >> n;
while (n--) {
cin >> t >> s;
if (found && t != '.') {
ans++;
}
if (t == '!') {
bool marked[26];
memset(marked, false, sizeof marked);
for (int i = 0; i < s.size(); i++) {
marked[s[i] - 97] = true;
}
for (auto itr = candidates.begin(); itr != candidates.end();) {
if (!marked[*itr - 97]) {
itr = candidates.erase(itr);
} else {
itr++;
}
}
} else if (t == '.') {
for (char c : s) {
candidates.erase(c);
}
} else {
candidates.erase(s[0]);
}
if (candidates.size() == 1) {
found = true;
}
}
cout << max(0, ans - 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int change(string ss) {
if (ss == "C")
return 1;
else if (ss == "C#")
return 2;
else if (ss == "D")
return 3;
else if (ss == "D#")
return 4;
else if (ss == "E")
return 5;
else if (ss == "F")
return 6;
else if (ss == "F#")
return 7;
else if (ss == "G")
return 8;
else if (ss == "G#")
return 9;
else if (ss == "A")
return 10;
else if (ss == "B")
return 11;
else if (ss == "H")
return 12;
else
return 0;
}
int main() {
int s[4];
string c;
cin >> c;
s[1] = change(c);
cin >> c;
s[2] = change(c);
cin >> c;
s[3] = change(c);
sort(s + 1, s + 4);
int t = 3;
while (t) {
t--;
if (s[3] - s[1] == 7) {
if (s[2] - s[1] == 3) {
cout << "minor";
return 0;
}
if (s[2] - s[1] == 4) {
cout << "major";
return 0;
}
}
s[1] += 12;
sort(s + 1, s + 4);
}
cout << "strange";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0', c = getchar();
}
return x * f;
}
const int MAXN = 3e5 + 10;
int n, r[MAXN], c[MAXN], p[MAXN], a[MAXN];
long long ans = 0;
inline bool cmp(const int &a, const int &b) { return r[a] < r[b]; }
void Solve(int l, int r) {
if (l > r) return;
if (l == r) {
::ans++;
return;
}
int mid = (l + r) >> 1;
static int mx[MAXN], mn[MAXN];
long long ans = 0;
mx[mid] = mn[mid] = a[mid];
mx[mid + 1] = mn[mid + 1] = a[mid + 1];
for (int i = mid - 1; i >= l; i--)
mn[i] = min(mn[i + 1], a[i]), mx[i] = max(mx[i + 1], a[i]);
for (int i = mid + 2; i <= r; i++)
mn[i] = min(mn[i - 1], a[i]), mx[i] = max(mx[i - 1], a[i]);
static int buc[MAXN * 3];
for (int i = l; i <= mid; i++) {
int nr = i + mx[i] - mn[i];
if (nr > mid && nr <= r && mn[nr] > mn[i] && mx[nr] < mx[i]) ans++;
}
for (int i = mid + 1; i <= r; i++) {
int nl = i - (mx[i] - mn[i]);
if (nl <= mid && nl >= l && mn[nl] > mn[i] && mx[nl] < mx[i]) ans++;
}
int j = mid + 1, k = j;
for (int i = mid; i >= l; i--) {
while (j <= r && mx[j] < mx[i]) {
int now = j + mn[j] + n;
buc[now]++, j++;
}
while (k < j && mn[k] > mn[i]) {
int now = k + mn[k] + n;
buc[now]--, k++;
}
ans += buc[i + mx[i] + n];
}
while (k < j) {
int now = k + mn[k] + n;
buc[now]--, k++;
}
j = mid + 1, k = j;
for (int i = mid; i >= l; i--) {
while (j <= r && mn[j] > mn[i]) {
int now = j - mx[j] + n;
buc[now]++, j++;
}
while (k < j && mx[k] < mx[i]) {
int now = k - mx[k] + n;
buc[now]--, k++;
}
ans += buc[i - mn[i] + n];
}
while (k < j) {
int now = k - mx[k] + n;
buc[now]--, k++;
}
::ans += ans;
Solve(l, mid), Solve(mid + 1, r);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) r[i] = read(), c[i] = read();
for (int i = 1; i <= n; i++) p[i] = i;
sort(p + 1, p + 1 + n, cmp);
for (int i = 1; i <= n; i++) a[i] = c[p[i]];
Solve(1, n);
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long denom = 1e9 + 7;
long long powmod(long long a, long long b) {
long long res = 1;
a %= denom;
for (; b; b >>= 1) {
if (b & 1) res = res * a % denom;
a = a * a % denom;
}
return res;
}
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
set<long long> s;
for (long long i = (0); i < (6); i++) {
long long temp;
cin >> temp;
s.insert(temp);
}
vector<long long> a;
for (auto x : s) a.push_back(x);
long long k = a.size();
long long n;
cin >> n;
vector<long long> b(n);
for (long long i = (0); i < (n); i++) cin >> b[i];
sort((b).begin(), (b).end());
map<long long, vector<pair<long long, long long>>> m;
for (long long j = (0); j < (n); j++) {
m[b[j] - a[0]].push_back({j, 0});
}
long long result = INT_MAX;
bool flag = true;
while (flag) {
auto it = m.end();
it--;
result = min(result, (it->first - m.begin()->first));
vector<pair<long long, long long>> v = it->second;
m.erase(it);
for (long long j = (0); j < (v.size()); j++) {
if (v[j].second == k - 1) {
flag = false;
break;
}
m[b[v[j].first] - a[v[j].second + 1]].push_back(
{v[j].first, v[j].second + 1});
}
}
cout << result << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, a[100];
cin >> n >> t;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int day = 0;
for (int i = 0; i < n; i++) {
t -= 86400 - a[i];
day++;
if (t <= 0) {
printf("%d\n", day);
return 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < v.size(); i++) os << v[i] << " ";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
for (typename set<T>::iterator it = v.begin(); it != v.end(); it++)
os << *it << " ";
}
const int mod = 1e9 + 7;
const int N = 1e6 + 5;
int vis[30];
vector<int> pos;
int n, tot, k;
string s[N];
int flag;
bool deal(string a, string b) {
pos.clear();
for (int i = (0); i <= (k - 1); i++) {
if (a[i] != b[i]) {
pos.push_back(i);
}
}
if ((int)pos.size() > 4) return 0;
if ((int)pos.size() == 1) return 0;
return 1;
}
int check(string a) {
vector<int> p;
for (int i = (1); i <= (n); i++) {
p.clear();
for (int j = (0); j <= (k - 1); j++) {
if (a[j] != s[i][j]) {
p.push_back(j);
}
}
if ((int)p.size() != 2) {
if ((int)p.size() == 0) {
if (!flag) return 0;
} else
return 0;
} else {
if (!(a[p[0]] == s[i][p[1]] && a[p[1]] == s[i][p[0]])) return 0;
}
}
return 1;
}
int main() {
srand(time(0));
cin >> n >> k;
for (int i = (1); i <= (n); i++) {
cin >> s[i];
}
sort(s + 1, s + n + 1);
n = unique(s + 1, s + n + 1) - s - 1;
if (n == 1) {
swap(s[1][0], s[1][1]);
cout << s[1];
return 0;
}
int p = rand() % n + 1;
if (p == 1) p = 2;
if (!deal(s[1], s[p])) {
cout << -1;
return 0;
}
flag = 0;
for (int i = (0); i <= (k - 1); i++) {
vis[s[1][i] - 'a']++;
}
for (int i = (0); i <= (25); i++) {
if (vis[i] > 1) {
flag = 1;
}
}
string a(s[1]);
for (int i = 0; i < (int)pos.size(); i++) {
int p = pos[i];
for (int j = 0; j < k; j++) {
if (j == p) continue;
swap(a[p], a[j]);
if (check(a)) {
cout << a;
return 0;
}
swap(a[p], a[j]);
}
}
cout << -1;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const int N = 1e5 + 1, OO = 0x3f3f3f3f;
int main() {
int n, m;
cin >> n >> m;
multiset<int> a;
multiset<int> ms;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
a.insert(x);
}
for (int i = 0; i < m; ++i) {
int x;
cin >> x;
ms.insert(x);
}
while ((int)a.size() && (int)ms.size()) {
if ((int)ms.size() == 0) break;
int need = *a.begin();
int prepared = *ms.begin();
if (need <= prepared) {
a.erase(a.begin());
ms.erase(ms.begin());
} else {
while (1) {
if ((int)ms.size() > 0) {
if (need > prepared) {
ms.erase(ms.begin());
prepared = *ms.begin();
} else {
ms.erase(ms.begin());
a.erase(a.begin());
break;
}
} else
break;
}
}
}
cout << (int)a.size() << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
long long a[maxn], b[maxn], sum1, sum2, ans1, ans2;
int main() {
int N, M;
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) scanf("%lld", &a[i]), sum1 += a[i];
for (int i = 1; i <= M; i++) scanf("%lld", &b[i]), sum2 += b[i];
ans1 = sum2;
ans2 = sum1;
sort(a + 1, a + N + 1);
sort(b + 1, b + M + 1);
for (int i = 1; i <= N - 1; i++) ans1 += min(a[i], sum2);
for (int i = 1; i <= M - 1; i++) ans2 += min(b[i], sum1);
printf("%lld\n", min(ans1, ans2));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
int n, m, q;
int dis[5010];
bool vis[5010];
vector<pair<int, int> > ve;
struct edge {
int to, nxt, v, c;
edge(int x = 0, int y = 0, int z = 0, int w = 0) {
to = x, nxt = y, v = z, c = w;
}
} e[5010];
int head[5010], edge_cnt = 1;
void add(int from, int to, int val, int cost) {
e[++edge_cnt] = edge(to, head[from], val, cost), head[from] = edge_cnt;
e[++edge_cnt] = edge(from, head[to], 0, -cost), head[to] = edge_cnt;
}
bool spfa() {
for (int i = 1; i <= n; ++i) vis[i] = false, dis[i] = 1000000000;
queue<int> q;
q.push(1), vis[1] = true, dis[1] = 0;
while (!q.empty()) {
int x = q.front();
q.pop(), vis[x] = false;
for (int i = head[x]; i; i = e[i].nxt) {
int y = e[i].to, c = e[i].c;
if (dis[y] <= dis[x] + c || !e[i].v) continue;
dis[y] = dis[x] + c;
if (!vis[y]) q.push(y), vis[y] = true;
}
}
return dis[n] != 1000000000;
}
int dfs(int x, int lim) {
if (x == n) return lim;
vis[x] = true;
int res = lim, flow;
for (int i = head[x]; i; i = e[i].nxt) {
int y = e[i].to, v = e[i].v;
if (dis[y] != dis[x] + e[i].c || vis[y] || !v) continue;
if (flow = dfs(y, min(res, v))) {
res -= flow, e[i].v -= flow, e[i ^ 1].v += flow;
if (!res) break;
}
}
return lim - res;
}
void dinic() {
int flow, v = 0, s = 0;
while (spfa())
while (flow = dfs(1, 1000000000))
v += flow, s += flow * dis[n], ve.push_back(make_pair(v, s));
}
int main() {
read(n), read(m);
for (int i = 1; i <= m; ++i) {
int x, y, v;
read(x), read(y), read(v), add(x, y, 1, v);
}
dinic(), read(q);
while (q--) {
int x;
double v = 1000000000;
read(x);
for (int i = 0; i < ve.size(); ++i)
v = min(v, (double)(x + ve[i].second) / ve[i].first);
printf("%.10lf\n", v);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int fff[111];
int ggg[111];
int m, n;
int lim;
char ch;
int ok;
char fh[111];
int num;
void test() {
for (int i = 1; i <= m; i++)
if (fff[i] < 1 || fff[i] > lim) ok = 0;
for (int i = 1; i <= n; i++)
if (ggg[i] < 1 || ggg[i] > lim) ok = 0;
}
void print() {
cout << "Possible" << endl;
cout << fff[1] << " ";
int l = 2, r = 1;
for (int i = 2; i <= num; i++) {
cout << fh[i] << " ";
if (fh[i] == '+') {
cout << fff[l++] << " ";
} else
cout << ggg[r++] << " ";
}
cout << "= " << lim << endl;
}
int main() {
m = 1;
n = 0;
ok = 1;
num = 1;
fh[1] = '+';
while (scanf(" %c", &ch) == 1 && ch != '=') {
scanf(" %c", &ch);
if (ch == '=') break;
num++;
fh[num] = ch;
if (ch == '+') m++;
if (ch == '-') n++;
}
cin >> lim;
int totneed = n + lim;
int kk = m;
for (int i = 1; i <= n; i++) ggg[i] = 1;
for (int i = 1; i <= m; i++) {
fff[i] = round((double)totneed / kk);
totneed -= fff[i];
kk--;
}
if (totneed != 0) ok = 0;
test();
if (ok) {
print();
} else {
ok = 1;
int totneed = m - lim;
int kk = n;
for (int i = 1; i <= m; i++) fff[i] = 1;
for (int i = 1; i <= n; i++) {
ggg[i] = round((double)totneed / kk);
kk--;
totneed -= ggg[i];
}
if (totneed != 0) ok = 0;
test();
if (ok)
print();
else
printf("Impossible\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int N = 33;
int a[N][N], c[N][N], ans[N][N], p[N];
pair<int, int> sq[N], t[N][N];
int used[N][N], b[N][N];
int dfs(int x, int col) {
int u = sq[x].first, v = sq[x].second;
c[u][v] = c[u + 1][v] = c[u][v + 1] = c[u + 1][v + 1] = col;
bool flag = true;
for (int i = 0; i <= 1; i++)
for (int j = 0; j <= 1; j++) {
pair<int, int> tmp = t[u + i][v + j];
if (c[tmp.first][tmp.second] >= 0 &&
used[min(c[tmp.first][tmp.second], c[u + i][v + j])]
[max(c[tmp.first][tmp.second], c[u + i][v + j])] &&
p[x] == -1)
flag = false;
if (c[tmp.first][tmp.second] >= 0 && p[x] < 0)
used[min(c[tmp.first][tmp.second], c[u + i][v + j])]
[max(c[tmp.first][tmp.second], c[u + i][v + j])]++;
}
int res = 0;
if (flag) {
if (x == 14) {
res = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
ans[i][j] = c[i][j];
}
} else if (p[x + 1] >= 0)
res = dfs(x + 1, p[x + 1]);
else {
for (int i = 0; i <= 6; i++) res += dfs(x + 1, i);
}
}
for (int i = 0; i <= 1; i++)
for (int j = 0; j <= 1; j++)
if (p[x] < 0) {
pair<int, int> tmp = t[u + i][v + j];
if (c[tmp.first][tmp.second] >= 0)
used[min(c[tmp.first][tmp.second], c[u + i][v + j])]
[max(c[tmp.first][tmp.second], c[u + i][v + j])]--;
c[u + i][v + j] = -1;
}
return res;
}
const int da[4] = {-1, 0, 1, 0};
const int db[4] = {0, 1, 0, -1};
signed main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
string st;
cin >> st;
for (int j = 1; j <= m; j++) {
if (st[j - 1] == '.')
a[i][j] = 0;
else if (st[j - 1] >= 'a' && st[j - 1] <= 'z')
a[i][j] = st[j - 1] - 'a' + 1;
else
a[i][j] = st[j - 1] == 'A' ? 27 : 28;
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
for (int d = 0; d < 4; d++) {
int u = i + da[d], v = j + db[d];
if (a[u][v] == a[i][j]) t[i][j] = make_pair(u, v);
}
}
memset(c, -1, sizeof(c));
int tmp = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] && !b[i][j]) {
b[i][j] = b[i + 1][j] = b[i][j + 1] = b[i + 1][j + 1] = ++tmp;
sq[tmp] = make_pair(i, j);
}
memset(p, -1, sizeof(p));
tmp = 0;
for (int i = 1; i <= 14; i++) {
int u = sq[i].first, v = sq[i].second;
bool flag = false;
for (int j = 0; j <= 1; j++)
for (int d = 0; d <= 1; d++) {
pair<int, int> tmp = t[u + j][v + d];
if (b[tmp.first][tmp.second] == b[u + j][v + d]) flag = true;
}
if (flag) {
p[i] = tmp;
c[u][v] = c[u + 1][v] = c[u][v + 1] = c[u + 1][v + 1] = tmp++;
for (int j = 0; j <= 1; j++)
for (int d = 0; d <= 1; d++) {
pair<int, int> tt = t[u + j][v + d];
if (c[tt.first][tt.second] >= 0)
used[min(c[tt.first][tt.second], c[u + j][v + d])]
[max(c[tt.first][tt.second], c[u + j][v + d])] = 1;
}
}
}
int res = 0;
if (p[1] >= 0)
res = dfs(1, p[1]);
else
for (int i = 0; i <= 6; i++) res += dfs(1, i);
for (int i = 1; i <= 6 - tmp + 1; i++) res /= i;
cout << res * 5040 << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ans[i][j] == -1)
cout << '.';
else
cout << ans[i][j];
}
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, p, sum = 0;
cin >> k >> p;
for (long long i = 1; i <= k; i++) {
string s1 = to_string(i);
string s2 = s1;
reverse(s2.begin(), s2.end());
string s = s1 + s2;
long long x = stoll(s);
x %= p;
sum += x;
sum %= p;
}
cout << sum;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int n, k;
cin >> n >> k;
long long int arr[n];
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
vector<pair<long long int, long long int> > ans;
for (long long int cnt = 0; cnt < k; cnt++) {
long long int mnindex = -1, mxindex = -1;
long long int mn = INT_MAX, mx = INT_MIN;
for (long long int i = 0; i < n; i++) {
if (mn > arr[i]) {
mn = arr[i];
mnindex = i;
}
if (mx < arr[i]) {
mx = arr[i];
mxindex = i;
}
}
if (mnindex != mxindex) {
if (mx == mn) {
break;
} else {
ans.push_back({mxindex + 1, mnindex + 1});
arr[mnindex]++;
arr[mxindex]--;
}
} else {
break;
}
}
long long int mnindex = -1, mxindex = -1;
long long int mn = INT_MAX, mx = INT_MIN;
for (long long int i = 0; i < n; i++) {
if (mn > arr[i]) {
mn = arr[i];
mnindex = i;
}
if (mx < arr[i]) {
mx = arr[i];
mxindex = i;
}
}
cout << mx - mn << " " << ans.size() << '\n';
for (long long int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e3 + 5;
int p[maxn], dp[maxn][maxn], p_back[maxn], n, k;
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
}
for (int i = 0; i <= n + 3; i++) {
for (int j = 0; j <= n + 3; j++) {
dp[i][j] = 0x3f3f3f3f;
}
}
dp[1][2] = 0;
for (int i = n; i >= 1; i--) {
if (i == n)
p_back[i] = p[i];
else
p_back[i] = max(p_back[i + 1], p[i]);
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (p_back[j] > 0 && p[i] < 100)
dp[j][j + 1] = min(dp[j][j + 1], dp[i][j] + 1);
if (p_back[j] < 100 && p[i] > 0)
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + 1);
if (p_back[j] > 0 && p[i] > 0)
dp[j + 1][j + 2] = min(dp[j + 1][j + 2], dp[i][j] + 1);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n + 1; j++) {
if (dp[i][j] <= k) ans++;
}
}
if (dp[n + 1][n + 2] <= k) ans++;
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const deque<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const deque<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T, typename OP>
vector<T> prefixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = 0; i < (int((v).size())); i++) r[i + 1] = op(r[i], v[i]);
return r;
}
template <typename C, typename T, typename OP>
vector<T> suffixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = (int((v).size())) - 1; i >= 0; i--) r[i] = op(v[i], r[i + 1]);
return r;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
int main() {
setIO();
int N, M;
re(N, M);
vs grid(N);
re(grid);
vi diff((N + 1) << N);
for (int j = 0; j < (M); j++) {
int col = 0;
for (int i = 0; i < (N); i++)
if (grid[i][j] - '0') col ^= 1 << i;
diff[col]++;
}
for (int i = 0; i < (N); i++) {
for (int jm = (int((diff).size()) - (1 << N)) - 1; jm >= 0; jm--) {
diff[(jm ^ (1 << i)) + (1 << N)] += diff[jm];
}
}
int ans = INT_MAX;
for (int m = 0; m < (1 << N); m++) {
int cand = 0;
for (int d = 0; d < (N + 1); d++)
cand += min(d, N - d) * diff[(d << N) + m];
ckmin(ans, cand);
}
ps(ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m, st[N << 1], tme, low[N << 1], comp[N << 1];
int cnt = 1;
vector<int> adj[N << 1], ans;
bool vis[N << 1];
stack<int> stck;
void tarjan(int v) {
vis[v] = true;
st[v] = ++tme;
low[v] = v;
stck.push(v);
for (int u : adj[v]) {
if (!vis[u]) {
tarjan(u);
if (st[low[v]] > st[low[u]]) low[v] = low[u];
} else if (vis[u] && !comp[u] && st[low[v]] > st[low[u]])
low[v] = low[u];
}
if (low[v] == v) {
while (stck.top() ^ v) comp[stck.top()] = cnt, stck.pop();
comp[v] = cnt++, stck.pop();
}
}
void scc() {
for (int i = 0; i < n << 1; i++)
if (!vis[i]) tarjan(i);
}
bool sat2() {
scc();
for (int i = 0; i < n << 1; i += 2) {
if (comp[i] == comp[i + 1]) return 0;
if (comp[i] < comp[i + 1]) ans.push_back(i >> 1);
}
return 1;
}
void add_clause(int u, int v) {
adj[u ^ 1].push_back(v), adj[v].push_back(u ^ 1);
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n >> m;
for (int i = 0, u, v, w; i < m; i++) {
cin >> u >> v >> w, --u, --v;
add_clause(u << 1 | 1 ^ w, v << 1 | 1), add_clause(u << 1 ^ w, v << 1);
}
if (sat2()) {
cout << ans.size() << '\n';
for (int x : ans) cout << x + 1 << ' ';
cout << '\n';
} else
cout << "Impossible\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void debug(T1 e) {
cout << e << endl;
}
template <class T1, class T2>
void debug(T1 e1, T2 e2) {
cout << e1 << "\t" << e2 << endl;
}
template <class T1, class T2, class T3>
void debug(T1 e1, T2 e2, T3 e3) {
cout << e1 << "\t" << e2 << "\t" << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void debug(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void debug(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << "\t" << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void debug(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << "\t" << e5 << "\t"
<< e6 << endl;
}
template <class T>
void debug(vector<vector<T> > e, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << " ";
cout << endl;
}
cout << endl;
}
template <class T>
void debug(vector<basic_string<T> > e, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j];
cout << endl;
}
cout << endl;
}
template <class T>
void debug(T e[110][110], int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << " ";
cout << endl;
}
}
template <class T>
string toString(T n) {
ostringstream oss;
oss << n;
oss.flush();
return oss.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
bool isVowel(char ch) {
ch = tolower(ch);
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
return true;
return false;
}
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
int dp[1 << 21 + 2];
bool col[1 << 21 + 2];
int n, m;
struct order {
char c;
int team;
};
order arr[30];
int s[200];
int dprec(int bit, int now) {
int &ret = dp[bit];
if (col[bit]) return ret;
col[bit] = true;
if (now > m) return ret = 0;
if (arr[now].team == 1) {
ret = -1000000000;
for (int i = 0; i < m; i++)
if (bit & (1 << i))
continue;
else {
if (arr[now].c == 'b')
ret = max(ret, dprec(bit | (1 << i), now + 1));
else
ret = max(ret, dprec(bit | (1 << i), now + 1) + s[i + 1]);
}
}
if (arr[now].team == 2) {
ret = 1000000000;
for (int i = 0; i < m; i++)
if (bit & (1 << i))
continue;
else {
if (arr[now].c == 'b')
ret = min(ret, dprec(bit | (1 << i), now + 1));
else
ret = min(ret, dprec(bit | (1 << i), now + 1) - s[i + 1]);
}
}
return ret;
}
bool comp(int p, int q) { return p > q; }
int main() {
while (cin >> n) {
int i;
for (i = 1; i <= n; i++) cin >> s[i];
sort(s + 1, s + n + 1, comp);
cin >> m;
for (i = 1; i <= m; i++) cin >> arr[i].c >> arr[i].team;
memset(col, false, sizeof(col));
cout << dprec(0, 1) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int n, i, j, k, s, m = 0, l = 0;
char c[100];
scanf("%s", c);
n = strlen(c);
if (n % 20)
k = n / 20 + 1;
else
k = n / 20;
if (n % k)
s = n / k + 1;
else
s = n / k;
printf("%d %d\n", k, s);
if (n % k) m = k - n % k;
for (i = 0; i < k; i++) {
for (j = 0; j < s - 1; j++) {
printf("%c", c[l++]);
}
if (m) {
printf("*\n");
m--;
} else
printf("%c\n", c[l++]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T0;
cin >> T0;
for (int _ = 0; _ < T0; _++) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
bool f = 1;
for (int i = 0; f && i < (n + 1) / 2; i++) {
if (a[i] < i) f = 0;
}
for (int i = (n + 1) / 2; f && i < n; i++) {
if (a[i] < n - 1 - i) f = 0;
}
if (!(n % 2) && a[n / 2 - 1] == a[(n) / 2] && a[n / 2] == n / 2 - 1) f = 0;
if (f)
cout << "Yes\n";
else
cout << "No\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[5][5];
bool used[100004];
int x, y;
bool isadj(int a, int b) {
if (a == 0 || b == 0) return false;
if (abs(a - b) == 1 && (a - 1) / y == (b - 1) / y) return true;
if (abs(a - b) == y) return true;
return false;
}
bool dfs(int cx, int cy) {
if (cy == y + 1) {
cy = 1;
cx++;
}
if (cx == x + 1) {
return true;
}
for (int i = 1; i <= x * y; i++) {
if (!used[i] && !isadj(i, a[cx - 1][cy]) && !isadj(i, a[cx][cy - 1])) {
used[i] = true;
a[cx][cy] = i;
if (dfs(cx, cy + 1)) return true;
used[i] = false;
}
}
return false;
}
void asrt(bool cond) {
if (!cond) {
cout << "NOOOO" << endl;
}
}
int main() {
scanf("%d %d", &x, &y);
if (max(x, y) > 4) {
vector<vector<int>> ans(x + 2, vector<int>(y + 2, 0));
if (y > 4) {
for (int i = 0; i < x; i++) {
int cur = 1;
for (int j = (i % 2); j < y; j += 2) {
ans[i + 1][cur++] = (i * y + j + 1);
}
for (int j = 1 - (i % 2); j < y; j += 2) {
ans[i + 1][cur++] = (i * y + j + 1);
}
}
} else {
for (int j = 0; j < y; j++) {
int cur = 1;
for (int i = (j % 2); i < x; i += 2) {
ans[cur++][j + 1] = (i * y + j + 1);
}
for (int i = 1 - (j % 2); i < x; i += 2) {
ans[cur++][j + 1] = (i * y + j + 1);
}
}
}
printf("YES\n");
memset(used, 0, sizeof(used));
for (int i = 1; i <= x; i++) {
for (int j = 1; j <= y; j++) {
printf("%d ", ans[i][j]);
asrt(ans[i][j] != 0);
asrt(ans[i][j] >= 1);
asrt(ans[i][j] <= x * y);
asrt(used[ans[i][j]] == false);
used[ans[i][j]] = true;
asrt(!isadj(ans[i][j], ans[i - 1][j]));
asrt(!isadj(ans[i][j], ans[i + 1][j]));
asrt(!isadj(ans[i][j], ans[i][j - 1]));
asrt(!isadj(ans[i][j], ans[i][j + 1]));
}
printf("\n");
}
return 0;
} else {
if (!dfs(1, 1)) {
printf("NO\n");
return 0;
}
printf("YES\n");
for (int i = 1; i <= x; i++) {
for (int j = 1; j <= y; j++) {
printf("%d ", a[i][j]);
}
printf("\n");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
int a, b, x, y;
cin >> a;
int c[a];
for (int i = 0; i < a; i++) cin >> c[i];
cin >> b;
for (int i = 0; i < b; i++) {
cin >> x >> y;
if (x == 1) {
c[x] = c[x] + (c[x - 1] - y);
c[x - 1] = 0;
} else if (x == a) {
c[x - 2] = c[x - 2] + (y - 1);
c[x - 1] = 0;
} else {
c[x] = c[x] + (c[x - 1] - y);
c[x - 2] = c[x - 2] + (y - 1);
c[x - 1] = 0;
}
}
for (int i = 0; i < a; i++) {
cout << c[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 1; i <= (n / 2) + 1; i++) {
for (int j = 1; j <= n; j++) {
if (j > (n / 2) + 1 - i && j < (n / 2) + 1 + i)
cout << 'D';
else
cout << "*";
}
cout << endl;
}
for (int i = (n / 2); i > 0; i--) {
for (int j = 1; j <= n; j++) {
if (j > (n / 2) + 1 - i && j < (n / 2) + 1 + i)
cout << 'D';
else
cout << "*";
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9;
const int mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll m, n, ta, tb, k, ans = -1;
cin >> n >> m >> ta >> tb >> k;
vector<ll> a(n), b(m);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
if (min(m, n) <= k) {
cout << -1;
return 0;
}
int kek = 0;
for (int i = 0; i <= k; i++) {
ll time = a[i] + ta, now = -1;
for (int j = kek; j <= m; j++) {
if (b[j] >= time) {
now = j;
kek = j;
break;
}
}
if (now == -1) {
cout << -1;
return 0;
}
if (now + k - i >= m) {
cout << -1;
return 0;
}
if (b[now + k - i] > ans) ans = b[now + k - i];
}
cout << ans + tb;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int id, l;
data() {}
data(int _id, int _l) {
id = _id;
l = _l;
}
};
vector<data> Q[100005];
int tree[2][4 * 100005], a[100005], n;
int opera(int id, int &a, int &b) {
if (id) return max(a, b);
return min(a, b);
}
int nulo(int id) {
if (id) return -2000000000;
return 2000000000;
}
void update(int node, int ini, int fin, int pos, int val, int id) {
if (pos < ini || pos > fin) return;
if (ini == fin && pos == ini) {
tree[id][node] = opera(id, tree[id][node], val);
return;
}
update((2 * node), ini, (ini + fin) / 2, pos, val, id);
update((2 * node + 1), (ini + fin) / 2 + 1, fin, pos, val, id);
tree[id][node] = opera(id, tree[id][(2 * node)], tree[id][(2 * node + 1)]);
}
int query(int node, int ini, int fin, int b, int e, int id) {
if (e < ini || b > fin) return nulo(id);
if (ini >= b && fin <= e) return tree[id][node];
int r1 = query((2 * node), ini, (ini + fin) / 2, b, e, id);
int r2 = query((2 * node + 1), (ini + fin) / 2 + 1, fin, b, e, id);
return opera(id, r1, r2);
}
vector<int> nums;
void build() {
nums.clear();
set<int> aux;
for (int i = 0; i < n; i++) a[i] = (2000000000 - a[i]);
for (int i = 0; i < n; i++) aux.insert(a[i]);
while (aux.size() > 0) nums.push_back(*aux.begin()), aux.erase(aux.begin());
for (int i = 0; i < 4 * n; i++) {
tree[0][i] = 2000000000;
tree[1][i] = -2000000000;
}
}
int getID(int val) {
return upper_bound(nums.begin(), nums.end(), val) - nums.begin() - 1;
}
int res[3 * 100005];
void solve() {
update(1, 0, n - 1, getID(a[0]), 0, 1);
for (int i = 1; i < n; i++) {
long long lo = a[i], hi = nums.back(), y, pos;
while (true) {
pos = query(1, 0, n - 1, getID(lo), getID(hi), 1);
if (pos == -2000000000) break;
y = a[pos];
update(1, 0, n - 1, pos, y - a[i], 0);
hi = (lo + y) / 2;
if (y == a[i]) break;
}
update(1, 0, n - 1, getID(a[i]), i, 1);
for (int j = 0; j < Q[i].size(); j++) {
res[Q[i][j].id] =
min(res[Q[i][j].id], query(1, 0, n - 1, Q[i][j].l, i, 0));
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int m, l, r;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &l, &r);
l--;
r--;
Q[r].push_back(data(i, l));
res[i] = 2000000000;
}
build();
solve();
build();
solve();
for (int i = 0; i < m; i++) printf("%d\n", res[i]);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long MaxN = 2e5 + 100;
const long long LogN = 20;
const long long Inf = 1e18;
double eps = 1e-3;
const long long md = 1e9 + 7;
long long N, K;
long long Ans = 0;
vector<long long> Gr[MaxN];
long long dp[MaxN][5];
long long Sz[MaxN];
void dfs(long long v, long long p = -1, long long h = 0) {
Sz[v] = dp[v][h % K] = 1;
for (long long to : Gr[v]) {
if (to == p) continue;
dfs(to, v, h + 1);
for (int i = 0; i < K; i++) {
for (int j = 0; j < K; j++) {
long long a = ((i + j) - 2 * h + K) % K;
long long b = ((K)-a + K) % K;
Ans += b * (dp[v][i]) * (dp[to][j]);
}
}
for (int i = 0; i < K; i++) {
dp[v][i] += dp[to][i];
}
Sz[v] += Sz[to];
}
Ans += Sz[v] * (N - Sz[v]);
}
int main() {
cin >> N >> K;
for (int i = 0; i < N - 1; i++) {
long long a, b;
cin >> a >> b;
a--;
b--;
Gr[a].push_back(b);
Gr[b].push_back(a);
}
dfs(0);
cout << Ans / K;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[55], b[55], s[55];
int main() {
int t;
scanf("%d", &t);
for (int i = 2; i <= t; i++) {
scanf("%d", &a[i]);
a[i] += a[i - 1];
}
for (int i = 1; i < t; i++) scanf("%d", &b[i]);
for (int i = t - 2; i >= 1; i--) b[i] += b[i + 1];
for (int i = 1; i <= t; i++) scanf("%d", &s[i]);
int res = 50050;
for (int i = 1; i <= t; i++) {
for (int j = 1; j <= t; j++) {
if (i == j) continue;
int sum = a[i] + b[i] + s[i];
sum += a[j] + b[j] + s[j];
res = min(res, sum);
}
}
printf("%d\n", res);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mat[2][2];
const long long mod = 1000000000;
const int maxn = 200010;
void mult(long long a[2][2], long long b[2][2], long long res[2][2]) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
res[i][j] = 0;
for (int k = 0; k < 2; k++) {
res[i][j] += a[i][k] * b[k][j];
}
res[i][j] %= mod;
}
}
}
void add(long long a[2][2], long long b[2][2], long long res[2][2]) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
res[i][j] = a[i][j] + b[i][j];
res[i][j] %= mod;
}
}
}
void minus(long long a[2][2], long long b[2][2], long long res[2][2]) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
res[i][j] = a[i][j] - b[i][j];
res[i][j] %= mod;
}
}
}
long long POW[200010][2][2];
long long fac[2][2];
long long sum[200010][2][2];
void build() {
fac[0][0] = 0;
fac[1][0] = 1;
fac[0][1] = 1;
fac[1][1] = 1;
POW[0][0][0] = 1;
POW[0][1][1] = 1;
for (int i = 1; i <= 200001; i++) {
mult(fac, POW[i - 1], POW[i]);
}
for (int i = 1; i <= 200001; i++) {
add(POW[i - 1], sum[i - 1], sum[i]);
}
}
void clear(long long a[2][2]) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
a[i][j] = 0;
}
}
}
struct SegNode {
long long sum[2][2];
int left, right;
long long add;
int mid() { return (left + right) >> 1; }
int len() { return right - left + 1; }
};
struct SegTree {
SegNode tree[4 * maxn];
void init(int left, int right, int idx, int val[]) {
tree[idx].left = left;
tree[idx].right = right;
clear(tree[idx].sum);
tree[idx].add = 0;
if (left == right) {
tree[idx].sum[0][0] = val[left];
tree[idx].sum[0][1] = 0;
tree[idx].sum[1][1] = val[left];
tree[idx].sum[1][0] = 0;
return;
}
int mid = tree[idx].mid();
init(left, mid, idx << 1, val);
init(mid + 1, right, (idx << 1) + 1, val);
push_up(idx);
}
void set(int pos, int idx, long long val) {
push_down(idx);
if (tree[idx].left == tree[idx].right) {
tree[idx].sum[0][0] = val;
tree[idx].sum[0][1] = 0;
tree[idx].sum[1][1] = val;
tree[idx].sum[1][0] = 0;
return;
}
int mid = tree[idx].mid();
if (pos <= mid)
set(pos, idx << 1, val);
else
set(pos, (idx << 1) + 1, val);
push_up(idx);
}
void add(int left, int right, int idx, long long val) {
push_down(idx);
if (left <= tree[idx].left && right >= tree[idx].right) {
tree[idx].add += val;
tree[idx].add %= mod;
return;
}
int mid = tree[idx].mid();
if (left <= mid) add(left, right, idx << 1, val);
if (mid < right) add(left, right, (idx << 1) + 1, val);
push_up(idx);
}
void push_down(int idx) {
if (tree[idx].add) {
int l = tree[idx].len();
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
tree[idx].sum[i][j] += sum[l][i][j] * tree[idx].add;
tree[idx].sum[i][j] %= mod;
}
}
if (tree[idx].left != tree[idx].right) {
tree[idx << 1].add += tree[idx].add;
tree[idx << 1].add %= mod;
tree[(idx << 1) + 1].add += tree[idx].add;
tree[(idx << 1) + 1].add %= mod;
}
tree[idx].add = 0;
}
}
void push_up(int idx) {
if (tree[idx].left == tree[idx].right) return;
push_down(idx << 1);
push_down((idx << 1) + 1);
long long tmp[2][2];
mult(tree[(idx << 1) + 1].sum, POW[tree[idx << 1].len()], tmp);
::add(tree[idx << 1].sum, tmp, tree[idx].sum);
}
void query(int left, int right, int idx, long long res[2][2]) {
push_down(idx);
if (left == tree[idx].left && right == tree[idx].right) {
memcpy(res, tree[idx].sum, sizeof(tree[idx].sum));
return;
}
int mid = tree[idx].mid();
if (right <= mid)
query(left, right, idx << 1, res);
else if (left > mid)
query(left, right, (idx << 1) + 1, res);
else {
long long tmp1[2][2];
long long tmp2[2][2];
query(left, mid, idx << 1, tmp1);
query(mid + 1, right, (idx << 1) + 1, tmp2);
int len = mid - left + 1;
long long tmp3[2][2];
mult(tmp2, POW[len], tmp3);
::add(tmp1, tmp3, res);
}
}
};
int N, M;
SegTree tree;
int arr[maxn];
void init() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%d", arr + i);
}
tree.init(1, N, 1, arr);
}
void work() {
for (int i = 1; i <= M; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int x, v;
scanf("%d%d", &x, &v);
tree.set(x, 1, v);
} else if (t == 2) {
int l, r;
scanf("%d%d", &l, &r);
long long tmp[2][2];
tree.query(l, r, 1, tmp);
long long res = tmp[1][1];
res %= mod;
res += mod;
res %= mod;
printf("%d\n", ((int)res));
} else {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
tree.add(l, r, 1, d);
}
}
}
int main() {
build();
init();
work();
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int mxn = 1e5 + 1;
const int MOD = 1e9 + 7;
using namespace std;
int main() {
int t = 1;
while (t--) {
int n;
cin >> n;
int A[n];
int mn = INT_MAX;
for (int i = 0; i < n; ++i) {
cin >> A[i];
mn = min(A[i], mn);
}
int ans = INT_MAX;
int last = -1;
for (int i = 0; i < n; ++i) {
if (A[i] == mn) {
if (last == -1)
last = i;
else {
ans = min(i - last, ans);
last = i;
}
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, nxt, w;
} e[400001];
int edge_num = -1;
int head[200001];
void add(int u, int v) {
e[++edge_num].nxt = head[u];
e[edge_num].to = v;
head[u] = edge_num;
}
void add_edge(int u, int v) {
add(u, v);
add(v, u);
}
struct node {
int l, r;
} q[200001];
int in[200001];
void dfs(int u) {
for (int i = head[u]; i != -1; i = e[i].nxt) {
head[u] = i;
if (e[i].w == 0) {
e[i].w = 1, e[i ^ 1].w = 2;
dfs(e[i].to);
}
}
}
int main() {
memset(head, -1, sizeof(head));
int n;
scanf("%d", &n);
vector<int> v;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].r++;
v.push_back(q[i].l);
v.push_back(q[i].r);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (int i = 1; i <= n; i++) {
q[i].l = lower_bound(v.begin(), v.end(), q[i].l) - v.begin() + 1;
q[i].r = lower_bound(v.begin(), v.end(), q[i].r) - v.begin() + 1;
add_edge(q[i].l, q[i].r);
in[q[i].l]++;
in[q[i].r]++;
}
vector<int> v1;
for (int i = 1; i <= v.size(); i++)
if (in[i] % 2 == 1) v1.push_back(i);
for (int i = 0; i < v1.size(); i += 2) add_edge(v1[i], v1[i + 1]);
for (int i = 1; i <= v.size(); i++) dfs(i);
for (int i = 0; i < 2 * n; i++) {
if (e[i].w == 1) printf("%d ", i % 2);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int mod = 998244353;
using namespace std;
struct ft {
int a1, b1, a2, b2;
} a[300000], b[300000];
int min_v[300000];
int n;
int find(int cur) {
int l = 0, r = n;
while (l + 1 < r) {
int mid = (l + r) >> 1;
if (a[mid].a1 > cur) {
r = mid;
} else {
l = mid;
}
}
return r;
}
int sb1[300000], sb2[300000];
int max_t;
void add(int* s, int t) {
for (; t <= max_t; t += t & -t) {
s[t]++;
}
}
int get(int* s, int t) {
int tot = 0;
while (t) {
tot += s[t];
t -= t & -t;
}
return tot;
}
map<int, int> sb_idx;
int max_v[300000];
int sol() {
memset(sb1, 0, sizeof(sb1));
memset(sb2, 0, sizeof(sb2));
set<int> x1, x2;
for (int i = 0; i < n; ++i) {
x2.insert(a[i].a2);
x2.insert(a[i].b2);
b[i] = a[i];
}
sb_idx.clear();
int idx = 1;
for (auto x : x2) {
sb_idx[x] = idx++;
}
max_t = idx;
auto cmp = [&](const ft& a, const ft& b) {
return a.a1 < b.a1 || (a.a1 == b.a1 && a.b1 < b.b1);
};
auto cmp1 = [&](const ft& a, const ft& b) { return a.b1 < b.b1; };
sort(a, a + n, cmp);
sort(b, b + n, cmp1);
int pos = n - 1;
int tot = 0;
set<int> ft1;
set<pair<int, int> > ft2;
for (int i = n - 1; i >= 0; --i) {
if (i == n - 1)
max_v[i] = a[i].a2;
else
max_v[i] = min(max_v[i + 1], a[i].a2);
ft2.insert(make_pair(a[i].a1, i));
while (pos > i) {
if (a[pos].a1 > b[i].b1) {
add(sb1, sb_idx[a[pos].a2]);
add(sb2, sb_idx[a[pos].b2]);
tot++;
pos--;
} else {
break;
}
}
int num = 0;
int cur = a[i].b2;
int ret = get(sb1, sb_idx[b[i].b2]);
num = tot - ret;
ret = get(sb2, sb_idx[b[i].a2] - 1);
num += ret;
if (num != tot) {
return 0;
}
}
return 1;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
int sa1, sb1, sa2, sb2;
cin >> sa1 >> sb1 >> sa2 >> sb2;
a[i] = {sa1, sb1, sa2, sb2};
}
int ok = 1;
if (!sol()) {
ok = 0;
} else {
for (int i = 0; i < n; ++i) {
swap(a[i].a1, a[i].a2);
swap(a[i].b1, a[i].b2);
}
ok = sol();
}
printf("%s\n", ok ? "YES" : "NO");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int add(int a, int b) { return (a + b) % MOD; }
int mul(int a, int b) { return (long long)a * b % MOD; }
int n;
char buf[100005];
string s;
vector<char> d;
vector<string> q;
pair<long long, long long> operator+(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return pair<long long, long long>(mul(a.first, b.first),
add(mul(a.second, b.first), b.second));
}
pair<long long, long long> dig[10];
pair<long long, long long> solve(string &s) {
int n = s.size();
pair<long long, long long> ret = {1, 0};
for (int i = 0; i < n; ++i) ret = ret + dig[s[i] - '0'];
return ret;
}
int main(void) {
cin >> s;
cin >> n;
for (int i = (0); i < (n); ++i) {
scanf("%s", buf);
d.push_back(buf[0]);
q.push_back(string(buf + 3));
}
for (int i = (0); i < (10); ++i) dig[i] = {10, i};
for (int i = n - 1; i >= 0; --i) dig[d[i] - '0'] = solve(q[i]);
cout << solve(s).second << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
long long dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
class pa3 {
public:
long long x;
long long y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
long long x;
long long y, z, w;
pa4(long long x = 0, long long y = 0, long long z = 0, long long w = 0)
: x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
long long x, y;
pa2(long long x = 0, long long y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long Gcd(long long v, long long b) {
if (v == 0) return b;
if (b == 0) return v;
if (v > b) return Gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return Gcd(v, b % v);
}
long long mod;
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 d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pair<long long, long long> operator+(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first + r.first, l.second + r.second};
}
pair<long long, long long> operator-(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first - r.first, l.second - r.second};
}
ostream &operator<<(ostream &os, const vector<long long> &VEC) {
for (auto v : VEC) os << v << " ";
return os;
}
ostream &operator<<(ostream &os, const pair<long long, long long> &PAI) {
os << PAI.first << " : " << PAI.second;
return os;
}
ostream &operator<<(ostream &os, const pa3 &PAI) {
os << PAI.x << " : " << PAI.y << " : " << PAI.z;
return os;
}
ostream &operator<<(ostream &os, const pa4 &PAI) {
os << PAI.x << " : " << PAI.y << " : " << PAI.z << " : " << PAI.w;
return os;
}
long long beki(long long wa, long long rr, long long warukazu) {
if (rr == 0) return 1 % warukazu;
if (rr == 1) return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
long long pr[1100000];
long long inv[1100000];
long long comb(long long nn, long long rr) {
if (rr < 0 || rr > nn || nn < 0) return 0;
long long r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(long long ert) {
pr[0] = 1;
for (long long i = 1; i <= ert; i++) {
pr[i] = ((long long)pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (long long i = ert - 1; i >= 0; i--) {
inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
}
}
struct unionfind {
private:
public:
vector<long long> par, ranks, kosuu;
void shoki(long long N) {
par.resize(N + 1, 0);
ranks.resize(N + 1, 0);
kosuu.resize(N + 1, 1);
for (long long i = 0; i <= N; i++) {
par[i] = i;
}
}
long long root(long long x) {
return par[x] == x ? x : par[x] = root(par[x]);
}
bool same(long long x, long long y) { return root(x) == root(y); }
bool is_root(long long x) { return x == root(x); }
void unite(long long x, long long y) {
x = root(x);
y = root(y);
long long xx = kosuu[x], yy = kosuu[y];
if (x == y) return;
if (ranks[x] < ranks[y]) {
par[x] = y;
kosuu[y] = yy + xx;
} else {
par[y] = x;
if (ranks[x] == ranks[y]) ranks[x] = ranks[x] + 1;
kosuu[x] = yy + xx;
}
return;
}
};
long long ch(long long a, long long b, long long d) {
if (a < 0 || b < 0) return 1;
if (a + b == 0) {
if (d == 0)
return 1;
else
return 0;
}
if (a == 0 && b == 1) {
if (d == 0) return 0;
return 1;
}
if (a == 1 && b == 0) {
if (d == 1) return 0;
return 1;
}
if (a) {
if (ch(a - 2, b, d) == 1 && ch(a - 1, b - 1, d) == 1) return 1;
}
if (b) {
if (ch(a - 1, b - 1, d ^ 1) == 1 && ch(a, b - 2, d ^ 1) == 1) return 1;
}
return 0;
}
long long ch2(long long a, long long b, long long g) {
if (g == 1) {
if (a % 2) {
if (b % 4 == 0) return 0;
return 1;
} else {
if (b % 4 == 0 || b % 4 == 3) return 0;
return 1;
}
}
if (g == 0) {
if (a % 2) {
if (b % 4 == 2) return 0;
return 1;
} else {
if (b % 4 == 2 || b % 4 == 1) return 0;
return 1;
}
}
}
void solve() {
long long n;
set<long long> se;
cin >> n;
long long a;
vector<long long> w;
cin >> a;
w.push_back(a);
long long it = 1;
vector<pair<long long, long long> > tan;
while (1) {
if (it > a) break;
long long g;
if (a % it == 0) {
g = a / it;
se.insert(g);
se.insert(g - 1);
it++;
continue;
}
g = a / it;
se.insert(g);
long long ue = a / g;
if (a % g == 0) ue--;
it = ue + 1;
}
vector<pair<long long, long long> > ve;
for (auto v : se) {
ve.push_back(make_pair(v, 1));
}
for (long long er = 1; er < n; er++) {
cin >> a;
w.push_back(a);
for (auto &v : ve)
if (v.second)
if (v.first > 0) {
long long x = v.first;
if (a / x < a / (x + 1) + !!(a % (x + 1))) {
v.second = 0;
}
}
}
long long gg = 1;
for (auto v : ve)
if (v.second) {
gg = v.first + 1;
}
long long ans = 0;
for (auto v : w) ans += v / gg + !!(v % gg);
cout << ans << endl;
}
signed main() {
mod = 1000000007;
cin.tie(0);
ios::sync_with_stdio(false);
long long n = 1;
for (long long i = 0; i < n; i++) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int b[10][10];
int a[20], r[20];
int val, n;
int cal() {
int delta = 0;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < n; j++) sum += b[i][j];
delta = max(delta, abs(sum - val));
}
for (int j = 0; j < n; j++) {
int sum = 0;
for (int i = 0; i < n; i++) sum += b[i][j];
delta = max(delta, abs(sum - val));
}
int sum = 0;
for (int i = 0; i < n; i++) sum += b[i][i];
delta = max(delta, abs(sum - val));
sum = 0;
for (int i = 0; i < n; i++) sum += b[i][n - 1 - i];
delta = max(delta, abs(sum - val));
return delta;
}
int main() {
while (scanf("%d", &n) == 1) {
int sum = 0;
for (int i = 0; i < n * n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
val = sum / n;
for (int i = 0; i < n * n; i++) r[i] = i;
while (true) {
random_shuffle(r, r + n * n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) b[i][j] = a[r[i * n + j]];
for (int i = 0; i < 1000; i++) {
int x = rand() % n, y = rand() % n;
int x2 = rand() % n, y2 = rand() % n;
int num1 = cal();
swap(b[x][y], b[x2][y2]);
int num2 = cal();
if (num1 < num2) swap(b[x][y], b[x2][y2]);
}
if (cal() == 0) {
printf("%d\n", val);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) printf("%d ", b[i][j]);
printf("\n");
}
break;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int SQRTMAX = 4e7;
const int MOD = 998244353;
long long D;
bool d[SQRTMAX + 5];
vector<int> primes;
vector<long long> primesInD;
void PrecomputePrimes() {
for (int i = 3; i * i <= SQRTMAX; i += 2)
if (!d[i])
for (int j = i * i; j <= SQRTMAX; j += 2 * i) d[j] = 1;
primes.push_back(2);
for (int i = 3; i <= SQRTMAX; i += 2)
if (!d[i]) primes.push_back(i);
}
long long GCD(long long x, long long y) {
long long r = x % y;
while (r) {
x = y;
y = r;
r = x % y;
}
return y;
}
const int DIVMAX = 1e3;
int fact[DIVMAX + 5], invFact[DIVMAX + 5];
int LgPut(int base, int exp) {
int ans = 1, aux = base;
for (long long i = 1LL; i <= exp; i <<= 1) {
if (i & exp) ans = (1LL * ans * aux) % MOD;
aux = (1LL * aux * aux) % MOD;
}
return ans;
}
void PrecFact() {
fact[0] = 1;
for (int i = 1; i <= DIVMAX; i++) {
fact[i] = (1LL * i * fact[i - 1]) % MOD;
invFact[i] = LgPut(fact[i], MOD - 2);
}
}
int FactRep(int n, vector<int> vf) {
int ans = fact[n];
for (auto it : vf) ans = (1LL * ans * invFact[it]) % MOD;
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
PrecomputePrimes();
PrecFact();
cin >> D;
for (auto it : primes)
if (D % it == 0) {
primesInD.push_back(it);
while (D % it == 0) D /= it;
}
if (D != 1) primesInD.push_back(D);
int Q;
cin >> Q;
while (Q--) {
long long x, y;
cin >> x >> y;
long long gcd = GCD(x, y);
long long xx = x / gcd, yy = y / gcd;
vector<int> frecsX;
int sumFrecsX = 0;
vector<int> frecsY;
int sumFrecsY = 0;
for (auto it : primesInD)
if (it <= xx) {
int exp = 0;
while (xx % it == 0) {
exp++;
xx /= it;
}
sumFrecsX += exp;
if (exp) {
frecsX.push_back(exp);
}
} else
break;
if (xx != 1) {
sumFrecsX += 1;
frecsX.push_back(1);
}
for (auto it : primesInD)
if (it <= yy) {
int exp = 0;
while (yy % it == 0) {
exp++;
yy /= it;
}
sumFrecsY += exp;
if (exp) frecsY.push_back(exp);
} else
break;
if (yy != 1) {
sumFrecsY += 1;
frecsY.push_back(1);
}
cout << (1LL * FactRep(sumFrecsX, frecsX) * FactRep(sumFrecsY, frecsY)) %
MOD
<< '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int a = 0, b = 0, c = 0;
char ch;
while (ch = getchar()) {
if (ch == '1')
a++;
else if (ch == '2')
b++;
else if (ch == '3')
c++;
else if (ch == '\n')
break;
}
bool first = true;
for (int i = 0; i < a; i++) {
if (first == true) {
printf("1");
first = false;
} else
printf("+1");
}
for (int i = 0; i < b; i++) {
if (first == true) {
printf("2");
first = false;
} else
printf("+2");
}
for (int i = 0; i < c; i++) {
if (first == true) {
printf("3");
first = false;
} else
printf("+3");
}
printf("\n");
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define mp make_pair
#define pb push_back
#define fr(i,a,b) for(ll i=a;i<b;i++)
#define fr1(j,a,b) for(ll j=a;j<b;j++)
#define fr2(v,a,b) for(ll v = a -1;v>=0;v--)
void solve()
{
ll n,k;
cin>>n>>k;
for(int i =1;i<=2*k-n-1;i++)
cout<<i<<" ";
for(int i = 1;i<=n-k;i++)
cout<<k-i+1<<" ";
cout<<2*k-n;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t = 1;
cin>>t;
while(t--)
{
solve();
cout<<endl;
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
queue<int> D, R;
int n;
string s;
cin >> n >> s;
for (int i = 0; i < n; ++i) s[i] == 'D' ? D.push(i + 1) : R.push(i + 1);
while (D.size() && R.size()) {
if (D.front() > R.front()) {
D.pop();
int tmp = R.front() + n;
R.pop();
R.push(tmp);
} else {
R.pop();
int tmp = D.front() + n;
D.pop();
D.push(tmp);
}
}
if (D.size())
puts("D");
else
puts("R");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double PI = acos(-1);
int main() {
double h, w, a;
cin >> w >> h >> a;
if (a == 180 || a == 0) {
cout << fixed << setprecision(10) << h * w << endl;
return 0;
}
if (a == 90) {
h = min(h, w);
w = h;
cout << fixed << setprecision(10) << h * w << endl;
return 0;
}
if (h > w) swap(h, w);
if (a > 90) a = 180 - a;
a *= PI;
a /= 180.0;
double a1 = 2 * atan2(h, w);
if (a >= a1) {
double h1 = h / sin(a);
double x = h1 * cos(a);
double res = h * x + (h1 - x) * h;
cout << fixed << setprecision(10) << res;
return 0;
}
double x1 = (w - h * (1 + cos(a)) / sin(a)) *
(sin(a) / (-(1 + cos(a)) * (1 + cos(a)) + sin(a) * sin(a)));
double l1 = (h - (x1 * (1 + cos(a)))) / sin(a);
double l2 = l1 * sin(a);
double l3 = l1 * cos(a);
double x2 = x1 * sin(a);
double x3 = x1 * cos(a);
double res = h * w;
res -= x3 * x2;
res -= l3 * l2;
cout << fixed << setprecision(10) << res;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[4], num, sum;
string s[4], str;
bool check(char ch) {
return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';
}
int work() {
sum = 0;
for (int i = str.length() - 1; i >= 0; i--) {
sum += check(str[i]);
if (sum == m) return i;
}
return -1;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 4; j++) {
cin >> str;
num = work();
if (!~num) {
puts("NO");
return 0;
}
s[j] = str.substr(num);
}
if (s[0] == s[1] && s[1] == s[2] && s[2] == s[3])
a[0] = 1;
else if (s[0] == s[1] && s[2] == s[3])
a[1] = 1;
else if (s[0] == s[2] && s[1] == s[3])
a[2] = 1;
else if (s[0] == s[3] && s[1] == s[2])
a[3] = 1;
else {
puts("NO");
return 0;
}
}
if (a[0] && !(a[1] || a[2] || a[3]))
puts("aaaa");
else if (a[1] && !(a[2] || a[3]))
puts("aabb");
else if (a[2] && !(a[1] || a[3]))
puts("abab");
else if (a[3] && !(a[1] || a[2]))
puts("abba");
else
puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = (long long int)1e9 + 7;
vector<string> vt;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
vt.push_back(str);
}
long long int ret = 1LL;
for (int i = 0; i < m; i++) {
set<int> s;
for (int j = 0; j < n; j++) {
s.insert(vt[j][i]);
}
ret = ret * 1LL * s.size();
ret %= mod;
}
cout << ret << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100];
priority_queue<int, vector<int>, greater<int>> pq;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
pq.push(1);
for (int i = 1; i < n; ++i) {
if (pq.top() <= a[i]) {
pq.push(pq.top() + 1);
pq.pop();
} else
pq.push(1);
}
cout << pq.size();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const N = 10e5 + 5;
int const mod = 998244353;
long double min(long double x, long double y) {
if (x < y)
return x;
else
return y;
}
long double max(long double x, long double y) {
if (x > y)
return x;
else
return y;
}
long long gcd(long long x, long long y) {
if (x == 0)
return y;
else
return gcd(y % x, x);
}
long long pwr(long long x, long long e) {
long long res = 1;
while (e) {
if (e & 1) {
res = (res * x) % mod;
}
e /= 2;
x = (x * x) % mod;
}
return res;
}
long long cnt[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long tt;
tt = 1;
while (tt--) {
long long n, m;
cin >> n;
vector<vector<long long> > v(n);
vector<long long> k(n);
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> k[i];
v[i].resize(k[i]);
for (auto &it : v[i]) {
cin >> it;
cnt[it]++;
}
}
for (int i = 0; i < n; i++) {
long long temp = 0;
for (auto j : v[i]) temp += cnt[j];
temp %= mod;
temp *= pwr(k[i], mod - 2);
temp %= mod;
temp *= pwr(n, mod - 2);
temp %= mod;
temp *= pwr(n, mod - 2);
temp %= mod;
ans += temp;
}
cout << ans % mod << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
class dsu {
public:
unordered_map<int, int> p, sz;
void make_set(int x) {
p[x] = x;
sz[x] += 1;
}
int find(int x) {
if (x == p[x]) return x;
return p[x] = find(p[x]);
}
void merge(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
p[b] = a;
sz[a] += sz[b];
sz.erase(b);
}
};
long long power(long long x, long long y, long long p) {
long long res = 1;
x %= p;
while (y) {
if (y & 1) res = (res % p * x % p) % p;
y >>= 1;
x = (x % p * x % p) % p;
}
return res;
}
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y >>= 1;
x = (x * x);
}
return res;
}
long long modi(long long a, long long p) { return power(a, p - 2, p); }
int main() {
int n;
cin >> n;
long long ans = 24 * power(4, n - 3) + (n - 3) * 36 * power(4, n - 4);
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& _s, vector<T> _t) {
for (int i = 0; i < (int)(_t.size()); i++) _s << (i ? " " : "") << _t[i];
return _s;
}
template <typename T>
istream& operator>>(istream& _s, vector<T>& _t) {
for (int i = 0; i < (int)(_t.size()); i++) _s >> _t[i];
return _s;
}
template <typename T, typename U>
ostream& operator<<(ostream& _s, pair<T, U> _t) {
_s << "(" << _t.first << "," << _t.second << ")";
return _s;
}
template <typename T, typename U>
istream& operator>>(istream& _s, pair<T, U>& _t) {
_s >> _t.first >> _t.second;
return _s;
}
const double PI = 3.14159265358979;
void fft(valarray<complex<double> >& x, valarray<complex<double> >& roots) {
int N = x.size();
if (N <= 1) return;
valarray<complex<double> > even = x[slice(0, N / 2, 2)];
valarray<complex<double> > odd = x[slice(1, N / 2, 2)];
valarray<complex<double> > rs = roots[slice(0, N / 2, 2)];
fft(even, rs);
fft(odd, rs);
for (int k = 0; k < (int)(N / 2); k++) {
auto t = roots[k] * odd[k];
x[k] = even[k] + t;
x[k + N / 2] = even[k] - t;
}
}
vector<double> conv(const vector<double>& a, const vector<double>& b) {
int s = a.size() + b.size() - 1, L = 32 - __builtin_clz(s), n = 1 << L;
if (s <= 0) return {};
valarray<complex<double> > av(n), bv(n), roots(n);
for (int i = 0; i < (int)(n); i++) roots[i] = polar(1.0, -2 * PI * i / n);
copy(a.begin(), a.end(), begin(av));
fft(av, roots);
copy(b.begin(), b.end(), begin(bv));
fft(bv, roots);
roots = roots.apply(conj);
valarray<complex<double> > cv = av * bv;
fft(cv, roots);
vector<double> c(s);
for (int i = 0; i < (int)(s); i++) c[i] = cv[i].real() / n;
return c;
}
long long fastexp(long long a, long long p, long long mod) {
a = ((a % mod) + mod) % mod;
long long res = 1 % mod;
for (; p; a = (a * a) % mod, p /= 2)
if (p % 2) res = (res * a) % mod;
return res;
}
const long long mod = (119 << 23) + 1, root = 3;
void ntt(long long* x, long long* temp, long long* roots, int N, int skip) {
if (N == 1) return;
int n2 = N / 2;
ntt(x, temp, roots, n2, skip * 2);
ntt(x + skip, temp, roots, n2, skip * 2);
for (int i = 0; i < (int)(N); i++) temp[i] = x[i * skip];
for (int i = 0; i < (int)(n2); i++) {
long long s = temp[2 * i], t = temp[2 * i + 1] * roots[skip * i];
x[skip * i] = (s + t) % mod;
x[skip * (i + n2)] = (s - t) % mod;
}
}
void ntt(vector<long long>& x, bool inv = false) {
long long e = fastexp(root, (mod - 1) / x.size(), mod);
if (inv) e = fastexp(e, mod - 2, mod);
vector<long long> roots(x.size(), 1), temp = roots;
for (int i = 1; i < (int)(x.size()); i++) roots[i] = roots[i - 1] * e % mod;
ntt(&x[0], &temp[0], &roots[0], x.size(), 1);
}
vector<long long> conv(vector<long long> a, vector<long long> b) {
int s = a.size() + b.size() - 1;
if (s <= 0) return {};
int L = s > 1 ? 32 - __builtin_clz(s - 1) : 0, n = 1 << L;
if (s <= 200) {
vector<long long> c(s);
for (int i = 0; i < (int)(a.size()); i++)
for (int j = 0; j < (int)(b.size()); j++)
c[i + j] = (c[i + j] + a[i] * b[j]) % mod;
return c;
}
a.resize(n);
ntt(a);
b.resize(n);
ntt(b);
vector<long long> c(n);
long long d = fastexp(n, mod - 2, mod);
for (int i = 0; i < (int)(n); i++) c[i] = a[i] * b[i] % mod * d % mod;
ntt(c, true);
c.resize(s);
return c;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
long long bound;
cin >> n >> bound;
vector<int> pref = {0};
vector<long long> orig;
for (int i = 0; i < (int)(n); i++) {
pref.push_back(pref.back());
int c;
cin >> c;
orig.push_back(c);
if (c < bound) pref.back()++;
}
vector<long long> a(n + 1, 0);
for (auto x : pref) a[x]++;
vector<long long> la1(n + 1, 0), la2(n + 1, 0);
vector<double> da1(n + 1, 0), da2(n + 1, 0);
for (int i = 0; i < (int)(n + 1); i++) {
da1[i] = a[i];
da2[i] = a[n - i];
la1[i] = a[i];
la2[i] = a[n - i];
}
vector<double> dres = conv(da1, da2);
vector<long long> lres = conv(la1, la2);
vector<long long> res(n + 1);
for (int i = 0; i < (int)(n + 1); i++) {
while (abs(lres[i] + mod - dres[i]) < abs(lres[i] - dres[i])) {
lres[i] += mod;
}
res[n - i] = lres[i];
}
res[0] = 0;
for (int i = 0; i < (int)(n); i++) {
res[0] += (a[i] * (a[i] - 1)) / 2;
}
for (int i = 0; i < (int)(n + 1); i++) {
cout << res[i] << " ";
}
cout << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ull = uint64_t;
using ll = int64_t;
using ld = long double;
using namespace std;
const int INF = 1e9 + 228;
const int N = 1000228;
bool w[N];
int cur[N];
vector<pair<int, int>> c[N];
vector<pair<int, int>> evs[N];
vector<int> e[N];
int sz[N];
vector<int> cc;
int d[N];
void dfs_sz(int v, int p) {
if (w[v]) {
sz[v] = 0;
return;
}
cc.push_back(v);
sz[v] = 1;
for (int u : e[v]) {
if (u != p) {
dfs_sz(u, v);
sz[v] += sz[u];
}
}
}
void dfs_push(int v, int p, int cen, int d) {
if (w[v]) {
return;
}
c[v].emplace_back(cen, d);
assert(c[v].size() < 22);
for (int u : e[v]) {
if (u != p) {
dfs_push(u, v, cen, d + 1);
}
}
}
int q[N];
int qe;
void dfs_main(int s) {
if (w[s]) {
return;
}
cc.clear();
dfs_sz(s, s);
int v = s;
for (int u : cc) {
d[u] = -1;
if (sz[u] * 2 >= sz[s] && sz[u] < sz[v]) {
v = u;
}
}
qe = 1;
q[0] = v;
d[v] = 0;
for (int qb = 0; qb < qe; ++qb) {
int u = q[qb];
c[u].emplace_back(v, d[u]);
for (int t : e[u]) {
if (d[t] == -1) {
d[t] = d[u] + 1;
q[qe++] = t;
}
}
}
w[v] = true;
for (int u : e[v]) {
dfs_main(u);
}
}
void z() {
cout << 0 << "\n";
exit(0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.setf(ios::fixed);
cout.precision(20);
string s;
cin >> s;
vector<int> c = {1};
vector<char> cc = {'a'};
char last{};
for (char x : s) {
if (x == last) {
++c.back();
} else {
last = x;
c.push_back(1);
cc.push_back(last);
}
}
if (c.size() % 2) {
z();
}
for (int i = 1;; ++i) {
int j = c.size() - i;
if (i >= j) {
break;
}
if (cc[i] != cc[j] || c[i] + c[j] < 3) {
z();
}
}
int m = c[c.size() / 2];
if (m < 2) {
z();
}
cout << m + 1 << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename TT>
ostream &operator<<(ostream &s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream &operator<<(ostream &s, vector<T> t) {
s << "{";
for (int i = 0; i < t.size(); i++)
s << t[i] << (i == t.size() - 1 ? "" : ",");
return s << "}" << endl;
}
long long c[1001][1001];
long long s[1001];
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> c[i][j];
int bx = -1;
long long B = 1LL << 60;
for (int i = 0; i < n; i++) s[i] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) s[i] += c[i][j];
for (int i = 0; i < n + 1; i++) {
long long w = 0;
int pos = 4 * i;
int akt = 2;
for (int j = 0; j < n; j++) {
w += ((pos - akt) * (pos - akt)) * s[j];
akt += 4;
}
if (w < B) {
B = w;
bx = i;
}
}
long long wyn = B;
int by = -1;
B = 1LL << 60;
for (int i = 0; i < m; i++) s[i] = 0;
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) s[i] += c[j][i];
for (int i = 0; i < m + 1; i++) {
long long w = 0;
int pos = 4 * i;
int akt = 2;
for (int j = 0; j < m; j++) {
w += ((pos - akt) * (pos - akt)) * s[j];
akt += 4;
}
if (w < B) {
B = w;
by = i;
}
}
cout << wyn + B << "\n";
;
cout << bx << " " << by << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int num, val;
} nums[200005];
int stc[200005], top = 0, ans[200005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &nums[i].num);
}
for (int i = 1; i <= n; i++) {
while (nums[stc[top]].num >= nums[i].num) {
nums[stc[top]].val += i - stc[top];
if (nums[stc[top]].num == nums[i].num) nums[stc[top]].val++;
top--;
}
nums[i].val = i - stc[top] - 1;
stc[++top] = i;
}
while (top) {
nums[stc[top]].val += n + 1 - stc[top];
top--;
}
for (int i = 1; i <= n; i++) {
if (nums[i].num > ans[nums[i].val]) ans[nums[i].val] = nums[i].num;
}
for (int i = n; i; i--) {
if (ans[i] < ans[i + 1]) ans[i] = ans[i + 1];
}
for (int i = 1; i <= n; i++) {
if (i > 1) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
long long N = 1e16;
int n;
cin >> n;
vector<long long> a(n + 1), b(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
vector<vector<long long>> dp(3, vector<long long>(n + 1, N));
for (int i = 1; i <= n; i++) dp[0][i] = b[i];
for (int i = 2; i <= n; i++) {
for (int j = 1; j < i; j++) {
if (a[i] > a[j]) {
dp[1][i] = min(dp[1][i], dp[0][j] + b[i]);
dp[2][i] = min(dp[2][i], dp[1][j] + b[i]);
}
}
}
long long ans = N;
int flag = 1;
for (int i = 1; i <= n; i++) {
if (dp[2][i] != N) {
flag = 0;
ans = min(ans, dp[2][i]);
}
}
if (flag) ans = -1;
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, k, l, arr[100009] = {}, brr[100009] = {};
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
brr[arr[i]]++;
}
m = 0;
for (i = 1; i <= 100000; i++) {
if (i == 1)
l = brr[i];
else if (brr[i] > l) {
printf("-1");
return 0;
} else if (brr[i] < l)
l = brr[i];
}
printf("%d\n", brr[1]);
for (i = 0; i < n; i++) {
m = arr[i];
l = brr[m];
printf("%d ", l);
brr[m]--;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 1;
struct Edge {
long long a;
long long b;
long long c;
long long t;
bool operator<(const Edge &other) const { return c < other.c; }
};
long long n, q;
long long arr[N];
long long ord[N];
long long ids[N];
long long mxi[N];
long long bst[N];
long long pre[N];
long long dep[N];
long long val[N][20];
long long tbl[N][20];
pair<long long, long long> que[N];
pair<long long, long long> ans[N];
vector<pair<long long, long long>> con[N];
long long get(long long u, long long v) {
if (dep[u] > dep[v]) swap(u, v);
long long dis = dep[v] - dep[u];
long long res = 0;
for (long long i = 19; i >= 0; i--) {
if (dis >> i & 1) {
res = max(res, val[v][i]);
v = tbl[v][i];
}
}
if (u == v) return res;
for (long long i = 19; i >= 0; i--) {
if (tbl[v][i] != tbl[u][i]) {
res = max(res, val[v][i]);
res = max(res, val[u][i]);
v = tbl[v][i];
u = tbl[u][i];
}
}
res = max(res, val[v][0]);
res = max(res, val[u][0]);
return res;
}
long long fnd(long long i) {
if (ids[i] != i) ids[i] = fnd(ids[i]);
return ids[i];
}
void unn(long long a, long long b) {
a = fnd(a);
b = fnd(b);
if (arr[bst[b]] > arr[bst[a]]) {
swap(a, b);
} else if (arr[bst[a]] == arr[bst[b]]) {
mxi[a] = max(get(bst[a], bst[b]), max(mxi[a], mxi[b]));
}
ids[b] = a;
}
void dfs(long long i, long long p, long long x, long long d) {
pre[i] = p;
dep[i] = d;
tbl[i][0] = p;
val[i][0] = x;
for (long long h = 1; h <= 19; h++) {
tbl[i][h] = tbl[tbl[i][h - 1]][h - 1];
val[i][h] = max(val[i][h - 1], val[tbl[i][h - 1]][h - 1]);
}
for (auto [v, t] : con[i]) {
if (v != p) {
dfs(v, i, t, d + 1);
}
}
}
bool cmp(long long a, long long b) { return que[a].first > que[b].first; }
signed main() {
cin >> n >> q;
for (long long i = 1; i <= n; i++) cin >> arr[i];
vector<Edge> edges;
for (long long i = 2; i <= n; i++) {
Edge e;
cin >> e.a >> e.b >> e.c >> e.t;
con[e.a].emplace_back(e.b, e.t);
con[e.b].emplace_back(e.a, e.t);
edges.push_back(e);
}
dfs(1, 0, 0, 0);
sort(begin(edges), end(edges));
for (long long i = 1; i <= q; i++) {
cin >> que[i].first >> que[i].second;
}
iota(ord + 1, ord + 1 + q, 1);
sort(ord + 1, ord + 1 + q, cmp);
iota(ids + 1, ids + 1 + n, 1);
iota(bst + 1, bst + 1 + n, 1);
long long idx = n - 2;
for (long long i = 1; i <= q; i++) {
long long j = ord[i];
while (idx >= 0 && edges[idx].c >= que[j].first) {
unn(edges[idx].a, edges[idx].b), idx--;
}
long long p = que[j].second;
long long r = max(get(p, bst[fnd(p)]), mxi[fnd(p)]);
ans[j] = make_pair(arr[bst[fnd(p)]], r);
}
for (long long i = 1; i <= q; i++)
cout << ans[i].first << " " << ans[i].second << "\n";
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mpp;
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
long long tt;
cin >> tt;
while (tt--) {
mpp.clear();
mpp[0] = 1;
long long n, x;
cin >> n >> x;
long long sum = 0;
string s;
cin >> s;
for (auto &i : s) {
if (i == '0')
sum++;
else
sum--;
mpp[sum]++;
}
if (!sum) {
if (mpp.find(x) != mpp.end())
cout << "-1\n";
else
cout << "0\n";
} else {
long long ans = 0;
for (auto &i : mpp) {
if ((x - i.first) % sum == 0 && (x - i.first) / sum >= 0) {
if (i.first == 0 && (x - i.first) / sum > 0) ans--;
ans += i.second;
}
}
cout << ans << "\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 11111;
const int INF = int(1e9);
int n, m;
int ans[N];
int value[N];
int L[N], R[N];
int main() {
scanf("%d%d", &n, &m);
while (n--) {
getchar();
bool flag = false;
for (int i = 0; i < m; ++i) {
value[i] = getchar() - '0';
flag |= value[i];
}
if (!flag) return puts("-1"), 0;
for (int i = 0; i < m; ++i)
L[i] = value[i] ? 0 : (i == 0 ? INF : L[i - 1] + 1);
for (int i = 0; i < m; ++i) L[i] = min(L[i], L[(i - 1 + m) % m] + 1);
for (int i = m - 1; i >= 0; --i)
R[i] = value[i] ? 0 : (i == m - 1 ? INF : R[i + 1] + 1);
for (int i = m - 1; i >= 0; --i) R[i] = min(R[i], R[(i + 1) % m] + 1);
for (int i = 0; i < m; ++i) ans[i] += min(L[i], R[i]);
}
int res = INF;
for (int i = 0; i < m; ++i) res = min(res, ans[i]);
printf("%d\n", res);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
int h, w;
int hor[N][N];
int ver[N][N];
char s[N][N];
void prepare() {
for (int i = 0; i <= h; i++) {
for (int j = 0; j <= w; j++) {
if (j == 0) {
hor[i][j] = 0;
} else {
hor[i][j] += hor[i][j - 1] + hor[i - 1][j] - hor[i - 1][j - 1];
if (j < w && s[i - 1][j - 1] == '.' && s[i - 1][j] == '.') hor[i][j]++;
}
if (i == 0) {
ver[i][j] = 0;
} else {
ver[i][j] += ver[i][j - 1] + ver[i - 1][j] - ver[i - 1][j - 1];
if (i < h && s[i - 1][j - 1] == '.' && s[i][j - 1] == '.') ver[i][j]++;
}
}
}
}
int main() {
scanf("%d %d", &h, &w);
for (int i = 0; i < h; i++) {
scanf("%s", s[i]);
}
prepare();
int q;
scanf("%d", &q);
while (q--) {
int xa, ya, xb, yb;
scanf("%d %d %d %d", &xa, &ya, &xb, &yb);
int ans = hor[xb][yb - 1] - hor[xa - 1][yb - 1] + hor[xa - 1][ya - 1] -
hor[xb][ya - 1];
ans += ver[xb - 1][yb] - ver[xa - 1][yb] - ver[xb - 1][ya - 1] +
ver[xa - 1][ya - 1];
printf("%d\n", ans);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
struct node {
int id, next;
node() {}
node(int a, int b) {
id = a;
next = b;
}
};
struct Brige {
int x, y;
} brige[maxn];
vector<int> v[maxn], g[maxn];
vector<node> q[maxn];
int dfn[maxn], low[maxn];
int f[maxn], belong[maxn];
bool visit[maxn];
int n, m, k, cnt, t, bge;
void init() {
for (int i = 1; i <= n; i++) {
v[i].clear();
g[i].clear();
}
}
int find(int x) {
if (x != f[x]) f[x] = find(f[x]);
return f[x];
}
void merge(int a, int b) {
int x = find(a), y = find(b);
if (x == y) return;
f[y] = x;
}
void tarjan(int u, int father) {
visit[u] = true;
cnt++;
dfn[u] = low[u] = cnt;
for (int i = 0; i < (int)v[u].size(); i++) {
int x = v[u][i];
if (!visit[x]) {
tarjan(x, u);
low[u] = min(low[u], low[x]);
if (low[x] > dfn[u]) {
bge++;
brige[bge].x = u;
brige[bge].y = x;
}
if (low[x] <= dfn[u]) merge(x, u);
} else if (x != father)
low[u] = min(low[u], dfn[x]);
}
}
void rebuild() {
t = 0;
memset(belong, -1, sizeof(belong));
for (int i = 1; i <= n; i++) {
int x = find(i);
if (belong[x] == -1) {
t++;
belong[x] = t;
}
belong[i] = belong[x];
}
for (int i = 1; i <= bge; i++) {
int a = brige[i].x, b = brige[i].y;
g[belong[a]].push_back(belong[b]);
g[belong[b]].push_back(belong[a]);
}
}
void solve() {
memset(visit, false, sizeof(visit));
cnt = 0;
bge = 0;
for (int i = 1; i <= n; i++) f[i] = i;
tarjan(1, 0);
rebuild();
}
bool Solve[maxn], check[maxn];
int ans[maxn], d[maxn];
void lca(int u) {
visit[u] = true;
for (int i = 0; i < (int)g[u].size(); i++) {
int x = g[u][i];
if (!visit[x]) {
d[x] = d[u] + 1;
lca(x);
f[x] = u;
}
}
check[u] = true;
for (int i = 0; i < (int)q[u].size(); i++) {
int x = q[u][i].next;
if (check[x] == true && Solve[q[u][i].id] == false) {
int ansestor = find(x);
ans[q[u][i].id] = d[u] + d[x] - 2 * d[ansestor];
Solve[q[u][i].id] = true;
}
}
}
int main() {
int a, b;
while (scanf("%d%d", &n, &m) != EOF) {
init();
while (m--) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
solve();
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d%d", &a, &b);
a = belong[a], b = belong[b];
q[a].push_back(node(i, b));
q[b].push_back(node(i, a));
}
memset(visit, false, sizeof(visit));
memset(Solve, false, sizeof(Solve));
memset(check, false, sizeof(check));
for (int i = 1; i <= t; i++) f[i] = i;
d[1] = 0;
lca(1);
for (int i = 1; i <= k; i++) printf("%d\n", ans[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e7 + 100;
int n, m;
long long ans, a, b, c;
bool isp[maxn];
int p[maxn], cnt[maxn], phi[maxn], cnt2[maxn];
void pre() {
phi[1] = 1;
for (int i = 2; i <= n; ++i) {
isp[i] = 1;
}
for (int i = 2; i <= n; ++i) {
if (isp[i]) {
phi[i] = i - 1;
p[m++] = i;
}
for (int j = 0; j < m; ++j) {
if (1ll * p[j] * i > n) {
break;
}
int x = p[j] * i;
++cnt[p[j]];
isp[x] = 0;
if (i % p[j] == 0) {
phi[x] = phi[i] * p[j];
break;
}
phi[x] = phi[i] * phi[p[j]];
}
}
for (int i = n - 1; i >= 0; --i) {
cnt[i] += cnt[i + 1];
}
return;
}
int main() {
scanf("%d", &n);
pre();
if (n <= 3) {
puts("0");
return 0;
}
for (int i = 2; i <= n; ++i) {
if (isp[i] && i * 2 > n) {
continue;
}
++b;
a += (i - phi[i] - 1);
if (isp[i]) {
cnt2[i] = 1;
c += cnt[n / i + 1];
}
}
for (int i = n - 1; i > 1; --i) {
cnt2[i] += cnt2[i + 1];
}
for (int i = 2; i <= n; ++i) {
if (isp[i] && i * 2 <= n) {
int j = n / i + 1;
if (j < i) {
c += cnt2[j] - cnt2[i];
}
}
}
b = b * (b - 1) / 2 - a - c;
printf("%I64d\n", a + b * 2 + c * 3);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, j, xx, yy, ans;
long long pr[500001];
int fs(int x) {
if (pr[x] == x)
return x;
else {
pr[x] = fs(pr[x]);
return pr[x];
}
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) pr[i] = i;
long long ans = 1, x, y;
for (i = 0; i < m; ++i) {
scanf("%d%d", &x, &y);
xx = fs(x);
yy = fs(y);
if (xx == yy) ans = (ans * 2) % 1000000009;
cout << (ans - 1 + 1000000009) % 1000000009 << endl;
if (xx != yy) pr[xx] = yy;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double pi = 3.14159265358979323846;
long long mod = 1000000000 + 7;
const int N = 1e5 + 5;
vector<bool> prime(N, true);
bool Rev(long long a, long long b) { return (a > b); }
void solve() {
long long n, m;
cin >> n >> m;
if (m == 1) {
long long i;
for (long long i = 0; i < n; i += 1) cout << 1 << "\n";
return;
}
if (m & 1) {
long long mid = (m + 1) / 2;
long long i;
long long flag = 1, f = 1;
long long k = 1;
for (long long i = 1; i < n + 1; i += 1) {
if (flag) {
cout << mid << "\n";
flag = 0;
} else {
cout << mid - k << "\n";
if (i < n) {
cout << mid + k << "\n";
i++;
}
if (mid + k == m) {
flag = 1;
k = 1;
} else
k++;
}
}
} else {
long long mid = (m + 1) / 2;
long long i;
long long k = 0;
for (long long i = 0; i < n; i += 1) {
cout << mid - k << "\n";
if (i < n - 1) {
cout << mid + k + 1 << "\n";
i++;
}
if (mid + k + 1 == m) {
k = 0;
} else
k++;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
solve();
}
| 2 |
// codeforce
// wangqc
#include<iostream>
#include<vector>
using namespace std;
const int M = 1e9+7;
vector<int> p, rk, ans;
int find(int x)
{
return x == p[x] ? x : p[x]=find(p[x]);
}
int connect(int x, int y)
{
int px = find(x), py = find(y);
if(px == py) return false;
if(rk[px] < rk[py]) swap(px, py);
if(rk[px] == rk[py]) rk[px]++;
p[py] = px;
return true;
}
int main()
{
int n, m;
cin >> n >> m;
p.resize(m+2), rk.resize(m+2), ans.clear();
for(int i = 0; i <= m; i++)
p[i] = i, rk[i] = 0;
int k, x, y;
for(int i = 1; i <= n; i++)
{
cin >> k >> x;
if(k == 1) y = m+1;
else cin >> y;
if(connect(x, y)) ans.push_back(i);
}
n = ans.size(), m = 1;
for(int _ = 0; _ < n; _++) m = (m<<1) % M;
cout << m << " " << n << endl;
for(int i : ans) cout << i << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long ans, visited[100009];
vector<pair<long long, long long>> adj[100009];
long long dfs(int s, int dist) {
visited[s] = 1;
long long mx = dist;
for (auto u : adj[s]) {
if (!visited[u.second]) mx = max(mx, dfs(u.second, dist + u.first));
}
return mx;
}
int main() {
long long n, i, a, b, w;
cin >> n;
int bas;
for (i = 1; i < n; i++) {
cin >> a >> b >> w;
adj[a].push_back({w, b});
adj[b].push_back({w, a});
ans += 2 * w;
}
cout << ans - dfs(1, 0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 150005;
const long long inf = 0x3f3f3f3f3f3f3f3f;
struct LineContainer {
static const long long inf = 2e18;
static bool modeQ;
struct Line {
mutable long long a, b, end;
long long intersect(const Line& r) const {
if (a == r.a) return b > r.b ? inf : -inf;
long long u = b - r.b, d = r.a - a;
return u / d - ((u ^ d) < 0 && u % d);
}
bool operator<(const Line& r) const {
return modeQ ? end < r.end : a < r.a;
}
};
multiset<Line> S;
void clear() { S.clear(); }
void init() {
S.clear();
S.insert({0, -inf, inf});
}
bool update(multiset<Line>::iterator it) {
auto cur = it++;
cur->end = inf;
if (it == S.end()) return false;
cur->end = cur->intersect(*it);
return cur->end >= it->end;
}
void ins(long long a, long long b) {
auto it = S.insert({a, b, inf});
while (update(it)) it = --S.erase(++it);
while (it != S.begin() && update(--it)) {
update(it = --S.erase(++it));
}
while (it != S.begin() && update(--it)) {
update(it = --S.erase(++it));
}
}
long long query(long long x) {
assert(!S.empty());
modeQ = 1;
auto l = *S.lower_bound({0, 0, x});
modeQ = 0;
return l.a * x + l.b;
}
} Tree;
bool LineContainer::modeQ = false;
struct edge {
int u, v, w, next;
} G[max_n * 2];
int head[max_n], tot;
void init(int n) {
tot = 2;
for (int i = 0; i <= n; i++) head[i] = 0;
}
void add_edge(int u, int v, int w = 1) {
G[tot] = {u, v, w, head[u]};
head[u] = tot++;
}
void reverse(int u) {
vector<int> edge;
for (int i = head[u]; i; i = G[i].next) edge.push_back(i);
reverse(edge.begin(), edge.end());
head[u] = edge[0];
for (int i = 0; i + 1 < edge.size(); i++) G[edge[i]].next = edge[i + 1];
G[edge.back()].next = 0;
}
int sz[max_n], big[max_n];
bool vis[max_n];
int SZ, rt;
void dfsrt(int u, int fa) {
sz[u] = 1;
big[u] = 0;
for (int i = head[u]; i; i = G[i].next) {
int v = G[i].v, w = G[i].w;
if (v == fa || vis[v]) continue;
dfsrt(v, u);
sz[u] += sz[v];
big[u] = max(big[u], sz[v]);
}
big[u] = max(big[u], SZ - sz[u]);
if (rt == -1 || big[u] < big[rt]) rt = u;
}
int getsz(int v, int u, int siz) { return sz[v] < sz[u] ? sz[v] : siz - sz[u]; }
int getrt(int u) {
SZ = sz[u], rt = -1;
dfsrt(u, 0);
return rt;
}
int a[max_n];
long long ans = 0;
void solve(int u) {
vis[u] = true;
function<void(int, int, int, long long, long long)> dfs1 =
[&](int u, int fa, int d, long long s1, long long s2) {
ans = max(ans, Tree.query(s1) + s2);
for (int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (v == fa || vis[v]) continue;
dfs1(v, u, d + 1, s1 + a[v], s2 + 1ll * a[v] * (d + 1));
}
};
function<void(int, int, int, long long, long long)> dfs2 =
[&](int u, int fa, int d, long long s1, long long s2) {
Tree.ins(d, s2);
ans = max(ans, s2);
for (int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (v == fa || vis[v]) continue;
dfs2(v, u, d + 1, s1 + a[v], s2 + s1 + a[v]);
}
};
ans = max(ans, a[u] * 1ll);
Tree.init();
Tree.ins(1, a[u]);
for (int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (vis[v]) continue;
dfs1(v, u, 1, a[v], a[v]);
dfs2(v, u, 2, a[u] + a[v], a[u] * 2 + a[v]);
}
reverse(u);
Tree.init();
for (int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (vis[v]) continue;
dfs1(v, u, 1, a[v], a[v]);
dfs2(v, u, 2, a[u] + a[v], a[u] * 2 + a[v]);
}
reverse(u);
int siz = SZ;
for (int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (vis[v]) continue;
solve(getrt(v));
}
}
int n;
int main() {
scanf("%d", &n);
init(n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v), add_edge(v, u);
}
for (int i = 1; i <= n; i++) scanf("%d", a + i);
sz[1] = n;
solve(getrt(1));
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long n;
long long a[N];
long long cache[N][2];
long long dp(long long x, long long sign) {
if (x <= 0 || x > n) return 0;
long long &ans = cache[x][sign];
if (ans != -1) return ans;
ans = -1e13;
if (!sign)
ans = a[x] + dp(x + a[x], sign ^ 1);
else
ans = a[x] + dp(x - a[x], sign ^ 1);
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
memset(cache, -1, sizeof(cache));
cin >> n;
for (long long i = 2; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n - 1; i++) {
long long ans = i + dp(i + 1, 1);
if (ans < 0) ans = -1;
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double eps = 1e-10;
const double pi = acos(-1.0);
const int maxn = 2e5 + 10;
const long long inf = 0x3f3f3f3f;
int a[maxn], dp[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, p, k;
cin >> n >> p >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
dp[0] = 0;
int ans = 0;
for (int i = 1; i <= n; i++) {
dp[i] = dp[i - 1] + a[i];
if (i >= k) dp[i] = min(dp[i], dp[i - k] + a[i]);
if (dp[i] <= p) ans = i;
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[1000];
int main() {
int n, mn = 100, cnt = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
mn = min(mn, a[i]);
}
for (int i = 1; i <= n; ++i) cnt += (a[i] == mn);
if (2 * cnt <= n)
cout << "Alice";
else
cout << "Bob";
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, i, max, a, b, train;
while (scanf("%d", &n) != EOF) {
train = 0;
max = 0;
for (i = 0; i < n; i++) {
scanf("%d %d", &a, &b);
train = train + b - a;
if (train > max) {
max = train;
}
}
printf("%d\n", max);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, a, b;
cin >> n >> k >> a >> b;
if (k == 1) {
cout << (n - 1) * a;
return 0;
}
long long ans = 0;
while (n) {
if (n == k) {
ans += min((n - 1) * a, b);
break;
}
if (n < k) {
ans += (n - 1) * a;
break;
}
long long kk = (n / k);
ans += min((n - kk) * a, b + (n % k) * a);
n /= k;
}
printf("%lld", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int64_t MOD = 1000000007;
int32_t main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int64_t n;
cin >> n;
string s, t;
cin >> s >> t;
vector<string> v;
string curr = "abc";
do {
string s1 = "";
for (int64_t i = 0; i < n; i++) s1 += curr;
v.push_back(s1);
v.push_back(string(n, curr[0]) + string(n, curr[1]) + string(n, curr[2]));
} while (next_permutation(curr.begin(), curr.end()));
for (auto str : v) {
if (str.find(s) == string::npos && str.find(t) == string::npos) {
cout << "YES" << '\n' << str << '\n';
return 0;
}
}
cout << "NO" << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll n, m;
int main() {
cin >> n >> m;
ll cur = 1;
const ll mod = 1000000009;
for (ll i = 1; i <= m; i++) {
cur = (cur * 2LL) % mod;
}
ll ans = 1;
for (ll i = 1; i <= n; i++) {
ll val = (cur - i) % mod + mod;
val %= mod;
ans = (ans * val) % mod;
}
ans = (ans + mod) % mod;
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int OO = 0x3f3f3f3f;
template <class A, class B>
ostream& operator<<(ostream& out, const pair<A, B>& p) {
return out << "(" << p.first << ", " << p.second << ")";
}
template <class A>
ostream& operator<<(ostream& out, const vector<A>& v) {
out << "[";
for (int i = 0; i < int((v).size()); ++i) {
if (i) out << ", ";
out << v[i];
}
return out << "]";
}
long long inv(long long a, long long b) {
return 1 < a ? b - inv(b % a, a) * b / a : 1;
}
long long Pow(long long B, long long P) {
long long R = 1;
while (P > 0) {
if (P & 1) R = (R * B);
P /= 2;
B = (B * B);
}
return R;
}
long long GCD(long long a, long long b) {
while (b) {
b ^= a ^= b ^= a %= b;
}
return a;
}
long long LCM(long long a, long long b) { return (a / GCD(a, b) * b); }
long long BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P & 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return (long long)R;
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
map<int, int> mp1, mp2;
for (int i = 0; i < m; ++i) {
int t;
cin >> t;
++mp1[t];
cin >> t;
++mp2[t];
}
int ans = 0;
for (int i = 2; i < n; ++i) {
if (mp1[i] == 0 && mp2[i] == 0) {
ans += 2;
if ((n & 1) && n / 2 == (i - 1)) --ans;
} else if (mp1[i] == 0 || mp2[i] == 0)
++ans;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int cnt[100010 + 1];
const int mod = 1e9 + 7;
void solve() {
map<int, int> nox, noy;
map<pair<int, int>, int> txy;
int n;
cin >> n;
long long int ans = 0;
while (n--) {
int x, y;
cin >> x >> y;
ans += (nox[x]++);
ans += (noy[y]++);
ans -= (txy[make_pair(x, y)]++);
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
t = 1;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a[110000], b[110000], mx = -1100000000, m;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (mx < a[i]) {
mx = a[i];
m = i;
}
b[i] = a[i];
}
sort(a + 1, a + n + 1);
if (k == 1)
cout << a[1];
else if (k == 2 && m < n && m > 1)
cout << max(b[1], b[n]);
else
cout << a[n];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
t = 1;
while (t--) {
string a, b;
long long i, ans = 0;
cin >> a >> b;
long long pre = 0;
for (i = 0; i < a.size(); i++) {
long long cur = (a[i] == '0') + (b[i] == '0');
if (cur == 0) {
pre = 0;
} else if (cur == 1) {
if (pre == 2) {
ans++;
pre = 0;
} else
pre = 1;
} else {
if (pre == 2) {
ans++;
pre = 1;
} else if (pre == 1) {
ans++;
pre = 0;
} else
pre = 2;
}
}
cout << ans;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
struct DSU {
long long M[400005];
DSU(long long n) {
for (long long i = 0; i < n; i++) {
M[i] = i;
}
}
long long find(long long x) {
while (M[x] != x) {
long long p = M[x];
M[x] = M[p];
x = p;
}
return x;
}
bool join(long long x, long long y) {
long long xr = find(x);
long long yr = find(y);
if (xr == yr) {
return false;
} else {
M[xr] = yr;
return true;
}
}
};
using namespace std;
int main() {
long long n, m, q;
cin >> n >> m >> q;
DSU dsu(n + m);
long long z = n + m - 1;
for (long long i = 0; i < q; i++) {
long long r, c;
cin >> r >> c;
r--;
c--;
if (dsu.join(r, c + n)) z--;
}
cout << z;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[102];
vector<int> cleared;
int n, m;
int main() {
cin >> n >> m;
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
adj[a - 1].push_back(b - 1);
adj[b - 1].push_back(a - 1);
}
int sum = 0;
int cnt = 0;
bool works = true;
while (works) {
cleared.clear();
for (int i = 0; i < n; i++) {
if (adj[i].size() == 1) {
cnt++;
cleared.push_back(i);
adj[i].clear();
}
}
for (int k = 0; k < cleared.size(); k++) {
int i = cleared[k];
for (int j = 0; j < adj[adj[i][0]].size(); j++) {
if (adj[adj[i][0]][j] == i) {
adj[adj[i][0]].erase(adj[adj[i][0]].begin() + j);
}
}
}
if (cnt == 0) {
works = false;
} else {
sum += 1;
}
cnt = 0;
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
inline bool mina(A &x, B y) {
return (x > y) ? (x = y, 1) : 0;
}
template <typename A, typename B>
inline bool maxa(A &x, B y) {
return (x < y) ? (x = y, 1) : 0;
}
int N;
long long L, R;
int PC(long long a) {
int c = 0;
while (a > 0) {
c += a & 1;
a >>= 1;
}
return c;
}
int main() {
cin >> N;
for (int _b = (N), n = (0); n < _b; ++n) {
cin >> L >> R;
long long best = L;
int bc = PC(L);
long long t = 0;
int c = 0;
for (int _a = (-1), i = (62); i > _a; --i) {
if (t + (1LL << i) <= R) {
t += 1LL << i;
if (t > L && maxa(bc, c + i)) best = t - 1;
++c;
}
}
if (maxa(bc, PC(R))) best = R;
cout << best << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<long long, bool> present;
long long x[2005];
long long y[2005];
long long ans = 0;
long long C[5005][5005];
long long fac[5005];
int main() {
long long a, b, c;
cin >> a >> b >> c;
fac[0] = 1;
C[0][0] = 1;
for (long long i = 1; i <= 5000; ++i) {
fac[i] = (fac[i - 1] * i) % (long long)998244353;
C[i][0] = 1;
for (long long j = 1; j <= i; ++j) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % (long long)998244353;
}
}
long long ans1 = 0;
for (long long i = 0; i <= min(a, b); ++i) {
long long res = 1;
res = (res * C[a][i]) % (long long)998244353;
res = (res * C[b][i]) % (long long)998244353;
res = (res * fac[i]) % (long long)998244353;
ans1 = (ans1 + res) % (long long)998244353;
}
long long ans2 = 0;
for (long long i = 0; i <= min(a, c); ++i) {
long long res = 1;
res = (res * C[a][i]) % (long long)998244353;
res = (res * C[c][i]) % (long long)998244353;
res = (res * fac[i]) % (long long)998244353;
ans2 = (ans2 + res) % (long long)998244353;
}
long long ans3 = 0;
for (long long i = 0; i <= min(c, b); ++i) {
long long res = 1;
res = (res * C[c][i]) % (long long)998244353;
res = (res * C[b][i]) % (long long)998244353;
res = (res * fac[i]) % (long long)998244353;
ans3 = (ans3 + res) % (long long)998244353;
}
cout << (((ans1 * ans2) % (long long)998244353) * ans3) % (long long)998244353
<< endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int powermodm(long long int x, long long int n, long long int M) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
long long int power(long long int _a, long long int _b) {
long long int _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a);
_b /= 2;
_a = (_a * _a);
}
return _r;
}
long long int gcd(long long int a, long long int b) {
while (a && b) a > b ? a %= b : b %= a;
return a + b;
}
long long int lcm(long long int a, long long int b) {
return (max(a, b) / gcd(a, b)) * min(a, b);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n, h;
cin >> n >> h;
long long int x1[n + 1], x2[n + 1], i, j;
for (i = 0; i < n; i++) cin >> x1[i] >> x2[i];
x1[n] = 1000000000;
x2[n] = 1000000001;
long long int dist[n + 2];
memset(dist, 0, sizeof(dist));
for (i = 1; i <= n; i++) {
dist[i] = dist[i - 1] + x1[i] - x2[i - 1];
}
long long int ans = 0;
for (i = 0; i < n; i++) {
long long int l = i + 1, r = n, mi = n;
ans = max(ans, x2[i] - x1[i]);
while (l <= r) {
long long int mid = (l + r) >> 1;
if (dist[mid] - dist[i] >= h) {
mi = min(mi, mid);
r = mid - 1;
} else
l = mid + 1;
}
long long int tmp = x2[mi - 1] - x1[i] + (h - (dist[mi - 1] - dist[i]));
ans = max(ans, tmp);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, dp[55][55][55][55], mdo[55][55];
bool use[55][55][55][55];
char c;
int getSum(int f1, int c1, int f2, int c2) {
return mdo[f2][c2] - mdo[f1 - 1][c2] - mdo[f2][c1 - 1] + mdo[f1 - 1][c1 - 1];
}
int fn(int f1, int c1, int f2, int c2) {
if (f1 > f2 || c1 > c2) return 0;
if (f1 == f2 && c1 == c2) return getSum(f1, c1, f2, c2);
if (!getSum(f1, c1, f2, c2)) return 0;
if (use[f1][c1][f2][c2]) return dp[f1][c1][f2][c2];
use[f1][c1][f2][c2] = true;
int myAns = max(f2 - f1 + 1, c2 - c1 + 1);
for (int i = c1; i < c2; i++)
myAns = min(myAns, fn(f1, c1, f2, i) + fn(f1, i + 1, f2, c2));
for (int i = f1; i < f2; i++)
myAns = min(myAns, fn(f1, c1, i, c2) + fn(i + 1, c1, f2, c2));
return dp[f1][c1][f2][c2] = myAns;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
scanf(" %c", &c);
if (c == '#') mdo[i][j] = 1;
mdo[i][j] += mdo[i - 1][j] + mdo[i][j - 1] - mdo[i - 1][j - 1];
}
printf("%d", fn(1, 1, n, n));
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.