solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a); i < (b); ++i)
#define sz(x) (int)(x).size()
#define all(x) begin(x), end(x)
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
void solve() {
int n, m;
cin >> n >> m;
vector<string> s(n);
vector<array<int, 26>> freq(m);
for (auto& arr : freq)
fill(all(arr), 0);
for (auto& x : s) {
cin >> x;
for (int j = 0; j < m; ++j) {
++freq[j][x[j] - 'a'];
}
}
for (int i = 0; i < n - 1; ++i) {
string x;
cin >> x;
for (int j = 0; j < m; ++j) {
--freq[j][x[j] - 'a'];
}
}
string res(m, 'a');
for (int i = 0; i < m; ++i) {
for (int j = 0; j < 26; ++j) {
if (freq[i][j]) {
assert(freq[i][j] == 1);
res[i] = 'a' + j;
}
}
}
cout << res << endl;
}
int main() {
int T;
cin >> T;
while (T-- > 0) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, m, t, i, j, res = 9;
cin >> n;
string s, s2 = "";
cin >> s;
for (i = n - 2; i >= 0; i -= 2) {
s2 += s[i];
}
for (i = (n + 1) % 2; i < n; i += 2) {
s2 += s[i];
}
cout << s2 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[2001];
int main() {
int d, n;
cin >> d >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int cnt = 0;
for (int i = 0; i < n - 1; i++) {
cnt += d - a[i];
}
cout << cnt;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int a, b, c, d;
cin >> a >> b >> c >> d;
int ans = 0;
b = b / d + (b % d > 0);
while (b > 0 && c >= a - 1) {
b -= a;
ans++;
c -= (a - 1);
}
if (b > 0) {
b -= (c + 1);
ans++;
c = 0;
}
if (b > 0) ans += b;
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100000];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
if (n == 1) {
printf("YES\n");
return 0;
}
int start = 0, width = 0;
for (int i = 1; i < n; i++) {
if (a[i] == a[start]) continue;
int w = i - start;
if (width == 0)
width = w;
else if (width != w) {
printf("NO\n");
return 0;
}
start = i;
}
if (width == 0)
printf("YES\n");
else if (n - start != width)
printf("NO\n");
else
printf("YES\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500;
int A[maxn + 1], B[maxn + 1], n, m;
bool ok = 1;
vector<pair<int, int>> ans;
void solve(int l, int r, int x) {
int Max = 0, j, d;
for (int i = l; i <= r; i++)
if (Max < A[i]) {
Max = A[i];
d = 1;
j = i;
} else if (Max == A[i])
d++;
if (d == r - l + 1 && d > 1) {
ok = 0;
return;
}
for (int i = l; i <= r; i++)
if (A[i] == Max) {
if (i - 1 >= l && A[i - 1] != Max) {
int j = i;
while (j != l) {
ans.push_back(make_pair(j - l + x, -1));
j--;
}
while (i != r) {
ans.push_back(make_pair(j - l + x, 1));
i++;
}
return;
}
if (i + 1 <= r && A[i + 1] != Max) {
int j = i;
while (j != r) {
ans.push_back(make_pair(i - l + x, 1));
j++;
}
while (i != l) {
ans.push_back(make_pair(i - l + x, -1));
i--;
}
return;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) cin >> A[i];
cin >> m;
for (int i = 1; i <= m; i++) cin >> B[i];
int i = 0;
for (int j = 1; j <= m; j++) {
int l = i + 1;
i++;
int s = A[i];
while (i <= n && s < B[j]) {
i++;
s += A[i];
}
if (s != B[j]) {
cout << "NO";
return 0;
}
solve(l, i, j);
if (!ok) {
cout << "NO";
return 0;
}
}
if (i < n) {
cout << "NO";
return 0;
}
cout << "YES\n";
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " ";
if (ans[i].second == -1)
cout << "L\n";
else
cout << "R\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 300 + 10;
int a[MaxN];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
int p = a[0];
int q = a[1];
for (int i = 0; i < min(p, q); ++i) {
cout << "PRPL";
--a[0];
--a[1];
}
if (a[0] > a[1]) {
for (int i = 0; i < a[0] - a[1]; ++i) cout << "PRL";
cout << "R";
} else {
for (int i = 0; i < a[1] - a[0]; ++i) cout << "RPL";
cout << "R";
}
for (int i = 2; i < n; ++i) {
cout << "R";
for (int j = 0; j < a[i]; ++j) cout << "PLR";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n, m, xc, yc, k;
cin >> n >> m >> xc >> yc >> k;
long long ans = 0;
while (k--) {
long long dx, dy;
cin >> dx >> dy;
long long k, l;
k = LLONG_MAX;
l = LLONG_MAX;
if (dx < 0) k = (1 - xc) / dx;
if (dy < 0) l = (1 - yc) / dy;
if (dx > 0) k = (n - xc) / dx;
if (dy > 0) l = (m - yc) / dy;
long long r = min(k, l);
ans += r;
xc += r * dx;
yc += r * dy;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long arr[301010];
long long dp[11][303030];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
long long k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 2; j <= min(i, m); j++) {
dp[j][i] = arr[i] + dp[j - 1][i - 1];
}
dp[1][i] = max(0LL, dp[m][i - 1]) + arr[i] - k;
for (int j = 1; j <= m; j++) {
ans = max(ans, dp[j][i]);
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isPerfectSquare(int x) {
double y = x;
return sqrt(y) == (int)sqrt(y);
}
bool canFit(int h, int w, int x, int y) {
if ((h == x && w == y) || (h == y && w == x)) {
return true;
}
return false;
}
int main() {
int x[3], y[3], totalArea = 0, maxLength = -1, h, used;
char letter[3] = {'A', 'B', 'C'};
for (int i = 0; i < 3; i++) {
cin >> x[i] >> y[i];
totalArea += x[i] * y[i];
if (x[i] > maxLength) maxLength = x[i];
if (y[i] > maxLength) maxLength = y[i];
}
if (!isPerfectSquare(totalArea)) {
cout << -1 << endl;
return 0;
}
char ans[maxLength][maxLength];
for (int i = 0; i < maxLength; i++) {
for (int j = 0; j < maxLength; j++) {
ans[i][j] = ' ';
}
}
for (int i = 0; i < 3; i++) {
if (x[i] == maxLength) {
for (int j = 0; j < y[i]; j++) {
for (int k = 0; k < maxLength; k++) {
ans[j][k] = letter[i];
}
}
h = maxLength - y[i];
used = i + 1;
break;
} else if (y[i] == maxLength) {
for (int j = 0; j < x[i]; j++) {
for (int k = 0; k < maxLength; k++) {
ans[j][k] = letter[i];
}
}
h = maxLength - x[i];
used = i + 1;
break;
}
}
bool ok = false;
for (int xLen = 1; xLen < maxLength; xLen++) {
if (used == 1 && canFit(h, xLen, x[1], y[1]) &&
canFit(h, maxLength - xLen, x[2], y[2])) {
ok = true;
for (int i = maxLength - h; i < maxLength; i++) {
for (int j = 0; j < xLen; j++) {
ans[i][j] = letter[1];
}
for (int j = xLen; j < maxLength; j++) {
ans[i][j] = letter[2];
}
}
} else if (used == 2 && canFit(h, xLen, x[0], y[0]) &&
canFit(h, maxLength - xLen, x[2], y[2])) {
ok = true;
for (int i = maxLength - h; i < maxLength; i++) {
for (int j = 0; j < xLen; j++) {
ans[i][j] = letter[0];
}
for (int j = xLen; j < maxLength; j++) {
ans[i][j] = letter[2];
}
}
} else if (used == 3 && canFit(h, xLen, x[0], y[0]) &&
canFit(h, maxLength - xLen, x[1], y[1])) {
ok = true;
for (int i = maxLength - h; i < maxLength; i++) {
for (int j = 0; j < xLen; j++) {
ans[i][j] = letter[0];
}
for (int j = xLen; j < maxLength; j++) {
ans[i][j] = letter[1];
}
}
}
}
for (int yLen = 1; yLen < maxLength; yLen++) {
if (used == 1 && canFit(yLen, maxLength, x[1], y[1]) &&
canFit(h - yLen, maxLength, x[2], y[2])) {
ok = true;
for (int j = 0; j < maxLength; j++) {
for (int i = maxLength - h; i < maxLength - h + yLen; i++) {
ans[i][j] = letter[1];
}
for (int i = maxLength - h + yLen; i < maxLength; i++) {
ans[i][j] = letter[2];
}
}
} else if (used == 2 && canFit(yLen, maxLength, x[0], y[0]) &&
canFit(h - yLen, maxLength, x[2], y[2])) {
ok = true;
for (int j = 0; j < maxLength; j++) {
for (int i = maxLength - h; i < maxLength - h + yLen; i++) {
ans[i][j] = letter[0];
}
for (int i = maxLength - h + yLen; i < maxLength; i++) {
ans[i][j] = letter[2];
}
}
} else if (used == 3 && canFit(yLen, maxLength, x[0], y[0]) &&
canFit(h - yLen, maxLength, x[1], y[1])) {
ok = true;
for (int j = 0; j < maxLength; j++) {
for (int i = maxLength - h; i < maxLength - h + yLen; i++) {
ans[i][j] = letter[0];
}
for (int i = maxLength - h + yLen; i < maxLength; i++) {
ans[i][j] = letter[1];
}
}
}
}
if (!ok) {
cout << -1 << endl;
return 0;
}
cout << maxLength << endl;
for (int i = 0; i < maxLength; i++) {
for (int j = 0; j < maxLength; j++) {
cout << ans[i][j];
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long n, d, idx, s;
friend bool operator<(node a, node b) {
if (a.s != b.s) return a.s < b.s;
return a.n * b.d < b.n * a.d;
}
};
long long k[100005] = {0}, b[100005] = {0};
vector<node> V;
int main() {
int n, i;
long long K = 0, B = 0, pK, pB;
node a;
cin >> n;
int ans1 = 0;
for (i = 0; i < n; i++) {
cin >> k[i] >> b[i];
if (k[i] == 0) continue;
ans1 = 1;
a.n = abs(b[i]);
a.idx = i;
a.d = abs(k[i]);
if (-b[i] * k[i] <= 0)
a.s = 0;
else
a.s = 1;
V.push_back(a);
if (k[i] < 0) K += k[i], B += b[i];
}
sort(V.begin(), V.end());
a.n = 0;
a.d = 1;
a.s = 1;
V.push_back(a);
pK = K;
pB = B;
int ans = 0;
for (i = 0; i < V.size() - 1; i++) {
if (k[V[i].idx] > 0)
K += k[V[i].idx], B += b[V[i].idx];
else
K -= k[V[i].idx], B -= b[V[i].idx];
if (V[i] < V[i + 1] == V[i + 1] < V[i]) continue;
if (pK != K || pB != B) {
ans++;
pK = K;
pB = B;
}
}
cout << max(ans1, ans) << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int64_t mod = 1000000007;
int64_t power(int x, int p) {
if (p == 0) return 1;
return (x * power(x, p - 1)) % mod;
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
int K = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == '?') K++;
}
int64_t dp[n + 1][4][4];
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= 3; ++j) {
for (int k = 0; k <= 3; ++k) {
dp[i][j][k] = 0;
}
}
}
dp[0][0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= 3; ++j) {
for (int k = 0; k <= j; ++k) {
dp[i][j][k] += dp[i - 1][j][k];
dp[i][j][k] = dp[i][j][k] % mod;
if (s[i - 1] - 'a' + 1 == j) {
dp[i][j][k] += dp[i - 1][j - 1][k];
} else if (s[i - 1] == '?' && k > 0) {
dp[i][j][k] += dp[i - 1][j - 1][k - 1];
}
dp[i][j][k] = dp[i][j][k] % mod;
}
}
}
int64_t ans = 0;
for (int k = 0; k <= 3 && k <= K; ++k) {
ans += (((dp[n][3][k]) % mod) * (power(3, K - k))) % mod;
ans = ans % mod;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string whatSay(int n) {}
int main() {
int n;
cin >> n;
string str = "";
for (int i = 1; i <= n; i++) {
if (i % 2 == 0) {
str += "I love ";
} else {
str += "I hate ";
}
if (i == n) {
str += "it";
} else {
str += "that ";
}
}
cout << str;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1, inf = 1e9;
int t[N], t2[N], sz, szz, i, n, a[N], j, l, r, mx;
void build(int v, int tl, int tr) {
if (tl == tr)
t[v] = a[tl];
else {
int tm = (tl + tr) >> 1;
int one = v << 1;
int two = one + 1;
build(one, tl, tm);
build(two, tm + 1, tr);
t[v] = max(t[one], t[two]);
}
}
void build2(int v, int tl, int tr) {
if (tl == tr)
t2[v] = a[tl];
else {
int tm = (tl + tr) >> 1;
int one = v << 1;
int two = one + 1;
build2(one, tl, tm);
build2(two, tm + 1, tr);
if (two <= szz && t2[two] < t2[one])
t2[v] = t2[two];
else
t2[v] = t2[one];
}
}
int get1(int v, int tl, int tr, int l, int r) {
if (tl > r || tr < l) return 0;
if (tl >= l && tr <= r) return t[v];
int tm = (tl + tr) >> 1;
int one = v << 1;
int two = one + 1;
return max(get1(one, tl, tm, l, r), get1(two, tm + 1, tr, l, r));
}
int get2(int v, int tl, int tr, int l, int r) {
if (tl > r || tr < l) return inf;
if (tl >= l && tr <= r) return t2[v];
int tm = (tl + tr) >> 1;
int one = v << 1;
int two = one + 1;
return min(get2(one, tl, tm, l, r), get2(two, tm + 1, tr, l, r));
}
inline char first(int x) {
int L = i, R = i + x;
return (get1(1, 1, sz, L, R) - get2(1, 1, sz, L, R) <= 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n;
for (i = 1; i <= n; ++i) cin >> a[i];
sz = 1;
while (sz < n) sz += sz;
szz = sz + n - 1;
build(1, 1, sz);
for (i = 1; i <= szz; ++i) t2[i] = inf;
build2(1, 1, sz);
for (i = 1; i <= n; ++i) {
int l = 0;
int r = n - i;
while (l + 1 < r) {
int m = (l + r) >> 1;
if (first(m))
l = m;
else
r = m;
}
if (first(r))
mx = max(mx, r);
else if (first(l))
mx = max(mx, l);
}
cout << mx + 1 << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j;
string s;
cin >> n >> s;
vector<string> str(6);
for (i = 0; i < n / 3; i++) {
str[0] += "RGB";
str[1] += "RBG";
str[2] += "BGR";
str[3] += "BRG";
str[4] += "GRB";
str[5] += "GBR";
}
if (n % 3 == 1) {
str[0] += "R";
str[1] += "R";
str[2] += "B";
str[3] += "B";
str[4] += "G";
str[5] += "G";
}
if (n % 3 == 2) {
str[0] += "RG";
str[1] += "RB";
str[2] += "BG";
str[3] += "BR";
str[4] += "GR";
str[5] += "GB";
}
long long m = 0, a = 200005, mi;
for (i = 0; i < 6; i++) {
m = 0;
for (j = 0; j < s.size(); j++) {
if (s[j] != str[i][j]) m++;
}
if (m < a) {
a = m;
mi = i;
}
}
cout << a << "\n";
cout << str[mi];
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a = 0, d = 0;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'A')
a++;
else
d++;
}
if (a == d)
cout << "Friendship" << endl;
else if (a > d)
cout << "Anton" << endl;
else
cout << "Danik" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r1 = 0, r2 = 0;
cin >> n;
string str;
cin >> str;
for (int i = 0, wl = 0, ib = 0; i < n; i++) {
if ((str[i] >= 'a' && str[i] <= 'z') || (str[i] >= 'A' && str[i] <= 'Z')) {
wl++;
if (!ib) {
r1 = max(r1, wl);
}
} else {
if (ib && wl) {
r2++;
}
if (str[i] == '(')
ib++;
else if (str[i] == ')')
ib--;
wl = 0;
}
}
cout << r1 << " " << r2;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
long n, i, k = 0, u = 0, d = 0, l = 0, r = 0;
cin >> n;
cin >> s;
for (i = 0; i < s.size(); i++) {
if (s[i] == 'U') u++;
if (s[i] == 'D') d++;
if (s[i] == 'L') l++;
if (s[i] == 'R') r++;
}
k += min(d, u) * 2;
k += min(r, l) * 2;
cout << k;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int tr[1 << 22], lazy[1 << 22];
void propagate(int i, int l, int r) {
if (lazy[i] == -1) return;
tr[i] = lazy[i];
if (l != r) lazy[i << 1] = lazy[i << 1 | 1] = lazy[i];
lazy[i] = -1;
}
void update(int i, int l, int r, int a, int b, int v) {
propagate(i, l, r);
if (l > b || r < a) return;
if (l >= a && r <= b) {
lazy[i] = v;
propagate(i, l, r);
return;
}
int mid = (l + r) >> 1;
update(i << 1, l, mid, a, b, v);
update(i << 1 | 1, mid + 1, r, a, b, v);
}
int get(int i, int l, int r, int a, int b) {
propagate(i, l, r);
if (l > b || r < a) return -1;
if (l >= a && r <= b) return tr[i];
int mid = (l + r) >> 1;
return max(get(i << 1, l, mid, a, b), get(i << 1 | 1, mid + 1, r, a, b));
}
int main() {
cin.sync_with_stdio(false);
int n, q;
cin >> n >> q;
vector<int> a(n);
vector<int> mn(q + 1, 2 * n), mx(q + 1, -1);
for (int i = 0; i < n; i++) {
cin >> a[i];
mn[a[i]] = min(mn[a[i]], i);
mx[a[i]] = max(mx[a[i]], i);
}
for (int i = 0; i < (1 << 22); i++) lazy[i] = -1, tr[i] = 1;
for (int i = 2; i <= q; i++) update(1, 0, n - 1, mn[i], mx[i], i);
vector<int> res(n);
bool ok = 1;
int zer = -1;
for (int i = 0; i < n; i++) {
res[i] = get(1, 0, n - 1, i, i);
if (!a[i]) zer = i;
if (a[i] && a[i] != res[i]) {
ok = 0;
break;
}
}
if (mx[q] == -1) {
if (zer == -1)
ok = 0;
else
res[zer] = q;
}
if (!ok)
cout << "NO\n";
else {
cout << "YES\n";
for (int i = 0; i < n; i++) cout << res[i] << ' ';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> v;
vector<vector<pair<int, int>>> g;
vector<int> used;
int N, M;
void dfs(int i, int j, int I, int m) {
if (i == j) v[I][j]++;
used[i] = 1;
for (auto u : g[i]) {
if (!used[u.second] && m == u.first) dfs(u.second, j, I, m);
}
}
int main() {
cin >> N >> M;
g.resize(N + 1);
used.resize(N + 1);
v.resize(N + 1, vector<int>(N + 1));
for (int i = 0; i < M; i++) {
int a, b, c;
cin >> a >> b >> c;
g[a].push_back({c, b});
g[b].push_back({c, a});
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (i == j) continue;
for (int f = 1; f <= M; f++) {
used.assign(N + 1, 0);
dfs(i, j, i, f);
}
}
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
cout << v[a][b] << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
int p[100100];
vector<int> inc[100100];
vector<int> vdu[100100];
bool proib[100100];
int dd[100100], du[100100];
int mk[100100];
int passo = 1;
void dfs(int no, int pai) {
p[no] = pai;
for (int i = 0; i < inc[no].size(); ++i) {
if (inc[no][i] == pai) continue;
dfs(inc[no][i], no);
}
}
int dfs2(int no) {
if (mk[no] == passo) return dd[no];
dd[no] = -oo;
mk[no] = passo;
if (proib[no]) dd[no] = 0;
for (int i = 0; i < inc[no].size(); ++i) {
if (inc[no][i] == p[no]) continue;
dd[no] = max(dd[no], dfs2(inc[no][i]) + 1);
}
if (dd[no] < -oo / 2) dd[no] = -oo;
return dd[no];
}
int dfs3(int no) {
if (mk[no] == passo) return du[no];
du[no] = -oo;
mk[no] = passo;
if (no != p[no]) {
if (proib[p[no]]) du[no] = 1;
if (vdu[p[no]].size() > 1) {
if (dd[no] == vdu[p[no]][vdu[p[no]].size() - 1])
du[no] = max(du[no], vdu[p[no]][vdu[p[no]].size() - 2] + 2);
else
du[no] = max(du[no], vdu[p[no]][vdu[p[no]].size() - 1] + 2);
}
du[no] = max(du[no], dfs3(p[no]) + 1);
}
if (du[no] < -oo / 2) du[no] = -oo;
return du[no];
}
int n, m, d;
int main() {
scanf("%d %d %d", &n, &m, &d);
int aux;
for (int i = 0; i < m; ++i) scanf("%d", &aux), proib[aux - 1] = true;
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d %d", &a, &b);
a--, b--;
inc[a].push_back(b), inc[b].push_back(a);
}
dfs(0, 0);
memset(dd, -1, sizeof dd);
memset(du, -1, sizeof du);
passo++;
dfs2(0);
passo++;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < inc[i].size(); ++j)
if (inc[i][j] != p[i]) vdu[i].push_back(dd[inc[i][j]]);
sort(vdu[i].begin(), vdu[i].end());
}
for (int i = 0; i < n; ++i) dfs3(i);
int rsp = 0;
for (int i = 0; i < n; ++i) {
if (dd[i] <= d && du[i] <= d) rsp++;
}
printf("%d\n", rsp);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 2e18;
long long int n, m;
vector<long long int> A;
long long int shift(long long int x, long long int y) {
if (y > x) {
return y - x;
} else if (y < x) {
return y + (m - x);
} else {
return 0;
}
}
bool ispossible(long long int val) {
long long int mn = 0;
for (auto x : A) {
if (x > mn) {
if (shift(x, mn) > val) mn = x;
} else if (x < mn) {
if (shift(x, mn) > val) return false;
} else {
continue;
}
}
return true;
}
long long int binary() {
long long int l = 0;
long long int h = m - 1;
long long int ans = m - 1;
while (l <= h) {
long long int mid = l + (h - l) / 2;
if (ispossible(mid)) {
ans = mid;
h = mid - 1;
} else {
l = mid + 1;
}
}
return ans;
}
int main() {
cin >> n >> m;
A.resize(n, 0);
for (long long int i = 0; i < n; i++) cin >> A[i];
cout << binary() << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, vector<int>> m;
vector<bool> c;
bool bb = true;
int a[500000];
vector<int> p, q;
void find(int i, int j) {
if (c[i - 1] && a[i - 1] != j % 2) {
bb = false;
return;
} else if (c[i - 1])
return;
c[i - 1] = true;
a[i - 1] = j % 2;
if (j % 2 == 0)
p.push_back(i);
else
q.push_back(i);
int k;
for (k = 0; k < m[i].size(); k++) {
find(m[i][k], j + 1);
}
}
int main() {
int n;
int k;
cin >> n >> k;
int f, s;
int i, j;
for (i = 0; i < k; i++) {
cin >> f >> s;
m[s].push_back(f);
m[f].push_back(s);
}
for (i = 0; i < n; i++) c.push_back(false);
for (i = 0; i < n; i++) a[i] = -1;
for (i = 1; i < n; i++) {
if (!c[i - 1]) find(i, 0);
if (!bb) {
cout << -1;
return 0;
}
}
cout << p.size() << "\n";
for (i = 0; i < p.size(); i++) cout << p[i] << " ";
cout << "\n";
cout << q.size() << "\n";
for (i = 0; i < q.size(); i++) cout << q[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long int> arr(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> arr[i];
arr[i] += arr[i - 1];
}
int cases;
cin >> cases;
while (cases--) {
long long int a, b;
cin >> a >> b;
cout << (arr[b] - arr[a - 1]) / 10 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int mod = 998244353;
int a[maxn], pos[maxn], b[maxn], ok[maxn];
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
ok[i] = 1;
}
for (int i = 1; i <= k; i++) {
cin >> b[i];
ok[pos[b[i]]] = 0;
}
long long ans = 1;
for (int i = 1; i <= k; i++) {
int f = 0;
if (pos[b[i]] > 1 && ok[pos[b[i]] - 1]) f++;
if (pos[b[i]] < n && ok[pos[b[i]] + 1]) f++;
ans *= f;
ans %= mod;
ok[pos[b[i]]] = 1;
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<int> a[1 << 15];
bool u[256];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n * (n - 1) / 2; i++) {
int k;
scanf("%d", &k);
for (int j = 0, x; j < k; j++) {
scanf("%d", &x);
a[i].insert(x);
}
}
if (n == 2) {
printf("1 %d\n", *a[0].begin());
printf("%d", a[0].size() - 1);
for (set<int>::iterator p = a[0].begin(); p != a[0].end(); p++)
if (p != a[0].begin()) printf(" %d", *p);
printf("\n");
return 0;
}
for (int i = 0, j, k, t; i < n - 2; i++) {
for (j = 0; !a[j].size(); j++)
;
set<int>::iterator p, q;
for (p = a[j].begin(); u[*p]; p++)
;
for (k = j + 1;; k++)
if (a[k].count(*p)) break;
set<int> cur;
for (q = a[j].begin(); q != a[j].end(); q++)
if (a[k].count(*q)) cur.insert(*q);
cout << cur.size();
for (q = cur.begin(); q != cur.end(); q++) {
cout << " " << *q;
u[*q] = true;
}
cout << endl;
if (i == n - 3) {
set<int> tmp;
for (q = a[j].begin(); q != a[j].end(); q++)
if (!cur.count(*q)) tmp.insert(*q);
cout << tmp.size();
for (q = tmp.begin(); q != tmp.end(); q++) cout << " " << *q;
cout << endl;
tmp.clear();
for (q = a[k].begin(); q != a[k].end(); q++)
if (!cur.count(*q)) tmp.insert(*q);
cout << tmp.size();
for (q = tmp.begin(); q != tmp.end(); q++) cout << " " << *q;
cout << endl;
}
for (; k < n * (n - 1) / 2; k++)
if (a[k].count(*p)) a[k].clear();
a[j].clear();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n;
int a[1500 + 1];
int Q;
bool ans;
void read() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
}
void chief() {
ans = 0;
for (int i = 2; i <= n; ++i)
for (int j = 1; j < i; ++j)
if (a[j] > a[i]) ans ^= 1;
scanf("%d", &Q);
for (int q = 1; q <= Q; ++q) {
int l, r;
scanf("%d%d", &l, &r);
r = r - l + 1;
l = (r * (r - 1)) >> 1;
ans ^= (l & 1);
puts(ans ? "odd" : "even");
}
}
int main() {
read();
chief();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long fast_exp(long long a, long long b) {
if (b <= 0)
return 1;
else {
long long res = 1;
res = fast_exp(a, b / 2);
res = (res * res) % mod;
if (b % 2 == 1) res = (res * a) % mod;
return res;
}
}
long long n, m, k;
long long dp[5001][5010] = {};
long long inv;
int main() {
cin >> n >> m >> k;
dp[0][0] = 1;
for (long long i = 0; i < k; i++) {
for (long long j = 0; j < 5001; j++) {
dp[i + 1][j] = (dp[i + 1][j] + (j)*dp[i][j]) % mod;
dp[i + 1][j + 1] = (dp[i + 1][j + 1] + (n - j) * dp[i][j]) % mod;
}
}
inv = fast_exp(m, mod - 2);
long long num = 0;
long long beg = fast_exp(m, n);
for (long long i = 0; i <= 5001; i++) {
num = (num + beg * dp[k][i]) % mod;
beg = (beg * inv) % mod;
}
long long denom = fast_exp(m, n);
denom = fast_exp(denom, mod - 2);
cout << (num * denom) % mod << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
vector<vector<long long> > mulmat(vector<vector<long long> > &mat1,
vector<vector<long long> > &mat2) {
vector<vector<long long> > ans(mat1.size(),
vector<long long>(mat2[0].size(), 0));
for (int i = 0; i < mat1.size(); i++) {
for (int j = 0; j < mat2[0].size(); j++) {
for (int k = 0; k < mat2.size(); k++) {
ans[i][j] = (ans[i][j] + mat1[i][k] * mat2[k][j]) % mod;
}
}
}
return ans;
}
vector<vector<long long> > matrixpow(vector<vector<long long> > &mat,
long long pow) {
int n = mat.size();
vector<vector<long long> > bas(mat.size(), vector<long long>(mat.size(), 0));
vector<vector<long long> > mul(mat);
for (int i = 0; i < mat.size(); i++) {
bas[i][i] = 1;
}
while (pow) {
if (pow & 1) bas = mulmat(bas, mul);
pow >>= 1;
mul = mulmat(mul, mul);
}
return bas;
}
long long fastpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
b >>= 1;
a = (a * a) % mod;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k, zc = 0;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 0) zc++;
}
vector<vector<long long> > vals(zc + 1, vector<long long>(zc + 1, 0));
for (int i = 0; i <= zc; i++) {
long long zer = i;
long long on = zc - zer;
long long zero = zc - i;
long long ono = n - zc - zero;
if (on < 0 || zero < 0 || ono < 0) continue;
if (i) vals[zer][zer - 1] = ono * zer;
vals[zer][zer] = n * (n - 1) / 2 - ono * zer - zero * on;
if (i != zc) vals[zer][zer + 1] = zero * on;
}
vector<vector<long long> > fmat = matrixpow(vals, k);
vector<vector<long long> > start(1, vector<long long>(zc + 1, 0));
int zco = 0;
for (int i = 0; i < zc; i++)
if (a[i] == 0) zco++;
start[0][zco] = 1;
vector<vector<long long> > finb = mulmat(start, fmat);
long long num = finb[0][zc];
long long den = 0;
for (int i = 0; i <= zc; i++) den = (den + finb[0][i]) % mod;
den = fastpow(den, mod - 2);
cout << (num * den) % mod << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int b[n];
for (int i = 0; i < n; i++) {
cin >> b[i];
}
sort(b, b + n);
for (int i = 0; i < n; i++) {
cout << b[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool prime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}
void solve() {
long long n;
cin >> n;
if (n % 2 == 0) {
if (n == 2)
cout << 1;
else
cout << 2;
} else {
if (prime(n))
cout << 1;
else if (prime(n - 2))
cout << 2;
else
cout << 3;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
int ara[100010];
int main() {
int n, i, x;
while (cin >> n) {
bool ch = true;
vec.clear();
memset(ara, 0, sizeof(ara));
for (i = 0; i < n; i++) {
cin >> x;
vec.push_back(x);
}
for (i = 0; i < n; i++) {
ara[vec[i]]++;
if (vec[i] == 50) {
if (ara[25] > 0)
ara[25]--;
else {
ch = false;
break;
}
} else if (vec[i] == 100) {
if (ara[25] > 0 && ara[50] > 0)
ara[25]--, ara[50]--;
else if (ara[25] > 2)
ara[25] -= 3;
else {
ch = false;
break;
}
}
}
if (ch)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, a[N], b[N], x, idx;
vector<int> v[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = (1); i <= (n); ++i) {
cin >> a[i];
v[n - a[i]].push_back(i);
}
for (int i = (1); i <= (n); ++i) {
if (v[i].size() % i != 0) {
cout << "Impossible";
return 0;
}
for (int j = 0; j < (v[i].size()); ++j) {
if (j % i == 0) ++idx;
b[v[i][j]] = idx;
}
}
cout << "Possible\n";
for (int i = (1); i <= (n); ++i) cout << b[i] << ' ';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, k;
cin >> n >> k;
long long int a[n * k];
for (int i = 0; i < n * k; i++) {
cin >> a[i];
}
int st = 0, e = n * k - 1;
sort(a, a + n * k);
long long int res = 0;
for (int i = 0; i < k; i++) {
long long int f = (n - (n - 1) / 2);
res += a[(e - f) + 1];
e -= f;
}
cout << res << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long double r, v, ep, pi, frst, lst, mid, d, tmp, res;
long long c, n;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> r >> v;
ep = powl(10, -8);
pi = 2 * asinl(1);
for (int i = 1; i <= n; i++) {
cin >> frst >> lst;
d = lst - frst;
c = d / (2 * pi * r);
d -= res = c * 2 * pi * r;
res /= v;
frst = 0;
lst = (pi * r) / v;
for (int i = 1; i <= 100; i++) {
if (lst - frst <= ep) break;
mid = (lst + frst) / 2;
tmp = 2 * ((v * mid) + (r * sinl((v * mid) / r)));
if (tmp < d) {
frst = mid;
} else {
lst = mid;
}
}
res += 2 * frst;
cout << fixed << setprecision(15) << res << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dp[252][252][252];
int hlp[100010][27];
int n, q;
string s, s1, s2, s3;
void make(int a, int b, int c) {
if (a) {
if (dp[a - 1][b][c] != 2000000011)
dp[a][b][c] = min(dp[a][b][c], hlp[dp[a - 1][b][c]][s1[a - 1] - 'a']);
}
if (b) {
if (dp[a][b - 1][c] != 2000000011)
dp[a][b][c] = min(dp[a][b][c], hlp[dp[a][b - 1][c]][s2[b - 1] - 'a']);
}
if (c) {
if (dp[a][b][c - 1] != 2000000011)
dp[a][b][c] = min(dp[a][b][c], hlp[dp[a][b][c - 1]][s3[c - 1] - 'a']);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q >> s;
for (int i = 0; i < (27); ++i) hlp[n][i] = 2000000011;
for (int i = n - 1; i >= (0); i--) {
for (int j = 0; j < (27); ++j) hlp[i][j] = hlp[i + 1][j];
hlp[i][(s[i] - 'a')] = i + 1;
}
for (int i = 0; i <= (250); i++) {
for (int j = 0; j <= (250); j++) {
for (int k = 0; k <= (250); k++) dp[i][j][k] = 2000000011;
}
}
dp[0][0][0] = 0;
int l1 = 0, l2 = 0, l3 = 0;
for (int I = 0; I < (q); ++I) {
char c;
int par;
cin >> c >> par;
if (c == '+') {
char t;
cin >> t;
if (par == 1) {
s1 += t;
l1++;
for (int i = 0; i <= (l2); i++) {
for (int j = 0; j <= (l3); j++) make(l1, i, j);
}
} else if (par == 2) {
s2 += t;
l2++;
for (int i = 0; i <= (l1); i++) {
for (int j = 0; j <= (l3); j++) make(i, l2, j);
}
} else {
s3 += t;
l3++;
for (int i = 0; i <= (l1); i++) {
for (int j = 0; j <= (l2); j++) make(i, j, l3);
}
}
} else {
if (par == 1) {
for (int i = 0; i <= (l2); i++) {
for (int j = 0; j <= (l3); j++) dp[l1][i][j] = 2000000011;
}
s1.pop_back();
l1--;
} else if (par == 2) {
for (int i = 0; i <= (l1); i++) {
for (int j = 0; j <= (l3); j++) dp[i][l2][j] = 2000000011;
}
s2.pop_back();
l2--;
} else {
for (int i = 0; i <= (l1); i++) {
for (int j = 0; j <= (l2); j++) dp[i][j][l3] = 2000000011;
}
s3.pop_back();
l3--;
}
}
cout << ((dp[l1][l2][l3] <= n) ? "YES\n" : "NO\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[1000], ans[1000], n;
char s[100009];
int sum = 0;
while (cin >> n) {
sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
int temp = sum, pos = 1;
int flag = 1;
while (temp) {
if (a[pos] > 0) {
sum--;
a[pos]--;
cout << "P";
if (sum == 0) break;
}
if (pos == n) flag = -1;
if (pos == 1) flag = 1;
if (flag == 1)
cout << "R";
else
cout << "L";
pos += flag;
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn];
int go(int now, int k) {
if (now == 0) return 0;
if (now == 1) return 1;
if (k == 1) {
if (now == 2) return 0;
if (now == 3) return 1;
if (now == 4) return 2;
if (now % 2 == 1) return 0;
return go(now / 2, k) == 1 ? 2 : 1;
} else {
if (now == 2) return 2;
if (now & 1) return 0;
return 1;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
int x = 0;
for (int i = 0; i < n; ++i) x ^= go(a[i], k & 1);
cout << (x ? "Kevin" : "Nicky") << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int f[N], a[N], b[N];
int n;
int find(int x) {
if (x != f[x]) f[x] = find(f[x]);
return f[x];
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= n; i++) {
if (i + b[i] <= n) {
int u = find(i), v = find(i + b[i]);
f[u] = v;
}
if (i - b[i] >= 1) {
int u = find(i), v = find(i - b[i]);
f[u] = v;
}
}
int flg = 1;
for (int i = 1; i <= n; i++) {
int u = find(i), v = find(a[i]);
if (u != v) {
flg = 0;
break;
}
}
if (flg)
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MOD2 = 1007681537;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
void XORFFT(int a[], int n, int p, int invert) {
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j += i << 1) {
for (int k = 0; k < i; k++) {
int u = a[j + k], v = a[i + j + k];
a[j + k] = u + v;
if (a[j + k] >= p) a[j + k] -= p;
a[i + j + k] = u - v;
if (a[i + j + k] < 0) a[i + j + k] += p;
}
}
}
if (invert) {
long long inv = fpow(n, p - 2, p);
for (int i = 0; i < n; i++) a[i] = a[i] * inv % p;
}
}
vector<int> pow_convol(vector<int> a, int k, int p) {
int n = a.size();
if (k == 1) {
return a;
} else if (k & 1) {
vector<int> r = pow_convol(a, k - 1, p);
vector<int> res(n, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - i; j++) {
res[i + j] = (res[i + j] + (long long)r[i] * a[j]) % p;
}
}
return res;
} else {
vector<int> r = pow_convol(a, k >> 1, p);
vector<int> res(n, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - i; j++) {
res[i + j] = (res[i + j] + (long long)r[i] * r[j]) % p;
}
}
return res;
}
}
vector<int> subset_pow_convol(vector<int> a, int k, int p) {
static const int logn = 19;
static int fa[logn][1 << logn];
static int fb[logn][1 << logn];
static int fc[logn][1 << logn];
int n = a.size();
while (n != (n & -n)) n += n & -n;
vector<int> res(n, 0);
for (int i = 0; i < logn; i++) {
for (int j = 0; j < n; j++) {
if (__builtin_popcountll(j) == i) {
fa[i][j] = j < int((a).size()) ? a[j] : 0;
} else {
fa[i][j] = 0;
}
fc[i][j] = 0;
}
XORFFT(fa[i], n, p, 0);
}
for (int i = (0); i < (n); i++) {
vector<int> va(logn);
for (int j = (0); j < (logn); j++) {
va[j] = fa[j][i];
}
va = pow_convol(va, k, p);
for (int j = (0); j < (logn); j++) {
fc[j][i] = va[j];
}
}
for (int i = 0; i < logn; i++) {
XORFFT(fc[i], n, p, 1);
for (int j = 0; j < n; j++)
if (__builtin_popcountll(j) == i) {
res[j] = fc[i][j];
}
}
return res;
}
const int maxn = 1e6 + 5;
int n, k, p;
int fac[maxn];
int ifac[maxn];
int dp[2][maxn];
int f[maxn];
void solve() {
cin >> n >> k >> p;
int nn = n;
for (int i = (0); i < (n + 1); i++)
if ((n & i) == i) {
int t = 0;
for (int j = (0); j < (20); j++)
if ((((n) >> (j)) & 1)) {
t <<= 1;
t |= (((i) >> (j)) & 1);
}
f[t] = i;
nn = t;
}
if (n & 1) {
cout << fpow(k, n, p) << "\n";
return;
}
fac[0] = 1;
for (int i = (1); i < (maxn); i++) fac[i] = mult(fac[i - 1], i, p);
for (int i = (0); i < (maxn); i++) ifac[i] = inv(fac[i], p);
vector<int> a(nn + 1, 0);
for (int i = (0); i < (nn + 1); i++) a[i] = ifac[f[i]];
int res = fpow(k, n, p);
a = subset_pow_convol(a, k, p);
submod(res, mult(a[nn], fac[n], p), p);
cout << res << "\n";
}
int main() {
int JUDGE_ONLINE = 1;
if (fopen("in.txt", "r")) {
JUDGE_ONLINE = 0;
assert(freopen("in.txt", "r", stdin));
} else {
ios_base::sync_with_stdio(0), cin.tie(0);
}
solve();
if (!JUDGE_ONLINE) {
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a;
long min = 10000000;
if (n == 1) {
cout << 1 << ' ' << 1;
} else {
for (int i = 1; i <= n / 2; i++) {
if (n % i == 0 && abs((n / i) - i) < min) {
a = i;
min = abs((n / i) - i);
}
}
cout << a << " " << n / a;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> u = {-1, -1, -1, 0, 1, 1, 1, 0};
vector<int> v = {1, 0, -1, -1, -1, 0, 1, 1};
int main(int argc, char const *argv[]) {
int n, ar, ac, br, bc, cr, cc;
int p, qu, r, s, t, w;
cin >> n >> p >> qu >> r >> s >> t >> w;
vector<vector<int>> visited(n, vector<int>(n, 0));
ar = n - qu;
ac = p - 1;
br = n - s;
bc = r - 1;
cr = n - w;
cc = t - 1;
queue<pair<int, int>> q;
q.push(make_pair(br, bc));
visited[br][bc] = 1;
int flag = 0;
while (!q.empty()) {
int p1 = q.front().first, p2 = q.front().second;
q.pop();
for (int k = 0; k < u.size(); k++) {
if (p1 + u[k] >= 0 && p1 + u[k] <= n - 1 && p2 + v[k] >= 0 &&
p2 + v[k] <= n - 1 && !visited[p1 + u[k]][p2 + v[k]]) {
if (((p1 + u[k] - ar) * (p2 + v[k] - ac) != 0) &&
((float)(p2 + v[k] - ac) / (p1 + u[k] - ar) != 1) &&
((float)(p2 + v[k] - ac) / (p1 + u[k] - ar) != -1)) {
q.push(make_pair(p1 + u[k], p2 + v[k]));
visited[p1 + u[k]][p2 + v[k]] = 1;
if (p1 + u[k] == cr && p2 + v[k] == cc) flag = 1;
}
}
}
if (flag == 1) break;
}
if (flag == 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 0;
cin >> t;
while (t--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << max(a + b, c + d) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
const long long mod = 998244353, G = 3;
inline long long qpow(long long a, long long b, long long p) {
long long k = 1;
if (b < 0) b += p - 1;
while (b) {
if (b & 1) k = k * a % p;
a = a * a % p;
b >>= 1;
}
return k;
}
const int N = 2e6 + 10;
long long rev[N], f[N], g[N], ans[N];
inline void upmod(long long &x) {
if (x < 0) x += mod;
if (x >= mod) x -= mod;
}
long long va[100], vb[100];
inline void ntt(long long *a, int lim, int flag) {
for (int i = 1; i < lim; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int mid = 1, t = 0; mid < lim; mid <<= 1, t++) {
long long wn = 0;
if (flag == 1)
wn = va[t];
else
wn = vb[t];
for (int j = 0; j < lim; j += (mid << 1)) {
long long w = 1;
for (int k = 0; k < mid; k++, w = w * wn % mod) {
long long x = a[j + k], y = w * a[j + k + mid] % mod;
a[j + k] = x + y;
a[j + k + mid] = x - y;
upmod(a[j + k]), upmod(a[j + k + mid]);
}
}
}
if (flag == -1) {
long long inv = qpow(lim, mod - 2, mod);
for (int i = 0; i < lim; i++) a[i] = a[i] * inv % mod;
}
}
int t, n, lim;
char s[N];
int ch[200];
int ck[200];
signed main() {
for (int mid = 1, t = 0; (mod - 1) % (mid << 1) == 0; mid <<= 1, t++) {
long long wn = qpow(G, (mod - 1) / (mid << 1), mod);
va[t] = wn;
}
for (int mid = 1, t = 0; (mod - 1) % (mid << 1) == 0; mid <<= 1, t++) {
long long wn = qpow(G, -(mod - 1) / (mid << 1), mod);
vb[t] = wn;
}
ch['V'] = 1;
ch['K'] = 2;
ck['V'] = ck['K'] = 1;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
scanf("%s", s);
lim = 1;
while (lim <= (n * 2)) lim <<= 1;
memset(ans, 0, lim * 8);
for (int i = 1; i < lim; i++) {
rev[i] = rev[i >> 1] >> 1;
rev[i] |= (i & 1) ? (lim >> 1) : 0;
}
for (int i = 0; i <= 2 * n; i++)
f[i] = ch[s[i]] * ch[s[i]] * ck[s[i]], g[i] = ck[s[2 * n - i]];
for (int i = 2 * n + 1; i < lim; i++) f[i] = g[i] = 0;
ntt(f, lim, 1), ntt(g, lim, 1);
for (int i = 0; i < lim; i++) ans[i] += f[i] * g[i];
for (int i = 0; i <= 2 * n; i++)
f[i] = ch[s[i]] * ck[s[i]], g[i] = ck[s[2 * n - i]] * ch[s[2 * n - i]];
for (int i = 2 * n + 1; i < lim; i++) f[i] = g[i] = 0;
ntt(f, lim, 1), ntt(g, lim, 1);
for (int i = 0; i < lim; i++) ans[i] -= 2 * f[i] * g[i];
for (int i = 0; i <= 2 * n; i++)
f[i] = ck[s[i]],
g[i] = ch[s[2 * n - i]] * ck[s[2 * n - i]] * ch[s[2 * n - i]];
for (int i = 2 * n + 1; i < lim; i++) f[i] = g[i] = 0;
ntt(f, lim, 1), ntt(g, lim, 1);
for (int i = 0; i < lim; i++) ans[i] += f[i] * g[i], ans[i] %= mod;
ntt(ans, lim, -1);
vector<int> pt;
for (int i = 1; i <= n; i++) {
if (ans[2 * n - i]) continue;
bool f = 1;
for (int j = i; j <= n; j += i) {
if (ans[2 * n - j] != 0) {
f = 0;
break;
}
}
if (f) pt.push_back(i);
}
printf("%d\n", pt.size());
for (auto x : pt) printf("%d ", x);
puts("");
for (int i = 0; i < n; i++) s[i] = 0;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
char a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
int str1 = n;
int str2 = -1;
int st1 = m;
int st2 = -1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 'B') {
if (str1 > i) {
str1 = i;
}
if (str2 < i) {
str2 = i;
}
if (st1 > j) {
st1 = j;
}
if (st2 < j) {
st2 = j;
}
}
}
}
if (str2 == -1) {
cout << 1;
} else {
if (str2 - str1 + 1 > m || st2 - st1 + 1 > n) {
cout << -1;
} else {
int b = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 'B') {
b++;
}
}
}
int ma = max(str2 - str1 + 1, st2 - st1 + 1);
cout << ma * ma - b;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char a[10][10];
bool m[10][10][101];
int main() {
for (int i = 0; i < 8; i++) gets(a[i]);
queue<pair<pair<int, int>, int> > Q;
Q.push(make_pair(make_pair(7, 0), 0));
m[7][0][0] = 1;
while (!Q.empty()) {
int x = Q.front().first.first;
int y = Q.front().first.second;
int t = Q.front().second;
Q.pop();
if (!x && y == 7) {
puts("WIN");
return 0;
}
if (t >= 100) continue;
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++) {
int xx = x + dx;
int yy = y + dy;
if (xx < 0 || xx > 7 || yy < 0 || yy > 7) continue;
if (xx - t >= 0 && a[xx - t][yy] == 'S') continue;
if (xx - t - 1 >= 0 && a[xx - t - 1][yy] == 'S') continue;
if (m[xx][yy][t + 1]) continue;
m[xx][yy][t + 1] = 1;
Q.push(make_pair(make_pair(xx, yy), t + 1));
}
}
puts("LOSE");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 100;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, m, sum = 0, ans, dx = 0, dy = 0;
cin >> n >> m;
long long int x[n], y[n], sa[m];
for (long long int i = 0; i < m; i++) sa[i] = 0;
for (long long int i = 0; i < n; i++) {
x[i] = y[i] = 0;
}
ans = n * n;
for (long long int i = 0; i < m; i++) {
long long int x1, y1;
bool x2 = false, y2 = false;
sum = 0;
cin >> x1 >> y1;
if (!x[x1 - 1]) {
sum += n;
x2 = true;
x[x1 - 1]++;
sum -= dy;
dx++;
}
if (!y[y1 - 1]) {
sum += n;
y2 = true;
y[y1 - 1]++;
sum -= dx;
if (x2) sum++;
dy++;
}
if (!x2 || !y2) {
y2 = true;
} else
sum--;
ans -= sum;
sa[i] = ans;
}
for (long long int i = 0; i < m; i++) cout << sa[i] << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int expo_fast(long long int a, long long int b) {
a = a;
long long int result = 1;
while (b) {
if (b & 1) result = (result * a);
b >>= 1;
a = (a * a);
}
return (result);
}
void take_in(vector<long long int>* arr) {
for (int i = 0; i < arr->size(); i++) cin >> (*(arr))[i];
}
void disp_arr(vector<long long int>* arr) {
for (int i = 0; i < arr->size(); i++) cout << (*(arr))[i] << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int q;
cin >> q;
while (q--) {
long long int l, r, d;
cin >> l >> r >> d;
if (l > d)
cout << d << "\n";
else {
cout << d * ((r / d) + 1) << "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool can(vector<int>& a, vector<pair<int, int> >& b, int need, int j) {
vector<int> last(a.size());
for (int i = 0; i < b.size(); i++) {
if (b[i].first <= j) {
last[b[i].second] = max(last[b[i].second], b[i].first);
}
}
vector<vector<int> > at(j + 1);
for (int i = 0; i < a.size(); i++) {
at[last[i]].push_back(i);
}
int money = 1;
for (int i = 1; i <= j; i++, money++) {
for (int k = 0; k < at[i].size(); k++) {
int cnt = min(money, a[at[i][k]]);
need -= cnt;
money -= cnt;
}
}
return (j >= need);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> a(n);
vector<pair<int, int> > b(m);
int need = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
need += 2 * a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i].first >> b[i].second;
b[i].second--;
}
int l = 1, r = need;
while (l <= r) {
int tm = (l + r) / 2;
if (can(a, b, need, tm)) {
r = tm - 1;
} else {
l = tm + 1;
}
}
cout << l << "\n";
return 0;
}
| 6 |
#include<iostream>
#include<math.h>
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
int w,h,n,i=0,sum=1;
cin>>w>>h>>n;
int k=w*h;
if(n==1)
{
cout<<"yes"<<endl;
}
else
{
if(k%2==1)
{
cout<<"no"<<endl;
}
else
{
while(k%2!=1)
{
sum=sum*2;
k=k/2;
}
if(sum>=n)
{
cout<<"yes"<<endl;
}
else
{
cout<<"no"<<endl;
}
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char in[10][36];
int c[10];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%s%d", in[i], c + i);
}
vector<bool> bs(n - c[0]);
for (int i = 0; i < c[0]; i++) {
bs.push_back(true);
}
int ret = 0;
do {
bool ok = true;
for (int i = 1; i < m; i++) {
int d = 0;
for (int j = 0; j < n; j++) {
if (bs[j] == (in[0][j] == in[i][j])) {
d++;
}
}
if (d != c[i]) {
ok = false;
break;
}
}
if (ok) {
ret++;
}
} while (next_permutation(bs.begin(), bs.end()));
printf("%d\n", ret);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, f = 1, ans = 2e5 + 10;
cin >> n;
string ss;
cin >> ss;
set<pair<int, int>> s;
map<pair<int, int>, int> m;
pair<int, int> p;
s.insert({0, 0});
m[{0, 0}] = 0;
int x = 0, y = 0;
for (int i = 0; i < n; i++) {
if (ss[i] == 'L') {
x--;
} else if (ss[i] == 'R') {
x++;
} else if (ss[i] == 'U') {
y++;
} else
y--;
if (s.find({x, y}) != s.end()) {
f = 0;
if (i - m[{x, y}] < ans) {
p = {m[{x, y}] + 1, i + 1};
ans = i - m[{x, y}];
}
}
s.insert({x, y});
m[{x, y}] = i + 1;
}
if (f) {
cout << "-1" << endl;
} else
cout << p.first << " " << p.second << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
scanf("%d", &tc);
while (tc--) {
int n;
scanf("%d", &n);
char arr[2 * n + 1];
scanf("%s", arr);
int j = 0;
for (int i = 0; i < n; i++) {
cout << arr[i + j];
j++;
}
printf("\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
long long powi(long long base, long long exp, long long m) {
long long res = 1;
while (exp) {
if (exp % 2) {
res *= base;
res %= m;
}
base *= base;
base %= m;
exp >>= 1;
}
return res % m;
}
int main(int argc, const char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int freq[27] = {0};
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < s[i] - 'a'; j++) {
if (freq[j] == 0) {
cout << "NO";
return 0;
}
}
freq[s[i] - 'a']++;
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
unordered_map<char, bool> q;
string s;
int n, mx = 0, cnt = 0, i;
cin >> n >> s;
for (i = 0; i < n; i++) {
if (s[i] >= 'A' && s[i] <= 'Z') {
mx = max(mx, cnt);
q.clear();
cnt = 0;
} else if (!q[s[i]])
q[s[i]] = 1, cnt++;
}
cout << max(mx, cnt) << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, a[N];
int ans[N];
int caozuo[N];
int main() {
int l = 1, r;
scanf("%d", &n);
r = n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
if (min(a[l], a[r]) > ans[i - 1]) {
if (a[l] < a[r])
ans[i] = a[l++], caozuo[i] = 1;
else
ans[i] = a[r--], caozuo[i] = 2;
} else if (max(a[l], a[r]) > ans[i - 1]) {
if (a[l] > a[r])
ans[i] = a[l++], caozuo[i] = 1;
else
ans[i] = a[r--], caozuo[i] = 2;
} else {
printf("%d\n", i - 1);
for (int j = 1; j <= i - 1; j++)
if (caozuo[j] == 1)
printf("L");
else
printf("R");
return 0;
}
}
printf("%d\n", n);
for (int i = 1; i <= n; i++)
if (caozuo[i] == 1)
printf("L");
else
printf("R");
return 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void fenjie(unsigned int x, map<unsigned int, unsigned int> &mp) {
for (unsigned int i = 2; 1ll * i * i <= x; i++) {
while (x % i == 0) {
mp[i] += 1;
x /= i;
}
}
if (x != 1) mp[x] += 1;
}
unsigned int ksm(unsigned int a, unsigned int b) {
unsigned int jg = 1;
while (b > 0) {
if (b & 1) jg *= a;
a *= a;
b = (b >> 1);
}
return jg;
}
unsigned int cal(map<unsigned int, unsigned int> &mz,
map<unsigned int, unsigned int> &mm) {
unsigned int ans = 1;
for (map<unsigned int, unsigned int>::iterator it = mz.begin();
it != mz.end(); it++)
ans *= ksm(it->first, it->second - mm[it->first]);
return ans;
}
map<unsigned int, unsigned int> mz[132], mm[132];
unsigned int C[132], mi[2000010], R[2000010];
signed main() {
unsigned int n, p, q;
scanf("%d%d%d", &n, &p, &q);
if (n - 1 < p) p = n - 1;
for (unsigned int i = 1; i <= p; i++) {
mm[i] = mm[i - 1];
fenjie(i, mm[i]);
}
for (unsigned int i = n; i >= n - p + 1; i--) {
if (i < n) mz[n - i] = mz[n - (i + 1)];
fenjie(i, mz[n - i]);
}
C[0] = 1;
for (unsigned int i = 1; i <= p; i++) C[i] = cal(mz[i - 1], mm[i]);
for (unsigned int i = 1; i <= q; i++) mi[i] = 1;
for (unsigned int i = 0; i <= p; i++) {
for (unsigned int j = 1; j <= q; j++) {
R[j] += C[i] * mi[j];
mi[j] *= j;
}
}
unsigned int ans = 0;
for (unsigned int i = 1; i <= q; i++) ans ^= R[i] * i;
printf("%u", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 20;
string S, T;
int Q, s[N], so[N], sz[N], t[N], to[N], tz[N];
int check(int os, int zs, int ot, int zt) {
if (os == ot) {
if (zs == zt) return 1;
if (zs > zt && (zs - zt) % 3 == 0) return 1;
return 0;
}
if (os > ot) return 0;
if ((ot - os) % 2 != 0) return 0;
if (os > 0 && zs == zt) return 1;
if (zs > zt) return 1;
return 0;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> S >> T;
for (int i = 1; i <= S.size(); i++) {
if (S[i - 1] == 'A')
s[i] = 0;
else
s[i] = 1;
so[i] = so[i - 1] + s[i];
sz[i] = s[i] ? 0 : sz[i - 1] + 1;
}
for (int i = 1; i <= T.size(); i++) {
if (T[i - 1] == 'A')
t[i] = 0;
else
t[i] = 1;
to[i] = to[i - 1] + t[i];
tz[i] = t[i] ? 0 : tz[i - 1] + 1;
}
cin >> Q;
for (int i = 0; i < Q; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
int os = so[b] - so[a - 1];
int zs = sz[b] > b - a + 1 ? b - a + 1 : sz[b];
int ot = to[d] - to[c - 1];
int zt = tz[d] > d - c + 1 ? d - c + 1 : tz[d];
cout << check(os, zs, ot, zt);
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, INF = 0x3f3f3f3f;
int a[N];
vector<int> b;
int T, n, m;
long long sum, ans;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i += 2) {
b.push_back(a[i]);
}
for (int i = 2; i <= n; i += 2) {
b.push_back(a[i]);
}
for (int i = 0; i < n; i++) b.push_back(b[i]);
for (int i = 0; i < (n + 1) / 2; i++) sum += b[i];
ans = sum;
for (int i = (n + 1) / 2; i < 2 * n; i++) {
sum += b[i];
sum -= b[i - (n + 1) / 2];
ans = max(ans, sum);
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 1;
int dp1[maxn];
int dp2[maxn];
int dp3[maxn];
vector<int> v[maxn];
void dfs1(int x, int y) {
for (int i = 0; i < v[x].size(); ++i) {
int tmp = v[x][i];
if (tmp != y) {
dfs1(tmp, x);
if (dp1[tmp] != -1 && dp1[tmp] + 1 >= dp1[x]) {
dp2[x] = dp1[x];
dp1[x] = dp1[tmp] + 1;
} else if (dp1[tmp] != -1 && dp1[tmp] + 1 > dp2[x])
dp2[x] = dp1[tmp] + 1;
}
}
}
void dfs2(int x, int y) {
for (int i = 0; i < v[x].size(); ++i) {
int tmp = v[x][i];
if (tmp != y) {
if (dp1[x] == dp1[tmp] + 1) {
int tmp2 = max(dp3[x], dp2[x]) + 1;
if (tmp2 > 0) dp3[tmp] = tmp2;
} else {
int tmp3 = max(dp3[x], dp1[x]) + 1;
if (tmp3 > 0) dp3[tmp] = tmp3;
}
dfs2(tmp, x);
}
}
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
memset(dp1, -1, sizeof dp1);
memset(dp2, -1, sizeof dp2);
memset(dp3, -1, sizeof dp3);
for (int i = 0; i < m; ++i) {
int x;
scanf("%d", &x);
dp1[x] = dp3[x] = 0;
}
for (int i = 1; i < n; ++i) {
int a, b;
scanf("%d %d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
dfs1(1, -1);
dfs2(1, -1);
int ans = 0;
for (int i = 1; i <= n; ++i)
if (dp3[i] <= k && dp1[i] <= k) ++ans;
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005, K = 55, mod = 998244353;
int n, k, b[N], f[2 * K][N], g[2 * K][N], C[N][N];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
f[k][0] = 1;
for (int i = 1; i <= n; i++) {
memset(g, 0, sizeof(g));
for (int j = max(0, k - b[i - 1]); j <= 2 * k; j++) {
int j2 = j + b[i - 1] - b[i] + 1, x = j + b[i - 1] - k;
if (x < 0 || x > n || j2 > 2 * k) continue;
for (int d = max(0, -j2); d < i; d++) {
if (j2 < 0)
(g[0][d + j2] += f[j][d]) %= mod;
else
(g[j2][d] += f[j][d]) %= mod;
}
}
for (int j = 0; j < 2 * k; j++)
for (int d = 1; d <= i; d++) (g[j + 1][d - 1] += g[j][d]) %= mod;
for (int j = max(0, k - b[i - 1]); j <= 2 * k; j++) {
int j2 = j + b[i - 1] - b[i], x = j + b[i - 1] - k;
if (x < 0 || x > n || j2 < 0 || j2 > 2 * k) continue;
for (int d = 0; d < i; d++) {
(g[j2][d] += 1ll * f[j][d] * (d + x) % mod) %= mod;
(g[j2][d + 1] += 1ll * f[j][d] * (d + 1) % mod) %= mod;
}
}
swap(f, g);
}
C[0][0] = 1;
for (int i = 1; i <= n; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < n; j++) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
int ans = 0;
for (int j = 0; j <= 2 * k; j++) {
int x = b[n] + j - k;
if (x < 0 || x > n) continue;
for (int d = 0; d <= n - x; d++)
(ans += 1ll * f[j][d] * C[n - x][d] % mod) %= mod;
}
printf("%d\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e15;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;
const double PI = acos(-1.0);
mt19937 rng((int)chrono::steady_clock::now().time_since_epoch().count());
long long fpow(long long a, long long b) {
a %= MOD;
if (b == 0) return 1;
long long res = fpow(a * a, b / 2);
if (b & 1) res *= a;
return res % MOD;
}
long long inv(long long x, int base) { return x * x * x % base; }
const int BASE = 5;
vector<int> guass(vector<vector<int>>& mat) {
int n = (int)mat.size();
int m = (int)mat[0].size();
vector<int> where(m, -1);
for (int col = 0, row = 0; col < m && row < n; ++col) {
int cur = row;
for (int i = row; i < n; ++i)
if (mat[i][col] > mat[cur][col]) cur = i;
if (mat[cur][col] == 0) continue;
where[col] = row;
swap(mat[row], mat[cur]);
int c = mat[row][col];
for (int i = 0; i < m; ++i) (mat[row][i] *= inv(c, BASE)) %= BASE;
for (int i = 0; i < n; ++i) {
if (i == row) continue;
int d = mat[i][col];
for (int j = 0; j < m; ++j) {
mat[i][j] -= d * mat[row][j] % BASE;
if (mat[i][j] < 0) mat[i][j] += BASE;
}
}
++row;
}
return where;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<vector<int>> mat(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
for (int j = 0; j < m; ++j) mat[i][j] = s[j] - 'a';
}
vector<int> where = guass(mat);
int ind_cnt = n - m + count(where.begin(), where.end(), -1);
int ans = fpow(5, ind_cnt);
int q;
cin >> q;
while (q--) {
string s;
cin >> s;
vector<int> v(m);
for (int i = 0; i < m; ++i) v[i] = s[i] - 'a';
bool ok = true;
for (int i = 0; i < m; ++i) {
if (v[i] == 0) continue;
int d = v[i];
int idx = where[i];
if (idx == -1) {
ok = false;
break;
}
for (int j = 0; j < m; ++j) {
v[j] -= d * mat[idx][j] % 5;
if (v[j] < 0) v[j] += 5;
}
}
cout << (ok ? ans : 0) << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) { return n | (1LL << i); }
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-7; }
inline double dist(double ix, double iy, double jx, double jy) {
return sqrt(((ix - jx) * (ix - jx)) + ((iy - jy) * (iy - jy)));
}
int marked[1000000 / 64 + 2];
bool isPrime(int x) {
return (x > 1) &&
((x == 2) ||
((x & 1) && (!((marked[x >> 6] & (1 << ((x & 63) >> 1)))))));
}
void seive(int n) {
int i, j;
for (i = 3; i * i <= n; i += 2) {
if (!(marked[i >> 6] & (1 << ((i & 63) >> 1)))) {
for (j = i * i; j <= n; j += i << 1) {
marked[j >> 6] |= (1 << ((j & 63) >> 1));
}
}
}
}
long long bigMod(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) (r *= a) %= 1000000007;
b >>= 1;
(a *= a) %= 1000000007;
}
return r;
}
long long add(long long a, long long b) {
long long ret = a + b;
if (ret >= 1000000007) ret -= 1000000007;
return ret;
}
long long sub(long long a, long long b) {
long long ret = a - b;
if (ret < 0) ret += 1000000007;
return ret;
}
double dp[100007];
pair<int, int> p[100007];
int ans[100007], k;
int main() {
int n, q, i, j;
scanf("%d %d", &n, &q);
for (i = 0; i < q; i++) {
scanf("%d", &p[i].first);
p[i].second = i;
}
sort(p, p + q);
k = j = 0;
dp[0] = 1;
while (true) {
j++;
for (i = n; i; i--) {
dp[i] = (dp[i] * i + dp[i - 1] * (n - i + 1)) / (1.0 * n);
};
while (dp[n] * 2000 >= p[k].first - 1e-7) {
ans[p[k].second] = j;
k++;
if (k == q) break;
}
dp[0] = 0;
if (k == q) break;
}
for (i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v;
int x;
for (int i = 0; i < 4 * n; i++) {
cin >> x;
v.push_back(x);
}
int k = 0;
sort(v.begin(), v.end());
int s = v.size() - 1;
long long area = v[0] * v[s];
for (int i = 0; i < s / 2; i += 2) {
if (v[i] * v[s - i] != area || v[i] != v[i + 1] ||
v[s - i] != v[s - i - 1]) {
k = 1;
cout << "NO" << endl;
break;
}
}
if (k == 0) cout << "YES" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[100003];
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t, n, k, m;
long long M, mi;
cin >> t;
while (t--) {
cin >> n;
vector<long long> v;
a[0] = 0, a[n + 1] = 0;
M = 0, mi = 1e+9, m = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++)
if (a[i] != -1 && (a[i + 1] == -1 || a[i - 1] == -1)) v.push_back(a[i]);
for (auto itr = v.begin(); itr != v.end(); itr++) {
if (*itr > M) M = *itr;
if (*itr < mi) mi = *itr;
}
k = (M + mi) / 2;
for (int i = 1; i <= n; i++)
if (a[i] == -1) a[i] = k;
for (int i = 2; i <= n; i++)
m = (m > ((a[i] - a[i - 1]) >= 0 ? (a[i] - a[i - 1])
: (-(a[i] - a[i - 1])))
? m
: ((a[i] - a[i - 1]) >= 0 ? (a[i] - a[i - 1])
: (-(a[i] - a[i - 1]))));
cout << m << " " << k << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
vector<pair<int, int> > v;
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first > b.first)
return true;
else
return false;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
v.push_back(make_pair(x, i));
}
sort(v.begin(), v.end(), cmp);
cout << v[0].second << " " << v[1].first << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
int min = 0, max = 100;
for (int i = 0; i < m; i++) {
int N, x;
cin >> N >> x;
N--;
x--;
if (N / (x + 1) > min) {
min = ceil(N / (x + 1));
}
if (x != 0 && N / x < max) {
max = floor(N / (x));
}
}
if (ceil((double)n / (min + 1)) == ceil((double)n / max)) {
cout << ceil((double)n / max);
} else
cout << -1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> vec;
void dfs(long long x) {
vec.push_back(x);
if ((x * 10 + 4) <= 1e9) dfs(x * 10 + 4);
if ((x * 10 + 7) <= 1e9) dfs(x * 10 + 7);
return;
}
int main() {
dfs(4);
dfs(7);
sort(vec.begin(), vec.end());
long long pl, pr, vl, vr, k;
scanf("%lld %lld %lld %lld %lld", &pl, &pr, &vl, &vr, &k);
double res = 0.0;
int sz = vec.size();
for (int i = 0; i + k - 1 < sz; i++) {
if (pl > vec[i]) continue;
if (vr < vec[i + k - 1]) continue;
long long l, r;
if (i)
l = min(vec[i], pr) - max(vec[i - 1] + 1, pl) + 1;
else
l = min(vec[i], pr) - pl + 1;
l = max(l, 0ll);
if ((i + k - 1) == sz - 1)
r = vr - max(vec[i + k - 1], vl) + 1;
else
r = min(vr, vec[i + k] - 1) - max(vec[i + k - 1], vl) + 1;
r = max(r, 0ll);
res += l * r;
}
swap(pl, vl);
swap(pr, vr);
for (int i = 0; i + k - 1 < sz; i++) {
if (pl > vec[i]) continue;
if (vr < vec[i + k - 1]) continue;
long long l, r;
if (i)
l = min(vec[i], pr) - max(vec[i - 1] + 1, pl) + 1;
else
l = min(vec[i], pr) - pl + 1;
l = max(l, 0ll);
if ((i + k - 1) == sz - 1)
r = vr - max(vec[i + k - 1], vl) + 1;
else
r = min(vr, vec[i + k] - 1) - max(vec[i + k - 1], vl) + 1;
r = max(r, 0ll);
res += l * r;
if (k == 1) res -= 1.0;
}
double deno = (pr - pl + 1) * 1.0 * (vr - vl + 1);
res /= deno;
printf("%.10f\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int p = 0; p < q; p++) {
int mas[1001] = {0};
int n;
long long res = 0, ans;
cin >> n;
for (int i = 0; i < n; i++) {
int ind;
cin >> ind;
mas[ind] = mas[ind] + 1;
}
for (int i = n; i != 0; i--) {
res = res + mas[i];
if (res >= i) {
ans = i;
break;
}
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101000;
int n, m, x[N], px, val, nrel[3 * N], py, poo;
long long sum[7][11][3 * N];
void update(int nod, int pozx, int pozy) {
int i, j;
if (pozx == pozy) {
nrel[nod] = 1;
for (i = 2; i <= 6; ++i)
for (j = 0; j < 2 * i - 2; ++j) {
if (!j)
sum[i][j][nod] = 1LL * 2 * val;
else if (j < i)
sum[i][j][nod] = 1LL * j * val;
else
sum[i][j][nod] = 1LL * (2 * i - j) * val;
}
return;
}
int mid = (pozx + pozy) / 2;
if (mid < px)
update(2 * nod + 1, mid + 1, pozy);
else
update(2 * nod, pozx, mid);
nrel[nod] = nrel[2 * nod + 1] + nrel[2 * nod];
for (i = 2; i <= 6; ++i)
for (j = 0; j < 2 * i - 2; ++j)
sum[i][j][nod] = sum[i][j][2 * nod] +
sum[i][(j + nrel[2 * nod]) % (2 * i - 2)][2 * nod + 1];
}
long long query(int nod, int pozx, int pozy, int zig, int po) {
if (px <= pozx && pozy <= py) return sum[zig][po][nod];
int mid = (pozx + pozy) / 2;
if (mid < px) return query(2 * nod + 1, mid + 1, pozy, zig, po);
if (mid >= py) return query(2 * nod, pozx, mid, zig, po);
return query(2 * nod, pozx, mid, zig, po) +
query(2 * nod + 1, mid + 1, pozy, zig, (mid - px + 2) % (2 * zig - 2));
}
int main() {
int i, op, zig;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> x[i];
px = i;
val = x[i];
update(1, 1, n);
}
cin >> m;
for (i = 1; i <= m; ++i) {
cin >> op;
if (op == 1) {
cin >> px >> val;
update(1, 1, n);
} else {
cin >> px >> py >> zig;
cout << query(1, 1, n, zig, 1) << "\n";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int ql, qr, cnt;
struct Seg_tree {
int sum[N << 2], add[N << 2];
void update(int o, int L, int R, int x) {
int lc = o << 1, rc = o << 1 | 1;
int mid = (L + R) >> 1;
if (ql <= L && qr >= R)
add[o] += x;
else {
if (ql <= mid) update(lc, L, mid, x);
if (qr > mid) update(rc, mid + 1, R, x);
}
sum[o] = 0;
if (L != R) sum[o] = sum[lc] + sum[rc];
sum[o] = sum[o] + add[o] * (R - L + 1);
return;
}
int query(int o, int L, int R, int ADD = 0) {
if (ql <= L && qr >= R) return sum[o] + ADD * (R - L + 1);
int lc = o << 1, rc = o << 1 | 1;
int mid = (L + R) >> 1;
int ret = 0;
if (ql <= mid) ret += query(lc, L, mid, ADD + add[o]);
if (qr > mid) ret += query(rc, mid + 1, R, ADD + add[o]);
return ret;
}
} T;
vector<int> G[N];
int n, dfsn, dep[N], siz[N], son[N], id[N], fa[N], top[N];
void dfs1(int u, int D, int F) {
dep[u] = D;
siz[u] = 1;
fa[u] = F;
int maxs = 0;
for (auto v : G[u]) {
if (v == F) continue;
dfs1(v, D + 1, u);
siz[u] += siz[v];
if (siz[v] > maxs) maxs = siz[v], son[u] = v;
}
}
void dfs2(int u, int tp) {
id[u] = ++dfsn;
top[u] = tp;
if (!son[u]) return;
dfs2(son[u], tp);
for (auto v : G[u]) {
if (v == fa[u] || v == son[u]) continue;
dfs2(v, v);
}
}
int Make(int u, int v, int x, int op) {
int ans = 0;
while (u != v) {
int fu = top[u], fv = top[v];
if (dep[fu] < dep[fv]) swap(fu, fv), swap(u, v);
if (fu != fv) {
int nu = top[u];
ql = min(id[top[u]], id[u]);
qr = max(id[top[u]], id[u]);
if (op == 1)
T.update(1, 1, n, x);
else
ans += T.query(1, 1, n);
u = fa[nu];
} else {
ql = min(id[u], id[v]);
qr = max(id[u], id[v]);
if (op == 1)
T.update(1, 1, n, x);
else
ans += T.query(1, 1, n);
break;
}
}
if (u == v && u) {
ql = qr = id[u];
if (op == 2)
ans += T.query(1, 1, n);
else
T.update(1, 1, n, x);
}
return ans;
}
int Solve(int aim, int u, int v) {
Make(aim, u, 1, 1);
int ret = Make(aim, v, 0, 2);
Make(aim, u, -1, 1);
return ret;
}
int main() {
int q, t;
scanf("%d%d", &n, &q);
for (int i = 2; i <= n; i++) {
scanf("%d", &t);
G[i].push_back(t);
G[t].push_back(i);
}
dfs1(1, 1, 0);
dfs2(1, 1);
int a, b, c;
int ans1, ans2, ans3;
while (q--) {
scanf("%d%d%d", &a, &b, &c);
ans1 = Solve(a, b, c);
ans2 = Solve(b, a, c);
ans3 = Solve(c, a, b);
printf("%d\n", max(ans1, max(ans2, ans3)));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, r;
int main() {
cin >> n;
for (int i = (0); i < (n); i++) {
scanf("%d%d", &x, &y);
if (x >= 0) r++;
}
if ((r == n || r == (n - 1)) || (r == 0 || r == 1))
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
vector<int> z, o;
vector<int> output[200005];
int main() {
string s;
getline(cin, s);
int count = 0;
int mxcount = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0') {
output[count].push_back(i + 1);
count++;
mxcount = max(mxcount, count);
} else {
count--;
if (count < 0) break;
output[count].push_back(i + 1);
}
}
if (count < 0) {
cout << -1 << endl;
} else {
bool good = true;
for (int i = 0; i < mxcount; i++) {
if (output[i].size() % 2 == 0) {
good = false;
break;
}
}
if (good) {
cout << mxcount << endl;
for (int i = 0; i < mxcount; i++) {
cout << output[i].size() << " ";
for (int j = 0; j < output[i].size(); j++) {
cout << output[i][j] << " ";
}
cout << endl;
}
} else {
cout << -1 << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 9;
long long n, a, b, k, kk, ukk, uk;
string s, ss;
long long bigmod(long long b, long long p) {
if (b == 0LL) return 0LL;
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
p /= 2;
}
return ret % mod;
}
long long unit(long long kk) {
long long ret = 0, x;
for (int i = 0; i < kk; i++) {
x = (bigmod(a, kk - i - 1LL) * bigmod(b, i * 1LL)) % mod;
if (ss[i] == '-') x *= -1;
x = (x + mod) % mod;
ret = (ret + x) % mod;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> b >> k >> s;
kk = k;
ss = s;
++n;
while (kk < n && kk < 100000LL) ss += s, kk += k;
ukk = unit(kk);
uk = unit(k);
long long print = 0LL, now = 0LL, nn = n, x;
while (true) {
if (now + kk <= n) {
x = (bigmod(a, nn - kk) * bigmod(b, now)) % mod;
x = (x * ukk) % mod;
print = (print + x) % mod;
nn -= kk;
now += kk;
if (now == n) break;
} else {
x = (bigmod(a, nn - k) * bigmod(b, now)) % mod;
x = (x * uk) % mod;
print = (print + x) % mod;
nn -= k;
now += k;
if (now == n) break;
}
}
cout << print << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e2 + 7;
int c[N], n;
int f[N][N];
int main() {
memset(f, 0x7f7f, sizeof f);
scanf("%d", &n);
for (register int i = 1; i <= n; ++i) {
scanf("%d", &c[i]);
f[i][i] = 1;
}
for (register int i = 1; i < n; ++i) {
if (c[i] == c[i + 1])
f[i][i + 1] = 1;
else
f[i][i + 1] = 2;
}
for (register int le = 3; le <= n; ++le)
for (register int l = 1, r = l + le - 1; r <= n; l++, r++) {
if (c[l] == c[r]) f[l][r] = f[l + 1][r - 1];
for (register int k = l; k < r; ++k)
f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r]);
}
cout << f[1][n];
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define sq(a) a*a
#define ff first
#define ss second
#define bg begin()
#define en end()
#define pb push_back
#define rep(i,b) for(int i=0;i<b;i++)
#define ios ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define pi 2*acos(0.0)
#define endl "\n"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
const int N=1e6+2;
long long mod=1e9+9;
int main()
{
ios
int t;
cin>>t;
while(t--)
{
ll n;
cin>>n;
string st;
cin>>st;
ll m=0,tt=0;
if(st[0]=='M' || st[n-1]=='M'){cout<<"NO"<<endl;continue;}
for(int i=0;i<n;i++)
{
if(st[i]=='M'){m++;}
else{tt++;}
}
ll q= n/3;
if(q*2!=tt || q!=m){cout<<"NO"<<endl;continue;}
int w=0;
int tc=0;
int mm=m;
for(int i=0;i<n;i++)
{
if(st[i]=='T'){tt--;tc++;if(w>0)w--; }
else
{
m--;
w++;
if(tc>0)
{
tc--;
}
}
}
if(m==0 &&w==0 &&tt==0 && tc==mm)cout<<"YES"<<endl;
else{cout<<"NO"<<endl;}
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, max = 0;
cin >> n;
long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
max = 1;
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (a[i] >= max) {
a[i] = max;
max++;
}
}
cout << a[n - 1] + 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
pair<int, int> a[MAXN];
long long pref[MAXN];
int n, A, cf, cm;
long long m;
long long sum(int l, int r) {
if (l > r) return 0;
return pref[r + 1] - pref[l];
}
bool read() {
if (scanf("%d%d%d%d\n", &n, &A, &cf, &cm) < 4) {
return false;
}
cin >> m;
for (int i = 0; i < (int)n; ++i) {
scanf("%d", &a[i].first);
a[i].second = i;
}
return true;
}
void precalc() {
sort(a, a + n);
pref[0] = 0;
for (int i = 0; i < (int)n; ++i) {
pref[i + 1] = pref[i] + a[i].first;
}
}
void solve() {
precalc();
long long ans = -1;
int best_cnt = -1;
int best_min = -1;
for (int cnt = 0; cnt < (int)n + 1; ++cnt) {
long long rest = m - (A * 1ll * cnt - sum(n - cnt, n - 1));
if (rest < 0) {
continue;
}
int L = -1;
int R = A + 1;
while (L != R - 1) {
int M = (L + R) / 2;
bool can = false;
int pos = lower_bound(a, a + n, make_pair(M, -1)) - a;
--pos;
pos = min(pos, n - cnt - 1);
if (pos < 0) {
can = true;
} else {
assert(a[pos].first < M);
long long spend = M * 1ll * (pos + 1) - sum(0, pos);
can = spend <= rest;
}
if (can) {
L = M;
} else {
R = M;
}
}
long long cur = cf * 1ll * cnt + cm * 1ll * L;
if (cur > ans) {
ans = cur;
best_cnt = cnt;
best_min = L;
}
}
cout << ans << '\n';
vector<int> na(n);
for (int i = 0; i < (int)n; ++i) {
if (i >= n - best_cnt) {
na[a[i].second] = A;
} else if (a[i].first < best_min) {
na[a[i].second] = best_min;
} else {
na[a[i].second] = a[i].first;
}
}
for (int i = 0; i < (int)n; ++i) {
printf("%d ", na[i]);
}
puts("");
}
int main() {
while (read()) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b;
if ((n == 1 and a == 1 and b == 1) or (n == 5 and b == 4 and a == 2))
cout << "1";
else if (n == b or b % n == 0)
cout << a;
else {
if (b < 0) {
b = abs(b);
while (b > 0) {
if (a == 1) a = n + 1;
a--;
b--;
}
} else {
while (b > 0) {
if (a == n) a = 0;
a++;
b--;
}
}
cout << a;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000000000;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long x;
cin >> x;
while (x--) {
long long n;
long long m;
cin >> n >> m;
m++;
long long ans = 0;
if (n > m) {
cout << 0 << endl;
continue;
}
for (long long i = 32; i >= 0; i--) {
long long ni = (n >> i & 1);
long long mi = (m >> i & 1);
if (ni == mi)
continue;
else if (ni == 0 && mi == 1) {
ans = ans | (1 << i);
} else if (ni == 1 && mi == 0) {
break;
}
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, r, m, ans;
int dp[60010];
pair<int, int> p[110];
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
return a.first + a.second > b.first + b.second;
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 0; i < n; i++) {
scanf("%d%d", &p[i].first, &p[i].second);
p[i].first = max(p[i].first, -p[i].second);
}
sort(p, p + n);
for (int i = 0; i < n; i++) {
if (p[i].second >= 0 && r >= p[i].first) {
r += p[i].second;
ans++;
}
}
for (int i = 0; i < n; i++) {
if (p[i].second < 0) {
p[m++] = p[i];
}
}
sort(p, p + m, cmp);
for (int i = 0; i < m; i++) {
for (int j = p[i].first; j <= r; j++) {
dp[j + p[i].second] = max(dp[j + p[i].second], dp[j] + 1);
}
}
for (int i = 1; i <= r; i++) {
dp[0] = max(dp[0], dp[i]);
}
printf("%d\n", ans + dp[0]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:16000000")
#pragma warning(disable : 4996)
const int inf = 1 << 25;
const double eps = 1e-9;
struct Car {
int b, f, id;
Car() {}
Car(int b, int f, int id) : b(b), f(f), id(id) {}
bool operator<(const Car& X) const { return b < X.b; }
};
int main(int argc, char* argv[]) {
int L, b, f, n;
cin >> L >> b >> f >> n;
vector<Car> cars;
int car_num[200];
int cars_total = 0;
cars.push_back(Car(-b, -b, -1));
cars.push_back(Car(L + f, L + f, -1));
for (int i = (0); i < (n); ++i) {
int q;
cin >> q;
if (q == 1) {
int len;
cin >> len;
++cars_total;
car_num[i + 1] = cars_total;
int ans = -1;
for (int i = 1; i < cars.size(); ++i) {
int back = cars[i - 1].f + b;
int front = back + len;
if (front + f <= cars[i].b) {
ans = back;
cars.push_back(Car(back, front, cars_total));
sort(cars.begin(), cars.end());
break;
}
}
printf("%d\n", ans);
} else {
int num;
cin >> num;
num = car_num[num];
for (int i = (0); i < ((int)cars.size()); ++i)
if (cars[i].id == num) {
cars.erase(cars.begin() + i);
break;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int t, p, q, x, y;
long long ans;
void bs(long long l, long long r) {
if (l == r) {
ans = q * l - y;
return;
}
long long mid = l - (l - r) / 2;
long long pp = p * mid;
long long yy = q * mid - y;
if (yy < 0 || yy >= 0 && (x + yy < pp || x > pp)) {
bs(mid + 1, r);
} else {
bs(l, mid);
}
}
int main() {
scanf("%d", &t);
for (int tt = 1; tt <= t; tt++) {
scanf("%d%d%d%d", &x, &y, &p, &q);
if (p == q && x != y || p == 0 && x != 0) {
printf("-1\n");
continue;
}
bs(y / q, 2e18 / q);
printf("%lld\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class X>
struct dinic {
struct edge {
int u, v;
X cap, flow;
edge() {}
edge(int u, int v, X cap) : u(u), v(v), cap(cap), flow(0) {}
};
int N;
vector<edge> E;
vector<vector<int>> g;
vector<int> d, pt;
dinic(int N) : N(N), E(0), g(N), d(N), pt(N) {}
void add_edge(int u, int v, X cap) {
if (u == v) return;
g[u].emplace_back(E.size());
E.emplace_back(edge(u, v, cap));
g[v].emplace_back(E.size());
E.emplace_back(edge(v, u, 0));
}
bool bfs(int S, int T) {
fill(d.begin(), d.end(), N + 1);
int qf = 0, qb = 1;
d[S] = 0;
pt[0] = S;
while (qf != qb) {
int u = pt[qf++];
if (u == T) break;
for (int k : g[u]) {
edge &e = E[k];
if (e.flow < e.cap && d[e.v] > d[e.u] + 1) {
d[e.v] = d[e.u] + 1;
pt[qb++] = e.v;
}
}
}
return d[T] != N + 1;
}
X dfs(int u, int T, X flow = -1) {
if (u == T || !flow) return flow;
for (int &i = pt[u]; i < (int)g[u].size(); ++i) {
edge &e = E[g[u][i]];
edge &oe = E[g[u][i] ^ 1];
if (d[e.v] == d[e.u] + 1) {
X amt = e.cap - e.flow;
if (flow != -1 && amt > flow) amt = flow;
if (X pushed = dfs(e.v, T, amt)) {
e.flow += pushed;
oe.flow -= pushed;
return pushed;
}
}
}
return 0;
}
X flow(int S, int T) {
X tot = 0;
while (bfs(S, T)) {
fill(pt.begin(), pt.end(), 0);
while (X flow = dfs(S, T)) tot += flow;
}
return tot;
}
};
map<int, int> factor(int n) {
map<int, int> ans;
for (int i = 2; i * i <= n; ++i) {
int pw = 0;
while (n % i == 0) {
++pw;
n /= i;
}
if (pw) ans[i] = pw;
}
if (n != 1) ans[n] = 1;
return ans;
}
vector<map<int, int>> A, B;
vector<int> before_a, before_b;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
int flow_left = 0, flow_right = 0;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
if (i % 2 == 0) {
A.push_back(factor(a));
flow_left += A.back().size();
} else {
B.push_back(factor(a));
flow_right += B.back().size();
}
}
dinic<long long> d(2 + flow_left + flow_right);
before_a.push_back(0);
for (int i = 0; i < (int)A.size(); ++i) {
before_a.push_back(before_a.back());
for (auto &x : A[i]) {
d.add_edge(0, ++before_a.back(), x.second);
}
}
before_b.push_back(flow_left);
for (int i = 0; i < (int)B.size(); ++i) {
before_b.push_back(before_b.back());
for (auto &x : B[i]) {
d.add_edge(++before_b.back(), 1 + flow_left + flow_right, x.second);
}
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
if (b % 2 == 0) swap(a, b);
a /= 2;
b /= 2;
int a_loc = 1;
for (auto x : A[a]) {
int b_loc = 1;
for (auto y : B[b]) {
if (x.first == y.first) {
d.add_edge(before_a[a] + a_loc, before_b[b] + b_loc,
min(x.second, y.second));
}
++b_loc;
}
++a_loc;
}
}
cout << d.flow(0, 1 + flow_left + flow_right) << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a, b;
scanf("%c%c", &a, &b);
int count = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i - 1 != 0 || j - 1 != 0) {
if (((a + (i - 1) <= 'h') && (a + (i - 1) >= 'a')) &&
((b + (j - 1) <= '8') && (b + (j - 1) >= '1'))) {
count++;
}
}
}
}
printf("%d\n", count);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)3e5 + 5;
const long long LINF = (long long)1e18;
long long fenw[MAXN << 2];
long long t[MAXN << 2], ext[MAXN << 2];
array<int, 3> que[MAXN];
pair<int, int> knight[MAXN];
int cnt[MAXN];
int n, m, q;
vector<int> pts;
void build(int v, int tl, int tr) {
t[v] = -LINF;
ext[v] = 0;
if (tl != tr) {
int c1 = (v << 1), c2 = (c1 | 1);
int mid = (tl + tr) >> 1;
build(c1, tl, mid);
build(c2, mid + 1, tr);
}
}
void push(int v, int tl, int tr) {
if (tl != tr) {
t[v] += ext[v];
if (tl != tr) {
int c1 = (v << 1), c2 = (c1 | 1);
ext[c1] += ext[v];
ext[c2] += ext[v];
}
ext[v] = 0;
}
}
long long query(int v, int tl, int tr, int l, int r) {
push(v, tl, tr);
if (l > r || tl > r || tr < l) {
return -LINF;
}
if (l <= tl && tr <= r) {
return t[v] + ext[v];
}
int mid = (tl + tr) >> 1;
int c1 = (v << 1), c2 = (c1 | 1);
return max(query(c1, tl, mid, l, r), query(c2, mid + 1, tr, l, r));
}
void update(int v, int tl, int tr, int l, int r, int x) {
push(v, tl, tr);
if (l > r || tl > r || tr < l) {
return;
}
if (l <= tl && tr <= r) {
ext[v] += x;
push(v, tl, tr);
return;
}
int mid = (tl + tr) >> 1;
int c1 = (v << 1), c2 = (c1 | 1);
update(c1, tl, mid, l, r, x);
update(c2, mid + 1, tr, l, r, x);
t[v] = max(t[c1] + ext[c1], t[c2] + ext[c2]);
}
void toggle(int v, int tl, int tr, int p, int x) {
push(v, tl, tr);
if (tl == tr) {
cnt[tl] += x;
if (cnt[tl] == 0) {
t[v] = -LINF;
} else {
t[v] = pts[tl];
}
return;
}
int mid = (tl + tr) >> 1;
int c1 = (v << 1), c2 = (c1 | 1);
if (p <= mid) {
toggle(c1, tl, mid, p, x);
push(c2, mid + 1, tr);
} else {
toggle(c2, mid + 1, tr, p, x);
push(c1, tl, mid);
}
t[v] = max(t[c1] + ext[c1], t[c2] + ext[c2]);
}
void fenwUpd(int p, long long x) {
for (; p < m; p |= (p + 1)) {
fenw[p] += x;
}
}
long long fenwPref(int p) {
long long ret = 0;
for (; p >= 0; --p) {
ret += fenw[p];
p &= (p + 1);
}
return ret;
}
long long fenwSeg(int l, int r) { return fenwPref(r) - fenwPref(l - 1); }
void solve() {
cin >> q;
for (int i = (1); i < (q + 1); ++i) {
char tp;
cin >> tp;
if (tp == '+') {
int t, d;
cin >> t >> d;
que[i] = {1, t, d};
pts.push_back(t);
} else if (tp == '-') {
int id;
cin >> id;
que[i] = {2, id, -1};
} else {
int t;
cin >> t;
pts.push_back(t);
que[i] = {3, t, -1};
}
}
sort((pts).begin(), (pts).end());
pts.resize(unique((pts).begin(), (pts).end()) - pts.begin());
m = (int)(pts).size();
build(1, 0, m - 1);
vector<pair<int, int> > arr;
for (int i = (1); i < (q + 1); ++i) {
int tp = que[i][0];
if (tp == 1) {
int t = que[i][1], d = que[i][2];
int pos = lower_bound((pts).begin(), (pts).end(), t) - pts.begin();
toggle(1, 0, m - 1, pos, 1);
update(1, 0, m - 1, 0, pos, d);
fenwUpd(pos, d);
} else if (tp == 2) {
int id = que[i][1];
int t = que[id][1], d = que[id][2];
int pos = lower_bound((pts).begin(), (pts).end(), t) - pts.begin();
fenwUpd(pos, -d);
toggle(1, 0, m - 1, pos, -1);
update(1, 0, m - 1, 0, pos, -d);
} else {
int t = que[i][1];
int pos = lower_bound((pts).begin(), (pts).end(), t) - pts.begin();
long long ans = query(1, 0, m - 1, 0, pos);
ans -= fenwSeg(pos + 1, m - 1);
cout << max(0ll, ans - t) << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int arr[t];
for (int i = 0; i < t; i++) {
cin >> arr[i];
}
int max = *max_element(arr, arr + t);
int ans = 0;
for (int i = 0; i < t; i++) {
ans += (max - arr[i]);
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, x;
cin >> q >> x;
unordered_map<int, int> mp;
int ans = 0;
int temp = 0, itr = 1;
while (q--) {
int a;
cin >> a;
a = a % x;
mp[a]++;
while (mp[temp] >= itr) {
temp = (temp + 1) % x;
ans++;
if (temp == 0) {
itr++;
}
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("in.in");
ofstream fout("out.out");
const int N = 1e5 + 10;
long long n, m, a[N], bit[N][40], pw[40], node[N << 2], s[40], l[N], r[N], x[N];
void buildTree(int s, int e, int tag) {
if (s + 1 == e) {
node[tag] = a[s];
return;
}
int mid = (s + e) >> 1;
buildTree(s, mid, tag * 2);
buildTree(mid, e, tag * 2 + 1);
node[tag] = (node[tag * 2] & node[tag * 2 + 1]);
}
long long getAnd(int s, int e, int tag, int l, int r) {
if (s >= r || e <= l) return pw[30] - 1;
if (s >= l && e <= r) return node[tag];
int mid = (s + e) >> 1;
return (getAnd(s, mid, tag * 2, l, r) & getAnd(mid, e, tag * 2 + 1, l, r));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
pw[0] = 1;
for (int i = 1; i <= 30; i++) pw[i] = pw[i - 1] << 1;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i] >> x[i];
l[i]--;
for (int j = 0; j < 30; j++) {
bit[l[i]][j] += (x[i] & pw[j]);
bit[r[i]][j] -= (x[i] & pw[j]);
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < 30; j++) {
s[j] += bit[i][j];
if (s[j]) a[i] |= pw[j];
}
buildTree(0, n, 1);
for (int i = 0; i < m; i++)
if (getAnd(0, n, 1, l[i], r[i]) != x[i]) return (cout << "NO"), 0;
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << a[i] << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, D;
int P[200010], S[200010];
int main() {
scanf("%d%d", &N, &D);
for (int i = 0; i < N; i++) scanf("%d", &S[i]);
for (int i = 0; i < N; i++) scanf("%d", &P[i]);
S[D - 1] = S[D - 1] + P[0];
int ct = 0;
for (int i = 0; i < D - 1; i++)
if (S[i] + P[N - ct - 1] <= S[D - 1]) ct++;
printf("%d\n", D - ct);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, a, b, k;
scanf("%d %d", &n, &a);
if (n * a >= 180 * (n - 2))
puts("1 2 3");
else {
b = n * a % 180;
k = n * a / 180;
if (!k)
puts("2 1 3");
else if (b <= 90)
printf("2 1 %d", k + 2);
else
printf("2 1 %d", k + 3);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> searchAns(long long n, long long a, long long b) {
long long minDiff = 1000000000;
long long x, y;
x = y = -1;
for (long long i = 0; i < 100000; i++) {
long long l = i;
long long r = 1000000000;
while (l <= r) {
long long mid = l + (r - l) / 2;
long long diff = (a + i) * (b + mid) - n;
if (diff >= 0) {
if (minDiff > diff) {
minDiff = diff;
x = i;
y = mid;
}
r = mid - 1;
} else {
l = mid + 1;
}
}
}
for (long long i = 0; i < 100000; i++) {
long long l = i;
long long r = 1000000000;
while (l <= r) {
long long mid = l + (r - l) / 2;
long long diff = (a + mid) * (b + i) - n;
if (diff >= 0) {
if (minDiff > diff) {
minDiff = diff;
x = mid;
y = i;
}
r = mid - 1;
} else {
l = mid + 1;
}
}
}
return make_pair(a + x, b + y);
}
int main() {
ios_base::sync_with_stdio(false);
long long n, a, b;
cin >> n >> a >> b;
if (a * b >= 6 * n) {
cout << a * b << endl;
cout << a << " " << b;
return 0;
}
pair<long long, long long> finalPair = searchAns(6 * n, a, b);
cout << finalPair.first * finalPair.second << endl;
cout << finalPair.first << " " << finalPair.second;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int tt = 1;
while (tt--) {
long long int n;
cin >> n;
long long int a[n], i;
for (i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << "1 1\n0\n1 1\n0\n1 1\n" << (-a[0]) << "\n";
} else {
cout << "1 1\n" << (-a[0]) << "\n1 " << n << "\n0 ";
for (i = 1; i < n; i++) cout << (-a[i]) * n << " ";
cout << "\n2 " << n << "\n";
for (i = 1; i < n; i++) cout << (n - 1) * a[i] << " ";
}
}
}
| 4 |
#include <bits/stdc++.h>
const int maxn = 11;
using namespace std;
int XYlen[maxn][maxn][maxn][maxn], ans;
int main() {
int x, y, r, c, n, k;
scanf("%d%d%d%d", &r, &c, &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
for (int i = 1; i <= x; i++)
for (int o = 1; o <= y; o++)
for (int j = x; j <= r; j++)
for (int z = y; z <= c; z++) XYlen[i][j][o][z]++;
}
for (x = 1; x <= r; x++)
for (y = 1; y <= c; y++)
for (int nx = x; nx <= r; nx++)
for (int ny = y; ny <= c; ny++)
if (XYlen[x][nx][y][ny] >= k) ans++;
printf("%d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long parent[1001];
long long num_nodes[1001];
long long n, m, k, w;
vector<pair<long long, pair<long long, long long> > > graph;
char s[11][11][1001];
long long d[1001][1001];
vector<long long> adj[1001];
bool v[1001];
void dfs(long long x) {
v[x] = true;
for (int i = 0; i < adj[x].size(); i++) {
if (!v[adj[x][i]]) {
cout << adj[x][i] << " " << x << "\n";
dfs(adj[x][i]);
}
}
return;
}
long long counter(int x, int y) {
long long sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j][x] != s[i][j][y]) sum++;
}
}
return sum;
}
void intialize() {
for (int i = 0; i <= k; i++) parent[i] = i, num_nodes[i] = 0;
}
long long find(long long x) {
if (parent[x] == x) return x;
return parent[x] = find(parent[x]);
}
bool sameset(long long i, long long j) { return find(i) == find(j); }
void connect(long long from, long long to) {
long long pf = find(from);
long long pt = find(to);
if (num_nodes[pf] == num_nodes[pt]) {
parent[pt] = pf;
num_nodes[pf]++;
} else if (num_nodes[pf] > num_nodes[pt])
parent[pt] = pf;
else
parent[pf] = pt;
return;
}
long long kruskal() {
long long sum = 0;
intialize();
sort(graph.begin(), graph.end());
for (int i = 0; i < graph.size(); i++) {
pair<long long, pair<long long, long long> > x = graph[i];
if (!sameset(x.second.first, x.second.second)) {
sum += x.first;
connect(x.second.first, x.second.second);
adj[x.second.second].push_back(x.second.first);
adj[x.second.first].push_back(x.second.second);
}
}
return sum;
}
int main() {
cin >> n >> m >> k >> w;
for (int l = 1; l <= k; l++)
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> s[i][j][l];
for (int i = 1; i <= k; i++) {
graph.push_back(make_pair(n * m, make_pair(i, 0)));
for (int j = i + 1; j <= k; j++) {
d[i][j] = counter(i, j);
graph.push_back(make_pair(w * (d[i][j]), make_pair(i, j)));
}
}
cout << kruskal() << "\n";
dfs(0);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 100;
const int M = 1e9 + 7;
long long mod(long long x) { return ((x % M + M) % M); }
long long add(long long a, long long b) { return mod(mod(a) + mod(b)); }
long long mul(long long a, long long b) { return mod(mod(a) * mod(b)); }
long long modPow(long long a, long long b) {
if (b == 0) return 1LL;
if (b == 1) return a % M;
long long res = 1;
while (b) {
if (b % 2 == 1) res = mul(res, a);
a = mul(a, a);
b = b / 2;
}
return res;
}
long long inv(long long x) { return modPow(x, M - 2); }
long long divide(long long a, long long b) { return mul(a, inv(b)); }
long long sumofdigits(long long n) {
if (n < 10) return n;
long long digit = 0;
long long sum = 0;
while (n > 0) {
digit = n % 10;
sum = sum + digit;
n = n / 10;
}
return sum;
}
long long modex(long long x, long long y, long long n) {
if (y == 0) return 1;
if (y % 2 == 0) {
long long half_number = modex(x, y / 2, n);
return (half_number * half_number) % n;
} else {
long long half_number = modex(x, y / 2, n);
half_number = (half_number * half_number) % n;
half_number = (half_number * x) % n;
return half_number;
}
}
vector<long long> createsieve(long long n) {
vector<long long> primes;
vector<long long> sieve(n + 1);
for (long long i = 2; i * i <= n; i++) {
if (sieve[i] == 0) {
for (long long j = i * i; j <= n; j += i) {
sieve[j] = 1;
}
}
}
for (long long i = 2; i <= n; i++) {
if (sieve[i] == 0) {
primes.push_back(i);
}
}
return primes;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
bool isPalindrome(string s, int l, int r) {
if (l >= r) return true;
if (s[l] != s[r]) {
return false;
}
return isPalindrome(s, l + 1, r - 1);
}
long long getonebits(long long n) {
long long count = 0;
while (n != 0) {
n = n & (n - 1);
count++;
}
return count;
}
long long fact(long long n) {
if (n == 0) return 1;
return n * fact(n - 1);
}
long long inv(long long a, long long m) {
long long m0 = m, t, q;
long long x0 = 0, x1 = 1;
if (m == 1) return 0;
while (a > 1) {
q = a / m;
t = m;
m = a % m, a = t;
t = x0;
x0 = x1 - q * x0;
x1 = t;
}
if (x1 < 0) x1 += m0;
return x1;
}
long long crt(long long num[], long long rem[], long long k) {
long long prod = 1;
for (long long i = 0; i < k; i++) prod *= num[i];
long long result = 0;
for (long long i = 0; i < k; i++) {
long long pp = prod / num[i];
result += rem[i] * inv(pp, num[i]) * pp;
}
return result % prod;
}
long long nCr(long long n, long long r) {
return fact(n) / (fact(n - r) * fact(r));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
char s[n];
if (n == 1) {
cout << -1 << "\n";
continue;
}
s[n - 1] = '3';
s[n - 2] = '8';
for (long long i = n - 3; i >= 0; i--) {
s[i] = '3';
}
for (long long i = 0; i < n; i++) {
cout << s[i];
}
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, k, ans, p = 0;
int a[200010];
int main() {
scanf("%d%d", &n, &k);
n--;
ans = 2 * (n / k);
if ((n % k) >= 2)
ans += 2;
else if ((n % k) == 1)
ans++;
printf("%d\n", ans);
int br = 1;
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= (n / k); j++) {
br++;
if (j == 1)
printf("1 %d\n", br);
else
printf("%d %d\n", br - 1, br);
if (j == (n / k)) a[++p] = br;
}
}
for (int i = 1; i <= (n % k); i++) {
br++;
printf("%d %d\n", a[i], br);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.);
const long long INF = 1000 * 1000 * 1000 + 1;
const long long MOD = 1000 * 1000 * 1000 + 7;
vector<int> resp(15);
int bin1(int n, int prev, string& s) {
int l = 0, r = n, cur, cntPrev = 0;
while (r - l > 1) {
int mid = l + (r - l) / 2;
string cp(s);
int cnt = 0;
for (int i = l; i < mid; ++i) {
cp[i] = '1';
++cnt;
}
cout << "? " << cp << endl;
fflush(stdout);
cin >> cur;
if (cur - prev == cnt) {
l = mid;
} else {
r = mid;
}
}
return l;
}
int bin0(int n, int prev, string& s) {
int l = 0, r = n, cur;
while (r - l > 1) {
int mid = l + (r - l) / 2;
string cp(s);
int cnt = 0;
for (int i = l; i < mid; ++i) {
cp[i] = '1';
++cnt;
}
cout << "? " << cp << endl;
fflush(stdout);
cin >> cur;
if (prev - cur == cnt) {
l = mid;
} else {
r = mid;
}
}
return l;
}
int main() {
int n;
cin >> n;
string guess(n, '0');
cout << "? " << guess << endl;
fflush(stdout);
cin >> resp[0];
guess[0] = '1';
cout << "? " << guess << endl;
fflush(stdout);
cin >> resp[1];
vector<int> pos(2, -1);
int need;
if (resp[1] > resp[0]) {
pos[0] = 0;
guess[0] = '0';
pos[1] = bin1(n, resp[0], guess);
} else {
pos[1] = 0;
guess[0] = '0';
pos[0] = bin0(n, resp[0], guess);
}
cout << "! " << pos[0] + 1 << " " << pos[1] + 1 << endl;
fflush(stdout);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
int main() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << "-1\n";
} else {
for (int i = (0); i < (n); i++) cout << i << " ";
cout << endl;
for (int i = (1); i < (n); i++) cout << i << " ";
cout << "0 \n";
for (int i = 1; i < n; i += 2) cout << i << " ";
for (int i = 0; i < n; i += 2) cout << i << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.14159265358979323;
const long long int linf = 1000111000111000111LL;
const long long int inf = 1011111111;
const long long int N = 100005;
bool cmp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.first == b.first)
return a.second > b.second;
else
return a.first < b.first;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int test;
cin >> test;
while (test--) {
long long int n, k;
cin >> n >> k;
long long int arr[n];
for (long long int i = 0; i < n; i++) cin >> arr[i];
long long int cnt = 0;
long long int id = 0;
for (long long int i = 1; i < k - 1; i++) {
if (arr[i] > arr[i - 1] and arr[i] > arr[i + 1]) cnt++;
}
vector<pair<long long int, long long int> > v1;
v1.push_back({cnt, id});
for (long long int i = k; i < n; i++) {
long long int pl = i - k + 1;
if (arr[pl] > arr[pl - 1] and arr[pl] > arr[pl + 1]) cnt--;
long long int p2 = i - 1;
if (arr[p2] > arr[p2 - 1] and arr[p2] > arr[p2 + 1]) cnt++;
id++;
v1.push_back({cnt, id});
}
sort((v1).begin(), (v1).end(), cmp);
long long int len = (long long int)(v1).size();
cout << v1[len - 1].first + 1 << " " << v1[len - 1].second + 1 << "\n";
}
cerr << '\n'
<< "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n";
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.