solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000")
using namespace std;
bool a[1100][1100];
bool visited[1100][1100];
bool valid(int n, int m) {
for (int(i) = 0; (i) < (n); (i)++) {
bool flag = false;
for (int(j) = (1); (j) < (m); (j)++) {
if (a[i][j - 1] && !a[i][j]) flag = true;
if (!a[i][j - 1] && a[i][j] && flag) return false;
}
}
for (int(j) = 0; (j) < (m); (j)++) {
bool flag = false;
for (int(i) = (1); (i) < (n); (i)++) {
if (a[i - 1][j] && !a[i][j]) flag = true;
if (!a[i - 1][j] && a[i][j] && flag) return false;
}
}
bool freerow = false, freecol = false;
for (int(i) = 0; (i) < (n); (i)++) {
bool flag = false;
for (int(j) = 0; (j) < (m); (j)++)
if (a[i][j]) {
flag = true;
break;
}
if (!flag) freerow = true;
}
for (int(j) = 0; (j) < (m); (j)++) {
bool flag = false;
for (int(i) = 0; (i) < (n); (i)++)
if (a[i][j]) {
flag = true;
break;
}
if (!flag) freecol = true;
}
return !(freecol ^ freerow);
}
void dfs(int x, int y, int &n, int &m) {
visited[x][y] = true;
int dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
for (int(i) = 0; (i) < (4); (i)++) {
int xx = x + dir[i][0];
int yy = y + dir[i][1];
if (xx >= 0 && xx < n && yy >= 0 && yy < m && a[xx][yy] && !visited[xx][yy])
dfs(xx, yy, n, m);
}
};
int main() {
int n, m;
cin >> n >> m;
for (int(i) = 0; (i) < (n); (i)++) {
string s;
cin >> s;
for (int(j) = 0; (j) < (m); (j)++) {
a[i][j] = s[j] == '#';
visited[i][j] = false;
}
}
if (!valid(n, m)) {
cout << -1 << endl;
} else {
int component = 0;
for (int(i) = 0; (i) < (n); (i)++)
for (int(j) = 0; (j) < (m); (j)++)
if (a[i][j] && !visited[i][j]) {
dfs(i, j, n, m);
component++;
}
cout << component << endl;
}
}
| 6 |
#include <bits/stdc++.h>
int arr[10][10] = {{1, 1, 1, 1, 1, 1, 0}, {0, 1, 1, 0, 0, 0, 0},
{1, 1, 0, 1, 1, 0, 1}, {1, 1, 1, 1, 0, 0, 1},
{0, 1, 1, 0, 0, 1, 1}, {1, 0, 1, 1, 0, 1, 1},
{1, 0, 1, 1, 1, 1, 1}, {1, 1, 1, 0, 0, 0, 0},
{1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 0, 1, 1}};
int devolve(int n) {
int count = 0;
for (int i = 0; i < 10; i++) {
count++;
for (int j = 0; j < 10; j++)
if (arr[n][j] == 1 && arr[i][j] == 0) {
count--;
break;
}
}
return count;
}
int main(void) {
char x, y;
scanf("%c", &x);
scanf("%c", &y);
x -= '0';
y -= '0';
printf("%d\n", devolve(x) * devolve(y));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mi, ma, n, d, k, l, r, mid, a[500007], b[500007], cnt[500007];
inline long long read() {
long long s = 0, w = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') w = -1;
for (; isdigit(c); c = getchar()) s = (s << 3) + (s << 1) + (c ^ 48);
return (s * w);
}
inline bool check() {
long long num = 0, sum = 0;
for (int i = 1; i <= n; i++) {
long long delta = mid - cnt[i] - b[i] - sum;
if (delta <= 0) {
sum = sum + b[i];
continue;
}
num = num + delta;
if (num > k) {
for (int j = min(i + 2 * d, n); j; j--) b[j] = 0;
return false;
}
b[i] = b[i] + delta;
if (i + 2 * d < n) b[i + 2 * d + 1] = b[i + 2 * d + 1] - delta;
sum = sum + b[i];
}
for (int i = 1; i <= n; i++) b[i] = 0;
return true;
}
int main() {
n = read(), d = read(), k = read();
mi = LLONG_MAX;
for (int i = 1; i <= n; i++) {
long long x = read();
a[max(1LL, i - d)] = a[max(1LL, i - d)] + x;
if (i + d < n) a[i + d + 1] = a[i + d + 1] - x;
}
for (int i = 1; i <= n; i++)
cnt[i] = cnt[i - 1] + a[i], ma = max(ma, cnt[i]), mi = min(mi, cnt[i]);
l = mi, r = ma + k;
while (l < r) {
mid = (l + r + 1) >> 1;
if (check())
l = mid;
else
r = mid - 1;
}
printf("%lld\n", l);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 5000 + 9;
int n;
int h[MAX_N];
int pref[MAX_N];
map<int, int> dp[MAX_N];
int main() {
scanf("%d", &n);
pref[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &h[i]);
pref[i] = pref[i - 1] + h[i];
}
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = i - 1; j >= 0; --j) {
int hnew = pref[i] - pref[j];
int steps = i - j - 1;
auto it = dp[j].lower_bound(hnew + 1);
if (it != dp[j].begin())
it--;
else
continue;
int s = steps + it->second;
auto nit = dp[i].upper_bound(hnew);
while (nit != dp[i].end() && nit->second >= s) {
auto tmp = nit++;
dp[i].erase(nit);
nit = tmp;
}
if (nit == dp[i].begin()) {
dp[i][hnew] = s;
} else {
nit--;
if (nit->second <= s) {
} else {
dp[i][hnew] = s;
}
}
}
}
cout << dp[n].rbegin()->second;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(int a, int b) { return a > b; }
int main() {
char a[10] = {1};
int b[7] = {1}, i, k = 0;
cin >> a;
sort(a, a + 6);
for (i = 0; i < 5; ++i) {
if (a[i] == a[i + 1])
b[k]++;
else {
++k;
b[k]++;
}
}
sort(b, b + k + 1, cmp);
if (b[0] == 6) {
cout << 1;
} else if (b[0] == 5 && b[1] == 1) {
cout << 1;
} else if (4 == b[0] && 2 == b[1]) {
cout << 2;
} else if (3 == b[0] && 3 == b[1]) {
cout << 2;
} else if (2 == b[0] && 2 == b[1] && 2 == b[2]) {
cout << 6;
} else if (3 == b[0] && 2 == b[1] && 1 == b[2]) {
cout << 3;
} else if (4 == b[0] && 1 == b[1] && 1 == b[1]) {
cout << 2;
} else if (3 == b[0] && 1 == b[1] && 1 == b[2] && 1 == b[3]) {
cout << 5;
} else if (2 == b[0] && 2 == b[1] && 1 == b[2] && 1 == b[3]) {
cout << 8;
} else if (2 == b[0] && 1 == b[1] && 1 == b[2] && 1 == b[3] && 1 == b[4]) {
cout << 15;
} else
cout << 30;
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, x, a[110000], ma = 0, mx = -1, sum[110000] = {0}, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
cin >> s;
for (int i = 0; i <= n; i++) {
if (i > 0) sum[i] = sum[i - 1];
if (s[i] == '0') sum[i] += a[i];
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '1' && sum[i] - a[i] > ma) {
ma = sum[i] - a[i];
mx = i;
}
}
for (int i = 0; i < n; i++) {
if (i < mx) ans += a[i];
if (i > mx && s[i] == '1') ans += a[i];
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l, r;
int cnt = 0;
int num[101] = {0};
int res[101] = {0};
for (size_t i = 0; i < n; i++) {
cin >> l >> r;
for (size_t j = l; j <= r; j++) {
num[j]++;
}
}
for (size_t i = 1, j = 0; i <= m; i++) {
if (num[i] == 0) {
res[j] = i;
cnt++;
j++;
}
}
cout << cnt << endl;
for (size_t i = 0; i < cnt; i++) {
cout << res[i] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
const long long N = 100000 + 10;
const long long inf = 0x3f3f3f3f;
long long i, j, n, k, save[N << 1];
int main() {
long long cnt = 0;
scanf("%I64d %I64d", &n, &k);
for (i = N; n; ++i) {
if (n & 1) {
save[i] = 1;
cnt++;
}
n >>= 1;
}
if (cnt > k) {
printf("No");
return 0;
}
printf("Yes\n");
k -= cnt;
for (i = N * 2 - 1; k >= save[i] && k; --i) {
k -= save[i];
save[i - 1] += save[i] * 2;
save[i] = 0;
}
for (i = 0; i <= N * 2; ++i)
if (save[i]) {
save[i--]--;
break;
}
for (; k; k--, i--) save[i]++;
save[++i]++;
for (i = N * 2; i >= 0; --i)
while (save[i]--) printf("%I64d ", i - N);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using std::set;
int num, tst, nr, c;
char buf[40];
long long arr[500000];
set<long long> cur, tm;
void gen(int pos, int ch) {
if (pos == num) {
if (ch) return;
long long t = 0;
for (int i = 0; i < num; ++i) t <<= 1, buf[i] == '1' && (t |= 1);
tm.insert(t);
} else {
if (num - pos >= ch && ch > 0) {
buf[pos] = 97 - buf[pos];
gen(pos + 1, ch - 1);
buf[pos] = 97 - buf[pos];
}
gen(pos + 1, ch);
}
}
int main() {
scanf("%d%d", &num, &tst);
scanf("%s%d", buf, &nr);
gen(0, num - nr);
cur = tm;
c = cur.size();
for (int i = 1; i < tst; ++i) {
tm.clear();
scanf("%s%d", buf, &nr);
gen(0, num - nr);
c = 0;
for (auto i = cur.begin(); i != cur.end(); ++i) {
if (tm.find(*i) != tm.end()) arr[c++] = *i;
}
if (c == 0) break;
cur.clear();
for (int i = 0; i < c; ++i) cur.insert(arr[i]);
}
printf("%d\n", c);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "{" << p.first << "," << p.second << "}";
return os;
}
const int N = 3e5 + 5;
const int oo = 1e9 + 7;
int incr[N << 2];
int decr[N << 2];
void build(int u, int ss, int se) {
if (ss == se) {
incr[u] = oo;
decr[u] = oo;
} else {
int mid = (ss + se) / 2;
build(u << 1, ss, mid);
build(u << 1 | 1, mid + 1, se);
incr[u] = oo;
decr[u] = oo;
}
}
void update_incr(int u, int ss, int se, int qs, int qe, int x) {
if (qe < ss or se < qs) return;
if (qs <= ss and se <= qe) {
incr[u] = min(incr[u], x + (ss - qs));
} else {
int mid = (ss + se) / 2;
update_incr(u << 1, ss, mid, qs, qe, x);
update_incr(u << 1 | 1, mid + 1, se, qs, qe, x);
}
}
void update_decr(int u, int ss, int se, int qs, int qe, int x) {
if (qe < ss or se < qs) return;
if (qs <= ss and se <= qe) {
decr[u] = min(decr[u], x - (ss - qs));
} else {
int mid = (ss + se) / 2;
update_decr(u << 1, ss, mid, qs, qe, x);
update_decr(u << 1 | 1, mid + 1, se, qs, qe, x);
}
}
int val(int u, int ss, int se, int x, int lazy) {
assert(ss <= x and x <= se);
lazy = min(lazy, incr[u] + (x - ss));
lazy = min(lazy, decr[u] - (x - ss));
if (ss == se) {
return lazy;
} else {
int mid = (ss + se) / 2;
if (x <= mid)
return val(u << 1, ss, mid, x, lazy);
else
return val(u << 1 | 1, mid + 1, se, x, lazy);
}
}
int a[N];
int b[N];
int ai[N];
int bi[N];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
ai[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
bi[b[i]] = i;
}
build(1, 1, n);
for (int i = 1; i <= n; i++) {
int x = ai[i];
int y = bi[i];
if (x <= y) {
int d = y - x;
update_decr(1, 1, n, 1, d + 1, d);
update_incr(1, 1, n, d + 1, y, 0);
d = n - x;
update_decr(1, 1, n, y + 1, n, d);
} else {
int d = x - y;
update_incr(1, 1, n, 1, y, d);
d = n - x;
update_decr(1, 1, n, y + 1, y + 1 + d, d);
update_incr(1, 1, n, y + 1 + d, n, 0);
}
}
for (int i = 1; i <= n; i++) cout << val(1, 1, n, i, oo) << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int S = 1e6, MAXN = S + 10;
int N;
bool vis[MAXN];
int A[MAXN];
vector<int> ans;
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
scanf("%d", &N);
for (int i = 0, x; i < N; i++) {
scanf("%d", &x);
vis[x] = true;
}
int npair = 0;
for (int i = 1; i <= S / 2; i++) {
bool v1 = vis[i], v2 = vis[S + 1 - i];
if (v1 && v2) {
npair++;
} else if (v1 || v2) {
if (v1) {
ans.push_back(S + 1 - i);
vis[S + 1 - i] = true;
} else {
ans.push_back(i);
vis[i] = true;
}
}
}
for (int i = 1; i <= S / 2 && npair; i++) {
if (!vis[i]) {
ans.push_back(i);
ans.push_back(S + 1 - i);
npair--;
}
}
printf("%d\n", int(ans.size()));
for (int x : ans) {
printf("%d ", x);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, w;
double arr[200000 + 5];
scanf("%d %d", &n, &w);
for (int i = int(0); i <= int(2 * n - 1); i++) {
scanf("%lf", &arr[i]);
}
sort(arr, arr + 2 * n);
double cap1 = arr[0], cap2 = arr[n] / 2.0, z = (double)w / (3 * n);
double ans = min(min(cap1, cap2), z);
cout << fixed;
cout << setprecision(6);
cout << ans * 3 * n << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[1000000 + 100];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
arr[i] += 1e9;
}
sort(arr + 1, arr + n + 1);
long long ans = 1e18, lo = 0, hi = 3e9;
for (int j = 0; j < 100; j++) {
long long m1 = lo + (hi - lo) / 3;
long long m2 = hi - (hi - lo) / 3;
long long d1 = 0, d2 = 0;
for (int i = 1; i <= n; i += m) {
d1 += max(0ll, m1 - arr[i]);
}
for (int i = n; i > 0; i -= m) {
d1 += max(0ll, arr[i] - m1);
}
for (int i = 1; i <= n; i += m) {
d2 += max(0ll, m2 - arr[i]);
}
for (int i = n; i > 0; i -= m) {
d2 += max(0ll, arr[i] - m2);
}
ans = min(ans, d1 * 2);
ans = min(ans, d2 * 2);
if (d1 * 2 <= d2 * 2) {
hi = m2;
} else {
lo = m1;
}
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using cd = complex<double>;
const int Inf = 1000000007;
const long long mod = 1000000007;
const double Pi = acos(-1);
void Fastio() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int n, t, ans = 0;
long long res = 0;
int Co[4], Color[100005], a[100005];
vector<int> Adj[100005];
map<int, long long> C;
int main() {
Fastio();
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int j = 2; j <= n; j++) {
int temp;
cin >> temp;
Adj[temp].emplace_back(j);
Adj[j].emplace_back(temp);
}
queue<int> BFS;
BFS.push(1);
Co[1] = 1;
Color[1] = 1;
while (BFS.empty() == false) {
int node = BFS.front();
for (auto x : Adj[node]) {
if (!Color[x]) {
Color[x] = 3 - Color[node];
Co[Color[x]]++;
BFS.push(x);
}
}
BFS.pop();
}
for (int i = 1; i <= n; i++) {
if (Adj[i].size() == 1 and i != 1) {
t = Color[i];
break;
}
}
t = 3 - t;
for (int i = 1; i <= n; i++) {
if (Color[i] == 3 - t) {
ans ^= a[i];
C[a[i]]++;
}
}
if (ans == 0) {
res += 1ll * Co[3 - t] * (Co[3 - t] - 1) / 2;
res += 1ll * Co[t] * (Co[t] - 1) / 2;
}
for (int i = 1; i <= n; i++) {
if (Color[i] == t) {
res += C[a[i] ^ ans];
}
}
cout << res;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 10006;
long long f[M], inv[M];
long long expo(long long base, long long exponent, long long mod) {
long long ans = 1;
while (exponent != 0) {
if (exponent & 1) ans = (1LL * ans * base) % mod;
base = (1LL * base * base) % mod;
exponent >>= 1;
}
return ans % mod;
}
void compute() {
f[0] = 1;
for (long long i = 1; i < M; i++) {
f[i] = (1LL * i * f[i - 1]) % 998244353;
}
inv[M - 1] = expo(f[M - 1], 998244353 - 2, 998244353);
for (long long i = M - 2; i >= 0; i--) {
inv[i] = (1LL * (i + 1) * inv[i + 1]) % 998244353;
}
}
long long C(long long n, long long r) {
return (1LL * ((1LL * f[n] * inv[r]) % 998244353) * inv[n - r]) % 998244353;
}
long long ff(long long n, long long s, long long u) {
if (n == 0) return s == 0;
if (s < 0 or u < 0) return 0;
long long ans = 0;
for (long long r = 0; r < n + 1; r++) {
long long k = s - (u + 1) * r;
if (k < 0) break;
if (r % 2) {
ans =
(ans - C(n, r) * C(n + k - 1, k) % 998244353 + 998244353) % 998244353;
} else {
ans =
(ans + C(n, r) * C(n + k - 1, k) % 998244353 + 998244353) % 998244353;
}
}
return ans;
}
long long inverse[1001];
void solve() {
compute();
for (long long i = 1; i < 1001; i++)
inverse[i] = expo(i, 998244353 - 2, 998244353);
long long p, s, r, ans = 0, den = 0;
cin >> p >> s >> r;
for (long long i = r; i < s + 1; i++) {
for (long long j = 1; j < p + 1; j++) {
ans = (ans + C(p - 1, j - 1) * ff(p - j, s - j * i, i - 1) % 998244353 *
inverse[j] % 998244353) %
998244353;
}
den = (den + ff(p - 1, s - i, s)) % 998244353;
}
ans = ans * expo(den, 998244353 - 2, 998244353) % 998244353;
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int all[4];
int getball[4];
int main() {
int i, cha = 0, zeng = 0;
for (i = 0; i < 3; i++) cin >> all[i];
for (i = 0; i < 3; i++) cin >> getball[i];
for (i = 0; i < 3; i++) {
if (all[i] - getball[i] < 0)
cha += all[i] - getball[i];
else
zeng += (all[i] - getball[i]) / 2;
}
if (cha + zeng >= 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const int maxn = 5010;
int t[2][maxn];
int inf = (long long)1e9 + 7;
int mod(int x) {
if (x < 0) {
return x + inf;
}
if (x >= inf) {
return x - inf;
}
return x;
}
int n;
void change(int it, int i, int delta) {
for (; i <= n; i = (i | (i + 1))) {
t[it][i] += delta;
t[it][i] = mod(t[it][i]);
}
}
int sum(int it, int r) {
int result = 0;
for (; r >= 1; r = (r & (r + 1)) - 1) {
result += t[it][r];
result = mod(result);
}
return result;
}
int sum(int it, int l, int r) {
if (l > 1) {
return mod(sum(it, r) - sum(it, l - 1));
} else {
return sum(it, r);
}
}
int mins(int x, int y) { return (x < y ? x : y); }
int maxs(int x, int y) { return (x > y ? x : y); }
int main() {
int k, a, b;
scanf("%d %d %d %d", &n, &a, &b, &k);
int now = 0;
for (int i = 1; i <= n; i++) {
t[1][i] = 1;
}
for (int i = 1; i <= k; i++) {
int nnow = (now + 1) & 1;
int sum = 0;
int last = 1;
for (int j = 1; j < b; j++) {
sum += t[nnow][j];
sum = mod(sum);
}
for (int j = 1; j < b; j++) {
int dst = abs(b - j) - 1;
if (dst == 0) {
t[now][j] = 0;
} else {
int l = maxs(1, j - dst);
while (last != l) {
sum -= t[nnow][last];
sum = mod(sum);
last++;
}
t[now][j] = mod(sum - t[nnow][j]);
}
}
sum = 0;
last = n;
for (int j = b + 1; j <= n; j++) {
sum += t[nnow][j];
sum = mod(sum);
}
for (int j = n; j > b; j--) {
int dst = abs(b - j) - 1;
if (dst == 0) {
t[now][j] = 0;
} else {
int l = mins(n, j + dst);
while (last != l) {
sum -= t[nnow][last];
sum = mod(sum);
last--;
}
t[now][j] = mod(sum - t[nnow][j]);
}
}
now = nnow;
}
now = (now + 1) & 1;
cout << t[now][a] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long cost = 1e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t;
cin >> t;
while (t--) {
long long int a, b, n, cnt = 0;
cin >> a >> b >> n;
while (max(a, b) <= n) {
if (a < b) {
a += b;
} else {
b += a;
}
cnt++;
}
cout << cnt << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const double eps = 1e-10;
int dcmp(double x) {
if (fabs(x) < eps) return 0;
return x < 0 ? -1 : 1;
}
const int N = 2e5 + 5;
int a[N], ans[N];
pair<int, int> b[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i].first), b[i].second = i;
sort(a, a + n);
sort(b, b + n);
for (int i = n - 1, j = 0; i >= 0; i--, j++) {
ans[b[j].second] = a[i];
}
for (int i = 0; i < n; i++) printf("%d%c", ans[i], i == n - 1 ? '\n' : ' ');
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 705;
long long G[MAXN][MAXN] = {}, G2[MAXN][MAXN], G3[MAXN][MAXN];
int main() {
int n, m, u, v;
long long res = 0;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
u--;
v--;
G[u][v] = 1;
G[v][u] = 1;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) G2[i][j] += G[i][k] * G[k][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) G3[i][j] += G2[i][k] * G[k][j];
for (int i = 0; i < n; i++) {
res -= (5 * G3[i][i] * (G2[i][i] - 1));
for (int k = 0; k < n; k++) res += G2[i][k] * G3[k][i];
}
printf("%I64d\n", res / 10);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, answer;
int main() {
cin >> n >> m;
while (n > 0 && m > 0) {
if (n > m) {
n -= 2, m--;
} else {
n--, m -= 2;
}
answer++;
}
if (n < 0 || m < 0) {
answer--;
}
cout << answer;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 10;
int v[maxn];
int t[4 * maxn];
int st[4 * maxn];
void sets(int it, int x) {
t[it] += x;
st[it] += x;
}
void push(int it) {
if (st[it] != 0) {
sets(2 * it, st[it]);
sets(2 * it + 1, st[it]);
st[it] = 0;
}
}
void change(int it, int l, int r, int lm, int rm, int x) {
if (l == lm && r == rm) {
sets(it, x);
} else {
push(it);
int m = (l + r) >> 1;
if (rm <= m) {
change(2 * it, l, m, lm, rm, x);
} else if (lm > m) {
change(2 * it + 1, m + 1, r, lm, rm, x);
} else {
change(2 * it, l, m, lm, m, x);
change(2 * it + 1, m + 1, r, m + 1, rm, x);
}
t[it] = max(t[2 * it], t[2 * it + 1]);
}
}
int go(int it, int l, int r) {
if (l == r) {
return v[l];
} else {
push(it);
int m = (l + r) >> 1;
if (t[2 * it + 1] > 0) {
return go(2 * it + 1, m + 1, r);
}
return go(2 * it, l, m);
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int p, tp, x;
scanf("%d %d", &p, &tp);
if (tp == 1) {
scanf("%d", &x);
}
v[p] = x;
if (tp == 0) {
change(1, 1, n, 1, p, -1);
} else {
change(1, 1, n, 1, p, +1);
}
if (t[1] <= 0) {
printf("-1\n");
} else {
printf("%d\n", go(1, 1, n));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int isPrime(long int k) {
if (k == 1) return 0;
if (k % 2 != 0) {
for (int i = 3; i <= sqrt(k); i += 2) {
if (k % i == 0) return 0;
}
return 1;
} else
return 0;
}
int pFact(long int k) {
if (k % 2 == 0)
return 2;
else if (k % 3 == 0)
return 3;
else {
for (int i = 5; i % 3 != 0 && i <= sqrt(k); i += 2) {
if (k % i == 0) return i;
}
return k;
}
}
int main() {
long int n;
cin >> n;
long long int j = n;
if (isPrime(n))
cout << n + 1;
else {
while (n > 1) {
int k = pFact(n);
j += n / k;
n /= k;
}
cout << j;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n;
cin >> n;
long long cnt0 = 0;
string ans;
long long flag = 0;
while (n--) {
string s;
cin >> s;
if (flag) continue;
if (s[0] == '0') {
ans = "0";
flag = 1;
}
long long t1 = 0, i = 0;
if (s[0] == '1') {
++i;
while (i < s.size() && s[i] == '0') ++i, ++t1;
}
if (i == s.size())
cnt0 += t1;
else {
ans = s;
}
}
if (flag)
cout << ans << "\n";
else {
if (ans.empty()) ans = "1";
while (cnt0--) {
ans += '0';
}
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string A[25][25];
bool check1(int r, int c) {
set<char> S;
int cnt = 0;
for (int i = r; i <= r + 2; i++)
for (int j = c; j <= c + 2; j++)
if (A[i][j] == "J1" || A[i][j] == "J2") {
cnt++;
} else
S.insert(A[i][j][0]);
return ((S.size() + cnt) == 9);
}
bool check2(int r1, int c1, int r2, int c2) {
for (int i = r1; i <= r1 + 2; i++)
for (int j = c1; j <= c1 + 2; j++)
if (r2 <= i && i <= r2 + 2 && c2 <= j && j <= c2 + 2) {
return false;
}
return true;
}
bool check3(int r, int c) {
set<char> S;
for (int i = r; i <= r + 2; i++)
for (int j = c; j <= c + 2; j++) S.insert(A[i][j][0]);
return (S.size() == 9);
}
int main() {
std::ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
string tmpRank[13] = {"2", "3", "4", "5", "6", "7", "8",
"9", "T", "J", "Q", "K", "A"};
string tmpSuit[4] = {"C", "D", "H", "S"};
set<string> Pack;
for (int i = 0; i < 13; i++)
for (int j = 0; j < 4; j++) Pack.insert(tmpRank[i] + tmpSuit[j]);
bool isThereJ1 = false;
int J1r;
int J1c;
bool isThereJ2 = false;
int J2r;
int J2c;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> A[i][j];
if (A[i][j] == "J1") {
isThereJ1 = true;
J1r = i;
J1c = j;
continue;
}
if (A[i][j] == "J2") {
isThereJ2 = true;
J2r = i;
J2c = j;
continue;
}
Pack.erase(Pack.find(A[i][j]));
}
vector<pair<int, int>> V;
for (int r = 1; r <= n - 2; r++)
for (int c = 1; c <= m - 2; c++)
if (check1(r, c)) V.push_back(make_pair(r, c));
for (int i = 0; i < V.size(); i++)
for (int j = 0; j < V.size(); j++) {
if (i == j) continue;
int r1 = V[i].first;
int c1 = V[i].second;
int r2 = V[j].first;
int c2 = V[j].second;
if (check2(r1, c1, r2, c2)) {
if (isThereJ1 && isThereJ2) {
for (set<string>::iterator it1 = Pack.begin(); it1 != Pack.end();
it1++)
for (set<string>::iterator it2 = Pack.begin(); it2 != Pack.end();
it2++) {
if (it1 == it2) continue;
A[J1r][J1c] = *it1;
A[J2r][J2c] = *it2;
if (check3(r1, c1) && check3(r2, c2)) {
cout << "Solution exists." << endl;
cout << "Replace J1 with " << (*it1) << " and J2 with "
<< (*it2) << "." << endl;
cout << "Put the first square to (" << r1 << ", " << c1 << ")."
<< endl;
cout << "Put the second square to (" << r2 << ", " << c2
<< ").";
return 0;
}
A[J1r][J1c] = "J1";
A[J2r][J2c] = "J2";
}
continue;
}
if (isThereJ1) {
for (set<string>::iterator it = Pack.begin(); it != Pack.end();
it++) {
A[J1r][J1c] = *it;
if (check3(r1, c1) && check3(r2, c2)) {
cout << "Solution exists." << endl;
cout << "Replace J1 with " << (*it) << "." << endl;
cout << "Put the first square to (" << r1 << ", " << c1 << ")."
<< endl;
cout << "Put the second square to (" << r2 << ", " << c2 << ").";
return 0;
}
A[J1r][J1c] = "J1";
}
continue;
}
if (isThereJ2) {
for (set<string>::iterator it = Pack.begin(); it != Pack.end();
it++) {
A[J2r][J2c] = *it;
if (check3(r1, c1) && check3(r2, c2)) {
cout << "Solution exists." << endl;
cout << "Replace J2 with " << (*it) << "." << endl;
cout << "Put the first square to (" << r1 << ", " << c1 << ")."
<< endl;
cout << "Put the second square to (" << r2 << ", " << c2 << ").";
return 0;
}
A[J2r][J2c] = "J2";
}
continue;
}
cout << "Solution exists." << endl;
cout << "There are no jokers." << endl;
cout << "Put the first square to (" << r1 << ", " << c1 << ")." << endl;
cout << "Put the second square to (" << r2 << ", " << c2 << ").";
return 0;
}
}
cout << "No solution.";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, k, res = 0;
cin >> n >> k;
int a[n + 5];
for (int i = 1; i <= n; i++) {
cin >> a[i];
res += a[i];
}
if (res % k) {
cout << "No";
return 0;
}
int cnt = 0, sum = 0;
vector<int> vec;
for (int i = 1; i <= n; i++) {
sum += a[i];
cnt++;
if (sum == res / k) {
vec.push_back(cnt);
sum = 0;
cnt = 0;
}
}
if (vec.size() != k) {
cout << "No";
} else {
cout << "Yes\n";
for (auto it : vec) {
cout << it << ' ';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = int(2e5) + 10;
const long long INF = 1LL << 60;
struct Tree {
long long v, add;
Tree *pl, *pr;
int l, r, m;
Tree(int l, int r) {
this->l = l, this->r = r;
add = 0;
m = (l + r) >> 1;
v = -INF;
if (l + 1 == r) {
pl = pr = 0;
return;
}
pl = new Tree(l, m);
pr = new Tree(m, r);
}
void apply(long long a) {
add += a;
v += a;
}
void relax() {
if (!add) {
return;
}
pl->apply(add);
pr->apply(add);
add = 0;
}
void update() { v = max(pl->v, pr->v); }
long long ask(int L, int R) {
if (L >= R) {
return -INF;
}
if (L == l && R == r) {
return v;
}
relax();
if (L >= m) {
return pr->ask(L, R);
} else if (R <= m) {
return pl->ask(L, R);
} else {
return max(pl->ask(L, m), pr->ask(m, R));
}
}
void addRange(int L, int R, long long a) {
if (L >= R) {
return;
}
if (L == l && R == r) {
apply(a);
return;
}
relax();
if (L >= m) {
pr->addRange(L, R, a);
} else if (R <= m) {
pl->addRange(L, R, a);
} else {
pl->addRange(L, m, a);
pr->addRange(m, R, a);
}
update();
}
void change(int at, long long to) {
if (l + 1 == r) {
v = to;
return;
}
relax();
if (at < m) {
pl->change(at, to);
} else {
pr->change(at, to);
}
update();
}
} * root;
struct Pay {
int l;
long long c;
Pay(int _l, long long _c) : l(_l), c(_c) {}
};
vector<Pay> at[MAX_N];
int nRoads, nPays;
long long cost[MAX_N];
int main() {
cin >> nRoads >> nPays;
for (int i = 1; i <= nRoads; ++i) {
int x;
scanf("%d", &x);
cost[i] = x;
}
for (int i = 0; i < nPays; ++i) {
int l, r, c;
scanf("%d%d%d", &l, &r, &c);
at[r].push_back(Pay(l, c));
}
root = new Tree(0, nRoads + 1);
root->change(0, 0);
for (int i = 1; i <= nRoads; ++i) {
long long me = root->ask(0, i);
root->change(i, me);
root->addRange(0, i, -cost[i]);
for (__typeof(at[i].begin()) e = at[i].begin(); e != at[i].end(); ++e) {
root->addRange(0, e->l, e->c);
}
}
long long ans = root->v;
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long f[1000007];
long long pw(long long a, long long b) {
if (b == 0) return 1;
long long r = pw(a, b / 2);
r = (r * r) % 1000000007;
if (b % 2) r = (r * a) % 1000000007;
return r;
}
inline long long inv(long long k) { return pw(k, 1000000007 - 2); }
inline long long placement(long long puraton, long long notun) {
return (f[puraton + notun] * inv(f[puraton])) % 1000000007;
}
int main(void) {
std::ios::sync_with_stdio(false);
long long n;
cin >> n;
f[0] = 1LL;
for (long long i = 1; i <= n; i++) f[i] = (i * f[i - 1]) % 1000000007;
map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
mp[a]++;
}
long long rem = n;
long long ans = 0;
for (pair<long long, long long> p : mp) {
rem -= p.second;
if (rem == 0) continue;
long long add =
(f[rem] * (p.second * placement(rem, p.second - 1)) % 1000000007) %
1000000007;
add = (add * placement(rem + p.second, n - rem - p.second)) % 1000000007;
ans = (ans + (add * p.first) % 1000000007) % 1000000007;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n;
vector<pair<int, int>> vec(n);
for (int i = 0; i < n; i++) {
cin >> a >> b;
vec[i] = pair<int, int>(a, b);
}
sort(vec.begin(), vec.end());
vector<int> ymx(n, -1);
ymx[0] = vec[0].second;
for (int i = 1; i < n; i++) {
ymx[i] = max(ymx[i - 1], vec[i].second);
}
int count = 0;
int temp;
vector<int> nxt(n, -1);
for (int i = n - 1; i > 0; i--) {
if (vec[i].first > vec[i - 1].first) {
nxt[i] = i - 1;
}
}
for (int i = 1; i < n; i++) {
if (nxt[i] == -1) nxt[i] = nxt[i - 1];
}
if (nxt[n - 1] == -1) {
cout << 0 << endl;
return 0;
}
for (int i = n - 1; i > 0; i--) {
if (nxt[i] < 0) {
continue;
}
if (ymx[nxt[i]] > vec[i].second) {
count++;
}
}
cout << count << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void read(int& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
int n, m, p, i, j, k, l, t, N, x, res, tot, ans;
int a[10010], b[100010], f[10010];
int li[1001];
long long pow(long long a, long long b, long long c) {
long long ans = 1;
for (; b; b >>= 1, a = a * a % c)
if (b & 1) ans = ans * a % c;
return ans;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long get(long long a) {
int i;
for (i = 1; i <= li[0]; i++)
if (pow(a, li[i], p) == 1) return li[i];
}
int main() {
read(n);
read(m);
read(p);
for (i = 1; i <= n; i++) read(a[i]);
for (i = 1; i <= m; i++) read(b[i]);
for (N = p - 1, i = 1; i * i <= N; i++)
if (N % i == 0) {
li[++li[0]] = i;
if (i * i != N) li[++li[0]] = N / i;
}
sort(li + 1, li + 1 + li[0]);
t = b[1];
for (i = 2; i <= m; i++) t = gcd(t, b[i]);
for (i = 1; i <= n; i++) a[i] = pow(a[i], t, p);
for (i = 1; i <= n; i++) a[i] = get(a[i]);
sort(a + 1, a + 1 + n);
j = 1;
for (i = 2; i <= n; i++)
if (a[i] != a[i - 1]) a[++j] = a[i];
n = j;
for (i = 1; i <= n; i++) {
f[i] = a[i];
for (j = 1; j <= i - 1; j++)
if (a[i] % a[j] == 0) f[i] -= f[j];
ans += f[i];
}
printf("%d\n", ans);
scanf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
scanf("%d", &n);
map<int, int> pos;
int ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
pos[x] = 1 + pos[x - 1];
ans = max(ans, pos[x]);
}
printf("%d\n", n - ans);
return 0;
}
| 4 |
//
// Created by Artist on 2021/1/23.
//
#include<bits/stdc++.h>
using namespace std;
int main(){
int t;cin>>t;
while(t--){
string s;cin>>s;
int len=s.size();
if(len&1) cout<<"NO"<<endl;
else if(s[0]==')'||s[len-1]=='(') cout<<"NO"<<endl;
else cout<<"YES"<<endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
bool fun(long long a, long long b, long long x) {
if (a % x == 0 && b % x == 0) return true;
return false;
}
int main() {
long long n;
cin >> n;
while (n--) {
long long a, b;
scanf("%lld %lld", &a, &b);
if (a == 1 && b == 1)
printf("Yes\n");
else {
long long x = 0;
long long low = 2, high = 1000000, mid;
while (low <= high) {
mid = (low + high) >> 1;
if (mid * mid * mid <= a * b) {
x = mid;
low = mid + 1;
} else
high = mid - 1;
}
x = cbrt(a * b);
if (x * (x * x) != (a * b) && (x + 1) * (x + 1) * (x + 1) != (a * b)) {
printf("NO\n");
} else {
if ((x + 1) * (x + 1) * (x + 1) == (a * b)) x = x + 1;
bool y = fun(a, b, x);
if (y)
printf("Yes\n");
else
printf("no\n");
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
const int N = 2 * 1e5 + 10;
int n, a[N];
string maxx(string l, string r) {
if (int(l.size()) > int(r.size())) return l;
return r;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
string ans = "", cur = "", s_l, s_r;
for (int l = 0, r = n - 1, ant = -1; l <= r;) {
18;
if (a[l] == a[r] && a[l] > ant) {
s_l = s_r = ans;
int _l, _r, _ant = ant;
_l = l, _r = r;
while (_l < r && a[_l] > _ant) {
s_l += "L";
_ant = a[_l];
_l++;
}
_ant = ant;
while (l < _r && a[_r] > _ant) {
s_r += "R";
_ant = a[_r];
_r--;
}
cur = maxx(cur, maxx(s_l, s_r));
}
18;
if ((a[l] < a[r] && ant < a[l]) || (ant >= a[r] && ant < a[l])) {
ans += "L";
ant = a[l];
l++;
} else if (ant < a[r]) {
ans += "R";
ant = a[r];
r--;
} else
break;
}
ans = maxx(ans, cur);
cout << int(ans.size()) << '\n' << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int i = 0;
int main() {
int n;
cin >> n;
while (n--) {
int a;
cin >> a;
if (a < 4) {
cout << 4 - a << endl;
} else {
if (a % 2 == 0) {
cout << '0' << endl;
} else {
cout << '1' << endl;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string s[n];
for (int i = 0; i < n; i++) cin >> s[i];
long long a[m];
for (int i = 0; i < m; i++) cin >> a[i];
long long ans = 0;
for (int i = 0; i < m; i++) {
long long maxi = 0;
for (char c = 'A'; c <= 'E'; c++) {
long long temp = 0;
for (int j = 0; j < n; j++) {
if (s[j][i] == c) temp += a[i];
}
maxi = max(temp, maxi);
}
ans += maxi;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long int inf = 1000000000;
const long long int mod = 1000000000 + 7;
inline void IO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
inline int dcmp(long double x) { return x < -1e-12 ? -1 : (x > 1e-12); }
template <class T>
inline int CHECK(T MASK, int i) {
return (MASK >> i) & 1;
}
template <class T>
inline T ON(T MASK, int i) {
return MASK | (T(1) << i);
}
template <class T>
inline T OFF(T MASK, int i) {
return MASK & (~(T(1) << i));
}
template <typename T>
inline int CNT(T MASK) {
if (numeric_limits<T>::digits <= numeric_limits<unsigned int>::digits)
return __builtin_popcount(MASK);
else
return __builtin_popcountll(MASK);
}
template <class T>
inline int RIGHT(T MASK) {
return log2(MASK & -MASK);
}
int dx4[] = {0, 0, -1, +1};
int dy4[] = {+1, -1, 0, 0};
int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1, 0};
int dy8[] = {0, 1, 1, 1, 0, -1, -1, -1, 0};
inline void I(int& a) { scanf("%d", &a); }
inline void I(long long int& a) { scanf("%I64d", &a); }
inline void I(unsigned long long int& a) { scanf("%I64u", &a); }
inline void I(char* a) { scanf("%s", a); }
char Iarr[2000010];
inline void I(string& a) {
scanf("%s", Iarr);
a = Iarr;
}
template <typename T, typename... Args>
void I(T& a, Args&... args) {
I(a);
I(args...);
}
inline void OUT(int a) { printf("%d", a); }
inline void OUT(long long int a) { printf("%I64d", a); }
inline void OUT(const char* a) { printf("%s", a); }
inline void OUT(char* a) { printf("%s", a); }
inline void OUT(bool a) { printf("%d", a); }
inline void OUT(string a) {
for (__typeof(a.end()) it = (a.begin()) - ((a.begin()) > (a.end()));
it != (a.end()) - ((a.begin()) > (a.end()));
it += 1 - 2 * ((a.begin()) > (a.end())))
printf("%c", *it);
}
inline void OUT(unsigned long long int a) { printf("%I64u", a); }
template <typename T, typename... Args>
void OUT(T a, Args... args) {
OUT(a);
OUT(" ");
OUT(args...);
}
template <typename... Args>
void O(Args... args) {
OUT(args...);
OUT("\n");
}
template <typename T1, typename T2>
inline ostream& operator<<(ostream& os, pair<T1, T2> p) {
os << "{" << p.first << ", " << p.second << "}";
return os;
}
template <typename T>
inline ostream& operator<<(ostream& os, vector<T>& a) {
os << "[";
for (int i = 0; i < (int)a.size(); i++) {
if (i) os << ", ";
os << a[i];
}
os << "]";
return os;
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << endl;
err(++it, args...);
}
const int M = 200010;
struct NCRMOD {
int n, MOD, PHI, residue[100001], fact[100001], inv_fact[100001];
vector<int> primeDivisors;
vector<vector<int> > C, P;
int ModExp(int a, int n) {
long long x = a % MOD, y = 1 % MOD;
while (n) {
if (n % 2) y = (x * y) % MOD;
x = (x * x) % MOD;
n /= 2;
}
return (int)y;
}
int ModInv(int a) { return ModExp(a, PHI - 1); }
void PreProcess() {
int m = MOD;
for (int i = 2; i * i <= m; ++i) {
if (m % i == 0) {
while (m % i == 0) m /= i;
primeDivisors.push_back(i);
}
}
if (m > 1) primeDivisors.push_back(m);
m = primeDivisors.size();
C.resize(m);
P.resize(m);
fact[0] = 1, inv_fact[0] = 1;
for (int i = 1; i <= n; ++i) residue[i] = i;
PHI = MOD;
for (int i = 0; i < m; ++i) {
int p = primeDivisors[i];
PHI /= p;
PHI *= (p - 1);
C[i].resize(n + 1);
for (int j = p; j <= n; j += p) {
int x = residue[j], k = 0;
while (x % p == 0) {
x /= p;
++k;
}
residue[j] = x;
C[i][j] = k;
}
for (int j = 1; j <= n; ++j) C[i][j] += C[i][j - 1];
P[i].resize(C[i][n] + 1);
P[i][0] = 1 % MOD;
for (int j = 1; j < P[i].size(); ++j)
P[i][j] = (1ll * p * P[i][j - 1]) % MOD;
}
for (int i = 1; i <= n; ++i)
fact[i] = (1ll * residue[i] * fact[i - 1]) % MOD;
inv_fact[n] = ModInv(fact[n]);
for (int i = n - 1; i > 0; --i)
inv_fact[i] = (1ll * residue[i + 1] * inv_fact[i + 1]) % MOD;
}
int NCR(int n, int r) {
if (n < 0 || r < 0 || n < r)
return 0;
else {
long long ans = fact[n];
ans = (ans * inv_fact[r]) % MOD;
ans = (ans * inv_fact[n - r]) % MOD;
for (int i = 0; i < primeDivisors.size(); ++i) {
int c = C[i][n] - C[i][r] - C[i][n - r];
ans = (ans * P[i][c]) % MOD;
}
return (int)ans;
}
}
} obj;
long long int func(long long int n, long long int sum, long long int MOD) {
long long int ret;
if (n % 2 == 0)
ret = obj.NCR(n, n / 2) - obj.NCR(n, n / 2 + sum / 2 + 1);
else {
if (sum % 2 == 0)
ret = obj.NCR(n, n / 2) - obj.NCR(n, n / 2 - sum / 2);
else
ret = obj.NCR(n, n / 2) - obj.NCR(n, n / 2 - sum / 2 - 1);
}
return ret;
}
long long int range(long long int n, long long int l, long long int r,
long long int MOD) {
long long int ret = func(n, r, MOD);
if (l > 0) ret -= func(n, l - 1, MOD);
ret %= MOD;
ret = (ret + MOD) % MOD;
return ret;
}
int main() {
long long int n, p, l, r;
I(n, p, l, r);
obj.MOD = p;
obj.n = n;
obj.PreProcess();
long long int ans = 0;
for (long long int i = l; i <= n; i++) {
long long int temp = obj.NCR(n, i);
temp %= p;
temp *= range(i, l, r, p);
temp %= p;
ans += temp;
ans %= p;
}
O(ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, a, b;
cin >> n >> a >> b;
string pre = "abcdefghijklmnopqrstuvwxyz";
string p = pre.substr(0, b), ans;
while (ans.size() <= n) {
ans += p;
}
ans = ans.substr(0, n);
cout << ans << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int n, a[100005], res = 0, x;
stack<long long int> s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
a[i] = x;
while (!s.empty() && s.top() < x) res = max(res, s.top() ^ x), s.pop();
if (!s.empty()) res = max(res, s.top() ^ x);
s.push(x);
}
while (!s.empty()) s.pop();
for (int i = n - 1; i >= 0; i--) {
x = a[i];
while (!s.empty() && s.top() < x) res = max(res, s.top() ^ x), s.pop();
if (!s.empty()) res = max(res, s.top() ^ x);
s.push(x);
}
cout << res << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, M = 1e4 + 5, OO = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
long long pre[N];
int main() {
string s;
cin >> s;
int m;
cin >> m;
while (m--) {
int x;
cin >> x;
pre[x - 1]++;
pre[s.length() - x]++;
}
partial_sum(pre, pre + N, pre);
for (int i = 0; i < ((s.length() + 1) / 2); ++i) {
if (pre[i] % 2) swap(s[i], s[(s.length() - (i + 1))]);
}
cout << s << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char A[104][104];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> A[i][j];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (A[i][j] != '*') {
int cnt = 0;
if (i == 0 && j == 0) {
cnt += (A[i + 1][j] == '*') + (A[i + 1][j + 1] == '*') +
(A[i][j + 1] == '*');
} else if (i == 0 && j == m - 1) {
cnt += (A[i + 1][j] == '*') + (A[i + 1][j - 1] == '*') +
(A[i][j - 1] == '*');
} else if (i == n - 1 && j == 0) {
cnt += (A[i - 1][j] == '*') + (A[i - 1][j + 1] == '*') +
(A[i][j + 1] == '*');
} else if (i == n - 1 && j == n - 1) {
cnt += (A[i - 1][j] == '*') + (A[i - 1][j - 1] == '*') +
(A[i][j - 1] == '*');
} else if (i == 0) {
cnt += (A[i + 1][j] == '*') + (A[i + 1][j + 1] == '*') +
(A[i][j + 1] == '*');
cnt += (A[i + 1][j - 1] == '*') + (A[i][j - 1] == '*');
} else if (i == n - 1) {
cnt += (A[i - 1][j] == '*') + (A[i - 1][j + 1] == '*') +
(A[i][j + 1] == '*');
cnt += (A[i - 1][j - 1] == '*') + (A[i][j - 1] == '*');
} else if (j == 0) {
cnt += (A[i + 1][j] == '*') + (A[i + 1][j + 1] == '*') +
(A[i][j + 1] == '*');
cnt += (A[i - 1][j + 1] == '*') + (A[i - 1][j] == '*');
} else if (j == m - 1) {
cnt += (A[i + 1][j] == '*') + (A[i - 1][j - 1] == '*') +
(A[i][j - 1] == '*');
cnt += (A[i + 1][j - 1] == '*') + (A[i - 1][j] == '*');
} else {
cnt += (A[i + 1][j] == '*') + (A[i + 1][j + 1] == '*') +
(A[i][j + 1] == '*');
cnt += (A[i - 1][j + 1] == '*') + (A[i - 1][j] == '*');
cnt += (A[i + 1][j - 1] == '*') + (A[i][j - 1] == '*') +
(A[i - 1][j - 1] == '*');
}
if (A[i][j] == '.') {
if (cnt != 0) {
cout << "NO\n";
return 0;
}
} else if ((A[i][j] - '0') != cnt) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const long long INF = 1e18;
const double eps = 1e-6;
const int maxn = 4e5 + 5;
map<long long, long long> mp;
long long n, I, K, idx, a, b[maxn], sum[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> I;
for (int i = 1; i <= n; ++i) {
cin >> a;
if (!mp[a]) b[++idx] = a;
++mp[a];
}
K = pow(2, min(19 * 1LL, 8 * I / n));
if (K >= idx) {
cout << 0 << endl;
return 0;
}
sort(b + 1, b + 1 + idx);
for (int i = 1; i <= idx; ++i) sum[i] = sum[i - 1] + mp[b[i]];
long long res = INF;
for (int i = 1; i + K - 1 <= idx; ++i)
res = min(res, (sum[i - 1] - sum[0]) + (sum[idx] - sum[i + K - 1]));
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void get_it_done() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
void swap(long long &a, long long &b) {
a ^= b;
b ^= a;
a ^= b;
}
const long long N = 1e5 + 5;
long long dp[N][2][2];
long long n;
string s, w;
long long solve(long long idx, long long c1, long long c2) {
if (idx == n) return c1 & c2;
if (dp[idx][c1][c2] != -1) return dp[idx][c1][c2];
long long i1, i2;
if (s[idx] == '?')
i1 = -1;
else
i1 = s[idx] - '0';
if (w[idx] == '?')
i2 = -1;
else
i2 = w[idx] - '0';
long long nc1 = c1, nc2 = c2;
long long ans = 0;
if (i1 != -1 && i2 != -1) {
if (i1 > i2)
nc1 = 1;
else if (i2 > i1)
nc2 = 1;
ans = solve(idx + 1, nc1, nc2);
} else if (i1 != -1 && i2 == -1) {
long long l = i1;
long long r = 9 - l;
ans = l * solve(idx + 1, 1, nc2) + r * solve(idx + 1, nc1, 1) +
solve(idx + 1, nc1, nc2);
} else if (i1 == -1 && i2 != -1) {
long long l = i2;
long long r = 9 - l;
ans = l * solve(idx + 1, nc1, 1) + r * solve(idx + 1, 1, nc2) +
solve(idx + 1, nc1, nc2);
} else {
for (long long i = 0; i < 10; ++i) {
long long r = 9 - i;
ans += i * solve(idx + 1, nc1, 1) + r * solve(idx + 1, 1, nc2) +
solve(idx + 1, nc1, nc2);
ans %= 1000000007;
}
}
ans %= 1000000007;
return dp[idx][c1][c2] = ans;
}
int32_t main() {
get_it_done();
long long t = 1;
while (t--) {
cin >> n;
cin >> s >> w;
memset(dp, -1, sizeof(dp));
long long ans = solve(0, 0, 0);
ans %= 1000000007;
cout << ans << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
const int INF = 1e2 + 7;
const double EPS = 1e-12;
const int P = 239017;
const int MOD = 1e9 + 7;
int fx[] = {1, -1, 0, 0, 1, 1, -1, -1};
int fy[] = {0, 0, 1, -1, -1, 1, -1, 1};
int f();
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
int n, m, mx, cnt = 1, c;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cnt *= i;
for (int i = 0; i < cnt; i++) {
int x = f();
if (x > mx) {
mx = x;
c = 1;
if (c == m)
for (int j = 0; j < n; j++) b[j] = a[j];
} else if (x == mx) {
c++;
if (c == m)
for (int j = 0; j < n; j++) b[j] = a[j];
}
next_permutation(a, a + n);
}
for (int i = 0; i < n; i++) cout << b[i] << ' ';
return 0;
}
int f() {
int s = 0, x;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
x = INF;
for (int k = i; k <= j; k++) x = min(x, a[k]);
s += x;
}
return s;
}
| 3 |
#include <bits/stdc++.h>
long int pre = -1;
long int gcd(long int x, long int y) {
long int c, a, b;
if (x >= y) {
a = x;
b = y;
} else {
a = y;
b = x;
}
while (1) {
c = a % b;
if (c == 0) return b;
a = b;
b = c;
}
}
int main() {
long int n;
scanf("%ld", &n);
long int max = 0;
long int t, i;
for (i = 0; i < n; i++) {
scanf("%ld", &t);
if (pre == -1) pre = t;
pre = gcd(pre, t);
if (max < t) max = t;
}
int o = (max / pre) - n;
if ((o) % 2 == 0)
printf("Bob\n");
else
printf("Alice\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5 + 7;
long long v[maxn];
long long t[maxn];
long long sum[maxn];
vector<long long> disa[maxn];
int disnum[maxn];
long long ans[maxn];
bool judge(int now, int sta, long long key) {
long long sub = sum[now] - sum[sta - 1];
if (sub >= key) {
return true;
} else {
return false;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &v[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &t[i]);
}
for (int i = 1; i <= n; i++) {
sum[i] = t[i] + sum[i - 1];
}
for (int i = 1; i <= n; i++) {
int left = i;
int right = n;
while (left <= right) {
int mid = (left + right) >> 1;
if (judge(mid, i, v[i])) {
right = mid - 1;
} else {
left = mid + 1;
}
}
disa[right + 1].push_back(v[i] - sum[right] + sum[i - 1]);
}
for (int i = 1; i <= n; i++) {
disnum[i] += disa[i].size();
disnum[i] += disnum[i - 1];
}
for (int i = 1; i <= n; i++) {
ans[i] = (i - disnum[i]) * t[i];
for (int j = 0; j < disa[i].size(); j++) {
ans[i] += disa[i][j];
}
}
for (int i = 1; i <= n; i++) {
printf("%lld ", ans[i]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N;
int ls[300010];
int main() {
cin >> N;
for (int i = 0; i < N; i++) scanf("%d", &ls[i]);
sort(ls, ls + N);
long long t, s;
long long ans = 0;
t = 1;
s = ls[0];
for (int i = 1; i < N; i++) {
ans += t * ls[i] - s;
ans %= 1000000007;
s = (s * 2 + ls[i]) % 1000000007;
t = (t * 2 + 1) % 1000000007;
}
ans = (ans + 1000000007) % 1000000007;
printf("%d\n", (int)ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
std::string s;
std::cin >> s;
if (s[0] != '-') {
std::cout << s << std::endl;
return 0;
}
s.erase(*s.rbegin() > *(s.rbegin() + 1) ? s.end() - 1 : s.end() - 2);
if (s == "-0") {
s = "0";
}
std::cout << s << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool ylmin(T &a, T b) {
return a < b ? 0 : (a = b, 1);
}
template <class T>
inline bool ylmax(T &a, T b) {
return a > b ? 0 : (a = b, 1);
}
template <class T>
inline T abs(T x) {
return x < 0 ? -x : x;
}
inline char read() {
static const int IO_LEN = 1024 * 1024;
static char buf[IO_LEN], *ioh, *iot;
if (ioh == iot) {
iot = (ioh = buf) + fread(buf, 1, IO_LEN, stdin);
if (ioh == iot) return -1;
}
return *ioh++;
}
template <class T>
inline void read(T &x) {
static int iosig;
static char ioc;
for (iosig = 0, ioc = read(); !isdigit(ioc); ioc = read())
if (ioc == '-') iosig = 1;
for (x = 0; isdigit(ioc); ioc = read()) x = (x << 1) + (x << 3) + (ioc ^ '0');
if (iosig) x = -x;
}
const int MAXN = 1e5 + 10;
const long long inf = 1e18;
int n, q, u, v, w, x, y, fa[MAXN], id[MAXN];
long long lim, dis[MAXN][2];
struct Edge {
int to, next, w;
} e[MAXN << 1];
int head[MAXN], cnt;
inline void add(int u, int v, int w) {
e[++cnt] = (Edge){v, head[u], w}, head[u] = cnt;
e[++cnt] = (Edge){u, head[v], w}, head[v] = cnt;
}
namespace findmaxlen {
int ans1, ans2, Maxpos;
long long dep[MAXN], Max;
inline void dfs(int u, int fa) {
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa) continue;
dep[v] = dep[u] + e[i].w;
dfs(v, u);
}
}
inline void work() {
memset(dep, 0, sizeof dep);
dfs(1, 1);
Max = Maxpos = 0;
for (int i = (1); i <= (n); i++)
if (ylmax(Max, dep[i])) Maxpos = i;
ans1 = Maxpos;
memset(dep, 0, sizeof dep);
dfs(ans1, ans1);
Max = Maxpos = 0;
for (int i = (1); i <= (n); i++)
if (ylmax(Max, dep[i])) Maxpos = i;
ans2 = Maxpos;
}
} // namespace findmaxlen
inline void getdis(int u, int fa, int type) {
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa) continue;
dis[v][type] = dis[u][type] + e[i].w;
getdis(v, u, type);
}
}
inline void dfs(int u, int father) {
fa[u] = father;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == father) continue;
dfs(v, u);
}
}
inline long long val(int u) { return max(dis[u][0], dis[u][1]); }
inline bool cmp(int a, int b) {
return val(a) < val(b) || (val(a) == val(b) && a > b);
}
namespace ufs {
int fa[MAXN], size[MAXN];
inline void clear() {
for (int i = (1); i <= (n); i++) fa[i] = i, size[i] = 1;
}
inline int find(int u) { return fa[u] == u ? u : fa[u] = find(fa[u]); }
inline void merge(int u, int v) {
u = find(u), v = find(v);
if (size[u] > size[v]) swap(u, v);
fa[u] = v, size[v] += size[u];
}
} // namespace ufs
int main() {
read(n);
for (int i = (2); i <= (n); i++) read(u), read(v), read(w), add(u, v, w);
findmaxlen::work();
x = findmaxlen::ans1, y = findmaxlen::ans2;
getdis(x, x, 0), getdis(y, y, 1);
long long Min = inf;
int Minpos = 0;
for (int i = (1); i <= (n); i++)
if (ylmin(Min, val(i))) Minpos = i;
dfs(Minpos, Minpos);
for (int i = (1); i <= (n); i++) id[i] = i;
sort(id + 1, id + n + 1, cmp);
for (read(q); q; q--) {
read(lim);
ufs::clear();
int ans = 0;
for (int l = n, r = n; l; l--) {
while (val(id[r]) > val(id[l]) + lim) ufs::size[ufs::find(id[r])]--, r--;
ylmax(ans, ufs::size[ufs::find(id[l])]);
ufs::merge(id[l], fa[id[l]]);
}
printf("%d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int kN = 1 << 17;
const int kK = 5;
vector<int> g[kN];
struct Dsu {
vector<int> p;
vector<int> to_del;
Dsu() : p(kN) {
for (int i = 0; i < p.size(); ++i) {
p[i] = i;
}
}
int Get(int u) { return u == p[u] ? u : (p[u] = Get(p[u])); }
bool Unite(int u, int v) {
u = Get(u);
v = Get(v);
if (u == v) {
return false;
}
if (rand() & 1) {
swap(u, v);
}
p[u] = v;
to_del.push_back(u);
return true;
}
void Reset() {
for (int x : to_del) {
p[x] = x;
}
to_del.clear();
}
};
Dsu dsu;
struct Node {
int lp[kK];
int rp[kK];
int from;
int to;
int cnt;
Node() : from(0), to(0), cnt(0) {
memset(lp, 255, sizeof(lp));
memset(rp, 255, sizeof(rp));
}
};
Node Combine(const Node& lhs, const Node& rhs) {
Node res;
res.cnt = lhs.cnt + rhs.cnt;
for (int i = 0; i < kK; ++i) {
if (lhs.from + i <= lhs.to) {
dsu.Unite(lhs.from + i, lhs.lp[i]);
}
if (lhs.to - i >= lhs.from) {
dsu.Unite(lhs.to - i, lhs.rp[i]);
}
if (rhs.from + i <= rhs.to) {
dsu.Unite(rhs.from + i, rhs.lp[i]);
}
if (rhs.to - i >= rhs.from) {
dsu.Unite(rhs.to - i, rhs.rp[i]);
}
}
for (int i = 0; i < kK; ++i) {
if (lhs.to - i < lhs.from) {
continue;
}
int u = lhs.to - i;
for (int v : g[u]) {
if (rhs.from <= v && v <= rhs.to) {
res.cnt -= dsu.Unite(u, v);
}
}
}
res.from = lhs.from;
res.to = rhs.to;
for (int i = 0; i < kK; ++i) {
if (res.from + i <= res.to) {
res.lp[i] = dsu.Get(res.from + i);
}
if (res.to - i >= res.from) {
res.rp[i] = dsu.Get(res.to - i);
}
}
dsu.Reset();
return res;
}
struct SegmentTree {
vector<Node> a;
SegmentTree() : a(2 * kN - 1) { Build(); }
void Build(int ind = 0, int tl = 0, int tr = kN - 1) {
if (tl == tr) {
a[ind].cnt = 1;
a[ind].lp[0] = a[ind].rp[0] = a[ind].from = a[ind].to = tl;
return;
}
int tm = (tl + tr) >> 1;
Build(ind * 2 + 1, tl, tm);
Build(ind * 2 + 2, tm + 1, tr);
a[ind] = Combine(a[ind * 2 + 1], a[ind * 2 + 2]);
}
Node Rsq(int l, int r, int ind = 0, int tl = 0, int tr = kN - 1) {
if (l == tl && r == tr) {
return a[ind];
}
int tm = (tl + tr) >> 1;
if (r <= tm) {
return Rsq(l, r, ind * 2 + 1, tl, tm);
} else if (tm + 1 <= l) {
return Rsq(l, r, ind * 2 + 2, tm + 1, tr);
} else {
return Combine(Rsq(l, tm, ind * 2 + 1, tl, tm),
Rsq(tm + 1, r, ind * 2 + 2, tm + 1, tr));
}
}
};
int main() {
std::ios_base::sync_with_stdio(false);
int n, k, m;
cin >> n >> k >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
g[u - 1].push_back(v - 1);
g[v - 1].push_back(u - 1);
assert(1 <= u && u <= n);
assert(1 <= v && v <= n);
}
SegmentTree st;
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
assert(1 <= l && l <= n);
assert(1 <= r && r <= n);
assert(l <= r);
cout << st.Rsq(l - 1, r - 1).cnt << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long kmaxn = 1e5;
const long long kmaxm = 4e3 + 5;
const long long M = 1e9 + 7;
long long fac[kmaxn], finv[kmaxn];
long long S2[kmaxm][kmaxm];
long long suf[kmaxn], sinv[kmaxn];
long long MAX;
long long n, m, k;
long long mpow(long long b, long long p) {
long long ans = 1;
while (p) {
if (p & 1) {
ans *= b;
ans %= M;
}
p >>= 1;
b *= b;
b %= M;
}
return ans;
}
void init() {
fac[0] = 1;
for (long long i = 1; i <= MAX; i++) fac[i] = (fac[i - 1] * i) % M;
finv[MAX] = mpow(fac[MAX], M - 2);
for (long long i = MAX - 1; i >= 0; i--)
finv[i] = (finv[i + 1] * (i + 1)) % M;
long long tp = max(n, m);
S2[0][1] = 1;
for (long long i = 1; i <= tp; ++i) {
for (long long j = 1; j <= i; ++j) {
S2[i][j] = S2[i - 1][j] * j % M + S2[i - 1][j - 1];
S2[i][j] %= M;
}
}
suf[0] = sinv[0] = 1;
tp = k;
for (long long i = 1; i <= MAX; ++i, --tp) {
suf[i] = suf[i - 1] * tp % M;
sinv[i] = mpow(suf[i], M - 2);
}
}
long long cal(long long y, long long x) {
long long ans = 1;
ans = suf[k - (y - x)] * sinv[k - y] % M;
return ans;
while (x--) {
ans *= y;
--y;
ans %= M;
}
return ans;
}
long long C(long long x, long long y) { return cal(y, x) * finv[x] % M; }
long long S(long long x, long long y) { return S2[x][y]; }
long long solve(long long s, long long t) {
long long q = t - s;
long long mcnt = C(s, k);
long long lcnt = C(q, k - s);
long long rcnt = C(q, k - s - q);
long long lway = S(n, t) * fac[t] % M, rway = S(n, t) * fac[t] % M;
long long mway = mpow(s, n * (m - 2));
return mcnt % M * lcnt % M * rcnt % M * lway % M * rway % M * mway % M;
}
void brute() {
long long ans = 0, cnt = 0, way = 0;
for (long long i = 1; i <= n; ++i) {
cnt = C(i, k);
way = S(n, i) * fac[i] % M;
;
if (m != 1)
ans += cnt * cnt % M * way % M * way % M;
else
ans += cnt * way % M;
ans %= M;
}
cout << ans << endl;
}
void work() {
MAX = max(n, m) * 4;
init();
if (m <= 2) {
brute();
return;
}
long long ans = 0, tp;
for (long long i = 1; i <= n; ++i) {
for (long long s = 1; s <= i; ++s) {
tp = solve(s, i);
ans += tp;
ans %= M;
}
}
cout << ans << endl;
return;
while (1) {
long long x, y;
cin >> x >> y;
cout << mpow(x, M - 2) * y % M << endl;
}
}
signed main() {
(cin >> n >> m >> k);
{ work(); }
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
bool f = true;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
f = true;
for (int j = 1; j <= n; j++) {
int k;
cin >> k;
if (k == 1 || k == 3)
f = false;
else if (j == n && f)
v.push_back(i);
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) cout << v[i] << ' ';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long long mod = 1e9 + 7;
const long long N = 4e5 + 5;
const long long INF = 1e18;
void solve() {
long long n, m;
cin >> n >> m;
;
vector<long long> ans(n + 1, 0);
vector<long long> temp(6);
for (long long i = 0; i < m; i++) {
for (long long j = 0; j < 3; j++) {
cin >> temp[j];
temp[j + 3] = temp[j];
}
long long index = -1;
for (long long j = 0; j < 3; j++) {
if (ans[temp[j]] > 0) {
index = j;
}
};
if (index == -1) {
long long cnt = 1;
for (long long j = 0; j < 3; j++) {
ans[temp[j]] = cnt;
cnt++;
}
} else {
long long cnt = ans[temp[index]];
for (long long j = index + 1; j < index + 3; j++) {
cnt++;
if (cnt > 3) cnt = 1;
ans[temp[j]] = cnt;
}
};
}
auto it = ans.begin();
ans.erase(it);
for (auto t : ans) cout << t << " ";
;
}
int32_t main() {
long long t;
t = 1;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n;
cin >> n;
if (n & 1)
cout << "0\n";
else
cout << n / 4 - !(n % 4);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long inf = 1e18;
long long f, T, T0, A1, T1, P1, A2, T2, P2, resFF, resTT, ans = inf;
inline void read(long long &x) {
x = 0;
long long y = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') y = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
x *= y;
}
signed main() {
read(f);
read(T);
read(T0);
read(A1);
read(T1);
read(P1);
read(A2);
read(T2);
read(P2);
if (T1 > T2) {
swap(A1, A2);
swap(P1, P2);
swap(T1, T2);
}
for (long long i = 0; (i - 1) * A1 <= f; ++i) {
resFF = f - min(i * A1, f);
resTT = T - min(i * A1, f) * T1;
if (resFF == 0) {
if (resTT < 0) break;
ans = min(ans, i * P1);
break;
}
if (T0 * resFF > resTT && T2 * resFF > resTT) continue;
if (T0 * resFF <= resTT)
ans = min(ans, i * P1);
else {
long long x = (resTT - T0 * resFF) / (T2 - T0) +
((resTT - T0 * resFF) % (T2 - T0) == 0 ? 0 : 1);
long long pk = (x / A2) + (x % A2 == 0 ? 0 : 1);
ans = min(ans, pk * P2 + i * P1);
}
}
ans = max(ans, (long long)0);
cout << (ans < inf ? ans : -1) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
string s1, s2;
cin >> s1 >> s2;
set<pair<char, char>> st;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s1[i] != s2[i]) {
cnt++;
st.insert(make_pair(s1[i], s2[i]));
}
}
if (cnt == 2 && st.size() == 1)
cout << "Yes";
else
cout << "No";
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int dp[maxn][2];
int opt[maxn], pai[maxn];
int find(int x) {
if (pai[x] == x) return x;
return pai[x] = find(pai[x]);
}
void join(int a, int b) {
a = find(a), b = find(b);
pai[a] = b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '?' or s[i] == '1') dp[i][1] = 1 + dp[i + 1][1];
if (s[i] == '?' or s[i] == '0') dp[i][0] = 1 + dp[i + 1][0];
opt[i] = max(dp[i][0], dp[i][1]);
pai[i] = i;
}
pai[n] = n;
for (int x = 1; x <= n; x++) {
int ans = 0;
for (int i = 0; i < n and find(i) < n;) {
if (opt[find(i)] >= x)
i = find(i) + x, ans++;
else
join(find(i), find(i) + 1);
}
cout << ans << " ";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int lim = 1e6 + 7;
int n;
map<int, int> negativeSlope;
map<int, int> positiveSlope;
int xi, yi;
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> xi >> yi;
int aux = yi - xi;
negativeSlope[aux]++;
aux = yi + xi;
positiveSlope[aux]++;
}
map<int, int>::iterator it = negativeSlope.begin();
long long answ = 0;
while (it != negativeSlope.end()) {
long long tmp = it->second;
answ += (tmp * (tmp - 1)) >> 1;
it++;
}
it = positiveSlope.begin();
while (it != positiveSlope.end()) {
long long tmp = it->second;
answ += (tmp * (tmp - 1)) >> 1;
it++;
}
cout << answ;
}
int main() {
if (fopen("d:\\lmo.in", "r") != NULL) freopen("d:\\lmo.in", "r", stdin);
cin.sync_with_stdio(false);
cin.tie(0);
solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)2e18 + 5;
const long long MOD = (long long)1e9 + 7;
const int MAXN = 55;
long long mul(long long x, long long y) {
if (x == 0) return 0;
if (y > INF / x) return INF;
return x * y;
}
long long add(long long x, long long y) { return min(x + y, INF); }
long long n, k, cnt[MAXN], fac[MAXN], dp[MAXN][MAXN], way[MAXN];
vector<int> get_p(long long len, long long k) {
vector<int> res, from(len + 1);
res.push_back(len);
for (int i = 1; i <= len; i++) {
from[i] = i;
}
for (int i = 2; i <= len; i++) {
int src = i;
while (from[src] != src) {
src = from[src];
}
int tgt = k / fac[max(0LL, len - i - 1)];
for (int j = 1; j <= len; j++) {
if (j != src && from[j] == j) {
if (tgt == 0) {
from[j] = i;
res.push_back(j);
break;
} else {
tgt--;
}
}
}
k %= fac[max(0LL, len - i - 1)];
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
fac[0] = cnt[0] = cnt[1] = 1;
for (int i = 1; i < MAXN; i++) fac[i] = mul(fac[i - 1], i);
for (int i = 2; i < MAXN; i++) cnt[i] = fac[i - 2];
dp[0][0] = way[0] = 1;
for (int i = 1; i < MAXN; i++) {
for (int j = 1; j <= i; j++) {
for (int k = 1; k <= i; k++) {
dp[i][j] = add(dp[i][j], mul(dp[i - k][j - 1], cnt[k]));
}
way[i] = add(way[i], dp[i][j]);
}
}
int tc;
cin >> tc;
while (tc--) {
cin >> n >> k;
k--;
if (k >= way[n]) {
cout << "-1\n";
continue;
}
int put = 0;
vector<int> ans;
while (put < n) {
long long seg, rem = n - put;
for (seg = 1; seg <= rem; seg++) {
long long tot = mul(cnt[seg], way[rem - seg]);
if (k >= tot) {
k -= tot;
} else {
break;
}
}
vector<int> p = get_p(seg, k / way[rem - seg]);
k %= way[rem - seg];
for (int x : p) {
ans.push_back(x + put);
}
put += seg;
}
for (int x : ans) {
cout << x << ' ';
}
cout << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long q;
scanf("%lld", &q);
set<string> old, news;
map<string, string> myset;
while (q--) {
string old_str, new_str;
cin >> old_str >> new_str;
if (news.find(old_str) == news.end()) old.insert(old_str);
news.insert(new_str);
if (myset.find(old_str) == myset.end()) {
myset[old_str] = new_str;
myset[new_str] = old_str;
} else {
myset[myset[old_str]] = new_str;
myset[new_str] = myset[old_str];
auto it = myset.find(old_str);
if (it != myset.end()) myset.erase(it);
}
}
cout << old.size() << endl;
for (string s : old)
if (myset.find(s) != myset.end()) cout << s << " " << myset[s] << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
int n, m, k, cnt[MAXN], myCnt[MAXN], ansx, ansy, st, ed, p;
int maxDis;
void getAns(int n, int m, int x, int y) {
memset(myCnt, 0, sizeof(myCnt));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
myCnt[abs(i - x) + abs(j - y)]++;
}
}
}
void pdAns(int n, int m) {
ansy = n + m - maxDis - ansx;
getAns(n, m, min(ansy, ansx), max(ansx, ansy));
}
int main() {
scanf("%d", &k);
maxDis = 0;
for (int i = 1; i <= k; ++i) {
int num;
scanf("%d", &num);
cnt[num]++;
maxDis = max(maxDis, num);
}
for (int i = 1; i < MAXN; ++i) {
if (cnt[i] != i * 4) {
ansx = i;
break;
}
}
bool ans = true;
for (n = 1; n <= k; ++n) {
if (k % n != 0) continue;
m = k / n;
pdAns(n, m);
ans = true;
for (int j = 0; j <= k; ++j) {
if (myCnt[j] != cnt[j]) {
ans = false;
break;
}
}
if (ans) {
break;
}
}
if (ans) {
printf("%d %d\n%d %d\n", n, m, ansx, ansy);
} else {
printf("-1\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char matrix[55][55];
int visited[55][55];
int dfs(int i, int j, int parentx, int parenty) {
visited[i][j] = 1;
if ((i - 1) >= 0 && matrix[i - 1][j] == matrix[i][j]) {
if (visited[i - 1][j] == 0) {
if (dfs(i - 1, j, i, j)) return 1;
} else {
if (i - 1 != parentx && j != parenty) return 1;
}
}
if ((i + 1) < n && matrix[i + 1][j] == matrix[i][j]) {
if (visited[i + 1][j] == 0) {
if (dfs(i + 1, j, i, j)) return 1;
} else {
if ((i + 1) != parentx && j != parenty) return 1;
}
}
if ((j - 1) >= 0 && matrix[i][j - 1] == matrix[i][j]) {
if (visited[i][j - 1] == 0) {
if (dfs(i, j - 1, i, j)) return 1;
} else {
if (i != parentx && (j - 1) != parenty) return 1;
}
}
if ((j + 1) < m && matrix[i][j + 1] == matrix[i][j]) {
if (visited[i][j + 1] == 0) {
if (dfs(i, j + 1, i, j)) return 1;
} else {
if (i != parentx && (j + 1) != parenty) return 1;
}
}
return 0;
}
int main() {
scanf("%d", &n);
;
scanf("%d", &m);
;
int i, j;
char c;
for (i = 0; i < n; i++) {
scanf("%c", &c);
for (j = 0; j < m; j++) {
scanf("%c", &matrix[i][j]);
visited[i][j] = 0;
}
}
int flag = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (visited[i][j] == 0) flag = max(flag, dfs(i, j, -1, -1));
}
}
if (flag) {
printf("Yes");
} else {
printf("No");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
string s;
while (t--) {
cin >> s;
for (int i = 0; i < s.length(); i = i + 2) {
cout << s[i];
}
cout << s[s.length() - 1];
cout << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2505;
struct pi {
int to;
int cost;
} pp[maxn];
struct ppi {
int x;
int y;
int p;
} pp1[maxn * maxn];
int cmp(ppi a, ppi b) { return a.p < b.p; }
vector<pi> g[maxn];
int fa[maxn];
int find(int p) {
if (fa[p] == -1 || fa[p] == p) return fa[p] = p;
return fa[p] = find(fa[p]);
}
void merg(int a, int b) {
int p = find(a);
int q = find(b);
if (p != q) fa[p] = q;
}
int flag;
int a[2505][2505];
void dfs(int u, int pa, int root, int s) {
if (a[u][root] != s) {
flag = 1;
return;
}
int p = g[u].size();
for (int i = 0; i < p; i++) {
if (g[u][i].to != pa) {
dfs(g[u][i].to, u, root, max(s, g[u][i].cost));
}
}
}
int main() {
int i, j, n, m = 0;
cin >> n;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
++m;
pp1[m].x = i;
pp1[m].y = j;
pp1[m].p = a[i][j];
}
}
int f = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i == j && a[i][j] != 0) {
f = 1;
}
if (a[i][j] != a[j][i]) {
f = 1;
}
}
}
if (f == 0) {
sort(pp1 + 1, pp1 + 1 + m, cmp);
memset(fa, -1, sizeof(fa));
for (i = 1; i <= m; i++) {
if (find(pp1[i].x) != find(pp1[i].y)) {
merg(pp1[i].x, pp1[i].y);
pi p1;
p1.to = pp1[i].y;
p1.cost = pp1[i].p;
g[pp1[i].x].push_back(p1);
p1.to = pp1[i].x;
g[pp1[i].y].push_back(p1);
}
}
for (i = 1; i <= n; i++) {
dfs(i, -1, i, 0);
if (flag) break;
}
if (flag)
printf("NOT MAGIC\n");
else
printf("MAGIC\n");
} else
printf("NOT MAGIC\n");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string p[6] = {"jolteon", "flareon", "umbreon",
"leafeon", "sylveon", "glaceon"};
int main() {
int n, j = -1;
string s, t;
cin >> n >> s;
if (n == 8)
cout << "vaporeon";
else if (n == 6)
cout << "espeon";
else {
do {
j++;
t = s;
for (int i = 0; i <= 6; i++)
if (t[i] == '.') t[i] = p[j][i];
} while (t != p[j]);
}
cout << t;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (long long i = 0; i < v.size(); ++i) {
os << v[i];
if (i != v.size() - 1) os << ", ";
}
os << "]";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "{";
for (auto it : v) {
os << it;
if (it != *v.rbegin()) os << ", ";
}
os << "}";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const map<T, S>& v) {
os << "{";
for (auto it : v) {
os << it.first << " : " << it.second;
if (it != *v.rbegin()) os << ", ";
}
os << "}";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
os << "(";
os << v.first << ", " << v.second << ")";
return os;
}
void solve() {
string s;
cin >> s;
for (long long i = 1; i < s.length(); i++) {
if (s[i] != '?' && s[i] == s[i - 1]) {
cout << -1 << "\n";
return;
}
}
for (long long i = 0; i < s.length(); i++) {
if (s[i] != '?') continue;
if (i == 0) {
if (s[i + 1] != 'a') {
s[i] = 'a';
} else if (s[i + 1] != 'b') {
s[i] = 'b';
} else if (s[i + 1] != 'c') {
s[i] = 'c';
}
} else if (i == s.length() - 1) {
if (s[i - 1] != 'a') {
s[i] = 'a';
} else if (s[i - 1] != 'b') {
s[i] = 'b';
} else if (s[i - 1] != 'c') {
s[i] = 'c';
}
} else {
if (s[i - 1] != 'a' && s[i + 1] != 'a') {
s[i] = 'a';
} else if (s[i - 1] != 'b' && s[i + 1] != 'b') {
s[i] = 'b';
} else if (s[i - 1] != 'c' && s[i + 1] != 'c') {
s[i] = 'c';
}
}
}
cout << s << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long tc;
cin >> tc;
while (tc--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int N, Q;
int fenwick[MAXN];
inline int lowbit(const int &a) { return a & (-a); }
int get(int x) {
int ret = 0;
while (x > 0) {
ret += fenwick[x];
x -= lowbit(x);
}
return ret;
}
void add(int x, int val) {
while (x <= N) {
fenwick[x] += val;
x += lowbit(x);
}
}
bool swp;
int l, r;
void fold(int center) {
if (swp) {
if (center > r - l - center) {
int posa = r - center, posb = posa + 1;
int nl = posa;
while (r - center > l) {
int val = get(posa) - get(posa - 1);
add(posb, val);
center++, posa--, posb++;
}
l = nl;
swp ^= 1;
} else {
int posa = r - center + 1, posb = posa - 1;
r = posb;
while (center) {
int val = get(posa) - get(posa - 1);
add(posb, val);
center--, posa++, posb--;
}
}
} else {
if (center > r - l - center) {
int posa = l + center + 1, posb = posa - 1;
int nr = posb;
while (l + center < r) {
int val = get(posa) - get(posa - 1);
add(posb, val);
center++, posa++, posb--;
}
r = nr;
swp ^= 1;
} else {
int posa = l + center, posb = posa + 1;
l = posa;
while (center) {
int val = get(posa) - get(posa - 1);
add(posb, val);
center--, posa--, posb++;
}
}
}
}
int query(int ql, int qr) {
if (swp) return get(r - ql) - get(r - qr);
return get(l + qr) - get(l + ql);
}
int main(int argc, const char *argv[]) {
while (scanf(" %d %d", &N, &Q) != EOF) {
l = 0, r = N;
swp = false;
memset(fenwick, 0, sizeof(fenwick));
for (int i = 1; i <= N; i++) add(i, 1);
for (int i = 1; i <= Q; i++) {
int typ, arg, brg;
scanf(" %d %d", &typ, &arg);
if (typ == 1) {
fold(arg);
} else {
scanf(" %d", &brg);
printf("%d\n", query(arg, brg));
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 1; i < n - 1; i++) {
if (a[i] == 0 && a[i - 1] == 1 && a[i + 1] == 1) {
a[i + 1] = 0;
ans++;
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
void solve() {
cin >> n;
cout << 2 * n * n - 2 * n + 1 << '\n';
}
int main() {
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
int father = 0;
using namespace std;
const int oo = 1e9;
const int M1 = 1000000007;
const int M2 = 1000000009;
const double PI = acos(-1);
const int SZ = 1 << 21;
const int MX = 300000;
const int N = MX + 100;
const int LOGN = 18;
int n, m, p[N], q, Z, vis[N], vsId, ans[N];
vector<int> g[N];
struct qu {
int l, r, idx;
qu(int _l, int _r, int _idx) {
l = _l;
r = _r;
idx = _idx;
}
bool operator<(const qu &rhs) const { return r < rhs.r; }
};
vector<qu> bk[350];
int dfs(int u, int bl, int br, int ql, int qr) {
if (u < ql || u > qr) return -1;
if (u < bl || u > br) return u;
if (vis[u] == vsId) return -1;
vis[u] = vsId;
int mx = u;
for (int i = 0; i < g[u].size(); ++i) {
if (g[u][i] > br) break;
mx = max(mx, dfs(g[u][i], bl, br, ql, qr));
}
vector<int>::iterator it = upper_bound(g[u].begin(), g[u].end(), qr);
if (it != g[u].begin()) {
--it;
mx = max(mx, dfs((*it), bl, br, ql, qr));
}
return mx;
}
int main() {
scanf("%d%d", &n, &m);
Z = sqrt(n) + 1;
for (int i = 1; i <= n; ++i) p[i] = i;
for (int u, v, i = 0; i < m; ++i) {
scanf("%d%d", &u, &v);
p[v] = u;
g[u].push_back(v);
}
for (int i = 2; i <= n; ++i) {
g[i].push_back(i - 1);
}
for (int i = 1; i <= n; ++i) {
sort(g[i].begin(), g[i].end());
}
scanf("%d", &q);
for (int x, y, i = 0; i < q; ++i) {
scanf("%d%d", &x, &y);
bk[x / Z].push_back(qu(x, y, i));
}
for (int i = 0; i <= Z; ++i) {
sort(bk[i].begin(), bk[i].end());
if (!bk[i].size()) continue;
int idx = i * Z + Z;
int st = i * Z;
int ed = min(n, idx - 1);
vector<pair<int, int> > all;
for (int j = 0; j < bk[i].size(); ++j) {
qu cur = bk[i][j];
while (idx <= cur.r) {
if (p[idx] <= ed) {
all.push_back(make_pair(idx, idx));
idx++;
continue;
}
int res = p[idx];
while (all.size() && all.back().second >= p[idx]) {
res = min(res, all.back().first);
all.pop_back();
}
all.push_back(make_pair(res, idx));
idx++;
}
vsId++;
int best = dfs(cur.l, st, ed, cur.l, cur.r);
for (int j = cur.l; j <= min(best, ed); ++j) {
best = max(best, dfs(j, st, ed, cur.l, cur.r));
}
vector<pair<int, int> >::iterator it =
upper_bound(all.begin(), all.end(), make_pair(best, oo));
if (it != all.begin()) {
--it;
best = max(best, (*it).second);
}
ans[cur.idx] = best;
}
}
for (int i = 0; i < q; ++i) {
printf("%d\n", ans[i]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
int gcd(int a, int b) {
if (b == 0) return a;
gcd(b, a % b);
}
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
if (gcd(a, b) != 1)
cout << "INFINITE" << endl;
else
cout << "FINITE" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int a[n];
vector<int> b(n);
pair<int, int> c[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
c[i].first = b[i];
c[i].second = i;
}
sort(b.begin(), b.end());
sort(c, c + n);
int kolit = 0;
for (int i = 0; i < n; i++) {
bool ik = false;
for (int j = 0; j < 31; j++) {
long long som = (1 << j);
int nomerok = lower_bound(b.begin(), b.end(), som - a[i]) - b.begin();
if (b[nomerok] == som - a[i] &&
(c[nomerok].second != i ||
c[nomerok].first == c[nomerok + 1].first)) {
ik = true;
break;
}
}
if (!ik) kolit++;
}
cout << kolit;
return 0;
}
| 2 |
# include <iostream>
typedef long long LL;
using namespace std;
const int kMaxN = 1e5 + 1;
LL n, t, c, mx, mx2;
LL a[kMaxN], f[kMaxN], g[kMaxN];
int main() {
scanf("%lld", &t);
while (t--) {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
f[i] = 0;
g[i] = 0;
}
c = 0;
mx = 0;
mx2 = 0;
for (int i = 1; i <= n; i++) {
c += i == 1 || a[i] == a[i - 1];
mx = max(mx, f[a[i]] += (i == 1 || a[i] == a[i - 1]) + (i == n || a[i] == a[i + 1]));
mx2 = max(mx2, ++g[a[i]]);
}
if (mx2 > (n + 1) / 2) {
printf("-1\n");
continue;
}
printf("%lld\n", c - 1 + max(mx - c - 1, 0ll));
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int di[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dj[] = {1, -1, 0, 0, -1, 1, 1, -1};
struct node {
int sum = 0;
node *left, *right;
node(int sum = 0) : sum(sum), left(this), right(this) {}
node(int sum, node *left, node *right) : sum(sum), left(left), right(right) {}
};
const int N = 1e5 + 5, M = 2 * N + 5, K = 18;
int n, m, q;
int arr[N], table[M][K], LG[M], parent[N];
vector<int> adj[N], people[N];
int sz = 0;
int E[M], L[M], F[N];
node *root[N];
node *insert(node *cur, int v, int l = 1, int r = m) {
if (v > r || v < l) return cur;
if (l == r) return new node(cur->sum + 1);
int mid = l + ((r - l) >> 1);
node *left = insert(cur->left, v, l, mid);
node *right = insert(cur->right, v, mid + 1, r);
return new node(cur->sum + 1, left, right);
}
int query(node *a, node *b, node *lca, node *lcap, int k, int l = 1,
int r = m) {
if (a->sum + b->sum - lca->sum - lcap->sum < k) return -1;
if (l == r) return l;
int mid = l + ((r - l) >> 1);
int lefCnt = a->left->sum + b->left->sum - lca->left->sum - lcap->left->sum;
if (k <= lefCnt)
return query(a->left, b->left, lca->left, lcap->left, k, l, mid);
return query(a->right, b->right, lca->right, lcap->right, k - lefCnt, mid + 1,
r);
}
void dfs(int cur, int par, int level) {
parent[cur] = par;
E[sz] = cur;
L[sz] = level;
F[cur] = sz++;
root[cur] = root[par];
for (int person : people[cur]) root[cur] = insert(root[cur], person);
for (int child : adj[cur]) {
if (child == par) continue;
dfs(child, cur, level + 1);
E[sz] = cur;
L[sz++] = level;
}
}
void build() {
root[0] = new node;
dfs(1, 0, 0);
LG[0] = -1;
for (int i = 0; i < sz; i++) {
table[i][0] = i;
LG[i + 1] = LG[i] + ((i & (i + 1)) == 0);
}
for (int j = 1; j < K; j++) {
for (int i = 1; i + (1 << j) - 1 < sz; i++) {
int f = table[i][j - 1];
int s = table[i + (1 << (j - 1))][j - 1];
table[i][j] = L[f] < L[s] ? f : s;
}
}
}
int RMQ(int l, int r) {
if (l > r) swap(l, r);
int lg = LG[r - l + 1];
int f = table[l][lg], s = table[r - (1 << lg) + 1][lg];
return L[f] < L[s] ? f : s;
}
int LCA(int a, int b) {
int pos = RMQ(F[a], F[b]);
return E[pos];
}
int main() {
scanf("%d%d%d", &n, &m, &q);
int a, b;
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
int c;
for (int i = 1; i <= m; i++) {
scanf("%d", &c);
people[c].push_back(i);
}
build();
int v, u;
while (q--) {
scanf("%d%d%d", &v, &u, &a);
int lca = LCA(v, u);
vector<int> info;
for (int i = 1; i <= a; i++) {
int x = query(root[v], root[u], root[lca], root[parent[lca]], i);
if (x == -1) break;
info.push_back(x);
}
printf("%d ", info.size());
for (int x : info) printf("%d ", x);
puts("");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
inline int read() {
int x = 0;
char w = 1;
register unsigned char c = getchar();
for (; c ^ '-' && (c < '0' || c > '9'); c = getchar())
;
if (c == '-') w = -1, c = getchar();
for (; c >= '0' && c <= '9'; c = getchar()) x = (x << 3) + (x << 1) + c - '0';
return x * w;
}
struct Node {
int idx, w;
};
inline bool operator<(const Node& a, const Node& b) { return a.w > b.w; }
int N, M, S, T, x, y, d1[MAXN], d2[MAXN], vis[MAXN], ans;
int first[MAXN * 2], nxt[MAXN * 2], to[MAXN * 2], num_edge;
priority_queue<Node> q;
bool had[1010][1010];
inline void add(int u, int v) {
to[++num_edge] = v;
nxt[num_edge] = first[u];
first[u] = num_edge;
}
inline void Dijkstra_S() {
memset(d1, 0x3f, sizeof(d1));
memset(vis, 0, sizeof(vis));
d1[S] = 0;
q.push((Node){S, 0});
int u, v;
while (!q.empty()) {
u = q.top().idx;
q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = first[u]; i; i = nxt[i]) {
v = to[i];
if (d1[u] + 1 < d1[v]) {
d1[v] = d1[u] + 1;
q.push((Node){v, d1[v]});
}
}
}
}
inline void Dijkstra_T() {
memset(d2, 0x3f, sizeof(d2));
memset(vis, 0, sizeof(vis));
d2[T] = 0;
q.push((Node){T, 0});
int u, v;
while (!q.empty()) {
u = q.top().idx;
q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = first[u]; i; i = nxt[i]) {
v = to[i];
if (d2[u] + 1 < d2[v]) {
d2[v] = d2[u] + 1;
q.push((Node){v, d2[v]});
}
}
}
}
int main() {
N = read(), M = read(), S = read(), T = read();
for (int i = 1; i <= M; ++i) {
x = read(), y = read();
add(x, y);
add(y, x);
had[x][y] = had[y][x] = 1;
}
Dijkstra_S();
Dijkstra_T();
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= N; ++j) {
if (i == j) continue;
if (had[i][j] || had[j][i]) continue;
if (d1[i] + d2[j] + 1 >= d1[T] && d2[i] + d1[j] + 1 >= d1[T]) {
++ans;
had[i][j] = had[j][i] = 1;
}
}
}
printf("%d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int x1, y1, x2, y2, x, y;
cin >> x1 >> y1 >> x2 >> y2 >> x >> y;
int absx = abs(x1 - x2);
int absy = abs(y1 - y2);
if (absx % x == 0 && absy % y == 0 && (absx / x) % 2 == (absy / y) % 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void Rd(int &res) {
char c;
res = 0;
int k = 1;
while (c = getchar(), c < 48 && c != '-')
;
if (c == '-') {
k = -1;
c = 48;
}
do {
res = (res << 3) + (res << 1) + (c ^ 48);
} while (c = getchar(), c >= 48);
res *= k;
}
long long sum[200005];
int n, A[200005];
int main() {
Rd(n);
for (int i = 1; i <= n; i++) {
Rd(A[i]);
sum[i] = sum[i - 1] + A[i];
}
long long mi = sum[n];
for (int i = n - 1; i > 1; i--)
if (sum[i] - mi > mi) mi = sum[i] - mi;
cout << mi << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
inline int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
inline int qpow(int x, int y = MOD - 2) {
long long r = 1, k = x;
for (; y; y >>= 1, k *= k, k %= MOD)
if (y & 1) r *= k, r %= MOD;
return r;
}
int main() {
int n = read(), m = read();
int ans = qpow(n * 2 + 2, m);
ans = 1ll * ans * (n + 1 - m) % MOD;
printf("%lld\n", 1ll * ans * qpow(n + 1) % MOD);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long q, n, B[26], C[26];
string t, s, t2, s2, r;
string Obrisi(char c) {
string ret;
for (long long i = 0; i < s2.size(); i++) {
if (s2[i] != c) {
ret += s2[i];
}
}
s2 = ret;
return ret;
}
bool Check() {
t2 = s2 = s;
for (long long i = 0; i < r.size(); i++) {
t2 += Obrisi(r[i]);
}
if (t2 == t) {
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> q;
while (q--) {
cin >> t;
r = s = "";
n = 0;
for (long long i = 0; i < 26; i++) {
B[i] = C[i] = 0;
}
for (long long i = t.size() - 1; i >= 0; i--) {
if (!B[t[i] - 'a']) {
r += t[i];
}
B[t[i] - 'a']++;
}
reverse(r.begin(), r.end());
for (long long i = 0; i < r.size(); i++) {
C[r[i] - 'a'] = (B[r[i] - 'a'] / (i + 1));
n += C[r[i] - 'a'];
}
for (long long i = 0; i < n; i++) {
s += t[i];
}
if (!Check()) {
cout << "-1\n";
continue;
}
cout << s << " " << r << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ans = 0, hash1[110000][18], hash2[110000][18], a[110000],
b[110000][27], B[20];
int n, last1[110000][27], last2[110000][27], len1[110000], len2[110000];
char str[110000];
bool p[110000][20];
int cal(int x, int y) {
int ans = 0;
for (int i = 16; i >= 0; i--)
if ((1 << i) <= x && (1 << i) <= n - y + 1 && hash1[x][i] == hash2[y][i])
ans += 1 << i, x -= 1 << i, y += 1 << i;
return ans;
}
int main() {
scanf("%s", str);
n = strlen(str);
for (int i = n; i; i--) str[i] = str[i - 1];
B[0] = 37;
for (int i = 1; i <= 16; i++) B[i] = B[i - 1] * B[i - 1] % 100000007;
for (int i = 1; i <= n; i++) {
hash1[i][0] = str[i];
for (int j = 0; j < 26; j++) last1[i][j] = last1[i - 1][j];
last1[i][str[i] - 'a'] = i;
for (int j = 1; (1 << j) <= i; j++)
hash1[i][j] =
(hash1[i - (1 << (j - 1))][j - 1] * B[j - 1] + hash1[i][j - 1]) %
100000007;
}
for (int i = 0; i < 26; i++) last2[n + 1][i] = n + 1;
for (int i = n; i; i--) {
hash2[i][0] = str[i];
for (int j = 0; j < 26; j++) last2[i][j] = last2[i + 1][j];
last2[i][str[i] - 'a'] = i;
for (int j = 1; (1 << j) <= n - i + 1; j++)
hash2[i][j] =
(hash2[i + (1 << (j - 1))][j - 1] * B[j - 1] + hash2[i][j - 1]) %
100000007;
}
for (int i = 1; i <= n; i++) {
len1[i] = cal(i - 1, i + 1);
len2[i] = cal(i - 1 - len1[i] - 1, i + 1 + len1[i] + 1);
len2[i] = min(len2[i] + len1[i] + 1, min(i - 1, n - i));
}
for (int j = 0, t = 0; j <= n; j = j * 2 + 1, ++t)
for (int i = 1; i <= n; i++) {
int len3 = min(i - 1 - last1[i - 1][str[i] - 'a'],
last2[i + 1][str[i] - 'a'] - 1 - i);
if (j <= len2[i]) {
if (j <= len1[i]) {
if (j > len3) continue;
if (!p[i - j / 2 - j % 2][t - 1] && t != 0) continue;
p[i][t] = 1;
ans += (long long)(j * 2 + 1) * (j * 2 + 1);
a[i - j] += (long long)(j * 2 + 1) * (j * 2 + 1);
a[i + j + 1] -= (long long)(j * 2 + 1) * (j * 2 + 1);
} else {
if (p[i + j / 2 + j % 2][t - 1] && str[i + len1[i] + 1] != str[i]) {
int len4 = last2[i + 1][str[i] - 'a'] - 1 - i;
if (last1[i - 1][str[i] - 'a'] > i - len1[i] - 1)
len4 = len3;
else
len4 = min(len4, i - 1 - last1[i - len1[i] - 2][str[i] - 'a']);
if (j > len4) continue;
b[i - len1[i] - 1][str[i + len1[i] + 1] - 'a'] +=
(long long)(j * 2 + 1) * (j * 2 + 1);
}
if (p[i - j / 2 - j % 2][t - 1] && str[i - len1[i] - 1]) {
int len4 = i - 1 - last1[i - 1][str[i] - 'a'];
if (last2[i + 1][str[i] - 'a'] < i + len1[i] + 1)
len4 = len3;
else
len4 = min(len4, last2[i + len1[i] + 2][str[i] - 'a'] - i - 1);
if (j > len4) continue;
b[i + len1[i] + 1][str[i - len1[i] - 1] - 'a'] +=
(long long)(j * 2 + 1) * (j * 2 + 1);
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int k = 0; k < 26; k++)
if (k != (int)(str[i] - 'a')) {
int len3 = min(i - 1 - last1[i - 1][k], last2[i + 1][k] - 1 - i);
for (int j = 0, t = 0; j <= len1[i] && j <= len3; j = j * 2 + 1, ++t)
if (t == 0 || p[i - j / 2 - j % 2][t - 1])
b[i][k] += (long long)(j * 2 + 1) * (j * 2 + 1);
}
}
for (int i = 1; i <= n; i++) a[i] += a[i - 1];
long long Max = ans;
for (int i = 1; i <= n; i++)
for (int j = 0; j < 26; j++) Max = max(Max, ans - a[i] + b[i][j]);
cout << Max << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, ans1, ans2;
int c[1010], d[1010];
bool f1[1010], f2[1010], flag;
string a, b;
cin >> n;
cin >> a;
cin >> b;
for (i = 0; i < n; i++) c[i] = a[i] - 48;
for (i = 0; i < n; i++) d[i] = b[i] - 48;
sort(c, c + n);
sort(d, d + n);
memset(f1, false, sizeof(f1));
memset(f2, false, sizeof(f2));
ans1 = ans2 = 0;
for (i = 0; i < n; i++) {
flag = false;
for (j = n - 1; j >= 0; j--) {
if (c[j] <= d[i] && !f1[j]) {
f1[j] = true;
flag = true;
break;
}
}
if (!flag) ans1++;
}
for (i = 0; i < n; i++) {
flag = false;
for (j = 0; j < n; j++) {
if (d[j] > c[i] && !f2[j]) {
f2[j] = true;
flag = true;
break;
}
}
if (flag) ans2++;
}
cout << ans1 << endl;
cout << ans2 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
long long int gcd(long long int a, long long int b) {
return (a ? gcd(b % a, a) : b);
}
long long int modPow(long long int a, long long int b, long long int MOD) {
long long int x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y) % MOD;
}
b /= 2;
y = (y * y) % MOD;
}
return x;
}
long long int modInverse(long long int a, long long int p) {
return modPow(a, p - 2, p);
}
using namespace std;
double EPS = 0.00000000001;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int k, d, t;
cin >> k >> d >> t;
if (k % d == 0) {
cout << t;
return 0;
} else {
double tonn = k;
double toff = d - (k % d);
double tfor1 = (double)tonn + toff;
long long int cnt = (2 * t) / (2 * tonn + toff);
double ans = (double)cnt * (tfor1);
double leftover = t - cnt * 1.0 * (tonn + toff / 2.0);
if (leftover + EPS <= k)
ans += leftover;
else
ans += k + (leftover - k) * 2.0;
cout << setprecision(11) << fixed;
;
cout << ans;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
template <class T>
void R(T &x) {
cin >> x;
}
void R(int &x) { scanf("%d", &x); }
void R(long long &x) { scanf("%lld", &x); }
void R(double &x) { scanf("%lf", &x); }
void R(char &x) { scanf(" %c", &x); }
void R(char *x) { scanf("%s", x); }
long long _pow(long long a, long long b) {
long long res = 1ll;
while (b) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return res;
}
int a[105], b[105], c[105][105];
int main() {
int n, m;
int x = 0;
R(n), R(m);
for (int i = 1; i <= n; i++) R(a[i]), x ^= a[i];
for (int i = 1; i <= m; i++) R(b[i]), x ^= b[i];
if (x != 0)
puts("NO");
else {
puts("YES");
memset((c), 0, sizeof(c));
;
for (int i = 1; i < n; i++) c[i][m] = a[i];
for (int i = 1; i < m; i++) c[n][i] = b[i];
c[n][m] = a[n];
for (int i = 1; i < m; i++) c[n][m] ^= b[i];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%d ", c[i][j]);
cout << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, nxt[1010];
bool vis[1010];
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> nxt[i];
}
for (int i = 1; i <= n; ++i) {
memset(vis, false, sizeof(vis));
int s = i;
while (!vis[s]) {
vis[s] = true;
s = nxt[s];
}
if (i > 1) cout << ' ';
cout << s;
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int q;
cin >> q;
while (q--) {
int n, i, j;
int sum0 = 0, sum1 = 0;
cin >> n;
for (i = 1; i <= n; i++) {
int a[105] = {0};
for (j = i + 1; j <= 2 * i; j++) {
a[j] = 1;
}
for (j = 2 * i + 2; j <= 2 * n; j += 2) {
a[j] = 1;
}
for (j = 1; j <= 2 * n; j++) {
if (a[j])
cout << ")";
else
cout << "(";
}
cout << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool compare(pair<int, int> a, pair<int, int> b) { return a.first > b.first; }
int main() {
int n;
cin >> n;
pair<int, int> arr[n];
for (int i = 0; i < n; i++) {
int x;
cin >> x;
arr[i] = make_pair(x, i + 1);
}
sort(arr, arr + n, compare);
int ans = 0;
int x = 0;
for (int i = 0; i < n; i++) {
ans += (arr[i].first) * i + 1;
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
cout << arr[i].second << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int solve(long long q, long long m, long long k) {
if (m > k) {
if ((m - k) % 2) {
if (q <= m - k + 1) {
return 0;
} else {
return solve(q - (m - k + 1), k - 1, k);
}
} else {
if (q <= m - k) {
return 0;
} else {
return solve(q - (m - k), k, k);
}
}
}
if (q <= 2 * m) {
return ((q - 1) % 2);
}
return 1;
}
int main() {
long long n, k, p, m, q;
cin >> n >> k >> p;
m = n - k;
for (int i = 0; i < p; i++) {
cin >> q;
cout << (solve(q, m, k) ? 'X' : '.');
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
int a[N];
int main() {
int n, ans = 0, b;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &b);
int z = i - b;
if (z < 0) z = 0;
a[z]++;
a[i]--;
}
for (int i = 1; i < n; i++) a[i] += a[i - 1];
for (int i = 0; i < n; i++) ans += bool(a[i]);
cout << n - ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct FT {
int n;
vector<int> ft;
void init(int l) {
n = l + 1;
ft.resize(n);
}
void up(int p, int v) {
for (int i = p; i < n; i += i & -i) ft[i] += v;
}
int get(int p) {
int ans = 0;
for (int i = p; i; i -= i & -i) ans += ft[i];
return ans;
}
};
void solve() {
int n, k;
cin >> n >> k;
vector<pair<int, pair<int, int>>> a(n);
vector<int> q(n);
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second.first >> a[i].second.second;
q[i] = a[i].second.second;
}
sort(q.begin(), q.end());
q.erase(unique(q.begin(), q.end()), q.end());
int m = q.size();
int pos[n];
vector<FT> ft(m);
vector<vector<int>> x(m);
sort(a.begin(), a.end(),
[](pair<int, pair<int, int>> a, pair<int, pair<int, int>> b) {
return a.second.first > b.second.first;
});
for (int i = 0; i < n; ++i) {
pos[i] = (lower_bound(q.begin(), q.end(), a[i].second.second) - q.begin());
x[pos[i]].push_back(a[i].first);
}
for (int i = 0; i < m; ++i) {
sort(x[i].begin(), x[i].end());
x[i].erase(unique(x[i].begin(), x[i].end()), x[i].end());
ft[i].init(x[i].size());
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
int qi = pos[i];
int ql =
lower_bound(q.begin(), q.end(), a[i].second.second - k) - q.begin();
int qr =
upper_bound(q.begin(), q.end(), a[i].second.second + k) - q.begin();
for (int j = ql; j < qr; ++j) {
int xl = lower_bound(x[j].begin(), x[j].end(),
a[i].first - a[i].second.first) -
x[j].begin();
int xr = upper_bound(x[j].begin(), x[j].end(),
a[i].first + a[i].second.first) -
x[j].begin();
if (xl < xr) ans += 1LL * ft[j].get(xr) - ft[j].get(xl);
}
ft[qi].up(
1 + lower_bound(x[qi].begin(), x[qi].end(), a[i].first) - x[qi].begin(),
1);
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n1, n2, k1, k2;
cin >> n1 >> n2 >> k1 >> k2;
if (n1 <= n2)
cout << "Second";
else
cout << "First";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int y1;
int T;
y1=0;
cin >> T;
y1=0;
while(T--) {
y1=0;
string s;
y1=0;
int n, k;
y1=0;
cin >> n >> k >> s;
y1=0;
bool ok = true;
y1=0;
for (int i = 0; i < k; i++) {
y1=0;
if (s[i] != s[n-1-i]) ok = false;
y1=0;
}
y1=0;
if (2*k == n) ok = false;
y1=0;
puts(ok ? "YES" : "NO");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, a, b;
int grid[55][55];
int solve(int x, int y) {
int ret = x * y;
for (int i = 1; i + x - 1 <= n; i++)
for (int j = 1; j + y - 1 <= m; j++) {
int trees = grid[i + x - 1][j + y - 1] - grid[i - 1][j + y - 1] -
grid[i + x - 1][j - 1] + grid[i - 1][j - 1];
ret = min(ret, trees);
}
return ret;
}
int main() {
cin >> n >> m;
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < m + 1; j++)
cin >> grid[i][j],
grid[i][j] += grid[i - 1][j] + grid[i][j - 1] - grid[i - 1][j - 1];
cin >> a >> b;
cout << min(solve(a, b), solve(b, a)) << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int n, c;
vector<long long int> a, b;
long long int pos(long long int l) {
long long int d1 = 0;
for (long long int i = 0; i < n; i++) {
long long int x = (a[i] * l) / b[i];
x++;
d1 += x;
}
return d1;
}
pair<long long int, long long int> fun(long long int l, long long int r) {
while (r - l > 2) {
long long int md1 = l + (r - l) / 3;
long long int md2 = r - (r - l) / 3;
long long int d1 = 0, d2 = 0;
d1 = pos(md1);
d2 = pos(md2);
if (d2 < c)
l = md2;
else if (d1 > c)
r = md1;
else if (d1 == c && d2 == c) {
pair<long long int, long long int> p1 = fun(l, md1);
pair<long long int, long long int> p2 = fun(md2, r);
pair<long long int, long long int> p = make_pair(p1.first, p2.second);
return p;
} else if (d2 == c) {
pair<long long int, long long int> p1 = fun(md1, md2);
pair<long long int, long long int> p2 = fun(md2, r);
pair<long long int, long long int> p = make_pair(p1.first, p2.second);
return p;
} else if (d1 == c) {
pair<long long int, long long int> p1 = fun(l, md1);
pair<long long int, long long int> p2 = fun(md1, md2);
pair<long long int, long long int> p = make_pair(p1.first, p2.second);
return p;
} else {
l = md1;
r = md2;
}
}
if (r - l > 2)
return {l, r};
else {
long long int in = 0;
for (long long int i = l; i <= r; i++) {
if (pos(i) == c) {
l = i;
in++;
break;
}
}
for (long long int i = r; i >= l; i--) {
if (pos(i) == c) {
r = i;
break;
}
}
if (in > 0)
return {l, r};
else
return {-1, -1};
}
}
int32_t main() {
cin >> n >> c;
a.resize(n);
b.resize(n);
long long int l = 0;
for (long long int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
if (a[i] == 0) continue;
long long int x = b[i] / a[i];
if (b[i] % a[i] != 0) x++;
l = max(x, l);
}
l = 1;
long long int r = 1e9 + 1;
pair<long long int, long long int> ans = fun(l, r);
l = ans.first;
r = ans.second;
if (l == -1)
cout << 0;
else
cout << r - l + 1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long numbit(long long x) { return (1LL << x) - 1LL; }
long long getbit(long long x, long long i) { return (x >> i) & 1LL; }
long long onbit(long long x, long long i) { return x | (1LL << i); }
long long offbit(long long x, long long i) { return x & (~(1LL << i)); }
int newMaskNULL(int mask, int m) { return (mask << 1) % (1 << m); }
int newMask(int mask, int m) { return ((mask << 1) % (1 << m)) | 1; }
const long long Inf64 = 1e18;
const long long Inf = 1e9;
const int Nmax = 1e5 + 10;
const long long Mod9 = 1e9 + 9;
const long long Mod7 = 1e9 + 7;
const int LOGN = 18;
const int MOD = 998244353;
int g = 3;
int mul(int a, int b) { return int(a * 1ll * b % MOD); }
int norm(int a) {
while (a >= MOD) a -= MOD;
while (a < 0) a += MOD;
return a;
}
int binPow(int a, int k) {
int ans = 1;
for (; k > 0; k >>= 1) {
if (k & 1) ans = mul(ans, a);
a = mul(a, a);
}
return ans;
}
int inv(int a) { return binPow(a, MOD - 2); }
vector<int> w[LOGN], rv;
bool precalced = false;
void precalc() {
if (precalced) return;
precalced = true;
int wb = binPow(g, (MOD - 1) / (1 << LOGN));
for (int st = int(0); st < int(LOGN); st++) {
w[st].assign(1 << st, 1);
int bw = binPow(wb, 1 << (LOGN - st - 1));
int cw = 1;
for (int k = int(0); k < int((1 << st)); k++) {
w[st][k] = cw;
cw = mul(cw, bw);
}
}
rv.assign(1 << LOGN, 0);
for (int i = int(1); i < int(int((rv).size())); i++)
rv[i] = (rv[i >> 1] >> 1) | ((i & 1) << (LOGN - 1));
}
const int MX = (1 << LOGN) + 3;
inline void fft(int a[MX], int n, bool inverse) {
precalc();
int ln = __builtin_ctz(n);
assert((1 << ln) < MX);
assert((1 << ln) == n);
for (int i = int(0); i < int(n); i++) {
int ni = rv[i] >> (LOGN - ln);
if (i < ni) swap(a[i], a[ni]);
}
for (int st = 0; (1 << st) < n; st++) {
int len = (1 << st);
for (int k = 0; k < n; k += (len << 1)) {
for (int pos = int(k); pos < int(k + len); pos++) {
int l = a[pos];
int r = mul(a[pos + len], w[st][pos - k]);
a[pos] = norm(l + r);
a[pos + len] = norm(l - r);
}
}
}
if (inverse) {
int in = inv(n);
for (int i = int(0); i < int(n); i++) a[i] = mul(a[i], in);
reverse(a + 1, a + n);
}
}
int aa[MX], bb[MX], cc[MX];
vector<int> multiply(const vector<int> &a, const vector<int> &b) {
int ln = 1;
while (ln < (int((a).size()) + int((b).size()))) ln <<= 1;
for (int i = int(0); i < int(ln); i++)
aa[i] = (i < int((a).size()) ? a[i] : 0);
for (int i = int(0); i < int(ln); i++)
bb[i] = (i < int((b).size()) ? b[i] : 0);
fft(aa, ln, false);
fft(bb, ln, false);
for (int i = int(0); i < int(ln); i++) cc[i] = mul(aa[i], bb[i]);
fft(cc, ln, true);
vector<int> ans(cc, cc + ln);
while (ans.back() == 0) ans.pop_back();
return ans;
}
struct cmp {
bool operator()(const vector<int> &a, const vector<int> &b) {
return int((a).size()) < int((b).size());
}
};
int main() {
int n;
cin >> n;
map<int, int> cnt;
for (long long i = (1); i <= (n); i++) {
int x;
cin >> x;
cnt[x]++;
}
multiset<vector<int>, cmp> polys;
for (auto p : cnt) polys.emplace(p.second + 1, 1);
while (int((polys).size()) > 1) {
auto it2 = polys.begin();
auto it1 = it2++;
polys.insert(multiply(*it1, *it2));
polys.erase(it1);
polys.erase(it2);
}
auto poly = *polys.begin();
cout << poly[n / 2] << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 1e6 + 5;
vector<int> a[Nmax];
vector<int> s[Nmax];
vector<int> p[Nmax];
vector<bool> flag[Nmax];
int n, m;
int sum(int x, int y, int u, int v) {
return s[u][v] + s[x - 1][y - 1] - s[u][y - 1] - s[x - 1][v];
}
void add(int x, int y, int u, int v) {
p[x][y]++;
p[u + 1][v + 1]++;
p[u + 1][y]--;
p[x][v + 1]--;
}
bool solve(int d) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
p[i][j] = 0;
}
for (int i = d + 1; i <= n - d; i++)
for (int j = d + 1; j <= m - d; j++) {
if (sum(i - d, j - d, i + d, j + d)) continue;
add(i - d, j - d, i + d, j + d);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
p[i][j] += p[i - 1][j] + p[i][j - 1] - p[i - 1][j - 1];
if (!a[i][j] && !p[i][j]) {
return false;
}
}
return true;
}
void trace(int d) {
for (int i = d + 1; i <= n - d; i++)
for (int j = d + 1; j <= m - d; j++) {
if (sum(i - d, j - d, i + d, j + d)) continue;
flag[i][j] = true;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << (flag[i][j] ? 'X' : '.');
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i <= n + 1; i++) {
a[i].resize(m + 2);
s[i].resize(m + 2);
p[i].resize(m + 2);
flag[i].resize(m + 2);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
a[i][j] = (c != 'X');
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
s[i][j] = a[i][j] + s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];
}
int l = 0;
int r = n;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (solve(mid))
l = mid;
else
r = mid;
}
cout << l << "\n";
trace(l);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T& num) {
char CH;
bool F = false;
for (CH = getchar(); CH < '0' || CH > '9'; F = CH == '-', CH = getchar())
;
for (num = 0; CH >= '0' && CH <= '9';
num = num * 10 + CH - '0', CH = getchar())
;
F && (num = -num);
}
int stk[70], tp;
template <class T>
inline void print(T p) {
if (!p) {
puts("0");
return;
}
while (p) stk[++tp] = p % 10, p /= 10;
while (tp) putchar(stk[tp--] + '0');
putchar('\n');
}
const long long mod = 1e9 + 7;
const double PI = acos(-1.0);
const long long inf = 1e18;
const int N = 2e5 + 10;
const int maxn = 1005;
const double eps = 1e-10;
int n, m, ind[N];
vector<int> ve[N];
queue<int> qu;
int main() {
int u, v;
read(n);
for (int i = 1; i <= n - 1; i++) {
read(u);
read(v);
ind[u]++;
ind[v]++;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans = ans + ind[i] * (ind[i] - 1) / 2;
}
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int k = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 1) {
if (i - 2 >= 0) {
if (a[i - 2] == 1 && a[i - 1] == 0) {
a[i] = 0;
k++;
}
}
}
}
cout << k;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MD = 1000000007;
const int INF = 1e9 + 9;
const int N = 1e3 + 33;
long long n, m, k;
vector<int> g[N];
int my[N], opp[N];
int mark[N];
int main() {
ios_base::sync_with_stdio(false);
cout.tie(nullptr);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) {
g[i].clear();
mark[i] = 0;
my[i] = 0;
opp[i] = 0;
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
g[a - 1].push_back(b - 1);
g[b - 1].push_back(a - 1);
}
cin >> k;
while (k--) {
int a;
cin >> a;
my[a - 1] = 1;
}
cin >> k;
int qq;
while (k--) {
int a;
cin >> a;
qq = a;
opp[a - 1] = 1;
}
cout << "B " << qq << endl;
int x;
cin >> x;
if (my[x - 1] == 1) {
cout << "C " << x << endl;
continue;
}
queue<int> bfsq;
bfsq.push(x - 1);
while (!bfsq.empty()) {
int v = bfsq.front();
mark[v] = 1;
bfsq.pop();
for (int u : g[v]) {
if (my[u] == 1) {
cout << "A " << u + 1 << endl;
int y;
cin >> y;
if (opp[y - 1] == 1) {
cout << "C " << u + 1 << endl;
break;
} else {
cout << "C " << -1 << endl;
break;
}
}
if (mark[u] == 0) bfsq.push(u);
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int Gcd(int a, int b) {
if (!b)
return a;
else
return Gcd(b, a % b);
}
int Cmp(const void *a, const void *b) { return (*(int *)a) - (*(int *)b); }
int main() {
int a, b, n, i, j;
bool escape = false;
scanf("%d %d %d", &a, &b, &n);
for (i = 0; i < 10; i++) {
if (!((a * 10 + i) % b)) {
escape = true;
printf("%d%d", a, i);
for (j = 1; j < n; j++) {
printf("0");
}
break;
}
}
if (!escape) {
printf("-1");
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char XML[1024];
int n, len;
void parse(int h) {
if (n >= len) return;
int idx = n;
for (__typeof(len) i = (n); i <= (len); i += 1) {
if (XML[i] == '<') {
idx = i;
break;
}
}
if (XML[idx + 1] == '/') {
n += 4;
for (__typeof(2 * (h - 1) - 1) i = (0); i <= (2 * (h - 1) - 1); i += 1)
cout << " ";
printf("</%c>\n", XML[idx + 2]);
parse(h - 1);
} else {
for (__typeof(2 * h - 1) i = (0); i <= (2 * h - 1); i += 1) cout << " ";
printf("<%c>\n", XML[idx + 1]);
n += 3;
parse(h + 1);
}
}
int main() {
scanf("%s", XML);
while (XML[len] != 0) len++;
parse(0);
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.