solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e3 + 10;
int main() {
int a, b;
cin >> a >> b;
int n = a - b;
if (n < 0) {
cout << 0;
return 0;
}
if (n == 0) {
cout << "infinity";
return 0;
}
vector<int> dvs;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
dvs.push_back(i);
if (i * i != n) dvs.push_back(n / i);
}
}
sort(dvs.begin(), dvs.end());
int fst = upper_bound(dvs.begin(), dvs.end(), b) - dvs.begin();
cout << dvs.size() - fst;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string s0, s1, s2, s3;
vector<vector<unsigned long long>> matrix(100001,
vector<unsigned long long>(5, 0));
int q, x, a0, a1, a2, a3;
unsigned long long k;
void precompute() {
matrix[0][4] = a0;
for (int i = 1; i <= 100000; i++) {
matrix[i][0] = a1;
matrix[i][1] = matrix[i - 1][4] + matrix[i][0];
matrix[i][2] = matrix[i][1] + a2;
matrix[i][3] = matrix[i - 1][4] + matrix[i][2];
matrix[i][4] = matrix[i][3] + a3;
}
}
char Find(int x, unsigned long long k) {
if (x == 0) {
if (k > s0.size())
return '.';
else
return s0[k - 1];
}
if (k > matrix[x][4]) return '.';
if (k <= matrix[x][0]) return s1[k - 1];
if (k <= matrix[x][1]) return Find(x - 1, k - matrix[x][0]);
if (k <= matrix[x][2]) return s2[k - matrix[x][1] - 1];
if (k <= matrix[x][3]) return Find(x - 1, k - matrix[x][2]);
return s3[k - matrix[x][3] - 1];
}
int main() {
s0 = "What are you doing at the end of the world? Are you busy? Will you "
"save us?";
s1 = "What are you doing while sending \"";
s2 = "\"? Are you busy? Will you send \"";
s3 = "\"?";
a0 = s0.size();
a1 = s1.size();
a2 = s2.size();
a3 = s3.size();
precompute();
cin >> q;
while (q--) {
cin >> x >> k;
cout << Find(x, k);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
long long x, y, idx;
pt operator+(pt p) { return {x + p.x, y + p.y}; }
pt operator-(pt p) { return {x - p.x, y - p.y}; }
bool operator==(pt p) { return (idx == p.idx); }
};
pt p[12333];
long double dis(pt a, pt b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
int main() {
int n, m;
cin >> n >> m;
int k = 0;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
if ((i > 3 and i < n - 3) or (j > 3 and j < m - 3)) continue;
p[k] = {i, j, k};
k++;
}
}
long double mx = 0;
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
for (int ii = 0; ii < k; ii++) {
for (int jj = 0; jj < k; jj++) {
if (i == j or i == ii or i == jj or j == ii or j == jj or ii == jj)
continue;
mx = max(mx, dis(p[i], p[j]) + dis(p[j], p[ii]) + dis(p[ii], p[jj]));
}
}
}
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
for (int ii = 0; ii < k; ii++) {
for (int jj = 0; jj < k; jj++) {
if (i == j or i == ii or i == jj or j == ii or j == jj or ii == jj)
continue;
if ((fabs(mx - (dis(p[i], p[j]) + dis(p[j], p[ii]) +
dis(p[ii], p[jj]))) < 1e-6)) {
cout << p[i].x << " " << p[i].y << endl;
cout << p[j].x << " " << p[j].y << endl;
cout << p[ii].x << " " << p[ii].y << endl;
cout << p[jj].x << " " << p[jj].y << endl;
return 0;
}
}
}
}
}
return 0;
}
| 10 |
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
#define int long long
using namespace std;
void solve()
{
int n,m;
string s,t;
cin>>n>>m;
cin>>s>>t;
//try to maximise the difference between some element
//iterate over all the positions to find the maximum
//at a position if we want it to be maximum then all entries from 1 to pos must be filled as early as
//possible and from pos+1 to m as late as possible. we can find this greedily
vector<int>first(m),last(m);
int idx=0;
for(int i=0;i<n;i++)
{
if(s[i]==t[idx])
{
first[idx]=i;
idx++;
}
}
idx=(m-1);
for(int i=(n-1);i>=0;i--)
{
if(s[i]==t[idx])
{
last[idx]=i;
idx--;
}
}
int ans=0;
for(int i=0;i<(m-1);i++)
{
ans=max(ans,last[i+1]-first[i]);
}
cout<<ans<<"\n";
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t=1;
//cin>>t;
while(t--)
solve();
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 710;
long long a[512345], mark[N + 9];
vector<pair<long long, int> > v[N + 9];
void build(int n) {
for (int i = 0; i < n; i++) {
v[i / N].push_back(make_pair(a[i], i));
}
int R = (n - 1) / N;
for (int i = 0; i <= R; i++) {
sort(v[i].begin(), v[i].end());
}
}
void update(int l, int r, long long q, int n) {
int L = l / N, R = r / N;
for (int i = L; i <= R; i++) {
if (i * N >= l && i * N + N - 1 <= r) {
mark[i] += q;
} else {
v[i].clear();
for (int j = i * N; j < i * N + N; j++) {
if (j >= n) break;
a[j] += mark[i];
if (j >= l && j <= r) a[j] += q;
v[i].push_back(make_pair(a[j], j));
}
mark[i] = 0;
sort(v[i].begin(), v[i].end());
}
}
}
long long gao(long long n, long long y) {
int R = (n - 1) / N;
int Min = n + 99, Max = -2;
vector<pair<long long, int> >::iterator it;
for (int i = 0; i <= R; i++) {
it = lower_bound(v[i].begin(), v[i].end(), make_pair(y - mark[i], -2));
if (it != v[i].end()) {
long long val = (*it).first;
int id = (*it).second;
if (val == y - mark[i]) {
Min = min(id, Min);
Max = max(id, Max);
}
}
it = upper_bound(v[i].begin(), v[i].end(), make_pair(y + 1 - mark[i], -2));
if (it != v[i].begin()) {
it--;
long long val = (*it).first;
int id = (*it).second;
if (val == y - mark[i]) {
Min = min(id, Min);
Max = max(id, Max);
}
}
}
if (Min == n + 99) {
return -1;
}
return Max - Min;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
build(n);
while (m--) {
int op;
scanf("%d", &op);
if (op == 1) {
int l, r, x;
scanf("%d%d%d", &l, &r, &x);
l--;
r--;
update(l, r, x, n);
} else {
long long y;
scanf("%I64d", &y);
printf("%d\n", gao(n, y));
}
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 5;
const int maxh = 10;
short rg[maxn][maxn], dw[maxn][maxn], mm[maxn], d[maxn][maxn][maxh][maxh];
int a[maxn][maxn];
int rmq(int x1, int y1, int x2, int y2) {
int k1 = mm[x2 - x1 + 1], k2 = mm[y2 - y1 + 1];
return max(max(d[x1][y1][k1][k2], d[x1][y2 - (1 << k2) + 1][k1][k2]),
max(d[x2 - (1 << k1) + 1][y1][k1][k2],
d[x2 - (1 << k1) + 1][y2 - (1 << k2) + 1][k1][k2]));
}
int main() {
mm[0] = -1;
for (int i = 1; i < maxn; ++i)
mm[i] = (i & (i - 1)) ? mm[i - 1] : mm[i - 1] + 1;
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
scanf("%d", &a[i][j]);
}
}
for (int i = n; i > 0; --i) {
for (int j = m; j > 0; --j) {
if (a[i][j]) {
rg[i][j] = rg[i][j + 1] + 1;
dw[i][j] = dw[i + 1][j] + 1;
d[i][j][0][0] = d[i + 1][j + 1][0][0] + 1;
d[i][j][0][0] = min(d[i][j][0][0], min(rg[i][j], dw[i][j]));
}
}
}
for (int i = 1; i <= n; ++i) {
for (int k = 1; (1 << k) <= m; ++k) {
for (int j = 1; j + (1 << k) - 1 <= m; ++j)
d[i][j][0][k] =
max(d[i][j][0][k - 1], d[i][j + (1 << (k - 1))][0][k - 1]);
}
}
for (int l = 1; (1 << l) <= n; ++l) {
for (int i = 1; i + (1 << l) - 1 <= n; ++i) {
for (int k = 0; (1 << k) <= m; ++k) {
for (int j = 1; j + (1 << k) - 1 <= m; ++j)
d[i][j][l][k] =
max(d[i][j][l - 1][k], d[i + (1 << (l - 1))][j][l - 1][k]);
}
}
}
int q;
scanf("%d", &q);
while (q--) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
int l = 0, r = min(x2 - x1, y2 - y1) + 1;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (rmq(x1, y1, x2 - mid + 1, y2 - mid + 1) >= mid)
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
long long inv[100010], fac[100010], p[100010], t[100010][20];
int n, l, r, P, tot, Phi;
int phi(int k) {
int i, s;
s = k;
for (i = 2; i * i <= k; i++) {
if (k % i == 0) s = s / i * (i - 1);
while (k % i == 0) k /= i;
}
if (k > 1) s = s / k * (k - 1);
return s;
}
long long qpow(long long a, long long b, long long mod) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
b >>= 1;
a = a * a % mod;
}
return res;
}
void init() {
long long x = P;
Phi = phi(P);
for (int i = 2; (long long)i * i <= x; i++) {
if (x % i) continue;
while (x % i == 0) x /= i;
p[++tot] = i;
}
if (x > 1) p[++tot] = x;
inv[0] = inv[1] = 1;
fac[0] = fac[1] = 1;
for (int i = 2; i < 100010; i++) {
x = i;
for (int j = 1; j <= tot; j++) {
t[i][j] = t[i - 1][j];
if (x % p[j]) continue;
while (x % p[j] == 0) x /= p[j], t[i][j]++;
}
fac[i] = fac[i - 1] * x % P;
inv[i] = qpow(fac[i], Phi - 1, P);
}
}
long long C(int n, int m) {
long long res = 0;
if (n < m || m < 0) return 0;
if (m == 0) return 1;
res = fac[n] * inv[m] % P * inv[n - m] % P;
for (int i = 1; i <= tot; i++) {
res = res * qpow(p[i], t[n][i] - t[m][i] - t[n - m][i], P) % P;
}
return res;
}
int main() {
scanf("%d%d%d%d", &n, &P, &l, &r);
init();
long long ans = 0;
for (int i = 0; i <= n; i++) {
int m = n - i;
ans =
(ans + C(n, i) * (-C(m, ((m - r - 1) >> 1)) + C(m, (m - l) >> 1)) % P) %
P;
}
printf("%lld\n", ans);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
char S[100005], T[100005];
int N;
int cnt(int x, int y) {
int ret = 0;
while (x < N && y < N) {
if (S[x] != T[y]) {
ret++;
(x < y) ? x++ : y++;
} else
x++, y++;
}
while (x < N) ret++, x++;
while (y < N) ret++, y++;
if (ret <= 1) return 1;
return 0;
}
int main() {
scanf("%d", &N);
int p = 0;
scanf("%s %s", S, T);
if (!strcmp(S, T)) {
printf("%d\n", N + 1);
return 0;
}
for (int i = 0; i < (int)N; i++)
if (S[i] != T[i]) {
p = cnt(i + 1, i) + cnt(i, i + 1);
break;
}
printf("%d\n", p);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long nInf = -1000000000;
const long long pInf = 1000000000;
const long long mod = 1000000007;
int main() {
int a[100][100];
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
}
}
bool isgood[100];
fill(isgood, isgood + 100, false);
vector<int> good;
for (int i = 0; i < n; i++) {
bool isg = true;
for (int j = 0; j < n; j++) {
if (i == j || a[i][j] == 0 || a[i][j] == 2) continue;
isg = false;
}
if (isg) good.push_back(i);
}
printf("%d\n", (int)good.size());
for (int i = 0; i < (int)good.size(); i++) {
printf("%d ", good[i] + 1);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 50;
int a[maxn], b[maxn];
int n, m, k;
vector<int> v;
bool flag;
bool cmp(const int &a, const int &b) { return a > b; }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < m; i++) scanf("%d", b + i);
sort(a, a + n, cmp);
sort(b, b + m, cmp);
flag = false;
for (int i = 0; i < n; i++) {
if (a[i] > b[i]) flag = true;
}
if (flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int R, C;
cin >> R >> C;
vector<string> fld(R);
for (int i = (int)(0); i < (int)(R); ++i) cin >> fld[i];
vector<int> tate(C, 0), yoko(R, 0);
int sum = 0;
for (int i = (int)(0); i < (int)(R); ++i)
for (int j = (int)(0); j < (int)(C); ++j)
if (fld[i][j] == '*') {
sum++;
tate[j]++;
yoko[i]++;
}
for (int i = (int)(0); i < (int)(R); ++i)
for (int j = (int)(0); j < (int)(C); ++j) {
int cosum = tate[j] + yoko[i];
if (fld[i][j] == '*') cosum--;
if (cosum == sum) {
cout << "YES" << endl;
cout << i + 1 << ' ' << j + 1 << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n);
long long sum = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum = sum + a[i];
}
cout << (ceil((double)sum / n) - floor((double)sum / n)) << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, X, Y, a[505][505], u[505][505];
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
char cc[4] = {'R', 'D', 'L', 'U'}, anticc[4] = {'L', 'U', 'R', 'D'};
char ans[3001005];
int ansi;
void fail() {
puts("NO");
exit(0);
}
void dfs(int x, int y) {
if (x <= 0 || x > n || y <= 0 || y > n) return;
if (u[y][x]) return;
u[y][x] = 1;
if (!a[y][x]) {
ans[ansi++] = '1';
a[y][x] = 1;
}
for (int i = 0; i < 4; ++i) {
bool good = false;
int nx = x, ny = y;
while (1) {
nx += dx[i];
ny += dy[i];
if (nx <= 0 || nx > n || ny <= 0 || ny > n) break;
if (a[ny][nx] == 1) {
good = true;
break;
}
}
if (good) {
ans[ansi++] = cc[i];
dfs(x + dx[i], y + dy[i]);
ans[ansi++] = anticc[i];
}
}
a[y][x] = 0;
ans[ansi++] = '2';
}
int main() {
scanf("%d%d%d", &n, &Y, &X);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) scanf("%d", &a[i][j]);
dfs(X, Y);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (a[i][j]) fail();
puts("YES");
puts(ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long long MIN_DIST = 0;
const long long MAX_DIST = 1e18;
const long long MAX_COORD = 1e18;
;
const long long MIN_COORD = -1e18;
bool InnerCheck(const vector<pair<long long, long long>>& x,
const vector<pair<long long, long long>>& prefix,
const vector<pair<long long, long long>>& suffix, int n,
long long maxDist) {
if ((prefix[n - 1].second - prefix[n - 1].first) *
(prefix[n - 1].second - prefix[n - 1].first) <=
maxDist) {
return true;
}
if ((x[n - 1].first - x[0].first) * (x[n - 1].first - x[0].first) <=
maxDist) {
return true;
}
for (int l = 0, r = -1; l < n; ++l) {
r = max(r, l);
while (r + 1 < n &&
(x[r + 1].first - x[l].first) * (x[r + 1].first - x[l].first) <=
maxDist &&
abs(x[r + 1].first) <= abs(x[l].first)) {
++r;
}
while (r - 1 > l && abs(x[r].first) > abs(x[l].first)) {
--r;
}
long long curMaxDist = 0;
long long minYCoord = MAX_COORD;
long long maxYCoord = MIN_COORD;
const auto& update = [&curMaxDist](long long x, long long y) {
curMaxDist = max(curMaxDist, x * x + y * y);
};
if (l != 0) {
update(prefix[l - 1].first, x[l].first);
update(prefix[l - 1].first, x[r].first);
update(prefix[l - 1].second, x[l].first);
update(prefix[l - 1].second, x[r].first);
minYCoord = min(minYCoord, prefix[l - 1].first);
maxYCoord = max(maxYCoord, prefix[l - 1].second);
}
if (r != n - 1) {
update(suffix[r + 1].first, x[l].first);
update(suffix[r + 1].first, x[r].first);
update(suffix[r + 1].second, x[l].first);
update(suffix[r + 1].second, x[r].first);
minYCoord = min(minYCoord, suffix[r + 1].first);
maxYCoord = max(maxYCoord, suffix[r + 1].second);
}
if (minYCoord < maxYCoord) {
curMaxDist =
max(curMaxDist, (maxYCoord - minYCoord) * (maxYCoord - minYCoord));
}
if (curMaxDist <= maxDist) {
return true;
}
}
return false;
}
bool Check(vector<pair<long long, long long>>& x,
vector<pair<long long, long long>>& prefix,
vector<pair<long long, long long>>& suffix, int n,
long long maxDist) {
if (InnerCheck(x, prefix, suffix, n, maxDist)) {
return true;
}
reverse(x.begin(), x.end());
reverse(prefix.begin(), prefix.end());
reverse(suffix.begin(), suffix.end());
bool result = InnerCheck(x, suffix, prefix, n, maxDist);
reverse(x.begin(), x.end());
reverse(prefix.begin(), prefix.end());
reverse(suffix.begin(), suffix.end());
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<pair<long long, long long>> x(n);
for (int i = 0; i < n; ++i) {
cin >> x[i].first >> x[i].second;
}
sort(x.begin(), x.end());
vector<pair<long long, long long>> prefix(n);
vector<pair<long long, long long>> suffix(n);
prefix[0].first = prefix[0].second = x[0].second;
for (int i = 1; i < n; ++i) {
prefix[i] = prefix[i - 1];
prefix[i].first = min(prefix[i].first, x[i].second);
prefix[i].second = max(prefix[i].second, x[i].second);
}
suffix[n - 1].first = suffix[n - 1].second = x[n - 1].second;
for (int i = n - 2; i >= 0; --i) {
suffix[i] = suffix[i + 1];
suffix[i].first = min(suffix[i].first, x[i].second);
suffix[i].second = max(suffix[i].second, x[i].second);
}
long long bl = MIN_DIST;
long long br = MAX_DIST;
long long ba = MAX_DIST;
while (bl <= br) {
long long bm = (bl + br) >> 1;
if (Check(x, prefix, suffix, n, bm)) {
ba = bm;
br = bm - 1;
} else {
bl = bm + 1;
}
}
cout << ba << endl;
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 10, M = 2e5 + 100, MOD = 1e9 + 7, ML = 25;
long long a[M];
set<long long> st;
map<long long, long long> mp;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
st.insert(l);
st.insert(l - 1);
st.insert(r);
st.insert(r + 1);
mp[l]++;
mp[r + 1]--;
}
long long x = 0, la = 0, pl = 0;
for (long long u : st) {
x += mp[u];
a[pl] += u - la;
la = u;
pl = x;
}
for (int i = 1; i <= n; i++) cout << a[i] << " ";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1000 + 5;
const int mod = 1000 * 1000 * 1000 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie();
int n, x;
cin >> n >> x;
if (n == 5) {
cout << ">...v\nv.<..\n..^..\n>....\n..^.<\n1 1\n";
return 0;
}
if (n == 3) {
cout << ">vv\n^<.\n^.<\n1 3\n";
return 0;
}
for (int i = 0; i < 100; i++) {
if (i == 0)
cout << ">";
else
cout << "^";
if (i % 2 == 0) {
cout << string(40, '>');
for (int i = 41; i < 99; i += 2) cout << ".>";
cout << "v";
cout << endl;
} else {
if (i == 99)
cout << "<";
else
cout << "v";
for (int i = 41; i < 99; i += 2) cout << ".<";
cout << string(40, '<');
cout << endl;
}
}
cout << "1 1" << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 18), M = 20;
int n, k, lim, ch[M], st[M], og[N][M];
long long ans[N], sum[N], g[M][N], p[M][N], dp[N][M];
bool fl[M][M];
char s[M];
inline void fwt(long long *s) {
for (int d = 1; d < lim; d = d << 1)
for (int i = 0, r = d << 1; i < lim; i += r)
for (int j = 0; j < d; j++) {
long long a = s[i + j], b = s[i + j + d];
s[i + j] = a, s[i + j + d] = a + b;
}
}
inline void dfs(int u, int c) {
if (ch[0] == n) {
for (int i = 0; i < lim; i++)
if (__builtin_popcount(i) % 2 == n % 2)
sum[c] += p[u - 1][i];
else
sum[c] -= p[u - 1][i];
return;
}
for (int i = max(ch[u - 1], 1); i + ch[0] <= n; i++) {
for (int x = 0; x < lim; x++) p[u][x] = p[u - 1][x] * g[i][x];
ch[0] += i, ch[u] = i, dfs(u + 1, og[c][i] = ++k), ch[0] -= i;
}
}
int main() {
cin >> n, lim = (1 << n);
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
dp[(1 << (i - 1))][i] = 1;
for (int j = 1; j <= n; j++) fl[i][j] = s[j] - 48;
}
for (int i = 1; i < (1 << n); i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++)
if (((1 << (j - 1)) & i) && (!((1 << (k - 1)) & i)) && fl[j][k])
dp[i | (1 << (k - 1))][k] += dp[i][j];
for (int i = 1; i < (1 << n); i++)
for (int j = 1; j <= n; j++) g[__builtin_popcount(i)][i] += dp[i][j];
g[0][0] = 1;
for (int i = 0; i <= n; i++) fwt(g[i]);
for (int i = 0; i < lim; i++) p[0][i] = g[0][i];
dfs(1, 0);
for (int i = 0; i < (1 << (n - 1)); i++) {
int x = 1;
st[0] = 0;
for (int j = 1; j < n; j++)
if (i & (1 << (j - 1)))
x++;
else
st[++st[0]] = x, x = 1;
st[++st[0]] = x;
sort(st + 1, st + st[0] + 1);
int u = 0;
for (int j = 1; j <= st[0]; j++) u = og[u][st[j]];
ans[i] = sum[u];
}
for (int i = 0; i < n - 1; ++i)
for (int j = 0; j < 1 << (n - 1); ++j)
if (j >> i & 1) ans[j - (1 << i)] -= ans[j];
for (int i = 0; i < 1 << (n - 1); ++i) printf("%lld ", ans[i]);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int main(int argc, char const *argv[]) {
cin >> n >> k;
vector<long long> v;
for (int i = 1; i <= k + 1; i++) {
cout << "? ";
vector<int> ask;
for (int j = 1; j <= k + 1; j++) {
if (j == i) continue;
ask.push_back(j);
}
for (auto j : ask) {
cout << j << ' ';
}
cout << endl;
int pos;
long long x;
cin >> pos >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
int cnt = 0;
for (auto i : v) {
if (i == v[(int)v.size() - 1]) cnt++;
}
cout << "! " << cnt << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int dp[510], a[510], b[510], f[510];
int main() {
int n, m;
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
memset(dp, 0, sizeof(dp));
memset(f, 0, sizeof(f));
int ans = 0;
for (int i = 1; i <= n; i++) {
int k = 0;
for (int j = 1; j <= m; j++) {
if (a[i] > b[j] && dp[k] < dp[j]) {
k = j;
} else if (a[i] == b[j]) {
dp[j] = dp[k] + 1;
f[j] = k;
}
}
}
int flag = 0;
for (int i = 1; i <= m; i++) {
if (dp[i] > ans) ans = dp[i], flag = i;
}
printf("%d\n", ans);
int c[510], cnt = 0;
while (flag != 0) {
c[cnt++] = flag;
flag = f[flag];
}
for (int i = cnt - 1; i >= 0; i--) printf("%d ", b[c[i]]);
printf("\n");
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int a[1002][1002];
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int c = 0;
for (int i = 0; i < n / 4; i++) {
for (int k = 0; k < n; k++) {
for (int j = 0; j < 4; j++) {
a[k][4 * i + j] = c++;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << a[i][j] << ' ';
}
cout << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct point {
long long x, y;
long long num = 0;
point() { x = 0, y = 0; }
point(long long a, long long b) { x = a, y = b; }
};
struct Vector {
long long x, y;
Vector() { x = 0, y = 0; }
Vector(point a, point b) {
x = b.x - a.x;
y = b.y - a.y;
}
};
long long skal(Vector a, Vector b) { return (a.x * b.x + a.y * b.y); }
long long vect(Vector a, Vector b) { return (a.x * b.y - a.y * b.x); }
bool cmp(const point& a, const point& b) {
if (a.x == b.x) return (a.y < b.y);
return (a.x < b.x);
}
int32_t main() {
long long n;
cin >> n;
vector<point> a(n);
for (long long i = 0; i < n; ++i) {
cin >> a[i].x >> a[i].y;
a[i].num = i;
}
sort(a.begin(), a.end(), cmp);
string s;
cin >> s;
point O = a[0];
vector<long long> used(n);
used[0] = 1;
vector<long long> ans;
ans.push_back(a[0].num);
for (long long i = 0; i < s.size(); ++i) {
long long cur = -1;
if (s[i] == 'L') {
for (long long j = 0; j < n; ++j) {
if (!used[j]) {
if (cur == -1) {
cur = j;
} else {
Vector OB(O, a[cur]);
Vector OC(O, a[j]);
if (vect(OB, OC) < 0) {
cur = j;
}
}
}
}
} else {
for (long long j = 0; j < n; ++j) {
if (!used[j]) {
if (cur == -1) {
cur = j;
} else {
Vector OB(O, a[cur]);
Vector OC(O, a[j]);
if (vect(OB, OC) > 0) {
cur = j;
}
}
}
}
}
if (cur == -1) {
cout << -1;
return 0;
}
ans.push_back(a[cur].num);
used[cur] = 1;
O = a[cur];
}
for (long long i = 0; i < n; ++i) {
if (!used[i]) {
ans.push_back(a[i].num);
}
}
for (auto elem : ans) {
cout << elem + 1 << ' ';
}
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int siz = 1e6 + 5;
const int MOD = 1e9 + 7;
void solve() {
int n;
cin >> n;
int x;
int pos[n + 1], a[n];
for (int i = 0; i < n; i++) {
cin >> x;
pos[x] = i + 1;
a[i] = x;
}
int flag = 0, last = n;
for (int i = 1; i < n; i++) {
if (pos[i] != last) {
if (pos[i + 1] != pos[i] + 1) {
flag = 1;
break;
}
}
if (pos[i] == last) last--;
}
flag = 0;
int i = 0;
while (i < n - 1) {
if (a[i + 1] < a[i])
i++;
else if (a[i + 1] == a[i] + 1)
i++;
else
break;
}
flag = (i == n - 1);
if (flag)
cout << "Yes\n";
else
cout << "No\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[1100000], a[1100000], b[1100000];
int ss[1100000], aa[1100000], bb[1100000];
int p[27], used[27], alp[27];
int len;
int k;
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d", &k);
scanf("%s", s + 1);
scanf("%s", a + 1);
scanf("%s", b + 1);
len = strlen(s + 1);
for (int i = 0; i <= k; i++) p[i] = -1, used[i] = 0, alp[i] = -1;
for (int i = 1; i <= len; i++) {
ss[i] = s[i] - 'a' + 1;
aa[i] = a[i] - 'a' + 1;
bb[i] = b[i] - 'a' + 1;
}
int x;
for (x = 1; x <= len; x++) {
used[ss[x]]++;
if (p[ss[x]] == -1 && alp[aa[x]] == -1) {
p[ss[x]] = aa[x];
alp[aa[x]] = ss[x];
continue;
}
if (p[ss[x]] == aa[x]) continue;
break;
}
if (x <= len) {
int xx = x;
used[ss[xx]]--;
for (; xx > 0; xx--) {
if (p[ss[xx]] > aa[xx]) break;
if (xx != x) {
used[ss[xx]]--;
if (used[ss[xx]] == 0) alp[aa[xx]] = -1, p[ss[xx]] = -1;
}
if (p[ss[xx]] != -1) continue;
int temp = -1;
for (int i = aa[xx] + 1; i <= k; i++) {
if (alp[i] == -1) {
temp = i;
break;
}
}
if (temp == -1) continue;
p[ss[xx]] = temp;
alp[temp] = ss[xx];
break;
}
if (xx == 0) {
printf("NO\n");
continue;
}
for (int i = xx + 1; i <= len; i++) {
if (p[ss[i]] != -1) continue;
for (int j = 1; j <= k; j++)
if (alp[j] == -1) {
p[ss[i]] = j;
alp[j] = ss[i];
break;
}
}
}
for (int i = 1; i <= k; i++) {
if (p[i] == -1) {
for (int j = 1; j <= k; j++) {
if (alp[j] == -1) {
p[i] = j;
alp[j] = i;
break;
}
}
}
}
int flag = 0;
for (int i = 1; i <= len; i++) {
if (p[ss[i]] < bb[i]) break;
if (p[ss[i]] > bb[i]) {
flag = 1;
break;
}
}
if (flag == 1)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i <= k; i++) printf("%c", 'a' + p[i] - 1);
printf("\n");
}
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const double eps = 1e-8;
const int DIM = 110;
int n;
pair<double, double> p[DIM][4];
double ch, ans;
double an[3];
vector<double> vec;
double sqr(double q) { return q * q; }
double dist(pair<double, double> A, pair<double, double> B) {
return sqrt(sqr(A.first - B.first) + sqr(A.second - B.second));
}
double vect(pair<double, double> A, pair<double, double> B) {
return A.first * B.second - A.second * B.first;
}
bool inter(pair<double, double> A, pair<double, double> B,
pair<double, double> C, pair<double, double> D) {
pair<double, double> CA = make_pair(C.first - A.first, C.second - A.second);
pair<double, double> BA = make_pair(B.first - A.first, B.second - A.second);
pair<double, double> DC = make_pair(D.first - C.first, D.second - C.second);
double zn = vect(BA, DC);
if (abs(zn) < eps) return false;
ch = vect(CA, DC);
ch /= zn;
return (-eps < ch && ch < 1 + eps);
}
bool inside(pair<double, double> E, int nn) {
for (int i = (0); i < (n); i++)
if (i != nn) {
for (int j = (0); j < (3); j++) {
pair<double, double> C = p[i][j];
pair<double, double> D = p[i][j + 1];
pair<double, double> DC =
make_pair(D.first - C.first, D.second - C.second);
pair<double, double> EC =
make_pair(E.first - C.first, E.second - C.second);
an[j] = vect(DC, EC);
}
bool g1 = 1, g2 = 1;
for (int j = (0); j < (3); j++) {
if (an[j] < eps) g1 = 0;
if (an[j] > -eps) g2 = 0;
}
if (g1 || g2) return true;
}
return false;
}
void cut(pair<double, double> A, pair<double, double> B, int nn) {
for (int i = (0); i < (n); i++)
if (i != nn) {
for (int j = (0); j < (3); j++) {
pair<double, double> C = p[i][j];
pair<double, double> D = p[i][j + 1];
if (inter(C, D, A, B) && inter(A, B, C, D)) {
vec.push_back(ch);
}
}
}
}
void solve() {
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (3); j++) {
pair<double, double> A = p[i][j];
pair<double, double> B = p[i][j + 1];
vec.clear();
cut(A, B, i);
vec.push_back(0.0);
vec.push_back(1.0);
sort(vec.begin(), vec.end());
for (int it = (0); it < ((int)(vec.size()) - 1); it++) {
pair<double, double> C =
make_pair(A.first + vec[it] * (B.first - A.first),
A.second + vec[it] * (B.second - A.second));
pair<double, double> D =
make_pair(A.first + vec[it + 1] * (B.first - A.first),
A.second + vec[it + 1] * (B.second - A.second));
if (dist(C, D) > eps) {
pair<double, double> E =
make_pair((C.first + D.first) / 2, (C.second + D.second) / 2);
if (!inside(E, i)) {
ans += dist(C, D);
}
}
}
}
}
printf("%.7lf\n", ans);
}
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (3); j++) {
scanf("%lf%lf", &p[i][j].first, &p[i][j].second);
}
p[i][3] = p[i][0];
}
solve();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int n, ex, ey;
int dx[200010], dy[200010];
string s;
int abs(int num) { return num > 0 ? num : -num; }
bool check(int data) {
int need_x, need_y, all;
for (int i = 1; i + data - 1 <= n; i++) {
need_x = ex - (dx[n] - dx[i + data - 1]) - dx[i - 1];
need_y = ey - (dy[n] - dy[i + data - 1]) - dy[i - 1];
all = data - (abs(need_x) + abs(need_y));
if (all >= 0 && all % 2 == 0) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> s;
cin >> ex >> ey;
memset(dx, 0, sizeof(dx));
memset(dy, 0, sizeof(dy));
for (int i = 0; i < n; i++) {
if (s[i] == 'U') {
dx[i + 1] = dx[i];
dy[i + 1] = dy[i] + 1;
} else if (s[i] == 'D') {
dx[i + 1] = dx[i];
dy[i + 1] = dy[i] - 1;
} else if (s[i] == 'L') {
dx[i + 1] = dx[i] - 1;
dy[i + 1] = dy[i];
} else {
dx[i + 1] = dx[i] + 1;
dy[i + 1] = dy[i];
}
}
int l = 0, r = n, flag = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) {
flag = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << flag << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
std::ostream& operator<<(std::ostream& str, const std::vector<T>& v) {
str << "[";
for (auto n : v) str << n << ", ";
str << "]";
return str;
}
const int MOD = 1e9 + 7;
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
long long t, a, b;
cin >> t >> a >> b;
if (t == 1 && a == 1 && b == 1) {
cout << "inf" << endl;
return 0;
}
int constant = (a == b);
bool power = false;
if (t == 1) {
if (a == 1) {
cout << 0 << endl;
return 0;
}
long long apow = a * a;
while (apow <= b) {
if (apow == b) {
power = true;
break;
}
if (apow * a < apow) break;
apow *= a;
}
}
int match = false;
if (a > 1 && (t > 1 || !power)) {
long long tpow = 1;
long long tsum = 0;
while (b) {
long long c = b % a;
tsum += c * tpow;
tpow *= t;
b /= a;
}
match = (tsum == a);
}
cout << match + constant + power << endl;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
long long int tree[1000009];
long long int child[1000009];
long long int rev[20], swa[20];
pair<long long int, long long int> children(long long int v, long long int d) {
pair<long long int, long long int> res = {2 * v, (2 * v) + 1};
if (swa[d] ^ rev[d]) swap(res.first, res.second);
return res;
}
void replace(long long int v, long long int tl, long long int tr,
long long int val, long long int pos, long long int d) {
if (d == 0) {
tree[v] = val;
return;
}
long long int mid = (tl + tr) / 2;
pair<long long int, long long int> ch = children(v, d);
if (pos <= mid)
replace(ch.first, tl, mid, val, pos, d - 1);
else
replace(ch.second, mid + 1, tr, val, pos, d - 1);
tree[v] = tree[(2 * v)] + tree[(2 * v) + 1];
}
void reverse(long long int d) {
for (long long int i = 0; i <= d; i++) {
rev[i] ^= 1;
}
}
void swaping(long long int d) { swa[d + 1] ^= 1; }
long long int query(long long int v, long long int tl, long long int tr,
long long int l, long long int r, long long int d) {
if (l > r) return 0;
if (l == tl && r == tr) return tree[v];
long long int mid = (tl + tr) / 2;
pair<long long int, long long int> ch = children(v, d);
return query(ch.first, tl, mid, l, min(mid, r), d - 1) +
query(ch.second, mid + 1, tr, max(l, mid + 1), r, d - 1);
}
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
void solve() {
long long int n, q;
cin >> n >> q;
long long int len = power(2, n);
long long int x;
for (long long int i = 0; i < len; i++) {
cin >> x;
replace(1, 1, len, x, i + 1, n);
}
long long int y, z;
for (long long int i = 0; i < q; i++) {
cin >> x;
if (x == 1) {
cin >> y >> z;
replace(1, 1, len, z, y, n);
} else if (x == 2) {
cin >> y;
reverse(y);
} else if (x == 3) {
cin >> y;
swaping(y);
} else {
cin >> y >> z;
cout << query(1, 1, len, y, z, n) << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int begtime = clock();
long long int t = 1;
for (long long int i = 0; i < t; i++) {
solve();
}
int endtime = clock();
cerr << "\n\n"
<< "Time elapsed: " << (endtime - begtime) * 1000 / CLOCKS_PER_SEC
<< " ms\n\n";
return 0;
}
| 16 |
#include <bits/stdc++.h>
using lint = int64_t;
constexpr int MOD = int(1e9) + 7;
constexpr int INF = 0x3f3f3f3f;
constexpr int NINF = 0xcfcfcfcf;
constexpr lint LINF = 0x3f3f3f3f3f3f3f3f;
const long double PI = acosl(-1.0);
int cmp_double(double a, double b = 0, double eps = 1e-9) {
return a + eps > b ? b + eps > a ? 0 : 1 : -1;
}
using namespace std;
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
int t_;
cin >> t_;
for (int z = 0; z < t_; z++) {
lint n, m;
cin >> n >> m;
vector<lint> a(n), b(n);
lint cnta = 0, cntb = 0;
lint suma = 0, sumb = 0;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
suma += a[i];
sumb += b[i];
a[i] = min(a[i], m);
b[i] = min(b[i], m);
cnta += a[i];
cntb += b[i];
}
bool sw = 0;
if (suma < sumb) {
swap(a, b);
swap(cnta, cntb);
swap(suma, sumb);
sw = 1;
}
lint d = suma - sumb;
lint aca = min(cnta, (d + n * m) / 2);
lint acb = m * n - aca;
cout << (suma + acb - aca - sumb) << "\n";
for (int i = 0; i < n; i++) {
lint A = (aca + a[i] - cnta);
lint B = min(m - A, b[i]);
A = max(m - B, A);
aca -= A;
cnta -= a[i];
acb -= B;
cntb -= b[i];
if (sw) swap(A, B);
cout << A << " " << B << "\n";
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 1e5 + 7;
vector<int> g[N];
int sz[N], lvl[N];
int cur_sz[N];
bool used[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
if (n < 3) {
cout << "No\n";
return 0;
}
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
vector<int> leaf(n, false);
vector<int> cur;
for (int i = 0; i < n; i++) {
sz[i] = g[i].size();
cur_sz[i] = g[i].size();
if (g[i].size() == 1) {
used[i] = true;
leaf[i] = true;
cur.push_back(i);
}
}
while (true) {
set<int> kek;
for (int v : cur) {
for (int to : g[v]) {
if (used[to]) continue;
if (lvl[to] != 0 && lvl[to] != lvl[v] + 1) {
cout << "No\n";
return 0;
}
lvl[to] = lvl[v] + 1;
cur_sz[to]--;
if (cur_sz[to] == 1) {
kek.insert(to);
}
if (cur_sz[to] != 1 && kek.count(to)) {
kek.erase(to);
}
}
cur_sz[v] = 0;
}
cur.clear();
for (int x : kek) {
used[x] = true;
cur.push_back(x);
}
if (cur.empty()) break;
}
int mx = -1;
int ind = 0;
for (int i = 0; i < n; i++) {
if (lvl[i] > mx) {
ind = i;
}
mx = max(mx, lvl[i]);
}
if (mx != k) {
cout << "No\n";
return 0;
}
for (int i = 0; i < n; i++) {
if (i != ind && lvl[i] == mx) {
cout << "No\n";
return 0;
}
if (leaf[i]) continue;
int need = 4;
need -= (ind == i);
if (sz[i] < need) {
cout << "No\n";
return 0;
}
}
cout << "Yes\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, r, p, s, k;
int x[210], y[210], z[210], ax[9], ay[9], tx[9], ty[9];
void go(int m, int p) {
if (p == n) {
int u = 0;
for (int i = 0; i < n - 1; i++)
for (int j = i + 1; j < n; j++)
u += (tx[i] - tx[j]) * (tx[i] - tx[j]) +
(ty[i] - ty[j]) * (ty[i] - ty[j]);
if (u > s) {
s = u;
for (int i = 0; i < n; i++) ax[i] = tx[i], ay[i] = ty[i];
}
} else
for (int i = m; i < k; i++) {
tx[p] = x[i], ty[p] = y[i];
go(i, p + 1);
}
}
int main() {
int i, j, r1, r2, t;
scanf("%d%d", &n, &r);
r1 = (r - 1) * (r - 1);
r2 = r * r;
k = 0;
for (i = -r; i <= r; i++)
for (j = -r; j <= r; j++) {
t = i * i + j * j;
if (t <= r2 && t > r1) x[k] = i, y[k] = j, z[k++] = t;
}
for (i = 0; i < k - 1; i++)
for (j = i + 1; j < k; j++)
if (z[j] > z[i]) {
swap(x[j], x[i]);
swap(y[j], y[i]);
swap(z[j], z[i]);
}
k = 30 - n * 2;
go(0, 0);
printf("%d\n", s);
for (i = 0; i < n; i++) printf("%d %d\n", ax[i], ay[i]);
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int len;
char s[100005];
stack<int> st;
char ans[100005];
int las[100005];
int main() {
cin >> s;
len = strlen(s);
if (len == 1) {
cout << s << endl;
return 0;
}
int now = 1;
st.push(s[0]);
las[len - 1] = s[len - 1] - 'a';
for (int i = len - 2; i >= 0; i--) {
las[i] = min(las[i + 1], s[i] - 'a');
}
int cnt = 0;
while (1) {
if (now == len) break;
if (st.empty()) {
st.push(s[now++]);
} else if (las[now] < st.top() - 'a') {
st.push(s[now++]);
} else {
ans[cnt++] = st.top();
st.pop();
}
}
while (!st.empty()) {
ans[cnt++] = st.top();
st.pop();
}
ans[cnt] = 0;
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
char s[400100];
int sum = 0, head[400100], a[400100][27];
struct Node {
int to, next;
} e[400100];
int d[400100];
void insert(int u, int v) {
e[++sum].to = v;
e[sum].next = head[u];
head[u] = sum;
d[v]++;
}
stack<int> vec;
void init() {
cin >> n >> m;
cin >> s + 1;
for (int i = 1; i <= n; i++) a[i][s[i] - 'a'] = 1;
for (int i = 1; i <= m; i++) {
int tx, ty;
scanf("%d%d", &tx, &ty);
insert(tx, ty);
}
}
int main() {
init();
int cnt = 0;
for (int i = 1; i <= n; i++)
if (d[i] == 0) vec.push(i);
while (!vec.empty()) {
int v = vec.top();
vec.pop();
for (int i = head[v]; i; i = e[i].next) {
d[e[i].to]--;
if (d[e[i].to] == 0) vec.push(e[i].to);
for (int j = 0; j < 26; j++)
if (j != s[e[i].to] - 'a')
a[e[i].to][j] = max(a[e[i].to][j], a[v][j]);
else
a[e[i].to][j] = max(a[e[i].to][j], a[v][j] + 1);
}
cnt++;
}
if (cnt < n)
cout << -1 << endl;
else {
ans = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j < 26; j++) ans = max(ans, a[i][j]);
cout << ans << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct test {
int test;
int index;
};
bool compareTests(test t1, test t2) { return t1.test < t2.test; }
vector<test> tests, sortedTests;
int total;
void insertTest(test t) {
total += t.test;
tests.push_back(t);
sortedTests.push_back(t);
sort(sortedTests.begin(), sortedTests.end(), compareTests);
}
int getMinN(int ind, int &m) {
int actTotal = total;
int res = 0;
for (int i = sortedTests.size() - 1; i >= 0 && actTotal > m; i--) {
if (sortedTests[i].index != ind) {
actTotal -= sortedTests[i].test;
res++;
}
}
return res;
}
int main() {
int n, m, i, t;
scanf("%d%d", &n, &m);
int arr[101];
scanf("%d", &t);
insertTest({t, 0});
printf("0");
int minN;
for (i = 1; i < n; i++) {
scanf("%d", &t);
insertTest({t, i});
minN = getMinN(i, m);
printf(" %d", minN);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long pos[1000000 + 1000];
long long dis1[1000000 + 1000];
long long dis2[1000000 + 1000];
int cnt;
int ans;
int main() {
scanf("%d %d", &n, &m);
dis2[n - 1] = 0;
for (int i = 0; i < n; i++) scanf("%lld", &pos[i]);
for (int i = 1; i < n; i++) {
if (i % m == 1 || m == 1) cnt++;
dis1[i] = dis1[i - 1] + (pos[i] - pos[i - 1]) * cnt;
dis2[n - 1 - i] = dis2[n - i] + (pos[n - i] - pos[n - 1 - i]) * cnt;
}
long long ans = dis1[0] + dis2[0];
for (int i = 0; i < n; i++) {
long long temp = dis1[i] + dis2[i];
ans = min(temp, ans);
}
printf("%I64d\n", ans * 2);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long low[1000005], dp[1000005][20], sum[20] = {1};
int main() {
long long i, j, r, n, q, ans, cnt, p;
for (i = 2; i <= 1000000; i++)
if (!low[i])
for (j = i; j <= 1000000; j += i) low[j] = i;
for (i = 0; i <= 1000000; i++) dp[i][0] = 1;
for (i = 1; i < 20; i++) {
dp[0][i] = 2;
sum[i] = sum[i - 1] + dp[0][i];
}
for (i = 1; i <= 1000000; i++) {
for (j = 1; j < 20; j++) {
dp[i][j] = sum[j];
sum[j] = (sum[j - 1] + dp[i][j]) % 1000000007;
}
}
scanf("%lld", &q);
while (q--) {
scanf("%lld%lld", &r, &n);
ans = 1;
while (n != 1) {
cnt = 0, p = low[n];
while (n % p == 0) {
cnt++;
n /= p;
}
ans = ans * dp[r][cnt] % 1000000007;
}
cout << ans << endl;
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int n, pt, k, ans;
struct in {
int ind, val;
} d[155];
struct compare {
bool operator()(in a, in b) { return a.val < b.val; }
};
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &d[i].val);
d[i].ind = i + 1;
}
sort(d, d + n, compare());
for (int i = 0; i < n; i++) {
pt += d[i].val;
if (pt > k) break;
ans++;
}
printf("%d\n", ans);
for (int i = 0; i < ans; i++)
printf("%d%s", d[i].ind, i == ans - 1 ? "\n" : " ");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a, w, h, t, p;
double x;
int gcd(int u, int v) { return u % v == 0 ? v : gcd(v, u % v); }
int main() {
scanf("%d%d%d", &a, &h, &w);
h += a, w += a, t = gcd(h, w);
if (t < a || h < a + a || w < a + a)
printf("-1");
else {
p = t / a;
x = t * 1.0000000000 / p - a, printf("%lf", x);
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 55, inf = 111111111;
int n, m, k, napr, dp[max_n][max_n][2], cnt[222];
string q;
vector<int> v1, v2;
int main() {
scanf("%d%d%d\n", &n, &m, &k);
getline(cin, q);
if (q == "to head") {
napr = 0;
} else {
napr = 1;
}
cin >> q;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
for (int f = 0; f < 2; ++f) {
if (f == 0) {
if (i == j) {
dp[i][j][f] = 0;
} else {
if (i < j) {
dp[i][j][f] = j - 1;
} else {
dp[i][j][f] = j + n - 2;
}
}
} else {
if (i == j) {
dp[i][j][f] = 0;
} else {
if (i > j) {
dp[i][j][f] = n - j;
} else {
dp[i][j][f] = 2 * n - j - 1;
}
}
}
}
}
}
for (int i = 0; i < q.length(); ++i) {
if (q[i] == '0') {
v1.push_back(i);
} else {
v2.push_back(i);
}
}
for (int i = 0; i < q.length(); ++i) {
if (q[i] == '0') {
int poz = *lower_bound(v2.begin(), v2.end(), i);
int cnt = dp[m][k][napr];
if (cnt <= poz - i) {
cout << "Controller " << i + dp[m][k][napr] << endl;
return 0;
}
for (int j = 0; j < poz - i; ++j) {
if (napr == 0) {
--k;
if (k == 1) {
napr = 1;
}
} else {
++k;
if (k == n) {
napr = 0;
}
}
}
i = poz - 1;
} else {
for (int j = 0; j < 1; ++j) {
if (napr == 0) {
--k;
if (k == 1) {
napr = 1;
}
} else {
++k;
if (k == n) {
napr = 0;
}
}
}
int max_dp = -1;
for (int j = 1; j <= n; ++j) {
if (max_dp < dp[j][k][napr]) {
max_dp = dp[j][k][napr];
m = j;
}
}
}
}
cout << "Stowaway" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > al;
long long dp[100011][4];
int x[100011];
long long p = 1000 * 1000 * 1000 + 7;
void DFS(int v) {
dp[v][0] = 1;
dp[v][1] = 0;
for (int i = 0; i < al[v].size(); i++) {
int u = al[v][i];
DFS(u);
dp[v][1] = (dp[v][1] * dp[u][0]) % p;
dp[v][1] = (dp[v][1] + (dp[v][0] * dp[u][1]) % p) % p;
dp[v][0] = (dp[v][0] * dp[u][0]) % p;
}
if (x[v] == 1)
dp[v][1] = dp[v][0];
else
dp[v][0] = (dp[v][0] + dp[v][1]) % p;
}
int main() {
memset(dp, -1, sizeof dp);
int n;
scanf("%d", &n);
al.assign(n + 5, vector<int>());
for (int i = 0; i < n - 1; i++) {
int t;
scanf("%d", &t);
al[t].push_back(i + 1);
}
for (int i = 0; i < n; i++) scanf("%d", &x[i]);
DFS(0);
printf("%d\n", dp[0][1]);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string s[n];
for (int i = 0; i <= n - 1; i++) {
cin >> s[i];
}
int maxi = 0;
for (int i = 0; i <= n - 1; i++) {
int cnt = 1;
for (int j = i + 1; j <= n - 1; j++) {
if (s[i].compare(s[j]) == 0) {
cnt++;
}
}
maxi = max(cnt, maxi);
}
cout << maxi;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> books(n + 1), books2(n + 1);
vector<int> query(m);
map<int, int> isMapExist, posX;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
books[i] = {i, x};
}
int u = 0;
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
x--;
query[i] = x;
if (!isMapExist[x]) {
books2[u] = books[x];
posX[books[x].first] = u;
u++;
}
isMapExist[x] = true;
}
for (int i = 0; i < n; i++) {
if (!isMapExist[i]) {
books2.push_back(books[i]);
posX[books[i].first] = u;
u++;
}
isMapExist[i] = true;
}
long long s = 0;
for (int i = 0; i < m; i++) {
int q = posX[query[i]];
pair<int, int> qq = books2[q];
for (int j = q - 1; j >= 0; j--) {
s += books2[j].second;
posX[books2[j].first]++;
books2[j + 1] = books2[j];
}
posX[qq.first] = 0;
books2[0] = qq;
}
cout << s;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, n, m, k;
string str[1000];
long long int mark[200][200];
memset(mark, false, sizeof(mark));
vector<pair<long long int, pair<long long int, long long int> > > ans;
cin >> n >> m;
for (i = 1; i <= n; ++i) {
cin >> str[i];
}
for (i = 1; i <= n; ++i) {
for (j = 0; j < m; ++j) {
if (str[i][j] == '*') {
long long int cnt1 = 0, cnt2 = 0, cnt3 = 0, cnt4 = 0, mi = INT_MAX;
for (k = i - 1; k >= 1; --k) {
if (str[k][j] == '*')
++cnt1;
else
break;
}
for (k = i + 1; k <= n; ++k) {
if (str[k][j] == '*')
++cnt2;
else
break;
}
for (k = j - 1; k >= 0; --k) {
if (str[i][k] == '*')
++cnt3;
else
break;
}
for (k = j + 1; k < m; ++k) {
if (str[i][k] == '*')
++cnt4;
else
break;
}
mi = min(cnt1, min(cnt2, min(cnt3, cnt4)));
if (!mi) continue;
for (k = i; k >= i - mi && k >= 0; --k) {
mark[k][j] = true;
}
for (k = i; k <= i + mi && k <= n; ++k) {
mark[k][j] = true;
}
for (k = j; k >= j - mi && k >= 0; --k) {
mark[i][k] = true;
}
for (k = j; k <= j + mi && k < m; ++k) {
mark[i][k] = true;
}
ans.push_back(make_pair(i, make_pair(j + 1, mi)));
}
}
}
long long int f = 0;
for (i = 1; i <= n; ++i) {
for (j = 0; j < m; ++j) {
if (str[i][j] == '*' && !mark[i][j]) {
f = 1;
}
}
}
if (f) {
cout << "-1";
return 0;
}
cout << ans.size() << "\n";
for (i = 0; i < ans.size(); ++i)
cout << ans[i].first << " " << ans[i].second.first << " "
<< ans[i].second.second << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int N = (int)5e7;
int T;
int n, m;
char a[505], b[505];
int pi[505], poz[505][2];
int16_t dp[505][505][505];
void precalc() {}
void solve() {
cin >> n >> m >> (a + 1) >> (b + 1);
int p = 0;
for (int i = 2; i <= m; i++) {
while (p && b[p + 1] != b[i]) p = pi[p];
if (b[p + 1] == b[i]) p++;
pi[i] = p;
}
for (int i = 0; i <= m; i++) {
for (char c = '0'; c <= '1'; c++) {
p = i;
while (p && b[p + 1] != c) p = pi[p];
if (b[p + 1] == c) p++;
poz[i][c - '0'] = p;
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= m; k++) dp[i][j][k] = static_cast<int16_t>(n + 5);
}
}
dp[0][0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
for (int k = 0; k <= m; k++) {
for (char c = '0'; c <= '1'; c++) {
int k2 = poz[k][c - '0'];
dp[i + 1][j + (k2 == m)][k2] =
min(dp[i + 1][j + (k2 == m)][k2],
static_cast<int16_t>(dp[i][j][k] + (a[i + 1] != c)));
}
}
}
}
for (int i = 0; i <= n - m + 1; i++) {
int16_t ans = n + 5;
for (int j = 0; j <= m; j++) ans = min(ans, dp[n][i][j]);
cout << (ans == n + 5 ? -1 : ans) << " ";
}
cout << '\n';
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
T = 1;
precalc();
for (; T; T--) {
solve();
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int MAX = 10000000;
double eps = 1e-9;
const long long BIG_INF = 7000000000000000000LL;
const int INF = 2000000000;
double PI = 3.1415926535897932384626433832795;
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
string inttostring(int n) {
stringstream a;
a << n;
string A;
a >> A;
return A;
}
int stringtoint(string A) {
stringstream a;
a << A;
int p;
a >> p;
return p;
}
int main() {
int m;
cin >> m;
int A[m];
for (int i = 0; i < m; i++) {
cin >> A[i];
}
int x, y;
cin >> x >> y;
for (int i = 1; i < m; i++) {
A[i] += A[i - 1];
}
int g = 0;
for (int i = 1; i < m; i++) {
int c = A[m - 1] - A[i - 1];
if (A[i - 1] >= x && A[i - 1] <= y && c >= x && c <= y) {
cout << i + 1 << "\n";
g = 1;
break;
}
}
if (!g) cout << "0\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, cnt[2], cnt1[2], Max;
;
long long a[200000];
cnt[1] = 0;
cnt[0] = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
cnt[a[i]]++;
}
cnt1[0] = cnt[0];
cnt1[1] = cnt[1];
for (int i = 1; i <= n; ++i) {
cnt[a[i]]--;
if (cnt[a[i]] == 0) {
Max = i;
break;
}
}
cout << Max;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> tu[200005];
int b[200005], a[200005], check[200005], cnt[200005];
int n;
int gcd(int x, int y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
void dfs(int son, int fa, int deep) {
int i, flag;
b[son] = gcd(a[son], b[fa]);
check[son] = b[fa];
for (i = 1; i * i <= a[son]; i++) {
if (a[son] % i == 0) {
flag = i;
if (cnt[flag] >= deep - 2) check[son] = max(flag, check[son]);
flag = a[son] / i;
if (cnt[flag] >= deep - 2) check[son] = max(flag, check[son]);
if (i * i == a[son])
cnt[i]++;
else
cnt[i]++, cnt[a[son] / i]++;
}
}
for (i = 0; i < tu[son].size(); i++) {
int k = tu[son][i];
if (k == fa) continue;
dfs(k, son, deep + 1);
}
for (i = 1; i * i <= a[son]; i++) {
if (a[son] % i == 0) {
if (i * i == a[son])
cnt[i]--;
else
cnt[i]--, cnt[a[son] / i]--;
}
}
}
int main() {
int x, y, i;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i < n; i++) {
cin >> x >> y;
tu[x].push_back(y);
tu[y].push_back(x);
}
dfs(1, 0, 1);
for (i = 1; i <= n; i++) cout << check[i] << " ";
cout << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
int x(0), f(1);
char c(getchar());
while (c < '0' || '9' < c) {
if (c == '-') {
f = -1;
}
c = getchar();
}
while ('0' <= c && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return f * x;
}
void Write(int x) {
if (x < 0) {
printf("-");
x = -x;
}
if (9 < x) {
Write(x / 10);
}
putchar(x % 10 + '0');
}
inline void Writeln(int x) {
Write(x);
puts("");
}
const int MAXN = 1e5 + 5;
const int MAXM = MAXN << 1;
int n, m;
char val[MAXN];
int sum[MAXN];
struct Query {
int deep, id;
Query(int deep, int id) : deep(deep), id(id) {}
};
vector<Query> query[MAXN];
struct Edge {
int to, next;
} edge[MAXM];
int edge_head[MAXN];
int edge_cnt = 0;
void AddEdge(int form, int to) {
edge[++edge_cnt].to = to;
edge[edge_cnt].next = edge_head[form];
edge_head[form] = edge_cnt;
}
int son[MAXN];
int size[MAXN];
int deep[MAXN];
int father[MAXN][19];
bool Check(int a) { return a == (a & -a); }
void DFS_1(int now = 1) {
for (int i = 1; i <= 18; ++i) {
father[now][i] = father[father[now][i - 1]][i - 1];
}
deep[now] = deep[father[now][0]] + 1;
size[now] = 1;
for (int edge_i = edge_head[now]; edge_i; edge_i = edge[edge_i].next) {
DFS_1(edge[edge_i].to);
size[now] += size[edge[edge_i].to];
if (size[son[now]] < size[edge[edge_i].to]) {
son[now] = edge[edge_i].to;
}
}
}
int Find(int now, int k) {
for (int i = 19; i >= 0; --i) {
if ((1 << i) <= k) {
now = father[now][i];
k -= (1 << i);
}
}
return now;
}
int im_son;
int answer[MAXN];
void Add(int now) {
sum[deep[now]]++;
for (int edge_i = edge_head[now]; edge_i; edge_i = edge[edge_i].next) {
if (edge[edge_i].to ^ im_son) {
Add(edge[edge_i].to);
}
}
}
void Delete(int now, bool flag = 1) {
sum[deep[now]]--;
for (int edge_i = edge_head[now]; edge_i; edge_i = edge[edge_i].next) {
if (edge[edge_i].to ^ im_son) {
Delete(edge[edge_i].to, 0);
}
}
}
void DFS_2(int now, int opt = 0) {
for (int edge_i = edge_head[now]; edge_i; edge_i = edge[edge_i].next) {
if (edge[edge_i].to ^ son[now]) {
DFS_2(edge[edge_i].to, 1);
}
}
if (son[now]) {
DFS_2(son[now], 0);
}
im_son = son[now];
Add(now);
if (query[now].size()) {
for (int i = 0; i <= query[now].size() - 1; ++i) {
answer[query[now][i].id] = sum[query[now][i].deep] - 1;
}
}
im_son = 0;
if (opt) {
Delete(now);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &father[i][0]);
AddEdge(father[i][0], i);
}
for (int i = 1; i <= n; ++i) {
if (!father[i][0]) {
DFS_1(i);
}
}
scanf("%d", &m);
int u, k;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &k);
u = Find(u, k);
if (u) {
query[u].push_back(Query{deep[u] + k, i});
}
}
for (int i = 1; i <= n; ++i) {
if (!father[i][0]) {
DFS_2(i, 1);
}
}
for (int i = 1; i <= m; ++i) {
printf("%d ", answer[i]);
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
string s1, s2;
int t1[maxn], t2[maxn];
int main() {
cin >> s1 >> s2;
int l1 = (int)s1.size(), l2 = (int)s2.size();
for (int i = 0; i < l1; i++) {
int n;
scanf("%d", &n);
t1[i] = n - 1;
}
int L = 0;
int R = l1 - l2;
int res = 0;
while (L <= R) {
int mid = (L + R) / 2;
int cnt = 0;
for (int i = mid; i < l1; i++) {
t2[cnt] = t1[i];
cnt++;
}
int num = l2 - 1;
sort(t2, t2 + cnt);
for (int i = cnt - 1; i >= 0; i--) {
if (s2[num] == s1[t2[i]]) num--;
if (num == -1) break;
}
if (num >= 0) R = mid - 1;
if (num < 0) {
res = max(res, mid);
L = mid + 1;
}
}
cout << res << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
long long int _gcd(long long int a, long long int b) {
if (a == 0) return b;
return _gcd(b % a, a);
}
long long int qpow(long long int a, long long int n) {
long long int res = 1;
while (n) {
if (n % 2) {
res = (res * a) % MOD;
n--;
} else {
n = n / 2;
a = (a * a) % MOD;
}
}
return res;
}
void soln() {
int n, i, o0, o1, e0, e1, ans1, ans2;
string a, b;
cin >> n >> a >> b;
o0 = o1 = e0 = e1 = 0;
for (i = 0; i < n; i++) {
if (a[i] == b[i]) {
if (a[i] == '0')
e0++;
else
e1++;
} else {
if (a[i] == '0')
o0++;
else
o1++;
}
}
ans1 = ans2 = INT_MAX;
if (o0 == o1) ans1 = o0 + o1;
if (e1 == e0 + 1) ans2 = e1 + e0;
if (ans1 == ans2 && ans1 == INT_MAX)
cout << -1 << "\n";
else
cout << min(ans1, ans2) << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) soln();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000 + 5, P = 1000000007;
int N, K, a[MAXN];
long long b[MAXN], cn[MAXN];
long long FastPow(long long a, int p, int m) {
long long ret = 1;
while (p) {
if (p & 1) ret = ret * a % m;
if (p >>= 1) a = a * a % m;
}
return ret;
}
long long comb(long long n, long long m) {
if (n < m) return 0;
long long ret = 1;
for (int i = 0; i < m; i++)
ret = ret * (n - i) % P * FastPow(i + 1, P - 2, P) % P;
return ret;
}
int main() {
while (~scanf("%d %d", &N, &K)) {
for (int i = 0; i < N; i++) scanf("%d", a + i);
for (int j = 1; j < N; j++) {
for (int i = N - 1; i >= j; i--) {
a[i] = ((a[i] - a[i - 1]) % P + P) % P;
}
}
for (int i = 0; i < N; i++) cn[i] = comb(K, i);
memset(b, 0, sizeof(b));
for (int i = 0; i < N; i++) {
for (int j = 0; j <= i; j++) b[i] = (b[i] + cn[j] * a[i - j]) % P;
for (int i = N - 1; i > 0; i--) cn[i] = (cn[i] + cn[i - 1]) % P;
}
for (int i = 0; i < N; i++) {
printf("%d%c", (int)b[i], i < N - 1 ? ' ' : '\n');
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "O3", "unroll-loops")
using namespace std;
const long long INF = (long long)(1e18);
const long long inf = 1e18 + 7;
long double eps = 1e-15;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long mod = 998244353;
long long pows(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
long long c = pows(a, b / 2);
return (c * c) % mod;
}
if (b % 2 == 1) return (a * pows(a, b - 1)) % mod;
}
vector<long long> fact, unfact;
long long getcnk(int n, int k) {
long long res = (unfact[k] * unfact[n - k]) % mod;
return (fact[n] * res) % mod;
}
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<int> aa(m);
for (int i = 0; i < m; i++) {
cin >> aa[i];
}
int g, r;
cin >> g >> r;
deque<pair<int, int>> q;
q.push_back({0, 0});
vector<vector<long long>> d;
d.resize(m, vector<long long>(g, inf));
sort((aa).begin(), (aa).end());
d[0][0] = 0;
while (!q.empty()) {
auto p = q.front();
q.pop_front();
int i = p.first, t = p.second;
if (i > 0) {
int t1 = aa[i] - aa[i - 1] + t;
if (aa[i] - aa[i - 1] + t < g &&
d[i - 1][aa[i] - aa[i - 1] + t] > d[i][t] + aa[i] - aa[i - 1]) {
d[i - 1][aa[i] - aa[i - 1] + t] = d[i][t] + aa[i] - aa[i - 1];
q.push_front({i - 1, t1});
}
if (t1 == g && d[i - 1][0] > d[i][t] + aa[i] - aa[i - 1]) {
d[i - 1][0] = d[i][t] + aa[i] - aa[i - 1] + r;
q.push_back({i - 1, 0});
}
}
if (i < m - 1) {
int t1 = aa[i + 1] - aa[i] + t;
if (t1 < g && d[i + 1][t1] > d[i][t] + aa[i + 1] - aa[i]) {
d[i + 1][t1] = d[i][t] + aa[i + 1] - aa[i];
q.push_front({i + 1, t1});
}
if (t1 == g && d[i + 1][0] > d[i][t] + aa[i + 1] - aa[i]) {
d[i + 1][0] = d[i][t] + aa[i + 1] - aa[i] + r;
q.push_back({i + 1, 0});
}
}
}
if (d[m - 1][0] != inf) d[m - 1][0] -= r;
long long mmin = inf;
for (int i = 0; i < g; i++) mmin = min(mmin, d[m - 1][i]);
if (mmin == inf) mmin = -1;
cout << mmin;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
char s[10005];
int n, len, ans;
vector<int> g[26];
int main() {
scanf("%s", s + 1);
len = strlen(s + 1);
for (int i = 1; i <= len; i++) g[s[i] - 'a'].push_back(i), s[i + len] = s[i];
for (int i = 0; i < 26; i++) {
int l1 = g[i].size();
int an = 0;
for (int j = 1; j < len; j++) {
n = 0;
map<int, int> mp;
bool f1 = 0;
for (int k = 0; k < l1; k++) mp[s[g[i][k] + j] - 'a']++;
for (int k = 0; k < l1; k++)
if (mp[s[g[i][k] + j] - 'a'] == 1) n++;
an = max(an, n);
}
ans += an;
}
printf("%.8f", 1.0 * ans / len);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
vector<int> ry;
for (int i = 1; i < 8; i++) {
ry.push_back(i);
}
while (t--) {
int a, b, c;
cin >> a >> b >> c;
int ans = 0;
if (a) {
a--;
ans++;
}
if (b) {
b--;
ans++;
}
if (c) {
c--;
ans++;
}
vector<int> ry;
ry.push_back(a);
ry.push_back(b);
ry.push_back(c);
sort(ry.begin(), ry.end());
if (ry[2] && ry[1]) {
ry[2]--;
ans++;
ry[1]--;
}
if (ry[2] && ry[0]) {
ry[2]--;
ry[0]--;
ans++;
}
if (ry[0] && ry[1]) {
ry[0]--;
ry[1]--;
ans++;
}
if (ry[0] && ry[1] && ry[2]) {
ans++;
}
cout << ans << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline void Read(int &x) {
int f = 1;
char c = getchar();
x = 0;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
x *= f;
}
const int p = 1000000007;
int n, m;
inline int Pow(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = 1ll * a * res % p;
a = 1ll * a * a % p, b >>= 1;
}
return res;
}
int main() {
Read(n), Read(m);
cout << 1ll * Pow(2, m) * Pow(n + 1, m - 1) % p * (n - m + 1) % p << endl;
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const int MAXA = 8191;
bool dp[MAXA + 1];
int n, a[MAXN], minv[MAXA + 1];
void solve() {
cin >> n;
for (int i = (1); i <= (n); ++i) cin >> a[i];
for (int i = (0); i <= (511); ++i) {
minv[i] = 0x7f7f7f7f;
}
dp[0] = 1;
minv[0] = -1;
for (int i = (1); i <= (n); ++i) {
for (int j = (0); j <= (511); ++j)
if ((a[i] ^ j) <= 511) {
dp[j] |= (minv[a[i] ^ j] < a[i]);
if ((minv[a[i] ^ j] < a[i])) minv[j] = min(minv[j], a[i]);
}
dp[a[i]] = 1;
minv[a[i]] = min(minv[a[i]], a[i]);
}
int cnt = 0;
for (int i = (0); i <= (511); ++i) cnt += (dp[i]);
cout << cnt << '\n';
for (int i = (0); i <= (511); ++i)
if (dp[i]) {
cout << i << ' ';
}
cout << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int _;
_ = 1;
while (_--) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int maxArr[100100];
int difArr[100100];
int nextArr[100100];
int arrx[100100], arry[100100];
int n, m;
void input() {
int i, x, y;
for (i = 0; i <= n; i++) {
maxArr[i] = 0;
}
m = 0;
for (i = 0; i < n; i++) {
scanf("%d %d", &x, &y);
if (maxArr[x] < y) {
maxArr[x] = y;
}
if (m < x) {
m = x;
}
}
}
int searchVal(int k) {
if (k > difArr[0] || k < difArr[m]) {
return -1;
}
int nBegin = 0;
int nEnd = m;
int nMid;
while (nBegin < nEnd) {
nMid = (nBegin + nEnd) / 2;
if (k >= difArr[nMid]) {
nEnd = nMid;
} else {
nBegin = nMid + 1;
}
}
if (k == difArr[nBegin]) {
return nBegin;
} else {
return -1;
}
}
void solve() {
int i, p, k;
for (i = 0; i <= m; i++) {
difArr[i] = -i;
nextArr[i] = 0;
}
bool flag = true;
for (i = 0; i < n; i++) {
scanf("%d", &p);
if (!flag) {
continue;
}
k = searchVal(p);
if (k != -1) {
if (nextArr[k] <= maxArr[k] &&
(k == 0 || nextArr[k] + 1 <= nextArr[k - 1])) {
arrx[i] = k;
arry[i] = nextArr[k];
nextArr[k]++;
difArr[k]++;
} else {
flag = false;
}
} else {
flag = false;
}
}
if (!flag) {
printf("NO\n");
return;
}
printf("YES\n");
for (i = 0; i < n; i++) {
printf("%d %d\n", arrx[i], arry[i]);
}
}
int main() {
while (scanf("%d", &n) != EOF) {
input();
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e6 + 9;
vector<long long> ca, cb;
long long cnt(int l, int r) {
if (l > r) return 0;
return ca[r] - ca[l - 1];
}
long long sum(int l, int r) {
if (l > r) return 0;
return cb[r] - cb[l - 1];
}
int main() {
ios_base::sync_with_stdio(0);
int n, x, y;
vector<int> a;
vector<bool> was;
cin >> n >> x >> y;
a.resize(MAXN);
was.resize(MAXN);
ca.resize(MAXN);
cb.resize(MAXN);
for (int i = 0; i < n; ++i) {
cin >> a[i];
ca[a[i]]++;
cb[a[i]] += a[i];
}
for (int i = 1; i < MAXN; ++i) {
ca[i] += ca[i - 1];
cb[i] += cb[i - 1];
}
long long ans = 1e18;
for (int g = 2; g < MAXN; ++g) {
if (!was[g]) {
long long res = 0;
for (int k = g; k < MAXN; k += g) {
was[k] = true;
int f = k - min(g - 1, x / y);
res += cnt(k - g + 1, f - 1) * x + (cnt(f, k) * k - sum(f, k)) * y;
}
ans = min(res, ans);
}
}
cout << ans << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200100];
int le[200100], ri[200100];
int sta[200100], sz;
int pre[200100][32];
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
while (sz > 0 && a[sta[sz]] < a[i]) --sz;
le[i] = sta[sz] + 1;
sta[++sz] = i;
}
sz = 0;
sta[0] = n + 1;
for (int i = n; i >= 1; --i) {
while (sz > 0 && a[sta[sz]] <= a[i]) --sz;
ri[i] = sta[sz] - 1;
sta[++sz] = i;
}
for (int i = 1; i <= n; ++i)
for (int j = 0; j < 32; ++j) {
pre[i][j] = pre[i - 1][j];
if (a[i] >> j & 1) ++pre[i][j];
}
for (int i = 1; i <= n; ++i) {
int L = le[i] - 1, R = ri[i] + 1;
for (int j = 0; j < 32; ++j) {
if (a[i] >> j & 1) continue;
int lb = i, ub = ri[i] + 1;
while (ub > lb + 1) {
int mid = (lb + ub) >> 1;
if (pre[mid][j] > pre[i][j])
ub = mid;
else
lb = mid;
}
R = min(R, ub);
lb = le[i] - 1, ub = i;
while (ub > lb + 1) {
int mid = (lb + ub) >> 1;
if (pre[i][j] - pre[mid - 1][j])
lb = mid;
else
ub = mid;
}
L = max(L, lb);
}
if (L < le[i] && R > ri[i]) continue;
ans += 1LL * (L - le[i] + 1) * (ri[i] - i + 1);
ans += 1LL * (ri[i] - R + 1) * (i - le[i] + 1);
ans -= 1LL * (L - le[i] + 1) * (ri[i] - R + 1);
}
printf("%I64d\n", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const char first[] = "input.txt";
const char fo[] = "";
int m, n, sl = 0;
char s[2002][2002];
void input() {
cin >> m >> n;
for (int i = 0; i < m; ++i) cin >> s[i];
}
vector<int> res;
string pa = "^>v<#";
int bx[] = {-1, 0, 1, 0, -3}, by[] = {0, 1, 0, -1, -3};
pair<int, int> next(const pair<int, int>& u) {
int vt = pa.find(s[u.first][u.second]);
return make_pair(u.first + bx[vt], u.second + by[vt]);
}
bool check(const pair<int, int>& u) {
return u.first >= 0 && u.first < m && u.second >= 0 && u.second < n;
}
bool cyc;
int res0, res1;
int dfs(const pair<int, int>& u) {
++sl;
int tmp = 1;
for (int i = 0; i < 4; ++i) {
pair<int, int> v = make_pair(u.first + bx[i], u.second + by[i]);
if (check(v) && next(v) == u) {
tmp = max(tmp, dfs(v) + 1);
}
}
return tmp;
}
void cal(const pair<int, int>& u) {
++sl;
for (int i = 0; i < 4; ++i) {
pair<int, int> v = make_pair(u.first + bx[i], u.second + by[i]);
if (check(v) && next(v) == u) {
int tmp = dfs(v);
if (tmp > res1) {
res0 = res1;
res1 = tmp;
} else
res0 = max(res0, tmp);
}
}
}
void solve() {
res0 = res1 = 0;
cyc = false;
for (int i = 0; i < m; ++i)
for (int j = 0; j < n; ++j)
if (s[i][j] == '#') cal(make_pair(i, j));
if (sl < m * n) cyc = true;
if (cyc) {
cout << -1;
return;
}
if (res1 == 0) {
cout << 0;
return;
}
int ans = 2 * res1 - 1;
if (res0 > 0) ans = max(ans, res0 + res1);
if (ans <= 1)
cout << 0 << '\n';
else
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0);
input();
solve();
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101000;
const long long MOD = 1000000007;
long long C[N][110];
long long a[N];
long long F[N][110];
long long d[110];
void add(long long &x, long long y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int main() {
for (int i = 0; i < N; i++) {
C[i][0] = 1;
for (int j = 1; j <= i && j <= 100; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
if (C[i][j] >= MOD) C[i][j] -= MOD;
}
}
int n, m, l, r, k;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) cin >> a[i];
while (m--) {
scanf("%d %d %d", &l, &r, &k);
for (int i = 0; i <= k; i++) {
add(F[l][i], C[k][k - i]);
add(F[r + 1][i], -C[k + r - l + 1][k - i]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 100; j++) add(d[j], F[i][j]);
add(a[i], d[0]);
for (int j = 0; j < 100; j++) add(d[j], d[j + 1]);
printf("%I64d ", a[i]);
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200], b, kol, j, ost, vid;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &b);
if (a[b - 1] == 0) {
vid++;
}
a[b - 1]++;
j++;
}
for (int i = 0; i < 101; i++) {
for (int j = 0; j < 101; j++) {
if (a[j] > a[j + 1]) {
swap(a[j], a[j + 1]);
}
}
}
if (a[101] % m > 0) {
ost = 1;
}
kol = vid * (a[101] / m + ost) * m;
printf("%d", kol - j);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[100010][101];
vector<int> adjList[100010];
queue<int> q[101];
int N, M, K, S;
int main() {
cin >> N >> M >> K >> S;
for (int i = 0; i < N; i++)
for (int j = 0; j < K; j++) dp[i][j] = N + 1;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
x--;
q[x].push(i);
dp[i][x] = 0;
}
for (int i = 0; i < M; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
adjList[x].push_back(y);
adjList[y].push_back(x);
}
for (int i = 0; i < K; i++) {
while (!q[i].empty()) {
int u = q[i].front();
q[i].pop();
for (auto v : adjList[u]) {
if (dp[v][i] > dp[u][i] + 1) {
dp[v][i] = dp[u][i] + 1;
q[i].push(v);
}
}
}
}
for (int i = 0; i < N; i++) {
sort(dp[i], dp[i] + K);
int total = 0;
for (int j = 0; j < S; j++) total += dp[i][j];
cout << total << ' ';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 5000;
string s[5001];
int n, m, ans, t;
int **l, **r, **u, **d;
void build() {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (!i)
u[i][j] = -1;
else {
u[i][j] = u[i - 1][j];
if (s[i - 1][j] != '.') u[i][j] = i - 1;
}
if (!j)
l[i][j] = -1;
else {
l[i][j] = l[i][j - 1];
if (s[i][j - 1] != '.') l[i][j] = j - 1;
}
}
for (int i = n - 1; i + 1; i--)
for (int j = m - 1; j + 1; j--) {
if (!(n - i - 1))
d[i][j] = -1;
else {
d[i][j] = d[i + 1][j];
if (s[i + 1][j] != '.') d[i][j] = i + 1;
}
if (!(m - j - 1))
r[i][j] = -1;
else {
r[i][j] = r[i][j + 1];
if (s[i][j + 1] != '.') r[i][j] = j + 1;
}
}
}
void upd(int y, int x) {
if (r[y][x] >= 0) l[y][r[y][x]] = l[y][x];
if (l[y][x] >= 0) r[y][l[y][x]] = r[y][x];
if (d[y][x] >= 0) u[d[y][x]][x] = u[y][x];
if (u[y][x] >= 0) d[u[y][x]][x] = d[y][x];
}
int go(int y, int x) {
if (min(x, y) < 0) return 0;
char c = s[y][x];
upd(y, x);
if (c == 'L') return go(y, l[y][x]) + 1;
if (c == 'R') return go(y, r[y][x]) + 1;
if (c == 'U') return go(u[y][x], x) + 1;
return go(d[y][x], x) + 1;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
l = new int *[n + 10];
r = new int *[n + 10];
u = new int *[n + 10];
d = new int *[n + 10];
for (int i = 0; i < n + 10; i++) {
l[i] = new int[m + 10];
r[i] = new int[m + 10];
d[i] = new int[m + 10];
u[i] = new int[m + 10];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] != '.') {
build();
int kk = go(i, j);
if (kk > ans) {
t = 0;
ans = kk;
}
if (kk == ans) t++;
}
cout << ans << " " << t << endl;
cin >> n;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
typedef struct var {
string name;
string type;
} var;
typedef struct fun {
string name;
vector<string> par;
int count;
} fun;
int main() {
int n;
vector<fun> func;
string tmp;
cin >> n;
getline(cin, tmp);
for (int j = 0; j < n; j++) {
fun f;
getline(cin, tmp);
int i = 0;
while (i < tmp.size() && tmp[i] != 'd') i++;
i++;
while (i < tmp.size() && tmp[i] == ' ') i++;
string tmp2 = "";
while (i < tmp.size() && tmp[i] != ' ' && tmp[i] != '(') {
tmp2 += tmp[i];
i++;
}
f.name = tmp2;
while (i < tmp.size() && tmp[i] != ')') {
i++;
while (i < tmp.size() && tmp[i] == ' ' || tmp[i] == ',' || tmp[i] == '(')
i++;
tmp2 = "";
while (i < tmp.size() && tmp[i] != ' ' && tmp[i] != ',' &&
tmp[i] != ')') {
tmp2 += tmp[i];
i++;
}
if (i < tmp.size() && tmp2 != "") f.par.push_back(tmp2);
}
f.count = 0;
func.push_back(f);
}
cin >> n;
vector<var> vari;
getline(cin, tmp);
for (int j = 0; j < n; j++) {
var v;
getline(cin, tmp);
int i = 0;
string tmp2 = "";
while (tmp[i] == ' ') i++;
while (tmp[i] != ' ') {
tmp2 += tmp[i];
i++;
}
v.type = tmp2;
while (tmp[i] == ' ') i++;
tmp2 = "";
while (tmp.size() > i && tmp[i] != ' ') {
tmp2 += tmp[i];
i++;
}
v.name = tmp2;
vari.push_back(v);
}
cin >> n;
getline(cin, tmp);
for (int j = 0; j < n; j++) {
fun f;
getline(cin, tmp);
int i = 0;
while (i < tmp.size() && tmp[i] == ' ') i++;
string tmp2 = "";
while (i < tmp.size() && tmp[i] != ' ' && tmp[i] != '(') {
tmp2 += tmp[i];
i++;
}
f.name = tmp2;
while (i < tmp.size() && tmp[i] != ')') {
i++;
while (i < tmp.size() && tmp[i] == ' ' || tmp[i] == ',' || tmp[i] == '(')
i++;
tmp2 = "";
while (i < tmp.size() && tmp[i] != ' ' && tmp[i] != ',' &&
tmp[i] != ')') {
tmp2 += tmp[i];
i++;
}
for (int z = 0; z < vari.size(); z++) {
if (tmp2 == vari[z].name) tmp2 = vari[z].type;
}
if (i < tmp.size() && tmp2 != "") f.par.push_back(tmp2);
}
f.count = 0;
for (int z = 0; z < func.size(); z++) {
if (func[z].name == f.name && func[z].par.size() == f.par.size()) {
bool ok = true;
for (int h = 0; h < f.par.size(); h++) {
if (func[z].par[h] != "T") {
if (func[z].par[h] != f.par[h]) {
ok = false;
break;
}
}
}
if (ok) f.count++;
}
}
cout << f.count << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int d0[4][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
int d1[8][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1},
{-1, 1}, {1, 1}, {1, -1}, {-1, -1}};
int n, m;
string t[1001];
int ans = 0;
int b1[1001][1001];
int id = 1;
bool ok;
set<pair<int, int>> lst;
bool valid(int x, int y) { return x >= 0 && y >= 0 && x < n && y < m; }
void dfs1(int x, int y) {
b1[x][y] = id;
for (int i = 0; i < 8; ++i) {
int nx = x + d1[i][0], ny = y + d1[i][1];
if (valid(nx, ny) && b1[nx][ny] != id && t[nx][ny] == '0') {
dfs1(nx, ny);
}
if (!valid(nx, ny)) ok = false;
}
for (int i = 0; i < 8; ++i) {
int nx = x + d1[i][0], ny = y + d1[i][1];
if (valid(nx, ny) && t[nx][ny] == '1') {
lst.insert(make_pair(nx, ny));
}
}
}
int bej;
int b2[1001][1001];
void dfs2(int x, int y) {
int szomsz = 0;
b2[x][y] = id;
bej++;
for (int i = 0; i < 4; ++i) {
int nx = x + d0[i][0], ny = y + d0[i][1];
if (valid(nx, ny) && lst.find(make_pair(nx, ny)) != lst.end()) {
szomsz++;
if (b2[nx][ny] != id) {
dfs2(nx, ny);
}
}
}
ok &= szomsz == 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> t[i];
for (int i = 0; i + 1 < n; ++i) {
for (int j = 0; j + 1 < m; ++j) {
if (t[i][j] == '1' && t[i + 1][j] == '1' && t[i][j + 1] == '1' &&
t[i + 1][j + 1] == '1')
ans = 4;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (b1[i][j] == 0 && t[i][j] == '0') {
lst.clear();
ok = true;
dfs1(i, j);
bej = 0;
if (!lst.empty()) {
dfs2(lst.begin()->first, lst.begin()->second);
ok &= bej == (int)lst.size();
if (ok) ans = max(ans, bej);
}
id++;
}
}
}
cout << ans << "\n";
return 0;
}
| 17 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:1048576")
using namespace std;
int IT_MAX = 1 << 18;
const long long MOD = 1000000009;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 1234567890123456789ll;
const double PI = acos(-1);
const double EPS = 1e-8;
char u[10005];
int main() {
int N;
scanf("%d", &N);
int ans = 0;
while (scanf("%s", u) != EOF) {
int c = 0, i;
for (i = 0; u[i] != 0; i++)
if (u[i] >= 'A' && u[i] <= 'Z') c++;
ans = max(ans, c);
}
return !printf("%d\n", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m, N;
vector<vector<long long> > g;
vector<long long> w, c;
long long res = 0;
void upd(long long& x, long long y) {
if (x < y) x = y;
}
void add(vector<long long>& dp, int e) {
if (!w[e]) return;
for (int i = k; i >= w[e]; --i) upd(dp[i], dp[i - w[e]] + c[e]);
}
void rec(int l, int r, vector<long long> dp) {
if (l == r) {
for (int j = 0; j <= k && j < g[r].size(); ++j)
upd(res, g[r][j] + dp[k - j]);
return;
}
int m = (l + r) / 2;
vector<long long> d = dp;
for (int i = m + 1; i <= r; ++i) add(d, i);
rec(l, m, d);
d = dp;
for (int i = l; i <= m; ++i) add(d, i);
rec(m + 1, r, d);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
N = 1;
while (N < n) N *= 2;
w = c = vector<long long>(N, 0);
g.resize(N);
for (int i = 0; i < n; ++i) {
cin >> m;
g[i].assign(m + 1, 0);
for (int j = 1; j <= m; ++j) {
cin >> g[i][j];
g[i][j] += g[i][j - 1];
}
w[i] = m;
c[i] = g[i][m];
}
rec(0, N - 1, vector<long long>(k + 1, 0));
cout << res << endl;
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
long long v;
vector<pair<long long, long long> > A, ret;
int main() {
scanf("%d", &n);
for (int i = 0, a, b; i < n; ++i)
scanf("%d %d", &a, &b), ret.emplace_back(a, b);
scanf("%lld", &v);
for (auto &first : ret)
A.emplace_back(first.second * v + first.first,
first.second * v - first.first);
sort(A.begin(), A.end());
vector<long long> V;
for (auto &first : A) {
auto it = upper_bound(V.begin(), V.end(), first.second);
if (it == V.end())
V.emplace_back(first.second);
else
*it = first.second;
}
int ans = V.size();
V.clear();
for (auto &first : A)
if (first.first >= 0 and first.second >= 0) {
auto it = upper_bound(V.begin(), V.end(), first.second);
if (it == V.end())
V.emplace_back(first.second);
else
*it = first.second;
}
printf("%d %d\n", (int)V.size(), ans);
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y, x1, y1, ar[5], ar1[5];
cin >> n;
if (n == 1) {
cout << -1 << endl;
return 0;
} else if (n == 2) {
cin >> x >> y >> x1 >> y1;
if (x != x1 && y != y1) {
cout << abs((x - x1) * (y - y1)) << endl;
return 0;
}
} else if (n == 3) {
for (int i = 0; i < 3; i++) {
cin >> ar[i] >> ar1[i];
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (ar[i] != ar[j] && ar1[i] != ar1[j]) {
cout << abs((ar[i] - ar[j]) * (ar1[i] - ar1[j])) << endl;
return 0;
}
}
}
} else if (n == 4) {
for (int i = 0; i < 4; i++) {
cin >> ar[i] >> ar1[i];
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (ar[i] != ar[j] && ar1[i] != ar1[j]) {
cout << abs((ar[i] - ar[j]) * (ar1[i] - ar1[j])) << endl;
return 0;
}
}
}
}
cout << -1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long m = 1000000000 + 7;
long long binom[4001][4001];
long long bell[4001];
int main() {
int n;
cin >> n;
binom[0][0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= i; ++j)
binom[i][j] = (j == 0 || j == i)
? 1
: ((binom[i - 1][j - 1] + binom[i - 1][j]) % m);
bell[0] = 1;
for (int i = 1; i <= n; ++i) {
long long curr = 0;
for (int k = 0; k <= i - 1; ++k) {
curr += binom[i - 1][k] * bell[k];
curr %= m;
}
bell[i] = curr;
}
long long ans = 0;
for (int k = 1; k <= n; ++k) {
ans += binom[n][k] * bell[n - k];
ans %= m;
}
cout << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1015;
int n, x, y, qwq1, qwq2;
int zn[N], cnt;
bitset<N> s[N], t[N], r;
pair<int, int> Ans1[N], Ans2[N];
void get1(int u, int v) {
if (u + 1 == v) return;
r = s[u] & s[v];
for (int i = u; i <= v; i++)
if (r[i]) {
Ans1[++qwq1] = pair<int, int>(u, v);
s[u][i] = s[v][i] = 0;
s[1][i] = s[i][1] = 1;
get1(u, i);
get1(i, v);
return;
}
}
void get2(int u, int v) {
if (u + 1 == v) return;
r = t[u] & t[v];
for (int i = u; i <= v; i++)
if (r[i]) {
Ans2[++qwq2] = pair<int, int>(1, i);
t[u][i] = t[v][i] = 0;
t[1][i] = t[i][1] = 1;
get2(u, i);
get2(i, v);
return;
}
}
int main() {
scanf("%d", &n);
for (int i = 2; i < n; i++) s[i][i - 1] = s[i][i + 1] = 1;
s[1][2] = s[1][n] = 1;
s[n][n - 1] = s[n][1] = 1;
for (int i = 1; i <= (n - 3); i++) {
scanf("%d%d", &x, &y);
s[x][y] = s[y][x] = 1;
}
zn[++cnt] = 2;
for (int i = 3; i < n; i++)
if (s[1][i]) zn[++cnt] = i;
zn[++cnt] = n;
for (int i = 1; i < cnt; i++) get1(zn[i], zn[i + 1]);
cnt = 0;
for (int i = 2; i < n; i++) t[i][i - 1] = t[i][i + 1] = 1;
t[1][2] = t[1][n] = 1;
t[n][n - 1] = t[n][1] = 1;
for (int i = 1; i <= (n - 3); i++) {
scanf("%d%d", &x, &y);
t[x][y] = t[y][x] = 1;
}
zn[++cnt] = 2;
for (int i = 3; i < n; i++)
if (t[1][i]) zn[++cnt] = i;
zn[++cnt] = n;
for (int i = 1; i < cnt; i++) get2(zn[i], zn[i + 1]);
printf("%d\n", qwq1 + qwq2);
for (int i = 1; i <= qwq1; i++)
printf("%d %d\n", Ans1[i].first, Ans1[i].second);
for (int i = qwq2; i >= 1; i--)
printf("%d %d\n", Ans2[i].first, Ans2[i].second);
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
char a[110][110];
int n, m;
int main() {
register int i, j;
while (cin >> n >> m) {
char c;
cin >> c;
memset((a), (0), sizeof(a));
for (int(i) = 0; (i) < (n); (i)++)
for (int(j) = 0; (j) < (m); (j)++) cin >> a[i][j];
bool visited[27] = {false};
visited[c - 'A'] = true;
int sum = 0;
for (int(i) = 0; (i) < (n); (i)++)
for (int(j) = 0; (j) < (m); (j)++) {
if (a[i][j] == c) {
if (i > 0 && isupper(a[i - 1][j]) && !visited[a[i - 1][j] - 'A']) {
visited[a[i - 1][j] - 'A'] = true;
sum++;
}
if (isupper(a[i + 1][j]) && !visited[a[i + 1][j] - 'A']) {
visited[a[i + 1][j] - 'A'] = true;
sum++;
}
if (j > 0 && isupper(a[i][j - 1]) && !visited[a[i][j - 1] - 'A']) {
visited[a[i][j - 1] - 'A'] = true;
sum++;
}
if (isupper(a[i][j + 1]) && !visited[a[i][j + 1] - 'A']) {
visited[a[i][j + 1] - 'A'] = true;
sum++;
}
}
}
cout << sum << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int last[2];
char ch;
int ctr = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> ch;
if (ch == 'B') {
ctr++;
last[0] = i + 1;
last[1] = j + 1;
}
}
}
int k = (sqrt(ctr) / 2);
while (k--) {
last[0]--;
last[1]--;
}
cout << last[0] << " " << last[1] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int MAX = numeric_limits<int>::max();
const int N = 1e6 + 5;
int main() {
long long ans = 0, x;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &x);
ans += ((x - 1) * (i) + x);
}
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool p = true;
for (int i = 0; i < s.size(); i++) {
if (s[i] != s[s.size() - i - 1]) {
p = false;
break;
}
}
if (p) {
cout << 0 << endl;
} else {
cout << 3 << endl;
cout << "L " << 2 << endl;
cout << "R " << 2 << endl;
int n = s.size() * 2;
cout << "R " << n - 1 << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n], count[101] = {0};
for (int i = 0; i < n; i++) {
cin >> a[i];
count[a[i]]++;
}
sort(count + 1, count + 101);
int dish = (count[100] + k - 1) / k, num = 0;
for (int i = 100; i > 0; i--) {
if (count[i] > 0)
num++;
else
break;
}
cout << dish * num * k - n;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int f[555][555], deg[555][555], tot, rel[555];
unordered_map<int, int> mp;
struct P {
int x, y;
} u, v;
queue<P> q;
void pre() {
for (int i = 0; i <= 8; ++i)
for (int ii = 0; i + ii <= 8; ++ii)
for (int iii = 0; i + ii + iii <= 8; ++iii)
for (int iv = 0; i + ii + iii + iv <= 8; ++iv) {
int id = i * 1 + ii * 10 + iii * 100 + iv * 1000;
rel[tot] = id;
mp[id] = tot++;
}
for (int i = 0; i <= 8; ++i)
for (int ii = 0; i + ii <= 8; ++ii)
for (int iii = 0; i + ii + iii <= 8; ++iii)
for (int iv = 0; i + ii + iii + iv <= 8; ++iv) {
int now = mp[i * 1 + ii * 10 + iii * 100 + iv * 1000];
if (!now) continue;
f[now][0] = -1;
q.push((P){now, 0});
for (int j = 0; j <= 8; ++j)
for (int jj = 0; j + jj <= 8; ++jj)
for (int jjj = 0; j + jj + jjj <= 8; ++jjj)
for (int jv = 0; j + jj + jjj + jv <= 8; ++jv) {
int el = mp[j * 1 + jj * 10 + jjj * 100 + jv * 1000];
if (!el) continue;
deg[now][el] =
(!!i + !!ii + !!iii + !!iv) * (!!j + !!jj + !!jjj + !!jv);
}
}
for (; !q.empty();) {
u = q.front();
q.pop();
static int a[5], b[5], x, y;
x = rel[u.x];
y = rel[u.y];
for (int i = 1; i <= 4; ++i) a[i] = y % 10, y /= 10;
a[0] = 8 - a[1] - a[2] - a[3] - a[4];
for (int i = 1; i <= 4; ++i) b[i] = x % 10, x /= 10;
b[0] = 8 - b[1] - b[2] - b[3] - b[4];
for (int i = 0; i <= 4; ++i)
for (int j = 1; j <= 4; ++j)
if (a[i] && b[j] && i != j) {
--a[i];
++a[(i - j + 555) % 5];
x = mp[a[1] * 1 + a[2] * 10 + a[3] * 100 + a[4] * 1000];
y = mp[b[1] * 1 + b[2] * 10 + b[3] * 100 + b[4] * 1000];
if (f[u.x][u.y] == 1) {
if (!--deg[x][y]) {
f[x][y] = -1;
q.push((P){x, y});
}
} else {
if (!f[x][y]) f[x][y] = 1, q.push((P){x, y});
}
++a[i];
--a[(i - j + 555) % 5];
}
}
}
int in() {
static int cnt[5], x;
memset(cnt, 0, sizeof cnt);
for (int i = 8; i--;) scanf("%d", &x), ++cnt[x];
return mp[cnt[1] * 1 + cnt[2] * 10 + cnt[3] * 100 + cnt[4] * 1000];
}
int main() {
pre();
int T, x, y, t, fir, res;
for (scanf("%d", &T); T--;) {
scanf("%d", &fir);
x = in();
y = in();
res = fir ? -f[y][x] : f[x][y];
switch (res) {
case 1:
puts("Alice");
break;
case 0:
puts("Deal");
break;
case -1:
puts("Bob");
break;
}
}
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
string ch = "";
string chr = "";
string table[1000000];
string cht[1000000];
string cht2[1000000];
string mat[100][100];
long long int t[1000000];
long long int t2[1000000];
long long int t3[1000000];
long long int t4[1000000];
long long int n, m, k, s, s1, p, x, y, z;
string str;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> t[i];
}
s1 = 0;
for (int j = 0; j < n; ++j) {
s = 0;
for (int i = 0; i < n; ++i) {
if (t[i] == t[j]) {
s++;
}
}
if (s > s1) {
s1 = s;
}
}
cout << s1;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int Transform(char c) {
if (c == 'A') return 0;
if (c == 'T') return 9;
if (c == 'J') return 10;
if (c == 'Q') return 11;
if (c == 'K') return 12;
return c - '1';
}
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
return a.second < b.second;
}
int main() {
pair<int, int> p[3];
int Minx = 1e9, Maxx = -1, Miny = 1e9, Maxy = 0;
for (int i = 0; i < 3; i++) {
int first, second;
scanf("%d %d", &first, &second);
p[i] = make_pair((first), (second));
Minx = min(Minx, first);
Maxx = max(Maxx, first);
Miny = min(Miny, second);
Maxy = max(Maxy, second);
}
printf("%d\n", Maxx - Minx + Maxy - Miny + 1);
sort(p, p + 3);
set<pair<int, int> > s;
for (int i = p[0].first; i <= p[1].first; i++) {
s.insert(make_pair((i), (p[0].second)));
}
for (int i = p[2].first; i >= p[1].first; i--) {
s.insert(make_pair((i), (p[2].second)));
}
int xx = p[1].first;
sort(p, p + 3, cmp);
for (int i = p[0].second; i <= p[2].second; i++) {
s.insert(make_pair((xx), (i)));
}
for (auto it : s) printf("%d %d\n", it.first, it.second);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
double a[100500];
double d[100500];
int n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%lf", &a[i]);
double res = 0;
for (int i = 0; i < n; i++) res += a[i];
d[0] = 0;
for (int i = 1; i < n; i++) d[i] = (d[i - 1] + a[i - 1]) * a[i];
for (int i = 0; i < n; i++) res += 2 * d[i];
printf("%0.8lf", res);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (abs(x1 - x2) == 0)
cout << 4 + (abs(y1 - y2) + 1) * 2;
else if (abs(y1 - y2) == 0)
cout << 4 + (abs(x1 - x2) + 1) * 2;
else
cout << (abs(x1 - x2) + 1) * 2 + (abs(y1 - y2) + 1) * 2;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool simple[1000001];
vector<int> q;
int a[1000001];
vector<int> p;
vector<int> gr[1000001];
int l[1000001], r[1000001];
bool was[1000001];
int w[1000001];
bool dfs(int v) {
if (was[v]) return false;
was[v] = true;
for (int i = 0; i < int(gr[v].size()); i++)
if (w[gr[v][i]] == -1 || dfs(w[gr[v][i]])) {
w[gr[v][i]] = v;
return true;
}
return false;
}
vector<int> first;
int main() {
for (int i = 2; i < 1000000; i++) simple[i] = true;
for (int i = 2; i < 1000000; i++)
if (simple[i]) {
for (int j = 2 * i; j < 1000000; j += i) simple[j] = false;
p.push_back(i);
}
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
vector<int> g;
for (int j = 0; j < int(p.size()) && a[i] >= p[j]; j++)
while (a[i] % p[j] == 0) {
a[i] /= p[j];
g.push_back(p[j]);
}
if (a[i] != 1) g.push_back(a[i]);
l[i] = int(q.size()), r[i] = int(q.size()) + int(g.size());
for (int j = 0; j < int(g.size()); j++) {
if (i % 2 == 0) first.push_back(int(q.size()));
q.push_back(g[j]);
}
}
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--, y--;
for (int j = l[x]; j < r[x]; j++)
for (int k = l[y]; k < r[y]; k++)
if (q[j] == q[k]) {
gr[k].push_back(j);
gr[j].push_back(k);
}
}
for (int i = 0; i < int(q.size()); i++) w[i] = -1;
for (int i = 0; i < int(first.size()); i++) {
for (int j = 0; j < int(q.size()); j++) was[j] = false;
dfs(first[i]);
}
int ans = 0;
for (int i = 0; i < int(q.size()); i++)
if (w[i] != -1) ans++;
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
long long a[n], dp1[n], dp2[n], ans;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (n == 1) {
cout << a[0] << "\n";
return 0;
}
dp1[0] = a[0];
dp1[1] = a[1];
for (int i = 2; i < n; i++) {
dp1[i] = a[i] + dp1[i - 2];
}
dp2[n - 1] = a[n - 1];
dp2[n - 2] = a[n - 2];
for (int i = n - 3; i > -1; i--) {
dp2[i] = a[i] + dp2[i + 2];
}
ans = dp2[0];
for (int i = 0; i < n - 1; i++) {
ans = max(ans, dp1[i] + dp2[i + 1]);
}
cout << ans << "\n";
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int t;
cin >> t;
while (t -- ){
int n, k;
cin >> n >> k;
for (int i = 0; i < k - 3; i ++ )
printf("1 ");
n -= k - 3;
if (n & 1)
printf("%d %d %d\n", 1, n / 2, n / 2);
else if (n % 4)
printf("%d %d %d\n", 2, n / 2 - 1, n / 2 - 1);
else
printf("%d %d %d\n", n / 2, n / 4, n / 4);
}
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
int dis = 0;
int mv = 0;
int is_there(int n) {
if (dis + 5 <= n)
dis += 5;
else if (dis + 4 <= n)
dis += 4;
else if (dis + 3 <= n)
dis += 3;
else if (dis + 2 <= n)
dis += 2;
else if (dis + 1 <= n)
dis += 1;
mv += 1;
if (dis == n) return mv;
is_there(n);
}
int main() {
int n;
scanf("%u", &n);
cout << is_there(n);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
int dp[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) dp[i][j] = 0;
for (int i = 0; i < n; i++) dp[i][i] = 1;
for (int i = 0; i < n - 1; i++) {
if (s[i] == s[i + 1])
dp[i][i + 1] = 2;
else
dp[i][i + 1] = 0;
}
int diff = 2;
for (int k = diff; k <= n - 1; k++) {
for (int i = 0; i + k < n; i++) {
int j = i + k;
if (s[i] != s[j])
dp[i][j] = 0;
else if (dp[i + 1][j - 1] == 0)
dp[i][j] = 0;
else
dp[i][j] = dp[i][(i + j - 1) / 2] + 1;
}
}
int ans[n + 1], tmp[n + 1];
for (int i = 0; i <= n; i++) ans[i] = 0, tmp[i] = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
tmp[dp[i][j]]++;
}
}
for (int i = 0; i <= n; i++) {
for (int j = i; j <= n; j++) {
ans[i] += tmp[j];
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, j, a = -1, b = 1, i;
cin >> n;
k = n;
for (int r = 1; r <= 1000; r++) {
i = r;
if ((i >= 1) && (i <= 9)) j = 1;
if ((i >= 10) && (i <= 99)) j = 2;
if ((i >= 100) && (i <= 999)) j = 3;
if ((k - j) > 0)
k = k - j;
else {
if ((k == 1) && (j != 1)) {
for (int p = 1; p < j; p++) b = b * 10;
a = i / b;
}
if ((k == 1) && (j == 1)) a = i;
if ((k == 2) && (j == 2)) {
a = i % 10;
}
if (k == 3) {
a = i % 10;
}
if ((k == 2) && (j == 3)) {
a = (i / 10) % 10;
}
}
if (a != -1) break;
}
cout << a << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> dp[501][501];
int a[501], n;
void solve(int tl, int tr) {
if (tl == tr) {
dp[tl][tr].first = 1;
dp[tl][tr].second = a[tl];
return;
}
if (dp[tl][tr].first != 0) return;
dp[tl][tr].first = n;
for (int i = tl + 1; i <= tr; i++) {
solve(tl, i - 1);
solve(i, tr);
dp[tl][tr].first =
min(dp[tl][tr].first, dp[tl][i - 1].first + dp[i][tr].first);
if (dp[tl][i - 1].first == 1 && dp[i][tr].first == 1 &&
dp[i][tr].second == dp[tl][i - 1].second) {
dp[tl][tr].first = 1;
dp[tl][tr].second = dp[i][tr].second + 1;
break;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
istream::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
solve(0, n - 1);
cout << dp[0][n - 1].first;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e6 + 10;
int a[SIZE];
int n;
vector<int> an;
void big_one(int x) {
if (x <= 6) {
an.push_back(x);
an.push_back(x + 3);
an.push_back(x + 6);
an.push_back(x + 3);
an.push_back(x + 4);
an.push_back(x + 5);
an.push_back(x + 4);
an.push_back(x + 5);
an.push_back(x + 6);
} else {
an.push_back(x - 6);
an.push_back(x - 3);
an.push_back(x);
an.push_back(x - 6);
an.push_back(x - 5);
an.push_back(x - 4);
an.push_back(x - 5);
an.push_back(x - 4);
an.push_back(x - 3);
}
}
void solve_big() {
vector<int> ones;
int r = n / 3 + 12;
for (int j = 1; j + 2 <= n; j++) {
for (int dd = (1); dd <= (1000); ++dd) {
if (j - dd < 1 || j + dd > n) break;
if (a[j] && a[j - dd] && a[j + dd]) {
a[j - dd] = 0;
a[j] = 0;
a[j + dd] = 0;
r--;
an.push_back(j - dd);
an.push_back(j);
an.push_back(j + dd);
}
}
}
for (int i = (1); i <= (n); ++i) {
if (a[i] == 1) ones.push_back(i);
}
set<int> H((ones).begin(), (ones).end());
while (((int)(H).size())) {
if (((int)(H).size()) * 3 <= r) {
for (int x : H) {
big_one(x);
}
break;
} else {
int x = *H.begin();
int y = *next(H.begin());
int z = y * 2 - x;
if (z <= n) {
an.push_back(x);
an.push_back(y);
an.push_back(z);
r--;
H.erase(x);
H.erase(y);
if (H.count(z)) {
H.erase(z);
} else
H.insert(z);
} else {
z = n;
if (n % 2 != x % 2) z--;
y = (x + z) / 2;
an.push_back(x);
an.push_back(y);
an.push_back(z);
r--;
H.erase(x);
if (H.count(y)) {
H.erase(y);
} else
H.insert(y);
if (H.count(z)) {
H.erase(z);
} else
H.insert(z);
}
}
}
W("YES");
W(((int)(an).size()) / 3);
for (int i = 0; i < ((int)(an).size()); i += 3) {
W(an[i], an[i + 1], an[i + 2]);
}
}
int gg[15][100], gg_r[15];
void solve_small() {
vector<int> mask;
int gn = 0;
vector<int> ker[100];
for (int dd = (1); dd <= (12); ++dd) {
for (int j = 1; j + dd * 2 <= n; j++) {
gg[j][gn] = 1;
gg[j + dd][gn] = 1;
gg[j + dd * 2][gn] = 1;
ker[gn] = {j, j + dd, j + dd * 2};
gn++;
}
}
for (int i = (1); i <= (n); ++i) {
if (a[i]) {
gg_r[i] = 1;
}
}
int st = 1;
for (int i = 0; i < gn; i++) {
int now = -1;
for (int j = st; j <= n; j++) {
if (gg[j][i]) {
now = j;
break;
}
}
if (now == -1) continue;
if (now != st) {
for (int j = 0; j < (gn); ++j) swap(gg[now][j], gg[st][j]);
swap(gg_r[now], gg_r[st]);
}
for (int j = (1); j <= (n); ++j) {
if (j == st) continue;
if (gg[j][i]) {
for (int k = 0; k < (gn); ++k) gg[j][k] ^= gg[st][k];
gg_r[j] ^= gg_r[st];
}
}
st++;
}
for (int i = (st); i <= (n); ++i) {
if (gg_r[i]) {
W("NO");
return;
}
}
W("YES");
for (int i = st - 1; i >= 1; i--) {
if (!gg_r[i]) continue;
for (int j = 0; j < gn; j++) {
if (gg[i][j]) {
for (int x : ker[j]) {
an.push_back(x);
}
break;
}
}
}
W(((int)(an).size()) / 3);
for (int i = 0; i < ((int)(an).size()); i += 3) {
W(an[i], an[i + 1], an[i + 2]);
}
}
int main() {
R(n);
for (int i = (1); i <= (n); ++i) R(a[i]);
if (n <= 12) {
solve_small();
} else {
solve_big();
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res % mod;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
const std::vector<std::pair<int, int>> moves{{0, -1}, {-1, 0}, {0, 1}, {1, 0}};
inline int bitCount(long long x) { return __builtin_popcountll(x); }
inline long long highestOneBit(long long x) {
return 1LL << (63 - __builtin_clzll(x | 1LL));
}
inline int binaryDigits(long long x) { return 64 - __builtin_clzll(x | 1LL); }
template <typename A>
string to_string(A *ptr) {
stringstream ss;
ss << "0x" << std::setw(16) << std::setfill('0') << std::hex
<< (uint64_t)(uintptr_t)ptr;
return ss.str();
}
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
template <const int &MOD>
struct _m_int {
int val;
_m_int(int64_t v = 0) {
if (v < 0) v = v % MOD + MOD;
if (v >= MOD) v %= MOD;
val = v;
}
static int inv_mod(int a, int m = MOD) {
int g = m, r = a, x = 0, y = 1;
while (r != 0) {
int q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + m : x;
}
explicit operator int() const { return val; }
explicit operator int64_t() const { return val; }
_m_int &operator+=(const _m_int &other) {
val -= MOD - other.val;
if (val < 0) val += MOD;
return *this;
}
_m_int &operator-=(const _m_int &other) {
val -= other.val;
if (val < 0) val += MOD;
return *this;
}
static unsigned fast_mod(uint64_t x, unsigned m = MOD) {
return x % m;
unsigned x_high = x >> 32, x_low = (unsigned)x;
unsigned quot, rem;
asm("divl %4\n" : "=a"(quot), "=d"(rem) : "d"(x_high), "a"(x_low), "r"(m));
return rem;
}
_m_int &operator*=(const _m_int &other) {
val = fast_mod((uint64_t)val * other.val);
return *this;
}
_m_int &operator/=(const _m_int &other) { return *this *= other.inv(); }
friend _m_int operator+(const _m_int &a, const _m_int &b) {
return _m_int(a) += b;
}
friend _m_int operator-(const _m_int &a, const _m_int &b) {
return _m_int(a) -= b;
}
friend _m_int operator*(const _m_int &a, const _m_int &b) {
return _m_int(a) *= b;
}
friend _m_int operator/(const _m_int &a, const _m_int &b) {
return _m_int(a) /= b;
}
_m_int &operator++() {
val = val == MOD - 1 ? 0 : val + 1;
return *this;
}
_m_int &operator--() {
val = val == 0 ? MOD - 1 : val - 1;
return *this;
}
_m_int operator++(int) {
_m_int before = *this;
++*this;
return before;
}
_m_int operator--(int) {
_m_int before = *this;
--*this;
return before;
}
_m_int operator-() const { return val == 0 ? 0 : MOD - val; }
bool operator==(const _m_int &other) const { return val == other.val; }
bool operator!=(const _m_int &other) const { return val != other.val; }
_m_int inv() const { return inv_mod(val); }
_m_int pow(int64_t p) const {
if (p < 0) return inv().pow(-p);
_m_int a = *this, result = 1;
while (p > 0) {
if (p & 1) result *= a;
a *= a;
p >>= 1;
}
return result;
}
friend ostream &operator<<(ostream &os, const _m_int &m) {
return os << m.val;
}
};
extern const int MOD = mod;
using mint = _m_int<MOD>;
void solve() {
int n, p;
cin >> n >> p;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
if (p == 1) {
cout << n % 2 << '\n';
return;
}
sort(a.rbegin(), a.rend());
long long diff = 0;
long long cur_k = a[0];
mint ans = 0;
for (int i = 0; i < n; i++) {
while (diff && cur_k > a[i] && abs(diff) <= n - i) {
--cur_k;
diff *= p;
}
if (abs(diff) >= n - i) {
int sgn = abs(diff) / diff;
for (int j = i; j < n; j++) ans += -sgn * powmod(p, a[j]);
break;
}
cur_k = a[i];
if (diff <= 0) {
diff += 1;
ans += powmod(p, a[i]);
} else {
diff -= 1;
ans -= powmod(p, a[i]);
}
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int _;
cin >> _;
while (_--) {
42;
solve();
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 100500;
char buf[10];
string scan_token() {
scanf("%s", buf);
return buf;
}
int n;
string name[N];
bool sample[N];
int samples_cnt;
string temp_file;
set<string> all_names;
vector<pair<string, string>> ops;
vector<string> sample_holes, test_holes;
vector<int> sample_bad, test_bad;
bool try_parse(const string& s, int& num) {
if (s.empty() || s[0] == '0') return false;
for (char c : s)
if (!isdigit(c)) return false;
num = atoi(s.c_str());
return true;
}
void fill_bad() {
sample_bad.clear();
test_bad.clear();
for (int i = 0; i < n; i++) {
int num;
if (!try_parse(name[i], num)) continue;
if (1 <= num && num <= samples_cnt && !sample[i]) test_bad.push_back(i);
if (samples_cnt < num && num <= n && sample[i]) sample_bad.push_back(i);
}
}
bool generate_temp(int p) {
if (p == 6) return !all_names.count(temp_file);
for (char c = 'a'; c <= 'z'; c++) {
temp_file += c;
if (generate_temp(p + 1)) return true;
temp_file.pop_back();
}
return false;
}
void solve() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
name[i] = scan_token();
all_names.insert(name[i]);
int t;
scanf("%d", &t);
sample[i] = t == 1;
samples_cnt += t;
}
generate_temp(0);
for (int i = 1; i <= n; i++) {
string f = to_string(i);
if (all_names.count(f)) continue;
if (i <= samples_cnt)
sample_holes.push_back(f);
else
test_holes.push_back(f);
}
fill_bad();
bool any = true;
while (any) {
any = false;
if (!test_bad.empty() && !test_holes.empty()) {
int i = test_bad.back();
test_bad.pop_back();
string hole = test_holes.back();
test_holes.pop_back();
sample_holes.push_back(name[i]);
ops.emplace_back(name[i], hole);
name[i] = hole;
any = true;
}
if (!sample_bad.empty() && !sample_holes.empty()) {
int i = sample_bad.back();
sample_bad.pop_back();
string hole = sample_holes.back();
sample_holes.pop_back();
test_holes.push_back(name[i]);
ops.emplace_back(name[i], hole);
name[i] = hole;
any = true;
}
}
for (int i = 0; i < n; i++) {
int num;
if (try_parse(name[i], num) && 1 <= num && num <= n) continue;
if (sample[i]) {
if (!sample_holes.empty()) {
string hole = sample_holes.back();
sample_holes.pop_back();
ops.emplace_back(name[i], hole);
name[i] = hole;
}
} else {
if (!test_holes.empty()) {
string hole = test_holes.back();
test_holes.pop_back();
ops.emplace_back(name[i], hole);
name[i] = hole;
}
}
}
fill_bad();
if (sample_bad.size() != test_bad.size()) throw logic_error("baaad");
if (!sample_bad.empty()) {
ops.emplace_back(name[sample_bad[0]], temp_file);
for (int i = 0; i < (int)sample_bad.size(); i++) {
ops.emplace_back(name[test_bad[i]], name[sample_bad[i]]);
if (i + 1 < (int)sample_bad.size())
ops.emplace_back(name[sample_bad[i + 1]], name[test_bad[i]]);
}
ops.emplace_back(temp_file, name[test_bad.back()]);
}
printf("%d\n", (int)ops.size());
for (const auto& e : ops)
printf("move %s %s\n", e.first.c_str(), e.second.c_str());
}
int main() {
solve();
(void)0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return 0;
}
template <typename T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return 0;
}
void solve() {
ll N;
cin >> N;
ll n2 = 2;
for (; n2 * (n2 - 1) / 2 <= N; ++n2) {
}
--n2;
N -= n2 * (n2 - 1) / 2;
cout << 1;
for (int i = (int)0; i < (int)n2 - 2; ++i) {
cout << 3;
}
for (int i = (int)0; i < (int)N; ++i) {
cout << 1;
}
cout << 337 << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int T;
cin >> T;
for (int i = (int)0; i < (int)T; ++i) solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 101, INF = -1 * (1e+9);
long long n, k, p, x;
bool check(long long x) {
if (k == -1) return 0;
if (x == n + 1) return 1;
if (k == 0) return 0;
if (k <= n / 2) {
if (x % 2 || x < n - (k - 1) * 2) return 0;
return 1;
}
if (x % 2 == 0) return 1;
long long q = k - n / 2;
if (n - (q - 1) * 2 - 1 > x) return 0;
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> p;
if (n % 2) {
n--;
k--;
}
for (int i = 0; i < p; i++) {
cin >> x;
if (check(x))
cout << 'X';
else
cout << '.';
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int pct(int x) { return __builtin_popcount(x); }
int pct(long long x) { return __builtin_popcountll(x); }
int bt(int x) { return 31 - __builtin_clz(x); }
int bt(long long x) { return 63 - __builtin_clzll(x); }
int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }
long long cdiv(long long a, long long b) {
return a / b + !(a < 0 || a % b == 0);
}
int nxt_C(int x) {
int c = x & -x, r = x + c;
return (((r ^ x) >> 2) / c) | r;
}
long long nxt_C(long long x) {
long long c = x & -x, r = x + c;
return (((r ^ x) >> 2) / c) | r;
}
vector<int> get_bits(int mask) {
vector<int> bb;
while (mask) {
int b = bt(mask);
bb.push_back(b);
mask ^= (1 << b);
}
reverse(bb.begin(), bb.end());
return bb;
}
int get_mask(vector<int> v) {
int mask = 0;
for (int x : v) {
mask ^= (1 << x);
}
return mask;
}
template <typename T>
void uniq(vector<T> &v) {
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rand(long long l, long long r) {
uniform_int_distribution<long long> uid(l, r);
return uid(rng);
}
void sc() {}
template <typename Head, typename... Tail>
void sc(Head &H, Tail &...T) {
cin >> H;
sc(T...);
}
const int mod = 1e9 + 7;
int pwr(int a, long long b) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * 1LL * a) % mod;
a = (a * 1LL * a) % mod;
b >>= 1;
}
return ans;
}
const int N = 505;
int a[N], b[N];
void solve() {
int n;
sc(n);
for (int i = 1; i <= n; i++) {
sc(a[i]);
}
for (int i = 1; i <= n; i++) {
sc(b[i]);
}
if ((n & 1) && a[(n + 1) / 2] != b[(n + 1) / 2]) {
cout << "No" << '\n';
return;
}
vector<pair<int, int> > v, v1;
for (int i = 1; i <= n / 2; i++) {
if (a[i] > a[n - i + 1]) swap(a[i], a[n - i + 1]);
if (b[i] > b[n - i + 1]) swap(b[i], b[n - i + 1]);
v.push_back({a[i], a[n - i + 1]});
v1.push_back({b[i], b[n - i + 1]});
}
sort(v.begin(), v.end());
sort(v1.begin(), v1.end());
cout << ((v == v1) ? "Yes" : "No") << '\n';
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
for (int tt = 1; tt <= t; tt++) {
solve();
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int inf = 1e9 + 7;
const double eps = 1e-8;
long long qpow(long long a, long long b, long long m) {
long long r = 1;
a %= m;
for (; b; b >>= 1) {
if (b & 1) r = r * a % m;
a = a * a % m;
}
return (r + m) % m;
}
const int maxn = 42;
int vis[50][50][50][4][4][4];
int a[4][4];
int ans = 0;
int dfs(int x1, int x2, int x3, int A, int B, int C) {
if (vis[x1][x2][x3][A][B][C]) return 0;
vis[x1][x2][x3][A][B][C] = 1;
int b[4] = {0, x1, x2, x3};
int c[4] = {0, A, B, C};
int g[50] = {0};
for (int i = 1; i <= 3; i++) g[b[i]] = i;
for (int i = 1; i <= 3; i++) {
int t = b[i];
if (t <= maxn) {
ans = max(ans, t);
if (!(c[i] & 1) && !g[maxn + i]) {
for (int j = max(0, t - a[i][2]); j <= t + a[i][2]; j++) {
if (j > 0 && !g[j]) {
b[i] = j;
c[i] ^= 1;
dfs(b[1], b[2], b[3], c[1], c[2], c[3]);
b[i] = t;
c[i] ^= 1;
}
}
}
if (!(c[i] & 2) && !g[maxn + i]) {
for (int j = 1; j <= 3; j++) {
int v = b[j];
if (abs(t - v) != 1) continue;
b[j] = maxn + i;
c[i] ^= 2;
dfs(b[1], b[2], b[3], c[1], c[2], c[3]);
b[j] = v;
c[i] ^= 2;
}
}
if (g[maxn + i]) {
int k = g[maxn + i];
for (int j = max(0, t - a[i][3]); j <= t + a[i][3]; j++) {
if (j > 0 && !g[j]) {
b[k] = j;
dfs(b[1], b[2], b[3], c[1], c[2], c[3]);
b[k] = maxn + i;
}
}
}
}
}
return 0;
}
int main() {
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++) cin >> a[i][j];
dfs(a[1][1], a[2][1], a[3][1], 0, 0, 0);
cout << ans << '\n';
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101;
const long long int mod = 1e9 + 7;
long long int dp[N][2];
int n, k, d;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> d;
dp[0][0] = 1;
dp[0][1] = 0;
for (int v = 1; v <= n; v++) {
for (int aresta = 1; aresta <= k; aresta++) {
if (aresta > v) break;
dp[v][0] += dp[v - aresta][0] % mod;
if (aresta < d) {
dp[v][1] += dp[v - aresta][1] % mod;
} else {
dp[v][1] += dp[v - aresta][0] % mod;
}
dp[v][0] %= mod;
dp[v][1] %= mod;
}
}
cout << dp[n][1] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long s = n - k - 1;
long long r = s % k;
s = s / k;
if (r == 1) {
cout << 2 + s + s + 1 << endl;
} else if (r >= 2) {
cout << 2 + s + 1 + s + 1 << endl;
} else {
cout << 2 + s + s << endl;
}
long long count = 2;
for (long long i = 0; i < r; i++) {
cout << 1 << " " << count << endl;
for (long long j = 0; j < s + 1; j++) {
cout << count << " " << count + 1 << endl;
count++;
}
count++;
}
for (long long i = 0; i < k - r; i++) {
cout << 1 << " " << count << endl;
for (long long j = 0; j < s; j++) {
cout << count << " " << count + 1 << endl;
count++;
}
count++;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
void JIZZ(string output = "") {
cout << output;
exit(0);
}
const long double PI = 3.14159265358979323846264338327950288;
const long double eps = 1e-13;
const long long mod = 1e9 + 7;
const long long p = 47017;
long long hsh[50005], ppp[50005];
inline long long ghh(int L, int R) {
return (hsh[R] - (L ? hsh[L - 1] : 0) + mod) * ppp[50004 - R] % mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.size();
ppp[0] = 1;
for (int i = 1; i < 50005; ++i) ppp[i] = ppp[i - 1] * p % mod;
hsh[0] = s[0];
for (int i = 1; i < n; ++i) hsh[i] = (hsh[i - 1] + s[i] * ppp[i]) % mod;
auto chk1 = [&]() -> void {
string ss;
for (char c : s) {
if (ss.size() && c == ss.back())
;
else
ss += c;
}
s = ss;
n = s.size();
hsh[0] = s[0];
for (int i = 1; i < n; ++i) hsh[i] = (hsh[i - 1] + s[i] * ppp[i]) % mod;
return;
};
auto chk2 = [&]() -> void {
bool rt = 0;
string ss;
for (char c : s) {
if (ss.size() > 1 && c == ss[ss.size() - 2] &&
ss.back() == ss[ss.size() - 3])
ss.pop_back();
else
ss += c;
}
s = ss;
n = s.size();
hsh[0] = s[0];
for (int i = 1; i < n; ++i) hsh[i] = (hsh[i - 1] + s[i] * ppp[i]) % mod;
return;
};
int len, spos;
auto chk = [&]() -> int {
for (int j = spos + len - 1, L, R, fr, bk, mid, jj; j + len < n; j += len) {
if (s[j] != s[j + len]) continue;
L = 0, R = len;
jj = j + len;
while (R > L) {
mid = (L + R + 1) >> 1;
if (ghh(j - mid + 1, j) == ghh(jj - mid + 1, jj))
L = mid;
else
R = mid - 1;
}
fr = L;
L = 0, R = min(len, n - jj);
while (R > L) {
mid = (L + R + 1) >> 1;
if (ghh(j, j + mid - 1) == ghh(jj, jj + mid - 1))
L = mid;
else
R = mid - 1;
}
bk = L - 1;
if (fr + bk >= len) {
s.erase(j, len);
n = s.size();
hsh[0] = s[0];
for (int i = 1; i < n; ++i) hsh[i] = (hsh[i - 1] + s[i] * ppp[i]) % mod;
return j - len + 1;
}
}
return -1;
};
chk1();
chk2();
for (len = 3; len <= s.size() >> 1; ++len) {
spos = 0;
while ((spos = chk()) != -1)
;
}
cout << s << endl;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string toString(T Number) {
stringstream st;
st << Number;
return st.str();
}
int stringconvert(string s) {
int p;
istringstream st(s);
st >> p;
return p;
}
long long bigmod(long long a, long long b, long long m) {
long long res = 1;
while (b) {
if (b & 1) {
res = ((res % m) * (a % m)) % m;
}
a = ((a % m) * (a % m)) % m;
b >>= 1;
}
return res;
}
long long modInverse(long long a, long long m) { return bigmod(a, m - 2, m); }
int main() {
ios_base::sync_with_stdio(0);
;
long long n, val[300010], sum[300010] = {0};
cin >> n;
for (int i = 0; i < n; i++) {
cin >> val[i];
}
sort(val, val + n);
sum[0] = val[0];
for (int i = 1; i < n; i++) {
sum[i] = sum[i - 1] + val[i];
}
long long ret = sum[n - 1];
for (int i = 0; i < n - 1; i++) {
ret += val[i];
ret += (sum[n - 1] - sum[i]);
}
cout << ret << endl;
return 0;
}
| 4 |
Subsets and Splits