solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using li = long long;
using ld = long double;
using pii = pair<int, int>;
const int INF = 2e9 + 13;
const int N = 3e5 + 13;
int a[N];
void solve() {
int n, k, d;
cin >> n >> k >> d;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int l = 0, r = 2 * k - 1;
for (int i = 0; i < n; i++) {
if (a[i] > d) {
cout << "No" << endl;
return;
}
if (a[i] + k <= d) {
l = 0;
r = 2 * k - 1;
continue;
}
int nl = max(0, k + a[i] - d);
int nr = min(2 * k - 1, d + k - a[i]);
if (l > 0) {
nl = max(nl, l + 1);
nr = min(nr, r + 1);
}
if (nr < nl) {
cout << "No" << endl;
return;
}
l = nl;
r = nr;
}
cout << "Yes" << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int a[1005];
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
n = unique(a, a + n) - a;
for (int i = 2; i < n; i++)
if (a[i] - a[i - 2] == 2) {
cout << "YES\n";
return 0;
}
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 5;
const long long mod = 1e9 + 7;
long long dp[N];
void pre() {
dp[3] = 4;
dp[4] = 4;
dp[5] = 12;
for (long long i = 6; i < N; i++) {
dp[i] = 4;
dp[i] += dp[i - 2];
dp[i] %= mod;
dp[i] += dp[i - 3];
dp[i] %= mod;
dp[i] += dp[i - 3];
dp[i] %= mod;
dp[i] += dp[i - 3];
dp[i] %= mod;
dp[i] += dp[i - 4];
dp[i] %= mod;
dp[i] += dp[i - 4];
dp[i] %= mod;
dp[i] += dp[i - 3];
dp[i] %= mod;
dp[i] += dp[i - 4];
dp[i] %= mod;
dp[i] += dp[i - 4];
dp[i] %= mod;
dp[i] = max(dp[i], ((2 * dp[i - 2]) % mod + dp[i - 1]) % mod);
}
}
int main() {
long long t;
pre();
cin >> t;
for (long long i = 0; i < t; i++) {
long long n;
cin >> n;
cout << dp[n] << '\n';
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-6;
int n, p;
int f(vector<int> v, long double k) {
double ans = 0;
double ans2 = 0;
for (int i = 0; i < n; i++) {
if (k < v[i]) {
ans += v[i] - k;
}
}
for (int i = 0; i < n; i++) {
if (v[i] < k) {
ans2 += k - v[i];
}
}
if (ans * (100 - p) / 100 >= ans2) {
return 1;
}
return 0;
}
int main() {
cin >> n >> p;
vector<int> v(n);
int maxi = 0;
for (int i = 0; i < n; i++) cin >> v[i], maxi = max(maxi, v[i]);
long double lo = 0, hi = 1000, mi;
for (int i = 0; i < 70; i++) {
mi = (lo + hi) / 2.0;
if (f(v, mi))
lo = mi;
else
hi = mi;
}
printf("%.8f\n", (double)hi);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m, k, x;
cin >> n >> m >> k;
map<int, int, greater<int> > s;
for (int i = 0; i < n; i++) {
cin >> x;
s[x]++;
}
for (int i = 0; i < m; i++) {
cin >> x;
s[x]--;
}
int now = 0;
for (map<int, int>::iterator i = s.begin(); i != s.end(); i++) {
now += i->second;
if (now > 0) {
cout << "YES\n";
return 0;
}
}
cout << "NO\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double pi = 3.1415926535;
double r, n;
cin >> n >> r;
double ans, d;
d = (n - 2) / n * pi;
d /= 2;
ans = r * cos(d) / (1 - cos(d));
cout << fixed << setprecision(7) << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300000;
const int INF = 1000000000;
const int MAXV = 40;
int n;
int a[MAXN];
int dp[2][MAXV + 1];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i <= MAXV; i++) dp[0][i] = INF;
dp[0][0] = 0;
int t = 0;
for (int i = 0; i < n; i++, t = 1 - t) {
for (int j = 0; j <= MAXV; j++) dp[1 - t][j] = INF;
for (int j = 0; j <= MAXV; j++)
if (dp[t][j] < INF) {
int nj = min(j + a[i] / 1000, MAXV);
dp[1 - t][nj] = min(dp[1 - t][nj], dp[t][j] + a[i]);
int discount = min(a[i], 100 * j);
nj = j - discount / 100;
dp[1 - t][nj] = min(dp[1 - t][nj], dp[t][j] + a[i] - discount);
}
}
int res = INF;
for (int i = 0; i <= MAXV; i++) res = min(res, dp[t][i]);
printf("%d\n", res);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int oo = (int)1e9;
const double PI = 2 * acos(0.0);
const double eps = 1e-9;
int n, m, x, l, f;
int main() {
ios_base::sync_with_stdio(false);
int arr[100010];
memset(arr, -1, sizeof(arr));
cin >> n;
int cnt = 0, previdx, prevval;
if (n % 2 == 1) arr[n / 2 + 1] = n / 2 + 1, cnt++;
while (cnt < n) {
int nxtidx = -1;
for (int i = 1; i < (int)(n + 1); i++)
if (arr[i] == -1) {
nxtidx = i;
break;
}
arr[nxtidx] = prevval = n - nxtidx;
cnt++;
previdx = nxtidx;
while (arr[n - prevval + 1] == -1) {
arr[n - prevval + 1] = previdx;
int t = previdx;
previdx = n - prevval + 1;
prevval = t;
cnt++;
}
}
bool valid = true;
for (int i = 1; i < (int)(n + 1); i++) {
if (arr[arr[i]] != n - i + 1) valid = false;
}
if (!valid)
cout << -1 << endl;
else
for (int i = 1; i < (int)(n + 1); i++) {
;
if (i != 1) cout << " ";
cout << arr[i];
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, ans = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
for (int i = 0; i < n; i++) {
if ((sum - a[i]) % 2 == 0) ans++;
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
string s, t;
cin >> s >> t;
int n = s.length();
int m = t.length();
int a[m], b[m];
int i = 0, k = 0;
while (i < n && k < m) {
if (t[k] == s[i]) {
a[k] = i;
k++;
}
i++;
}
i = n - 1;
k = m - 1;
while (i >= 0 && k >= 0) {
if (t[k] == s[i]) {
b[k] = i;
k--;
}
i--;
}
int maximum;
maximum = max(a[0], n - b[m - 1] - 1);
maximum = max(maximum, max(n - 1 - a[m - 1], b[0]));
for (int i = 0; i < m - 1; i++) {
maximum = max(maximum, b[i + 1] - a[i] - 1);
}
cout << maximum << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, used[300005], d[300005], up[300005], mn[300005], mx[300005],
sf[300005];
vector<int> g[300005];
pair<int, int> t[4 * 300005];
long long pr[300005];
pair<int, int> merge(pair<int, int> a, pair<int, int> b) {
return make_pair(max(a.first, b.first), min(a.second, b.second));
}
void upd(int v, int l, int r, int pos, pair<int, int> val) {
if (l == r) {
t[v] = val;
return;
}
int m = (l + r) / 2;
if (pos <= m)
upd(v * 2, l, m, pos, val);
else
upd(v * 2 + 1, m + 1, r, pos, val);
t[v] = merge(t[v * 2], t[v * 2 + 1]);
}
pair<int, int> get(int v, int l, int r, int i, int j) {
if (i > j) return make_pair(0, 1000000007ll);
if (l == i && r == j) return t[v];
int m = (l + r) / 2;
return merge(get(v * 2, l, m, i, min(j, m)),
get(v * 2 + 1, m + 1, r, max(i, m + 1), j));
}
void dfs(int v, int p) {
upd(1, 1, n, d[v], make_pair(v, v));
used[v] = 1;
mn[v] = 1000000007ll;
vector<int> c;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) continue;
if (used[to]) {
if (d[to] < d[up[v]]) up[v] = to;
continue;
}
d[to] = d[v] + 1;
dfs(to, v);
if (d[up[to]] < d[up[v]]) up[v] = up[to];
c.push_back(to);
}
for (int i = 0; i < c.size(); i++) {
int to = c[i];
if (up[to] != up[v]) continue;
mx[v] = max(mx[v], mx[to]);
mn[v] = min(mn[v], mn[to]);
}
pair<int, int> mxn = get(1, 1, n, d[up[v]], d[v]);
mx[v] = max(mx[v], mxn.first);
mn[v] = min(mn[v], mxn.second);
upd(1, 1, n, d[v], make_pair(0, 1000000007ll));
}
int main() {
cin >> n >> m;
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
d[0] = 1000000007ll;
for (int i = 1; i <= n; i++)
if (!used[i]) {
d[i] = 1;
dfs(i, -1);
}
sf[n + 1] = 1000000007ll;
for (int i = n; i >= 1; i--) {
sf[i] = sf[i + 1];
if (up[i] && mn[i] == i) sf[i] = min(sf[i], mx[i] - 1);
}
for (int i = 1; i <= n; i++) pr[i] = pr[i - 1] + sf[i] - i + 1;
cin >> q;
while (q--) {
int L, R;
scanf("%d%d", &L, &R);
int l = L, r = R, m, pos = L - 1;
while (l <= r) {
m = (l + r) / 2;
if (sf[m] <= R) {
l = m + 1;
pos = m;
} else
r = m - 1;
}
long long ans = pr[pos] - pr[L - 1];
long long len = R - pos;
ans += (len + 1ll) * (len) / 2;
printf("%lld\n", ans);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int md = 1000000007, MX = 105;
int n, G[MX][MX];
struct poly {
int a[MX];
poly() { memset(a, 0, sizeof(a)); }
inline int &operator[](const int x) { return a[x]; }
inline int deg() {
for (int i = n; i; i--)
if (a[i - 1]) return i;
return 0;
}
inline void mod() {
for (int i = 0; i < n; i++) a[i] = (md + a[i]) % md;
}
inline int operator()(const int x) {
return (a[0] + (long long)a[1] * x) % md;
}
} I, X, O;
inline poly operator+(const poly &l, const poly &r) {
poly res;
for (int i = 0; i < n; i++) res.a[i] = (l.a[i] + r.a[i]) % md;
return res;
}
inline poly operator-(const poly &l, const poly &r) {
poly res;
for (int i = 0; i < n; i++) res.a[i] = (md + l.a[i] - r.a[i]) % md;
return res;
}
inline poly operator*(const int x, const poly &r) {
poly res;
for (int i = 0; i < n; i++) res.a[i] = (long long)r.a[i] * x % md;
return res;
}
inline poly mul(const poly &l, const poly &r) {
poly res;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i + j < n)
res.a[i + j] = (res.a[i + j] + (long long)l.a[i] * r.a[j]) % md;
return res;
}
inline poly tx(const poly &p, int x) {
poly res;
for (int i = 0; i + x < n; i++) res.a[i + x] = p.a[i];
return res;
}
poly A[MX][MX];
int ans[MX], y[MX];
inline int pw(int x, int y) {
int a = 1;
while (y) {
if (y & 1) a = (long long)a * x % md;
x = (long long)x * x % md;
y >>= 1;
}
return a;
}
pair<int, int> fp(int i) {
int a[2], c = 0;
for (int j = i; j < n; j++)
if (A[j][i].deg()) {
a[c++] = j;
if (c == 2) break;
}
if (c < 2) return make_pair(0, 0);
return make_pair(a[0], a[1]);
}
void det_gauss() {
int v, i, j, k, N = n - 1, K;
pair<int, int> pt;
for (v = 0; v < n; v++) {
K = 1;
for (i = 1; i <= N; i++)
for (j = 1; j <= N; j++) G[i][j] = A[i][j](v);
for (i = 1; i <= N; i++) {
for (j = i; j <= N; j++)
if (G[j][i]) break;
if (j == N + 1) {
y[v] = 0;
break;
}
if (j != i) {
K = md - K;
for (k = i; k <= N; k++) swap(G[i][k], G[j][k]);
}
for (j = i + 1; j <= N; j++)
if (G[j][i]) {
int tk = (long long)pw(G[i][i], md - 2) * (md - G[j][i]) % md;
for (k = i; k <= N; k++)
G[j][k] = (G[j][k] + (long long)G[i][k] * tk) % md;
}
}
y[v] = K;
for (i = 1; i <= N; i++) y[v] = (long long)y[v] * G[i][i] % md;
}
poly res;
for (v = 0; v < n; v++) {
K = 1;
for (i = 0; i < n; i++)
if (i != v) K = (long long)K * pw((v - i + md) % md, md - 2) % md;
poly tmp = I;
for (i = 0; i < n; i++)
if (i != v) {
poly t2 = O;
for (j = 0; j + 1 < n; j++) t2[j + 1] = (t2[j + 1] + tmp[j]) % md;
for (j = 0; j < n; j++)
t2[j] = (t2[j] + (long long)tmp[j] * (md - i)) % md;
tmp = t2;
}
for (i = 0; i < n; i++) tmp[i] = (long long)tmp[i] * K % md * y[v] % md;
res = res + tmp;
}
memcpy(ans, res.a, sizeof(int) * n);
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
I.a[0] = X.a[1] = 1;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
G[u][v] = G[v][u] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
++A[i][i][G[i][j]], ++A[j][j][G[i][j]];
--A[i][j][G[i][j]], --A[j][i][G[i][j]];
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) A[i][j].mod();
det_gauss();
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long modpow(long long a, long long n) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % 1000000007ll;
b = (b * b) % 1000000007ll;
n >>= 1;
}
return (long long)ret;
}
bool pal(int x, int y) {
string hour = to_string(x);
if (hour.size() == 1) hour = "0" + hour;
string minute = to_string(y);
if (minute.size() == 1) minute = "0" + minute;
reverse(minute.begin(), minute.end());
return hour == minute;
}
int main() {
string s;
cin >> s;
int hour = stoi(s.substr(0, 2));
int minute = stoi(s.substr(3, 2));
int ans = 0;
while (true) {
if (pal(hour, minute)) break;
minute++;
++ans;
if (minute == 60) {
hour++;
minute = 0;
}
if (hour == 24) hour = 0;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int t;
cin >> t;
while (t--) {
char arr[9][9];
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
cin >> arr[i][j];
if (arr[i][j] == '2') arr[i][j] = '9';
cout << arr[i][j];
}
cout << "\n";
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int a[n];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int sum[n], dp[n][2];
sum[n - 1] = a[n - 1];
dp[n - 1][0] = 0;
dp[n - 1][1] = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
sum[i] = sum[i + 1] + a[i];
dp[i][1] = max(dp[i + 1][0] + a[i], dp[i + 1][1]);
dp[i][0] = sum[i] - dp[i][1];
}
printf("%d %d\n", dp[0][0], dp[0][1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const double pi = 4.0 * atan(1.0);
const double e = exp(1.0);
const int maxn = 1e6 + 8;
const long long mod = 1e9 + 7;
const unsigned long long base = 1e7 + 7;
using namespace std;
string s, t;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
cin >> s >> t;
int is = -1;
for (int i = 0; i < n; i++) {
if (s[i] == '*') {
is = i;
}
}
int i;
for (i = 0; i < is; i++) {
if (s[i] != t[i]) {
cout << "NO" << endl;
return 0;
}
}
if ((is != -1 && n > m + 1) || (is == -1 && n != m)) {
cout << "NO" << endl;
return 0;
}
int j = m - n;
for (int i = is + 1; i < n; i++) {
if (s[i] != t[i + j]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
pair<long long, long long> intersect(pair<long long, long long> a,
pair<long long, long long> b) {
return make_pair(a.first * (b.second - a.second),
a.second * (b.first - a.first));
}
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
return a.first * b.second < b.first * a.second;
}
vector<pair<int, int>> pts;
int a[N], b[N];
vector<pair<int, int>> ConvexHull(vector<pair<int, int>> vp) {
sort(vp.begin(), vp.end());
vector<pair<int, int>> hull;
for (int i = 0; i < vp.size(); i++) {
while (!hull.empty() && hull.back().second <= vp[i].second) hull.pop_back();
hull.push_back(vp[i]);
}
return hull;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
pts.push_back({a[i], b[i]});
}
sort(pts.begin(), pts.end());
pts = ConvexHull(pts);
vector<pair<int, int>> upperHull;
for (int i = 0; i < pts.size(); i++) {
while (upperHull.size() > 1 &&
cmp(intersect(pts[i], upperHull.back()),
intersect(upperHull[upperHull.size() - 2], upperHull.back())))
upperHull.pop_back();
upperHull.push_back(pts[i]);
}
set<pair<int, int>> st;
for (auto x : upperHull) st.insert(x);
for (int i = 0; i < n; i++) {
if (st.count(make_pair(a[i], b[i]))) cout << i + 1 << ' ';
}
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, t, x;
cin >> m;
n = m;
t = 0;
while (n % 10 == 0) {
n = n / 10;
}
m = n;
while (n > 0) {
x = n % 10;
t = t * 10 + x;
n = n / 10;
}
if (t == m)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
int sg[] = {
0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5,
6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8,
8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10,
};
int main() {
int n, x, kk = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &x), kk ^= sg[x];
if (!kk)
puts("YES");
else
puts("NO");
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
long long int SPF(long long int n) {
long long int i;
for (i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return i;
}
}
return n;
}
int main() {
fastio();
int T = 1;
while (T--) {
long long int n;
cin >> n;
long long int ans = 0;
while (n > 1) {
ans += n;
n = n / SPF(n);
}
cout << ans + 1;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
int p[2000], score[2000];
char name[2000][20];
int i, n;
int main() {
scanf("%d", &n);
int cnt = 0;
for (i = 1; i <= n; i++) {
char s[20];
int num;
scanf("%s%d", s, &num);
if (mp.find(s) != mp.end()) {
int x = mp.find(s)->second;
int val = score[x];
if (num > val) {
p[val]--;
p[num]++;
score[x] = num;
}
} else {
cnt++;
strcpy(name[cnt], s);
mp.insert(make_pair(s, cnt));
score[cnt] = num;
p[num]++;
}
}
for (i = 1; i <= 1000; i++) p[i] += p[i - 1];
printf("%d\n", cnt);
for (i = 1; i <= cnt; i++) {
printf("%s ", name[i]);
int x = mp.find(name[i])->second;
x = score[x];
if (p[x] * 100 >= cnt * 99)
printf("pro\n");
else if (p[x] * 100 >= cnt * 90)
printf("hardcore\n");
else if (p[x] * 100 >= cnt * 80)
printf("average\n");
else if (p[x] * 100 >= cnt * 50)
printf("random\n");
else
printf("noob\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int C = 200001, D = 26;
int sget2(char tab[]) {
bool ff = 0;
for (int z = 0;; z++) {
tab[z] = getchar();
if (tab[z] > 32) ff = 1;
if (tab[z] <= 32 && ff == 1)
return z;
else if (tab[z] <= 32)
z--;
}
}
int p[C], p2[C], pt[C][D], ptb[C][D], fst[26];
int changepat(char tab[], int a, int k, int b) {
int i, j;
for (i = 0; i < D; i++) pt[a][i] = -1;
for (i = 0; i < D; i++) {
if (fst[i] <= k && fst[i] != -1) {
if (pt[a][tab[a - k + b + fst[i]] - 97] != -1 &&
pt[a][tab[a - k + b + fst[i]] - 97] != i)
return 0;
if (pt[a][i] != -1 && pt[a][i] != tab[a - k + b + fst[i]] - 97) return 0;
pt[a][tab[a - k + b + fst[i]] - 97] = i;
pt[a][i] = tab[a - k + b + fst[i]] - 97;
}
}
return 1;
}
int eq(char tab[], char tab2[], int a, int b) {
if (pt[a][tab[a] - 97] == tab2[b] - 97) return 1;
if (pt[a][tab[a] - 97] == -1 && pt[a][tab2[b] - 97] == -1) return 1;
return 0;
}
void chpat(char tab[], int a, int k, int b) {
int i, j;
for (i = 0; i < D; i++) pt[a][i] = -1, ptb[a][i] = -1;
for (i = 0; i < D; i++) {
if (fst[i] <= k && fst[i] != -1) {
pt[a][tab[a - k + b + fst[i]] - 97] = i;
ptb[a][i] = tab[a - k + b + fst[i]] - 97;
}
}
}
int eqp(char tab[], int a, int b) {
if (pt[a][tab[a] - 97] == tab[b] - 97) return 1;
if (pt[a][tab[a] - 97] == -1 && ptb[a][tab[b] - 97] == -1) return 1;
return 0;
}
void KM(char tab[], int n) {
int i, j;
p[0] = -1;
for (i = 0; i < D; i++) pt[0][i] = -1, ptb[0][i] = -1, fst[i] = -1;
fst[tab[0] - 97] = 0;
for (i = 1; i < n; i++) {
p[i] = p[i - 1];
if (fst[tab[i] - 97] == -1) fst[tab[i] - 97] = i;
for (j = 0; j < D; j++) pt[i][j] = pt[i - 1][j], ptb[i][j] = ptb[i - 1][j];
for (; p[i] > -1; p[i] = p[p[i]], chpat(tab, i, p[i], -1))
if (eqp(tab, i, p[i] + 1)) break;
if (eqp(tab, i, p[i] + 1)) {
chpat(tab, i, p[i] + 1, 0);
p[i]++;
}
}
}
void FindStr(char tab1[], int n1, char tab2[], int n2, int p[], int p2[]) {
int j = -1, i, jj;
for (i = 0; i < D; i++) pt[0][i] = -1;
for (int i = 0; i < n1; i++) {
if (i > 0)
for (jj = 0; jj < D; jj++) pt[i][jj] = pt[i - 1][jj];
while (j >= 0 && (!eq(tab1, tab2, i, j + 1))) {
j = p[j];
while (j > -1 && changepat(tab1, i, j, -1) == 0) j = p[j];
}
changepat(tab1, i, j, -1);
if (eq(tab1, tab2, i, j + 1)) j++, changepat(tab1, i, j, 0);
p2[i] = j + 1;
if (j + 1 == n2) {
j = p[j];
while (j > -1 && changepat(tab1, i, j, 0) == 0) j = p[j];
}
changepat(tab1, i, j, 0);
}
}
char a[C], b[C];
int main() {
int n, m, i, j, s = 0;
scanf("%d %d", &n, &m);
sget2(a);
sget2(b);
KM(b, m);
FindStr(a, n, b, m, p, p2);
for (i = 0; i < n; i++)
if (p2[i] == m) s++;
printf("%d\n", s);
for (i = 0; i < n; i++)
if (p2[i] == m) printf("%d ", i + 2 - m);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int MX = (309), MOD = 1e9 + 9;
int comb[MX][MX], sz[MX], faksan[MX];
vector<int> v[MX];
int dp[MX][MX], compy;
int results[MX][MX];
int n;
void dfs(int x, int p) {
sz[x] = 1;
long long indp[2][MX];
memset(indp, 0, sizeof(indp));
bool phase = 0;
indp[0][0] = 1;
for (auto nxt : v[x]) {
if (nxt == p) continue;
dfs(nxt, x);
sz[x] += sz[nxt];
for (int j = 0; j <= n; j++) indp[phase ^ 1][j] = 0;
for (int pick = 0; pick <= sz[nxt]; pick++) {
for (int j = n; j >= 0; j--) {
long long theta = 1ll * indp[phase][j] * dp[nxt][pick];
theta %= MOD;
theta *= 1ll * comb[j + pick][pick];
theta %= MOD;
indp[phase ^ 1][j + pick] += theta;
indp[phase ^ 1][j + pick] %= MOD;
}
}
phase ^= 1;
}
for (int j = 0; j <= n; j++) dp[x][j] = indp[phase][j];
if (!(p != -1 && faksan[x])) dp[x][sz[x]] = dp[x][sz[x] - 1];
}
int magic[MX][MX][2];
int root;
int calc(int pos, int rem, int flag) {
if (pos == -1) {
if (faksan[root])
return rem == 0 && flag == 0;
else
return rem == 0;
}
int &ret = magic[pos][rem][flag];
if (ret != -1) return ret;
ret = 0;
int node = v[root][pos];
for (int pick = 0; pick <= min(sz[node], rem); pick++) {
if (flag && pick != sz[node]) continue;
int nflag = flag;
if (nflag == 0 && pick != sz[node]) nflag = 1;
long long theta = calc(pos - 1, rem - pick, nflag);
theta *= dp[node][pick];
theta %= MOD;
theta *= comb[rem][pick];
theta %= MOD;
ret += theta;
ret %= MOD;
}
return ret;
}
void solve(vector<int> vec) {
++compy;
results[compy][0] = 1;
for (auto xx : vec) {
dfs(xx, -1);
root = xx;
memset(magic, -1, sizeof(magic));
for (int j = 1; j <= n; j++) {
results[compy][j] += calc(v[root].size() - 1, j - 1, 0);
results[compy][j] %= MOD;
}
}
}
int depth[MX], low[MX], timer, good[MX];
stack<int> S;
vector<int> adj[MX];
void dfs1(int x, int p) {
depth[x] = low[x] = ++timer;
S.push(x);
for (auto nxt : v[x]) {
if (nxt == p) continue;
if (depth[nxt] == -1) {
dfs1(nxt, x);
low[x] = min(low[x], low[nxt]);
} else
low[x] = min(low[x], depth[nxt]);
}
if (low[x] != depth[x]) return;
if (S.top() == x) good[x] = 1;
while (S.top() != x) S.pop();
S.pop();
}
int col[MX], alex;
void dfs2(int x) {
if (col[x] == alex) return;
col[x] = alex;
for (auto nxt : v[x]) dfs2(nxt);
}
vector<int> nodes[MX];
int m;
long long kosom_el3tees[2][MX];
int main() {
scanf("%d %d", &n, &m);
for (int j = 1; j <= m; j++) {
int a, b;
scanf("%d %d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
memset(depth, -1, sizeof(depth));
for (int j = 1; j <= n; j++)
if (depth[j] == -1) dfs1(j, -1);
for (int j = 1; j <= n; j++) {
if (good[j]) continue;
for (auto nxt : v[j]) faksan[nxt] = 1;
}
for (int j = 1; j <= n; j++) {
if (!good[j]) continue;
for (auto i : v[j]) {
if (!good[i]) continue;
adj[j].push_back(i);
}
}
for (int j = 1; j <= n; j++) v[j].swap(adj[j]);
memset(col, -1, sizeof(col));
for (int j = 1; j <= n; j++) {
if (!good[j]) continue;
if (col[j] == -1) ++alex, dfs2(j);
}
comb[0][0] = 1;
for (int j = 1; j < MX; j++) {
comb[j][0] = 1;
for (int i = 1; i <= j; i++) {
comb[j][i] = comb[j - 1][i - 1] + comb[j - 1][i];
comb[j][i] %= MOD;
}
}
for (int j = 1; j <= n; j++) {
if (col[j] == -1) continue;
nodes[col[j]].push_back(j);
}
for (int j = 1; j <= alex; j++) solve(nodes[j]);
kosom_el3tees[0][0] = 1;
bool phase = 0;
for (int comp = 1; comp <= alex; comp++) {
memset(kosom_el3tees[phase ^ 1], 0, sizeof(kosom_el3tees[phase ^ 1]));
for (int pick = 0; pick <= n; pick++) {
for (int j = n; j >= 0; j--) {
long long theta = kosom_el3tees[phase][j];
theta *= results[comp][pick];
theta %= MOD;
theta *= comb[j + pick][pick];
theta %= MOD;
kosom_el3tees[phase ^ 1][j + pick] += theta;
kosom_el3tees[phase ^ 1][j + pick] %= MOD;
}
}
phase ^= 1;
}
for (int j = 0; j <= n; j++) cout << kosom_el3tees[phase][j] << endl;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int l, r;
int loA, hiB;
bool good;
};
Node seg[1000000];
int N, M, Q;
set<int> stA[200005], stB[200005];
set<pair<int, int>> st;
void build(int l, int r, int idx) {
seg[idx].good = 1;
seg[idx].l = l;
seg[idx].r = r;
seg[idx].hiB = 1e9;
if (l == r) {
return;
}
int mid = l + r >> 1;
build(l, mid, 2 * idx);
build(mid + 1, r, 2 * idx + 1);
}
void upd(int p, int idx) {
if (seg[idx].l == seg[idx].r) {
seg[idx].loA = (stA[p].empty() ? 0 : *stA[p].rbegin());
seg[idx].hiB = (stB[p].empty() ? 1e9 : *stB[p].begin());
seg[idx].good = seg[idx].loA < seg[idx].hiB;
return;
}
int mid = seg[idx].l + seg[idx].r >> 1;
if (p <= mid) {
upd(p, 2 * idx);
} else {
upd(p, 2 * idx + 1);
}
seg[idx].good = seg[2 * idx + 1].loA < seg[2 * idx].hiB;
seg[idx].loA = max(seg[2 * idx].loA, seg[2 * idx + 1].loA);
seg[idx].hiB = min(seg[2 * idx].hiB, seg[2 * idx + 1].hiB);
seg[idx].good &= (seg[2 * idx].good && seg[2 * idx + 1].good);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> M >> Q;
build(1, M, 1);
while (Q--) {
int x, y;
cin >> x >> y;
swap(x, y);
if (st.count(make_pair(x, y))) {
st.erase(make_pair(x, y));
bool isB = x % 2 == 1;
x = (x + 1) / 2;
y = (y + 1) / 2;
if (!isB) {
stA[x].erase(y);
} else {
stB[x].erase(y);
}
} else {
st.insert(make_pair(x, y));
bool isB = x % 2 == 1;
x = (x + 1) / 2;
y = (y + 1) / 2;
if (!isB) {
stA[x].insert(y);
} else {
stB[x].insert(y);
}
}
upd(x, 1);
if (seg[1].good) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, t;
cin >> n >> k >> t;
if (t <= k)
cout << t;
else if (t > k and t <= n)
cout << k;
else if (t > n)
cout << n - (t - k);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int mod = 998244353;
const int gmod = 3;
const int inf = 1039074182;
const double eps = 1e-9;
const double pi = 3.141592653589793238462643383279;
const long long llinf = 2LL * inf * inf;
template <typename T1, typename T2>
inline void chmin(T1 &x, T2 b) {
if (b < x) x = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &x, T2 b) {
if (b > x) x = b;
}
inline void chadd(int &x, int b) {
x += b - mod;
x += (x >> 31 & mod);
}
template <typename T1, typename T2>
inline void chadd(T1 &x, T2 b) {
x += b;
if (x >= mod) x -= mod;
}
template <typename T1, typename T2>
inline void chmul(T1 &x, T2 b) {
x = 1LL * x * b % mod;
}
template <typename T1, typename T2>
inline void chmod(T1 &x, T2 b) {
x %= b, x += b;
if (x >= b) x -= b;
}
template <typename T>
inline T mabs(T x) {
return (x < 0 ? -x : x);
}
using namespace std;
using namespace std;
template <typename T>
ostream &operator<<(ostream &cout, const vector<T> &vec) {
cout << "{";
for (int i = 0; i < (int)vec.size(); i++) {
cout << vec[i];
if (i != (int)vec.size() - 1) cout << ',';
}
cout << "}";
return cout;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &cout, pair<T1, T2> p) {
cout << "(" << p.first << ',' << p.second << ")";
return cout;
}
template <typename T, typename T2>
ostream &operator<<(ostream &cout, set<T, T2> s) {
vector<T> t;
for (auto x : s) t.push_back(x);
cout << t;
return cout;
}
template <typename T, typename T2>
ostream &operator<<(ostream &cout, multiset<T, T2> s) {
vector<T> t;
for (auto x : s) t.push_back(x);
cout << t;
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, queue<T> q) {
vector<T> t;
while (q.size()) {
t.push_back(q.front());
q.pop();
}
cout << t;
return cout;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &cout, map<T1, T2, T3> m) {
for (auto &x : m) {
cout << "Key: " << x.first << ' ' << "Value: " << x.second << endl;
}
return cout;
}
template <typename T1, typename T2>
void operator+=(pair<T1, T2> &x, const pair<T1, T2> y) {
x.first += y.first;
x.second += y.second;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &x, const pair<T1, T2> &y) {
return make_pair(x.first + y.first, x.second + y.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &x, const pair<T1, T2> &y) {
return make_pair(x.first - y.first, x.second - y.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> x) {
return make_pair(-x.first, -x.second);
}
template <typename T>
vector<vector<T>> operator~(vector<vector<T>> vec) {
vector<vector<T>> v;
int n = vec.size(), m = vec[0].size();
v.resize(m);
for (int i = 0; i < m; i++) {
v[i].resize(n);
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
v[i][j] = vec[j][i];
}
}
return v;
}
void print0x(int x) {
std::vector<int> vec;
while (x) {
vec.push_back(x & 1);
x >>= 1;
}
std::reverse(vec.begin(), vec.end());
for (int i = 0; i < (int)vec.size(); i++) {
std::cout << vec[i];
}
std::cout << ' ';
}
template <typename T>
void print0x(T x, int len) {
std::vector<int> vec;
while (x) {
std::cout << (x & 1);
x >>= 1;
len--;
}
while (len--) cout << 0;
}
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
template <int mod>
struct ModInt {
int x;
ModInt() { x = 0; }
ModInt(const int &_x) {
x = _x % mod;
if (x < 0) x += mod;
}
ModInt(const long long &_x) {
x = _x % mod;
if (x < 0) x += mod;
}
ModInt<mod> &operator++() {
++x;
if (x == mod) x = 0;
return *this;
}
ModInt<mod> operator++(int) {
int t = x;
x++;
if (x == mod) x = 0;
return t;
}
ModInt<mod> &operator--() {
--x;
if (x == -1) x += mod;
return *this;
}
ModInt<mod> operator--(int) {
int t = x;
x--;
if (x == -1) x += mod;
return t;
}
ModInt<mod> operator-() const { return ModInt<mod>((x == 0 ? 0 : mod - x)); }
};
template <int mod>
inline ModInt<mod> operator*(const ModInt<mod> &a, const int &c) {
return 1LL * a.x * c % mod;
}
template <int mod>
inline int mabs(const ModInt<mod> &a) {
return a.x;
}
template <int mod>
bool operator==(const ModInt<mod> &a, const ModInt<mod> &b) {
return a.x == b.x;
}
template <int mod>
bool operator!=(const ModInt<mod> &a, const ModInt<mod> &b) {
return (a.x != b.x);
}
template <int mod>
inline ModInt<mod> operator+(const ModInt<mod> &a, const ModInt<mod> &b) {
int tmp = a.x + b.x;
if (tmp >= mod) tmp -= mod;
return tmp;
}
template <int mod>
inline ModInt<mod> operator-(const ModInt<mod> &a, const ModInt<mod> &b) {
int tmp = a.x - b.x;
if (tmp < 0) tmp += mod;
return tmp;
}
template <int mod>
inline void operator-=(ModInt<mod> &a, const ModInt<mod> &b) {
a.x -= b.x;
a.x += (a.x >> 31 & mod);
}
template <int mod>
inline ModInt<mod> operator*(const ModInt<mod> &a, const ModInt<mod> &b) {
return 1LL * a.x * b.x % mod;
}
template <int mod>
inline void operator*=(ModInt<mod> &a, const ModInt<mod> &b) {
a.x = 1LL * a.x * b.x % mod;
}
template <int mod>
inline void operator+=(ModInt<mod> &a, const ModInt<mod> &b) {
a.x += b.x;
if (a.x >= mod) a.x -= mod;
}
template <int mod>
inline ModInt<mod> mod_inv(ModInt<mod> x) {
int m = mod - 2;
ModInt<mod> basic = x;
x = 1;
while (m) {
if (m & 1) x *= basic;
m >>= 1;
basic *= basic;
}
return x;
}
template <int mod>
ModInt<mod> operator/(const ModInt<mod> &a, const ModInt<mod> &b) {
return a * mod_inv(b);
}
template <int mod>
void operator/=(ModInt<mod> &a, const ModInt<mod> &b) {
a = a / b;
}
template <int mod>
inline ModInt<mod> operator^(const ModInt<mod> &basic, int x) {
ModInt<mod> res = 1;
while (x) {
if (x & 1) res *= basic;
basic *= basic;
x >>= 1;
}
return res;
}
template <int mod>
istream &operator>>(istream &cin, const ModInt<mod> &x) {
cin >> x.x;
x.x %= mod;
if (x.x < 0) x.x += mod;
return cin;
}
template <int mod>
ostream &operator<<(ostream &cout, const ModInt<mod> x) {
cout << x.x;
return cout;
}
template <int mod, int root, int LogN>
struct NTT {
using Int = ModInt<mod>;
static const int MaxN = (1 << LogN);
int w[MaxN + 5];
int fac[MaxN + 5], ifac[MaxN + 5], inum[MaxN + 5];
int fastpow(int basic, int x) {
int res = 1;
while (x) {
if (x & 1) res = 1LL * res * basic % mod;
basic = 1LL * basic * basic % mod;
x >>= 1;
}
return res;
}
int inv[MaxN + 5];
int buf[MaxN + 5];
int ww[MaxN + 5];
inline void ntt(vector<int> &v, int rev, int lg) {
int n = (1 << lg);
memset(buf, 0, sizeof(int) * n);
v.resize(n, 0);
for (int i = 0; i < n; i++) {
inv[i] = (inv[i >> 1] >> 1) | ((i & 1) << (lg - 1));
}
for (int i = 0; i < n; i++) {
buf[i] = v[inv[i]];
}
int lvl = LogN;
int *ba, *bb, *wa, *wb;
int tmp;
for (int b = 1; b < n; b *= 2) {
lvl--;
for (int i = 0; i < b * 2; i++)
ww[i] = (rev ? w[MaxN - (i << lvl)] : w[i << lvl]);
for (int i = 0; i < n; i += b * 2) {
ba = buf + i;
bb = buf + i + b;
wa = ww;
for (int j = 0; j < b; j++) {
tmp = 1LL * *wa * *bb % mod;
*bb = *ba - tmp;
*ba += tmp - mod;
*ba += ((*ba) >> 31 & mod);
*bb += ((*bb) >> 31 & mod);
ba++;
bb++;
wa++;
}
}
}
int t = fastpow(n, mod - 2);
if (rev) {
for (int i = 0; i < (1 << lg); i++) {
buf[i] = 1LL * buf[i] * t % mod;
}
}
for (int i = 0; i < (1 << lg); i++) v[i] = buf[i];
}
void add(const vector<int> &a, const vector<int> &b, vector<int> &c) {
int n = a.size(), m = b.size();
c.resize(max(n, m), 0);
for (int i = 0; i < max(n, m); i++) {
c[i] = (i >= n ? 0 : a[i]) + (i >= m ? 0 : b[i]) - mod;
c[i] += (c[i] >> 31) & mod;
}
}
void multiply(vector<int> a, vector<int> b, vector<int> &c) {
int n = (int)a.size() + b.size() - 1;
if (min(a.size(), b.size()) <= 30) {
c.clear();
c.resize(max(0, n), 0);
for (int i = 0; i < (int)a.size(); i++) {
for (int j = 0; j < (int)b.size(); j++) {
c[i + j] = (1LL * a[i] * b[j] + c[i + j]) % mod;
}
}
while (c.size() && c.back() == 0) c.pop_back();
return;
}
int nn = 1, lg = 0;
while (nn < n) {
nn <<= 1;
lg++;
}
c.resize(nn);
a.resize(nn, 0);
b.resize(nn, 0);
ntt(a, 0, lg);
ntt(b, 0, lg);
for (int i = 0; i < nn; i++) {
c[i] = 1LL * a[i] * b[i] % mod;
}
ntt(c, 1, lg);
while (c.size() && c.back() == 0) c.pop_back();
}
inline void togf(vector<int> &v) {
int n = v.size();
for (int i = 0; i < n; i++) v[i] = 1LL * v[i] * fac[i] % mod;
}
inline void toegf(vector<int> &v) {
int n = v.size();
for (int i = 0; i < n; i++) v[i] = 1LL * v[i] * ifac[i] % mod;
}
void sqr(vector<int> &a) {
int n = (int)a.size() + a.size() - 1;
if (a.size() <= 20) {
vector<int> res(n, 0);
for (int i = 0; i < (int)a.size(); i++) {
for (int j = 0; j < (int)a.size(); j++) {
chadd(res[i + j], 1LL * a[i] * a[j] % mod);
}
}
a = res;
return;
}
int nn = 1, lg = 0;
while (nn < n) {
nn <<= 1;
lg++;
}
a.resize(nn, 0);
ntt(a, 0, lg);
for (int i = 0; i < nn; i++) {
a[i] = 1LL * a[i] * a[i] % mod;
}
ntt(a, 1, lg);
while (a.size() && a.back() == 0) a.pop_back();
}
inline vector<int> derivative(const vector<int> &v) {
int n = v.size();
if (n == 0) return v;
vector<int> rv(n - 1);
for (int i = 0; i < n - 1; i++) {
rv[i] = 1LL * v[i + 1] * (i + 1) % mod;
}
return rv;
}
inline void integral(vector<int> &v, int c = 0) {
int n = v.size() + 1;
v.emplace_back(0);
for (int i = n - 1; i >= 1; i--) {
v[i] = 1LL * inum[i] * v[i - 1] % mod;
}
v[0] = c;
}
inline void multiply(vector<int> &v, int c) {
for (auto &x : v) {
x = 1LL * x * c % mod;
}
}
inline vector<int> add(const vector<int> &a, const vector<int> &b) {
vector<int> v = a;
if (v.size() < b.size()) v.resize(b.size(), 0);
for (int i = 0; i < (int)b.size(); i++) {
v[i] += b[i] - mod;
v[i] += ((v[i] >> 31) & mod);
}
return v;
}
inline vector<int> sub(const vector<int> &a, const vector<int> &b) {
vector<int> v = a;
if (v.size() < b.size()) v.resize(b.size(), 0);
for (int i = 0; i < (int)b.size(); i++) {
v[i] -= b[i];
v[i] += ((v[i] >> 31) & mod);
}
return v;
}
void inverse(vector<int> &v) {
int n = v.size();
if (n == 1) {
v[0] = fastpow(v[0], mod - 2);
return;
}
int tn = (n - 1) / 2 + 1;
vector<int> f0(tn);
for (int i = 0; i < tn; i++) f0[i] = v[i];
inverse(f0);
vector<int> rv = f0;
multiply(rv, 2);
sqr(f0);
multiply(v, f0, f0);
v = sub(rv, f0);
v.resize(n);
}
void div(const vector<int> &F, const vector<int> &G, vector<int> &Q,
vector<int> &R) {
int n = F.size(), m = G.size();
if (n < m) {
Q.clear();
R = F;
return;
}
vector<int> f = F, g = G;
reverse(f.begin(), f.end());
reverse(g.begin(), g.end());
g.resize(n - m + 1, 0);
inverse(g);
multiply(f, g, Q);
Q.resize(n - m + 1, 0);
reverse(Q.begin(), Q.end());
multiply(G, Q, R);
R.resize(m - 1, 0);
for (int i = 0; i < m - 1; i++) {
R[i] = (F[i] - R[i] + mod) % mod;
}
}
void internal_multipoint_eval(const vector<int> &v, const vector<int> &u,
int x, int l, int r, vector<int> &res,
vector<int> *f) {
if (l >= res.size()) return;
if (r - l == 1) {
res[l] = v[0];
return;
}
vector<int> Q, R;
div(v, f[x * 2], Q, R);
internal_multipoint_eval(R, u, x * 2, l, l + r >> 1, res, f);
div(v, f[x * 2 + 1], Q, R);
internal_multipoint_eval(R, u, x * 2 + 1, l + r >> 1, r, res, f);
}
vector<int> multipoint_eval(vector<int> &v, const vector<int> &u) {
if ((int)u.size() <= 32) {
int n = u.size(), m = v.size();
vector<int> res(n, 0);
for (int i = 0; i < n; i++) {
int ex = 1;
for (int j = 0; j < m; j++) {
chadd(res[i], 1LL * ex * v[j] % mod);
ex = 1LL * ex * u[i] % mod;
}
}
return res;
}
vector<int> *f;
int n = u.size(), nn = 1;
while (nn < n) nn <<= 1;
f = new vector<int>[nn + nn];
for (int i = 0; i < n; i++) f[nn + i] = {mod - u[i], 1};
for (int i = n; i < nn; i++) f[nn + i] = {1};
for (int i = nn - 1; i >= 2; i--) {
multiply(f[i * 2], f[i * 2 + 1], f[i]);
}
vector<int> res(n);
internal_multipoint_eval(v, u, 1, 0, nn, res, f);
delete[] f;
return res;
}
vector<int> interpolation(const vector<int> &x, vector<int> y) {
int n = x.size();
vector<int> *f = new vector<int>[n];
vector<int> *f2 = new vector<int>[n];
for (int i = 0; i < n; i++) {
f[i] = {mod - x[i], 1};
}
for (int b = 1; b < n; b *= 2) {
for (int i = 0; i < n; i += b * 2) {
if (i + b < n) multiply(f[i], f[i + b], f[i]);
}
}
vector<int> M = f[0], dM = derivative(M);
vector<int> tmp = multipoint_eval(dM, x);
for (int i = 0; i < n; i++) {
y[i] = 1LL * y[i] * fastpow(tmp[i], mod - 2) % mod;
}
for (int i = 0; i < n; i++) {
f[i] = {mod - x[i], 1};
f2[i] = {y[i]};
}
for (int b = 1; b < n; b <<= 1) {
for (int i = 0; i < n; i += b * 2) {
if (i + b < n) {
vector<int> tmp;
multiply(f2[i], f[i + b], tmp);
multiply(f[i], f2[i + b], f2[i]);
f2[i] = add(f2[i], tmp);
multiply(f[i], f[i + b], f[i]);
}
}
}
vector<int> res = f2[0];
delete[] f2;
delete[] f;
return res;
}
vector<int> log(const vector<int> &v) {
int n = v.size();
vector<int> dv = derivative(v), iv = v;
inverse(iv);
multiply(dv, iv, dv);
integral(dv);
dv.resize(n);
return dv;
}
vector<int> exp(const vector<int> &v) {
int n = v.size(), tn = (n - 1) / 2 + 1;
vector<int> rv;
if (n == 1) {
rv.push_back(1);
return rv;
}
vector<int> f0(tn);
for (int i = 0; i < tn; i++) f0[i] = v[i];
f0 = exp(f0);
f0.resize(n, 0);
vector<int> rhs(1, 1);
rhs = sub(rhs, log(f0));
rhs = add(rhs, v);
multiply(f0, rhs, f0);
f0.resize(n);
return f0;
}
inline void multiply(const vector<Int> &a, const vector<Int> &b,
vector<Int> &c) {
vector<int> ta(a.size()), tb(b.size());
for (int i = 0; i < (int)a.size(); i++) ta[i] = a[i].x;
for (int i = 0; i < (int)b.size(); i++) tb[i] = b[i].x;
vector<int> tc;
multiply(ta, tb, tc);
c.clear();
c.resize(tc.size());
for (int i = 0; i < (int)c.size(); i++) c[i].x = tc[i];
}
vector<Int> multiply(const vector<Int> &a, const vector<Int> &b) {
vector<int> ta(a.size()), tb(b.size());
for (int i = 0; i < (int)a.size(); i++) ta[i] = a[i].x;
for (int i = 0; i < (int)b.size(); i++) tb[i] = b[i].x;
vector<int> tc;
multiply(ta, tb, tc);
vector<Int> c(tc.size());
for (int i = 0; i < (int)c.size(); i++) c[i].x = tc[i];
return c;
}
vector<int> pow(vector<int> bas, int n, int n2) {
int c0 = 0;
for (int i = 0; i < (int)bas.size(); i++) {
if (bas[i]) break;
c0 = i + 1;
}
for (int i = 0; i < (int)bas.size() - c0; i++) bas[i] = bas[i + c0];
for (int i = 0; i < c0; i++) bas.pop_back();
int c = bas[0], inum = fastpow(bas[0], mod - 2);
for (auto &x : bas) x = 1LL * x * inum % mod;
bas = log(bas);
for (auto &x : bas) x = 1LL * x * (n % mod) % mod;
bas = exp(bas);
c = fastpow(c, n2);
for (auto &x : bas) x = 1LL * x * c % mod;
auto safepow = [](int x, long long n, long long lim) -> int {
if (x == 1) return min(1LL, lim);
if (x == 0) return 0;
long long res = 1;
for (int i = 0; i < n; i++) {
res *= x;
if (res > lim) break;
}
res = min(res, lim);
};
c0 = safepow(c0, n, bas.size());
for (int i = c0; i < (int)bas.size(); i++) {
bas[i] = bas[i - c0];
}
for (int i = 0; i < c0; i++) bas[i] = 0;
return bas;
}
NTT() {
w[0] = 1;
int ur = fastpow(root, (mod - 1) >> LogN);
fac[0] = 1;
for (int i = 1; i <= MaxN; i++) {
w[i] = 1LL * w[i - 1] * ur % mod;
fac[i] = 1LL * fac[i - 1] * i % mod;
}
ifac[MaxN] = fastpow(fac[MaxN], mod - 2);
for (int i = MaxN - 1; i >= 0; i--) {
ifac[i] = 1LL * ifac[i + 1] * (i + 1) % mod;
}
for (int i = 1; i <= MaxN; i++) {
inum[i] = 1LL * ifac[i] * fac[i - 1] % mod;
}
}
};
namespace combinatorics {
int *fac;
int *ifac;
int __Tmod;
inline int add(int a, int b) { return (a + b) % __Tmod; }
inline int sub(int a, int b) { return (a - b + __Tmod) % __Tmod; }
inline int mult(int a, int b) { return (1LL * a * b) % __Tmod; }
inline int fastpow(int basic, int x) {
chmod(x, __Tmod - 1);
if (x == 0) return 1;
int res = 1;
while (x) {
if (x & 1) res = mult(res, basic);
basic = mult(basic, basic);
x >>= 1;
}
return res;
}
inline int inv(int x) { return fastpow(x, __Tmod - 2); }
inline int div(int a, int b) { return mult(a, inv(b)); }
void init(int n, int tmod) {
__Tmod = tmod;
fac = new int[n + 5];
ifac = new int[n + 5];
fac[0] = 1;
for (int i = 1; i <= n; i++) {
fac[i] = mult(fac[i - 1], i);
}
ifac[n] = inv(fac[n]);
for (int i = n - 1; i >= 0; i--) {
ifac[i] = mult(ifac[i + 1], i + 1);
}
}
inline int C(int n, int m) {
if (n < m || n < 0 || m < 0) return 0;
return mult(mult(fac[n], ifac[m]), ifac[n - m]);
}
inline int Cat(int x) { return mult(C(x * 2, x), inv(x + 1)); }
} // namespace combinatorics
using namespace std;
int n;
vector<int> edges[250005];
int s;
map<int, int> degs;
vector<int> F[250005];
NTT<mod, 3, 19> ntt;
void dfs(int x, int par) {
int deg = 0;
for (auto u : edges[x]) {
if (u == par) continue;
dfs(u, x);
deg++;
}
degs[deg]++;
}
inline int fastpow(long long basic, int x) {
long long res = 1;
while (x) {
if (x & 1) (res *= basic) %= mod;
(basic *= basic) %= mod;
x >>= 1;
}
return res;
}
int pw[250005];
int main() {
combinatorics::init(250000, mod);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
edges[x].emplace_back(y);
edges[y].emplace_back(x);
}
dfs(0, -1);
int m = 0;
int l = 0;
for (auto [d, s] : degs) {
if (d == 0) {
l = s;
continue;
}
F[m].resize(s + 1);
pw[0] = 1;
for (int i = 1; i <= s; i++) pw[i] = 1LL * pw[i - 1] * d % mod;
for (int i = 0; i <= s; i++)
F[m][i] = 1LL * combinatorics::C(s, i) * pw[s - i] % mod;
m++;
}
for (int b = 1; b < m; b <<= 1) {
for (int i = 0; i + b < m; i += b + b) {
ntt.multiply(F[i], F[i + b], F[i]);
}
}
int res = 0;
for (int i = 0; i <= n - l; i++) {
int v = 1LL * F[0][i] * combinatorics::fac[i + l] % mod;
if ((n - l - i) & 1)
chadd(res, mod - v);
else
chadd(res, v);
}
cout << res << endl;
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt[6], flg;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int edg1, edg2;
cin >> edg1 >> edg2;
cnt[edg1]++;
cnt[edg2]++;
}
for (int i = 1; i < 6; i++) {
if (cnt[i] != 2) {
cout << "WIN" << endl;
return 0;
}
}
cout << "FAIL" << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, next;
} a[200001];
int vis[100001], st[100001], cnt = 0;
void add(int x, int y) {
a[++cnt] = (node){y, st[x]};
st[x] = cnt;
}
bool dfs(int x, int y) {
if (vis[x])
if (vis[x] + y == 3)
return 0;
else
return 1;
vis[x] = y;
int i, to;
for (i = st[x]; i; i = a[i].next) {
to = a[i].to;
if (!dfs(to, 3 - y)) return 0;
}
return 1;
}
int main() {
int n, m;
int i;
int x, y;
int ans1 = 0, ans2 = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
for (i = 1; i <= n; i++)
if (!vis[i])
if (!dfs(i, 1)) break;
if (i <= n) {
printf("-1");
goto end;
}
for (i = 1; i <= n; i++)
if (vis[i] == 1)
ans1++;
else
ans2++;
if (ans2 == 0) ans1--, ans2 = 1, vis[1] = 2;
printf("%d\n", ans1);
for (i = 1; i <= n; i++)
if (vis[i] == 1) printf("%d ", i);
printf("\n");
printf("%d\n", ans2);
for (i = 1; i <= n; i++)
if (vis[i] == 2) printf("%d ", i);
printf("\n");
end:;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
void solve() {
int n;
cin >> n;
string s, c;
cin >> s;
c = "xxx";
int ans = 0;
int i = 0;
while (i < n) {
if (s.find(c, i) != string::npos && (s.find(c, i) == i)) {
ans++;
}
i++;
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char c;
int num, f = 1;
while (c = (char)getchar(), !isdigit(c))
if (c == '-') f = -1;
num = (int)(c - '0');
while (c = (char)getchar(), isdigit(c)) num = num * 10 + (int)(c - '0');
return num * f;
}
int n, m;
vector<int> a;
long long greaterCount(int m) {
vector<int> s(2 * n + 1);
int sum = n;
long long result = 0;
s[sum] = 1;
long long add = 0;
for (int i = 0; i < n; i++) {
if (a[i] < m)
sum--, add -= s[sum];
else
add += s[sum], sum++;
result += add;
s[sum]++;
}
return result;
}
void work() {
cin >> n >> m;
a = vector<int>(n);
for (int i = 0; i < n; i++) cin >> a[i];
cout << greaterCount(m) - greaterCount(m + 1) << endl;
return;
}
signed main() {
int T = 1;
for (int Case = 1; Case <= T; Case++) {
work();
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, s;
cin >> s >> a >> b >> c;
if (a + b + c == 0) {
printf("0 0 0 ");
return 0;
}
printf("%.18lf %.18lf %.18lf ", (double)s / (a + b + c) * a,
(double)s / (a + b + c) * b, (double)s / (a + b + c) * c);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, sum;
cin >> n >> sum;
cout << (sum + n - 1) / n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int ncr(long long int n, long long int r) {
if (n == r) return 1;
if (r == 1) return n;
return ncr(n - 1, r) + ncr(n - 1, r - 1);
}
long long int fact(long long int n) {
long long int i, res = 1;
for (i = 2; i <= n; i++) res *= i;
return res;
}
int main() {
long long int n, res;
cin >> n;
if (n == 2)
cout << "1" << endl;
else if (n == 4)
cout << "3" << endl;
else {
res = ncr(n, n / 2) / 2;
long long int fa = fact(n / 2 - 1);
res *= (fa * fa);
cout << res << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int mod = ((1E9) + 7);
const int intmax = ((1E9) + 7);
using namespace std;
long long aa[100005];
int main() {
int test, a, b, c, n;
scanf("%d", &n);
for (int i = 0; i < n; i++) cin >> aa[i];
long long prev = aa[0];
long long steps = 0;
for (int i = 1; i < n; i++) {
if (aa[i] < prev) steps += prev - aa[i];
prev = aa[i];
}
cout << steps;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, M, k, c, d;
string s;
int main() {
scanf("%d%d%d%d%d", &c, &d, &N, &M, &k);
if (N * M <= k) {
cout << 0;
return 0;
}
int mi = c * M;
for (int x = 0; x * N <= N * (M + 1) - k; ++x) {
int y = max(0, N * M - k - x * N);
int z = x * c + y * d;
if (z < mi) {
mi = z;
}
}
cout << mi;
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
using namespace std;
const long long inf = 1e9;
long long dp[2511 << 1][2511][2];
long long h[2511 << 1];
int n;
int main() {
int i, j, k;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%I64d", &h[i]);
h[0] = h[n + 1] = -inf;
k = n / 2 + n % 2;
for (i = 0; i <= n; ++i) {
for (j = 0; j <= k; ++j) {
dp[i][j][0] = dp[i][j][1] = inf;
}
}
for (i = 0; i <= n; ++i) dp[i][0][0] = 0;
for (i = 1; i <= n; ++i) {
for (j = 1; j <= k && j <= i; ++j) {
dp[i][j][0] = min(dp[i][j][0], min(dp[i - 1][j][1], dp[i - 1][j][0]));
if (i > 1) {
dp[i][j][1] =
min(dp[i - 2][j - 1][0] + h[i - 1] - min(h[i - 1], h[i] - 1) +
h[i + 1] - min(h[i + 1], h[i] - 1),
dp[i - 2][j - 1][1] + h[i + 1] - min(h[i + 1], h[i] - 1) +
min(h[i - 2] - 1, h[i - 1]) -
min(h[i] - 1, min(h[i - 2] - 1, h[i - 1])));
} else {
dp[i][j][1] =
min(dp[i - 1][j - 1][0] + h[2] - min(h[2], h[1] - 1), dp[i][j][1]);
}
}
}
for (i = 1; i <= k; ++i) {
printf("%I64d ", min(dp[n][i][0], dp[n][i][1]));
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum, limit, x = 0;
vector<int> s;
vector<pair<int, int>> lowbit;
cin >> sum >> limit;
for (int i = 1; i <= limit; i++) lowbit.push_back(make_pair(i & -i, i));
sort(lowbit.begin(), lowbit.end());
for (int i = lowbit.size() - 1; i >= 0; i--) {
if (x + lowbit[i].first <= sum) {
x += lowbit[i].first;
s.push_back(lowbit[i].second);
}
}
if (x != sum) {
cout << -1;
} else {
cout << s.size() << endl;
for (int i = 0; i < s.size(); i++) cout << s[i] << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double c[10005];
int pp[10005];
int q[10005];
int all;
int n, t;
double prop[10005];
double F[10005];
double P[5005][5005];
double p[10005];
int main() {
scanf("%d %d", &n, &t);
for (int i = 0; i < n; ++i) {
scanf("%d %d", &pp[i], &q[i]);
pp[i] = 100 - pp[i];
all += q[i];
prop[i] = 1;
double now = 1;
for (int j = 0; j < q[i] - 1; ++j) {
now = now * pp[i] / 100.0;
}
F[i] = now;
prop[i] = now;
p[i] = pp[i] / 100.0;
}
if (all <= t) {
printf("%d\n", n);
return 0;
}
P[0][0] = 1.0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= t + t; ++j) c[j] = 0;
for (int j = 0; j < t; ++j) {
if (P[i][j] < 1e-20) continue;
c[j + 1] += (1 - p[i]) * P[i][j];
c[j + q[i]] -= (1 - p[i]) * F[i] * P[i][j];
if (j + q[i] <= t) P[i + 1][j + q[i]] += P[i][j] * prop[i];
}
double now = 0;
for (int j = 1; j <= t; ++j) {
now += c[j];
P[i + 1][j] += now;
now = now * p[i];
}
}
double ans = 0;
for (int i = 1; i <= n; ++i) {
double ret = 1;
for (int j = t; j >= 0; --j) {
if (i == n)
ans += n * P[n][j];
else {
if (j + q[i] > t) ans += i * P[i][j] * ret;
}
ret = ret * p[i];
}
}
cout.precision(15);
cout << fixed << ans << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long int a, b;
void print(long long int a, long long int b) {
cout << "! " << a << " " << b << endl;
}
long long int ask(long long int c, long long int d) {
cout << "? " << c << " " << d << endl;
long long int ret;
cin >> ret;
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int ret = ask(0, 0);
if (ret == 0) {
long long int val = 0;
for (long long int i = 0; i <= 29; ++i) {
long long int rr = ask(0, (1LL << i));
if (rr == 1) val += (1LL << i);
}
print(val, val);
return 0;
}
long long int sa = 0, sb = 0, va = 0, vb = 0;
for (long long int i = 29; i >= 0; i--) {
long long int rr = ask(sa + (1LL << i), sb + (1LL << i));
if (rr == ret) {
if (ret == 1) {
long long int cc = ask(sa + (1LL << i), sb);
if (cc == -1) {
va += (1LL << i);
vb += (1LL << i);
}
} else {
long long int cc = ask(sa, sb + (1LL << i));
if (cc == 1) {
va += (1LL << i);
vb += (1LL << i);
}
}
continue;
}
if (ret == 1) {
va += (1LL << i);
sa += (1LL << i);
} else {
vb += (1LL << i);
sb += (1LL << i);
}
if (!i) break;
rr = ask(sa, sb);
if (rr == 0) {
long long int val = 0;
for (long long int j = 0; j <= i - 1; ++j) {
long long int rr = ask(sa, sb + (1LL << j));
if (rr == 1) val += (1LL << j);
}
va += val;
vb += val;
break;
} else
ret = rr;
}
print(va, vb);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int a[N], n, m;
bool check(int i, int j) {
int x1 = (i - 1) / m + 1;
int y1 = (i - 1) % m + 1;
int x2 = (j - 1) / m + 1;
int y2 = (j - 1) % m + 1;
for (int k = 0; k < 4; k++)
if (x1 + dx[k] == x2 && y1 + dy[k] == y2) return 1;
return 0;
}
bool dfs(int d) {
if (d == n * m + 1) return 1;
int i = (d - 1) / m + 1, j = (d - 1) % m + 1;
for (int k = d; k <= n * m; k++) {
swap(a[d], a[k]);
if (i != 1 && check(a[d], a[(i - 2) * m + j])) continue;
if (j != 1 && check(a[d], a[(i - 1) * m + j - 1])) continue;
if (dfs(d + 1)) return 1;
swap(a[d], a[k]);
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int t = (i - 1) * m + j;
a[t] = t;
}
if (!dfs(1)) {
printf("NO");
return 0;
}
puts("YES");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%d ", a[(i - 1) * m + j]);
printf("\n");
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
if (n % 2 == 1)
cout << n / 2;
else {
int l = 1;
while (l <= n) l *= 2;
l /= 2;
cout << (n - l) / 2;
}
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
bool igual(long double a, long double b) { return fabs(a - b) < 1e-9; }
bool maior(long double a, long double b) { return a > 1e-9 + b; }
bool menor(long double a, long double b) { return a + 1e-9 < b; }
bool maiorIgual(long double a, long double b) {
return maior(a, b) || igual(a, b);
}
bool menorIgual(long double a, long double b) {
return menor(a, b) || igual(a, b);
}
struct pv {
long double x, y;
long double ang;
pv() {}
pv(long double _ang, long double _x, long double _y) {
ang = _ang;
x = _x;
y = _y;
}
pv operator-(pv other) { return pv(x - other.x, y - other.y, 0); }
bool operator<(pv other) const { return menor(ang, other.ang); }
};
long double cross(pv a, pv b) { return a.x * b.y - a.y * b.x; }
long double dot(pv a, pv b) { return a.x * b.x + a.y * b.y; }
long double polarAngle(pv v) {
long double x = v.x;
long double y = v.y;
long double aux = atan2(y, x);
if (menor(aux, 0.0)) aux += 2.0 * acos(-1);
return aux;
}
long double toDegree(long double rad) { return rad * 180 / acos(-1); }
long double norma(pv a) { return sqrt(dot(a, a)); }
long double angle2Vec(pv v, pv u) {
long double ang1 = polarAngle(v);
long double ang2 = polarAngle(u);
long double ans = 0.0;
ans = min(fabs(ang1 - ang2), fabs(2.0 * acos(-1) + ang1 - ang2));
ans = min(ans, fabs(2.0 * acos(-1) + ang2 - ang1));
return ans;
}
bool ccw(pv a, pv b, pv c) {
long double aux = cross(b - a, c - b);
return maior(aux, 0.0);
}
long double func(pv a, pv b, int op) {
if (op == 0) return b.ang - a.ang;
return 2 * acos(-1) - a.ang + b.ang;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
vector<pv> v;
cin >> n;
long double x, y;
for (int i = 0; i < n; i++) {
cin >> x >> y;
v.push_back(pv(polarAngle(pv(0, x, y)), x, y));
}
sort(v.begin(), v.end());
v.push_back(v[0]);
long double ans = -1;
long double aux;
for (int i = 0; i < v.size() - 1; i++) {
aux = func(v[i], v[i + 1], i == v.size() - 2 ? 1 : 0);
if (maior(aux, ans)) ans = aux;
}
cout << fixed << setprecision(12) << 360 - toDegree(ans) << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 710, mod = 1e9 + 7;
long long n, ans, a[N], dp[N][N][10][2];
char s[N];
signed main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (long long i = 1; i <= n; i++) a[i] = s[i] - '0';
for (long long i = 1; i <= 9; i++) dp[0][0][i][0] = 1;
for (long long dig = 1; dig <= 9; dig++)
for (long long i = 0; i < n; i++)
for (long long j = 0; j <= i; j++)
for (long long lim = 0; lim <= 1; lim++)
for (long long k = 0; k <= ((lim == 1) ? 9 : a[i + 1]); k++) {
(dp[i + 1][j + (k >= dig)][dig][lim | (k < a[i + 1])] +=
dp[i][j][dig][lim]) %= mod;
}
for (long long dig = 1; dig <= 9; dig++) {
long long mul = 1;
for (long long i = 1; i <= n; i++)
ans = (ans + (dp[n][i][dig][0] + dp[n][i][dig][1]) * mul % mod) % mod,
mul = (mul * 10 + 1) % mod;
}
printf("%lld", ans);
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long a[500005];
vector<int> G[500005];
bool min_sud = 0;
int ans = 0;
void dfs(int u, int fa, int d) {
if (G[u].size() == 1 && d % 2 == 1 && fa != 0) {
min_sud = 1;
}
int num = -1;
for (auto to : G[u]) {
if (G[to].size() == 1) {
num++;
}
if (to == fa) continue;
dfs(to, u, d + 1);
}
ans -= max(0, num);
}
long long pos[3][4] = {{0, 1, 2, 3}, {0, 2, 3, 1}, {0, 3, 1, 2}};
int main() {
ios::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
cin >> n;
long long num = (n + 2) / 3;
long long ans = 0;
long long cc = (n - 1) % 3;
if (num == 1) {
cout << n << endl;
} else {
long long st = 0;
while (num - ((long long)1 << st) > 0) {
num -= ((long long)1 << st);
st += 2;
}
long long dd = num - 1;
for (int i = 0; i < 32; i++) {
long long th = (dd >> (i * 2)) & 3;
ans |= (pos[cc][th] << ((long long)i * 2));
}
ans |= ((cc + 1) << st);
cout << ans << endl;
}
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int ar[n];
for (int i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
int m;
cin >> m;
long long ans = 0;
for (int i = 0; i < min(n, m); i++) {
ans += ar[i];
}
if (m > n) {
ans -= (m - n) * d;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int N = 1005;
const int mod = 1e9 + 7;
int n, k;
long long ppow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res *= a;
res %= mod;
}
a *= a;
a %= mod;
b >>= 1;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
long long ans = pow(k, k - 2);
ans %= mod;
ans *= ppow(n - k, n - k);
ans *= k;
ans %= mod;
ans %= mod;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool deb_mode = 0;
class debugger {
vector<string> vars;
public:
template <typename T>
debugger &operator,(const T v) {
stringstream ss;
ss << v, vars.push_back(ss.str());
return *this;
}
void printall() {
int j = 0, l = vars.size();
for (int i = 0; i < (l - 1); i++) {
if (i) cout << ", ";
for (j; j < vars[l - 1].size(); j++) {
if (vars[l - 1][j] == ',') {
j++;
break;
}
cout << vars[l - 1][j];
}
cout << " = " << vars[i];
}
vars.clear();
}
} Dbug;
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << "(" << p.first << "," << p.second << ")";
}
template <typename T>
inline ostream &operator<<(ostream &os, const vector<T> &v) {
bool first = true;
os << "{";
for (unsigned int i = 0; i < v.size(); i++) {
if (!first) os << ",";
os << v[i];
first = false;
}
return os << "}";
}
template <typename T>
inline ostream &operator<<(ostream &os, const set<T> &v) {
bool first = true;
os << "{";
for (typename set<T>::const_iterator ii = v.begin(); ii != v.end(); ++ii) {
if (!first) os << ",";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const map<T1, T2> &v) {
bool first = true;
os << "{";
for (typename map<T1, T2>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ",";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T>
void getarray(T a[], int b, int e) {
for (int i = b; i < e + b; i++) cin >> a[i];
}
template <typename T>
void printarray(T a[], int b, int e) {
for (int i = b; i < e - 1 + b; i++) cout << a[i] << " ";
if (e - 1 + b >= 0) cout << a[e - 1 + b] << endl;
}
template <typename T>
void printV(vector<T> v) {
int sz = v.size();
if (sz) cout << v[0];
for (int i = 1; i < sz; i++) cout << " " << v[i];
puts("");
}
template <typename T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <class T>
inline void read(T &x) {
bool Minus = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') Minus = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (Minus) x = -x;
}
char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
int CI(int &_x) { return scanf("%d", &_x); }
int CI(int &_x, int &_y) { return scanf("%d %d", &_x, &_y); }
int CI(int &_x, int &_y, int &_z) { return scanf("%d %d %d", &_x, &_y, &_z); }
int CI(int &_a, int &_b, int &_c, int &_d) {
return scanf("%d %d %d %d", &_a, &_b, &_c, &_d);
}
template <class T>
string toString(T n) {
ostringstream oss;
oss << n;
return oss.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long int toLong(string s) {
long long int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
bool isVowel(char ch) {
ch = tolower(ch);
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
return true;
return false;
}
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
int dr8[8] = {+1, -1, +0, +0, +1, -1, -1, +1};
int dc8[8] = {+0, +0, -1, +1, +1, +1, -1, -1};
int dr4[4] = {+0, +0, +1, -1};
int dc4[4] = {-1, +1, +0, +0};
int kn8r[8] = {+1, +2, +2, +1, -1, -2, -2, -1};
int kn8c[8] = {+2, +1, -1, -2, -2, -1, +1, +2};
const double EPS = 1e-9;
const int INF = (1 << 30) - 1;
const long long int LINF = (1ll << 62) - 1;
const int mod = (int)1e9 + 7;
const int MAX = (int)1e5;
struct PT {
double x, y;
PT() {}
PT(double x, double y) : x(x), y(y) {}
PT(const PT &p) : x(p.x), y(p.y) {}
PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
PT operator*(double c) const { return PT(x * c, y * c); }
PT operator/(double c) const { return PT(x / c, y / c); }
void scan() { scanf("%lf %lf", &x, &y); }
void print() { printf("(%lf,%lf)\n", x, y); }
double mag2() { return (x) * (x) + (y) * (y); }
double mag() { return sqrt(mag2()); }
bool operator<(PT a) {
if (x == a.x) return y < a.y;
return x < a.x;
}
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double dist(PT p, PT q) { return sqrt(dist2(p, q)); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
ostream &operator<<(ostream &os, const PT &p) {
os << "(" << p.x << "," << p.y << ")";
}
PT RotateCCW90(PT p) { return PT(-p.y, p.x); }
PT RotateCW90(PT p) { return PT(p.y, -p.x); }
PT RotateCCW(PT p, double t) {
return PT(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));
}
PT RotateCCWAroundOrigByT(PT p, PT orig, double t) {
p = p - orig;
p = RotateCCW(p, t);
p = p + orig;
return p;
}
double ComputeSignedArea(const vector<PT> &p) {
double area = 0;
for (int i = 0; i < p.size(); i++) {
int j = (i + 1) % p.size();
area += p[i].x * p[j].y - p[j].x * p[i].y;
}
return area / 2.0;
}
double ComputeArea(const vector<PT> &p) { return fabs(ComputeSignedArea(p)); }
class LineSegment {
public:
PT v0;
PT v1;
LineSegment() {}
LineSegment(const PT &begin, const PT &end) : v0(begin), v1(end) {}
enum IntersectResult {
PARALLEL,
COINCIDENT,
NOT_INTERESECTING,
INTERESECTING
};
IntersectResult Intersect(const LineSegment &L, PT &intersection) {
double denom = ((L.v1.y - L.v0.y) * (v1.x - v0.x)) -
((L.v1.x - L.v0.x) * (v1.y - v0.y));
double nume_a = ((L.v1.x - L.v0.x) * (v0.y - L.v0.y)) -
((L.v1.y - L.v0.y) * (v0.x - L.v0.x));
double nume_b =
((v1.x - v0.x) * (v0.y - L.v0.y)) - ((v1.y - v0.y) * (v0.x - L.v0.x));
if (denom == 0.0f) {
if (nume_a == 0.0f && nume_b == 0.0f) return COINCIDENT;
return PARALLEL;
}
double ua = nume_a / denom;
double ub = nume_b / denom;
if (ua >= 0.0f && ua <= 1.0f && ub >= 0.0f && ub <= 1.0f) {
intersection.x = v0.x + ua * (v1.x - v0.x);
intersection.y = v0.y + ua * (v1.y - v0.y);
return INTERESECTING;
}
return NOT_INTERESECTING;
}
};
PT V[100];
int hull[100];
int Turn(PT &V0, PT &V1, PT &V2) {
double v = cross((V1 - V0), (V2 - V0));
if (fabs(v) < EPS) return 0;
if (v > 0) return 1;
return -1;
}
bool cmp(PT V1, PT V2) {
int t = Turn(V[0], V1, V2);
if (!t) {
return (V1 - V[0]).mag2() < (V2 - V[0]).mag2();
}
return t > 0;
}
int cHull(int N) {
int loleft = 0, i = 0, top = 0;
if (N <= 2) {
hull[top++] = 0;
if (N == 2) hull[top++] = 1;
return top;
}
for (i = 1; i < N; i++) {
if (V[loleft].y == V[i].y) {
if (V[loleft].x > V[i].x) loleft = i;
}
if (V[loleft].y > V[i].y) loleft = i;
}
swap(V[0], V[loleft]);
sort(V + 1, V + N, cmp);
hull[top++] = 0;
hull[top++] = 1;
for (i = 2; i < N; i++) {
while (Turn(V[hull[top - 2]], V[hull[top - 1]], V[i]) < 1 && top > 1) top--;
hull[top++] = i;
}
return top;
}
int main() {
if (deb_mode) srand(int(time(NULL)));
int i, j, k, l, n, m, q, a, b, c;
double w, h, angel;
cin >> w >> h >> angel;
if (angel > 90) angel = 180 - angel;
angel = (acos(-1.0) / 180.0) * angel;
LineSegment L1[4], L2[4];
L1[0] = LineSegment(PT(w / 2, -h / 2), PT(w / 2, h / 2));
L1[1] = LineSegment(PT(w / 2, h / 2), PT(-w / 2, h / 2));
L1[2] = LineSegment(PT(-w / 2, h / 2), PT(-w / 2, -h / 2));
L1[3] = LineSegment(PT(-w / 2, -h / 2), PT(w / 2, -h / 2));
L2[0] = LineSegment(RotateCCWAroundOrigByT(L1[0].v0, PT(0, 0), angel),
RotateCCWAroundOrigByT(L1[0].v1, PT(0, 0), angel));
L2[1] = LineSegment(RotateCCWAroundOrigByT(L1[1].v0, PT(0, 0), angel),
RotateCCWAroundOrigByT(L1[1].v1, PT(0, 0), angel));
L2[2] = LineSegment(RotateCCWAroundOrigByT(L1[2].v0, PT(0, 0), angel),
RotateCCWAroundOrigByT(L1[2].v1, PT(0, 0), angel));
L2[3] = LineSegment(RotateCCWAroundOrigByT(L1[3].v0, PT(0, 0), angel),
RotateCCWAroundOrigByT(L1[3].v1, PT(0, 0), angel));
int inx = 0;
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++) {
PT p;
if (L1[i].Intersect(L2[j], p) == 3) {
V[inx++] = p;
}
}
inx = cHull(inx);
vector<PT> HullA;
for (i = 0; i < inx; i++) {
HullA.push_back(V[hull[i]]);
}
if (deb_mode) {
cout << "Line= " << 383 << " -> ";
Dbug, HullA, "HullA";
Dbug.printall();
cout << endl;
};
double area = ComputeArea(HullA);
cout << fixed << setprecision(10) << area << "\n";
if (deb_mode) cerr << "TIME = " << clock() << " ms" << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
void prefixsum(double a[], int size, double b[]) {
b[0] = a[0];
for (int i = 1; i < size; i++) {
b[i] = b[i - 1] + a[i];
}
}
int findmaxnumber(double b[], int size) {
map<double, int> a;
for (int i = 0; i < size; i++) {
if (a.find(b[i]) == a.end()) {
a[b[i]] = 1;
} else {
a[b[i]] += 1;
}
}
map<double, int>::iterator it;
int max_value = -5;
for (it = a.begin(); it != a.end(); it++) {
if (it->second >= max_value) {
max_value = it->second;
}
}
return max_value;
}
int main() {
int n;
cin >> n;
double a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
double b[n];
prefixsum(a, n, b);
int max_val = findmaxnumber(b, n);
cout << n - max_val << "\n";
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1000000007;
template <typename T>
vector<T> get_vector(long long int size) {
vector<T> out;
for (long long int sahdfjhfsk = 0; sahdfjhfsk < size; ++sahdfjhfsk) {
T temp;
cin >> temp;
out.push_back(temp);
}
return out;
}
struct Node {
vector<int> chs;
int deps;
bool col;
Node(vector<int> chs, int deps, bool col) : chs(chs), deps(deps), col(col) {}
Node() : deps(0) {}
};
int main() {
int n;
int m;
cin >> n >> m;
vector<Node> ns(n);
for (int i = 0; i < n; ++i) {
int tmp;
cin >> tmp;
ns[i].col = tmp == 0;
ns[i].deps = 0;
}
for (int i = 0; i < m; ++i) {
int t1, t2;
cin >> t1 >> t2;
ns[t2].chs.push_back(t1);
ns[t1].deps++;
}
vector<int> bl_free;
vector<int> wh_free;
for (int i = 0; i < n; ++i) {
if (ns[i].deps == 0) {
if (ns[i].col) {
wh_free.push_back(i);
} else {
bl_free.push_back(i);
}
}
}
int times = 0;
while (!wh_free.empty() || !bl_free.empty()) {
while (!wh_free.empty()) {
int last = wh_free.back();
wh_free.pop_back();
for (int ch : ns[last].chs) {
ns[ch].deps--;
if (ns[ch].deps == 0) {
if (ns[ch].col) {
wh_free.push_back(ch);
} else {
bl_free.push_back(ch);
}
}
}
}
bool sub_black = false;
while (!bl_free.empty()) {
sub_black = true;
int last = bl_free.back();
bl_free.pop_back();
for (int ch : ns[last].chs) {
ns[ch].deps--;
if (ns[ch].deps == 0) {
if (ns[ch].col) {
wh_free.push_back(ch);
} else {
bl_free.push_back(ch);
}
}
}
}
if (sub_black) times++;
}
cout << times << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
map<int, int> mpOdd, mpEven;
mpEven[0]++;
int c = 0;
for (int i = 1; i <= n; i++) {
int temp;
cin >> temp;
c ^= temp;
if (i % 2 == 1)
mpOdd[c]++;
else
mpEven[c]++;
}
long long out = 0;
for (auto j : mpEven) {
long long t = j.second;
out += (t * (t - 1)) / 2;
}
for (auto j : mpOdd) {
long long t = j.second;
out += (t * (t - 1)) / 2;
}
cout << out << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const long long INFL = 1e18 + 123;
const double PI = atan2(0, -1);
mt19937 tw(960172);
long long rnd(long long x, long long y) {
static uniform_int_distribution<long long> d;
return d(tw) % (y - x + 1) + x;
}
void solve() {
int n, k;
cin >> n >> k;
vector<vector<char>> field(n, vector<char>(n));
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
for (int j = 0; j < n; ++j) {
field[i][j] = s[j];
}
}
vector<pair<pair<int, int>, int>> vars;
string ans = "";
if (k && field[0][0] != 'a') {
vars.push_back({{0, 0}, k - 1});
ans += 'a';
} else {
vars.push_back({{0, 0}, k});
ans += field[0][0];
}
vector<pair<int, int>> shifts = {{1, 0}, {0, 1}};
while (vars[0].first.first + vars[0].first.second < (n - 1) * 2) {
vector<vector<pair<pair<int, int>, int>>> next(26);
for (auto p : vars) {
for (pair<int, int> d : shifts) {
int nx = p.first.first + d.first;
int ny = p.first.second + d.second;
if (nx < n && ny < n) {
char c = field[nx][ny];
int k = p.second;
if (k && c > 'a') {
c = 'a';
--k;
}
next[c - 'a'].push_back({{nx, ny}, k});
}
}
}
for (int i = 0; i < 26; ++i) {
if (((int)(next[i]).size())) {
sort(next[i].begin(), next[i].end());
ans += 'a' + i;
vars.clear();
for (int j = 0; j < ((int)(next[i]).size()); ++j) {
if (j < ((int)(next[i]).size()) - 1 &&
next[i][j].first == next[i][j + 1].first) {
vars.push_back({next[i][j].first,
max(next[i][j].second, next[i][j + 1].second)});
++j;
} else {
vars.push_back(next[i][j]);
}
}
break;
}
}
}
cout << ans << "\n";
}
int main() {
cerr << fixed << setprecision(15);
cout << fixed << setprecision(15);
ios::sync_with_stdio(false);
int tests = 1;
for (int it = 1; it <= tests; ++it) {
solve();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<long long, int> taken;
int n, k;
cin >> n >> k;
long long ans = 0;
long long array[100100];
for (int i = 0; i < n; i++) {
long long a;
scanf("%lld", array + i);
}
sort(array, array + n);
for (int i = 0; i < n; i++) {
if (array[i] % k == 0) {
if (taken.count(array[i] / k) == 0) taken.insert(make_pair(array[i], 0));
} else
taken.insert(make_pair(array[i], 0));
}
cout << taken.size() << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
using namespace std;
long long mod = (1000000007LL);
inline long long Mod(long long a, long long b) { return (a % b); }
inline long long poww(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) {
while (b) {
a %= b, swap(a, b);
}
return a;
}
void read(vector<int> &w, int n) {
w.resize(n);
for (int i = 0; i < n; i++) cin >> w[i];
}
void print(vector<int> &w) {
for (int i = 0; i < (int)(w).size(); i++) {
if (i == (int)(w).size() - 1)
cout << w[i] << "\n";
else
cout << w[i] << " ";
}
}
int prodmod(vector<int> w);
int summod(vector<int> w);
int n, l, m, q, k, v[300050], ans, p[300050];
pair<int, int> w[300050];
string second;
bool vis[220][220][220];
double dp[220][220][220];
double solve(int i, int j, int z) {
z = min(z, 210);
if (i > n) {
if (j >= l and z >= 0) return 1.0;
return 0.0;
}
if (vis[i][j][z]) return dp[i][j][z];
vis[i][j][z] = 1;
double p1 = (1.0 * p[i] / 100.0) * solve(i + 1, j + 1, z + v[i]);
double p2 = (1.0 - 1.0 * p[i] / 100.0) * solve(i + 1, j, z);
return dp[i][j][z] = p1 + p2;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> l >> k;
for (int i = (1); i < (n + 1); ++i) cin >> p[i];
for (int i = (1); i < (n + 1); ++i) cin >> v[i];
cout << setprecision(10) << fixed;
cout << solve(1, 0, k) << "\n";
}
int summod(vector<int> w) {
int curr = 0;
for (int i = 0; i < (int)(w).size(); i++) {
curr = (curr + w[i]) % mod;
if (curr < 0) curr += mod;
}
return curr;
}
int prodmod(vector<int> w) {
int curr = 1;
for (int i = 0; i < (int)(w).size(); i++) {
if (w[i] >= mod) w[i] %= mod;
curr = (curr * w[i]) % mod;
if (curr < 0) curr += mod;
}
return curr;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, m;
cin >> N >> m;
long long arr[N + 1];
for (int x = 1; x <= N; x++) cin >> arr[x];
long long cum[N + 2];
cum[0] = 0;
for (int x = 1; x <= N; x++) {
cum[x] = cum[x - 1] + arr[x];
}
long long NuOfl;
for (int x = 0; x < m; x++) {
int ind;
cin >> NuOfl;
ind = lower_bound(cum, cum + N + 1, NuOfl) - cum;
cout << ind << " " << NuOfl - cum[ind - 1] << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int main() {
string str;
int k;
cin >> str >> k;
int a[300];
memset(a, 0, sizeof(a));
for (int i = 0; i < str.length(); i++) {
a[str[i] + 150]++;
}
vector<pair<int, char> > v;
for (int i = 0; i < 300; i++) {
if (a[i] != 0) {
v.push_back(make_pair(a[i], (char)(i - 150)));
}
}
sort(v.begin(), v.end());
int t = 0;
memset(a, 0, sizeof(a));
for (int i = 0; i < v.size(); i++) {
if (k >= v[i].first) {
k -= v[i].first;
a[v[i].second + 150] = 1;
t++;
} else {
break;
}
}
cout << v.size() - t << endl;
for (int i = 0; i < str.length(); i++) {
if (a[str[i] + 150] == 0) {
cout << str[i];
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
;
vector<int> a, b;
for (int i = 0; i < 2 * n; ++i) {
char c;
cin >> c;
a.push_back(c == '0' ? 0 : 1);
}
for (int i = 0; i < 2 * n; ++i) {
char c;
cin >> c;
b.push_back(c == '0' ? 0 : 1);
}
int ca = 0, cb = 0;
int c1 = 0, ca1 = 0, cb1 = 0;
for (int i = 0; i < 2 * n; ++i) {
if (a[i] == 1 && b[i] == 1)
c1++;
else if (a[i] == 1)
ca1++;
else if (b[i] == 1)
cb1++;
}
c1 %= 2;
if (cb1 == ca1 + c1 || cb1 == ca1 + c1 + 1) cout << "Draw";
if (cb1 < ca1 + c1) cout << "First";
if (cb1 > ca1 + c1 + 1) cout << "Second";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char q[100001];
int cnt[3][100001];
int main() {
cin >> q;
int length = strlen(q);
for (int i = 0; i <= length; i++)
if (i == 0)
cnt[0][i] = cnt[1][i] = cnt[2][i] = 0;
else {
cnt[0][i] = cnt[0][i - 1];
cnt[1][i] = cnt[1][i - 1];
cnt[2][i] = cnt[2][i - 1];
cnt[q[i - 1] - 'x'][i]++;
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
int x1 = cnt[0][b] - cnt[0][a - 1];
int y1 = cnt[1][b] - cnt[1][a - 1];
int z1 = cnt[2][b] - cnt[2][a - 1];
if (max(x1, max(y1, z1)) - min(x1, min(y1, z1)) <= 1 || b - a < 2)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[4] = {};
cin >> n;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
a[x]++;
}
sort(a + 1, a + 4);
cout << a[1] + a[2];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b = -1, x, y, i, j, m[300005];
pair<int, int> p[300005];
int main() {
cin >> n >> k;
while (i < n) {
cin >> m[i];
p[i].first = m[i];
if (p[i].first == 0) {
p[i].second++;
p[i].first++;
}
p[i].first += p[i - 1].first;
p[i].second += p[i - 1].second;
i++;
}
i = 0;
while (i < n) {
while (j < n) {
if (p[j].second - p[i - 1].second > k) {
break;
}
if (p[j].first - p[i - 1].first > x) {
x = p[j].first - p[i - 1].first;
a = i;
b = j;
}
j++;
}
i++;
}
i = 0;
while (a <= b) {
m[a] = 1;
a++;
}
cout << x << endl;
while (i < n) {
cout << m[i] << " ";
i++;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 10;
int main() {
ios::sync_with_stdio(0), ios_base::sync_with_stdio(0), cin.tie(0),
cout.tie(0);
;
long long n, k, q, odds, evens;
cin >> n >> k >> q;
if (!(n & 1)) {
odds = n, evens = 0;
long long energy = (n >> 1);
if (k <= energy)
odds = (k << 1) - 1;
else
evens = ((k - energy) << 1);
} else {
odds = (k > 0), evens = n - 1;
long long energy = (n >> 1) + 1;
if (k <= energy)
evens = (k - 1) << 1;
else
odds = (((k - energy) << 1) | 1);
}
while (q--) {
long long x;
cin >> x;
x = n - x + 1;
if ((x & 1) && odds >= x)
cout << 'X';
else if (!(x & 1) && (evens >= x))
cout << 'X';
else
cout << '.';
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
char s[3][1000010];
int n;
unsigned long long bs[1000010], base = 233;
struct str_hash {
unsigned long long v[1000010];
void init(char s[]) {
for (int i = 1; i <= n; i++) v[i] = v[i - 1] * base + s[i];
}
unsigned long long get(int l, int r) {
return v[r] - v[l - 1] * bs[r - l + 1];
}
} h[3];
int nxt[1000010], nxt2[1000010];
void get_fail(char s[], char t[], int f[], int i) {
int p = 0;
for (; i <= n; i++) {
while (p && s[p + 1] != t[i]) p = nxt[p];
if (s[p + 1] == t[i]) ++p;
f[i] = p;
}
}
int main() {
gets(s[0] + 1);
gets(s[1] + 1);
n = strlen(s[0] + 1);
if (strlen(s[1] + 1) != n) {
puts("-1 -1");
return 0;
}
memcpy(s[2], s[0], sizeof(s[2]));
reverse(s[2] + 1, s[2] + n + 1);
bs[0] = 1;
for (int i = 1; i <= n; i++) bs[i] = bs[i - 1] * base;
for (int _ = 0; _ <= 2; _++) h[_].init(s[_]);
int p = 0;
get_fail(s[2], s[2], nxt, 2);
get_fail(s[2], s[1], nxt2, 1);
int al = -1, ar = -1;
for (int i = 1; i < n; i++) {
int u = nxt2[i];
if (!u) continue;
if (u == i) u = 1;
if (h[1].get(1, i - u) == h[0].get(n - i + 1, n - u) &&
h[1].get(i + 1, n) == h[2].get(i + 1, n)) {
int l = n - i - 1, r = n - u;
if (al < l || (al == l && ar > r)) al = l, ar = r;
}
}
printf("%d %d\n", al, ar);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 10;
const double inf = 1e9;
const long long mod = 1e9 + 7;
long long _pow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a;
a = a * a;
b >>= 1;
}
return ans;
}
long long gcd(long long a, long long b) {
if (!b)
return a;
else
return gcd(b, a % b);
}
int mpt[10][10], vis[10];
int s[10][10];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
mpt[u][v] = 1;
mpt[v][u] = 1;
}
if (n == 1) {
cout << "0" << endl;
}
if (n == 2) {
cout << min(m, 1) << endl;
}
if (n == 3) {
cout << min(3, m) << endl;
}
if (n == 4) {
cout << min(6, m) << endl;
}
if (n == 5) {
cout << min(10, m) << endl;
}
if (n == 6) {
cout << min(15, m) << endl;
}
if (n == 7) {
int ans = 22;
for (int i = 1; i <= 7; i++) {
for (int j = 1; j <= 7; j++) {
int num = 0;
for (int k = 1; k <= 7; k++) {
if (mpt[i][k] && mpt[j][k]) {
num++;
}
}
ans = min(ans, num);
}
}
cout << m - ans << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long a[110000], n, sum[110000];
long long solve(long long k) {
long long now = n - 1, temp = 0, kk = k;
while (1) {
temp = temp + sum[now];
if (now <= kk) break;
now -= kk;
kk = kk * k;
}
return temp;
}
int main() {
long long k, i, q, ans;
scanf("%I64d", &n);
for (i = 1; i <= n; i++) scanf("%I64d", &a[i]);
sort(a + 1, a + 1 + n);
sum[0] = 0;
for (i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
scanf("%I64d", &q);
long long spec = 0;
for (i = 1; i < n; i++) spec = spec + sum[i];
for (i = 1; i <= q; i++) {
scanf("%I64d", &k);
if (k == 1) {
printf("%I64d ", spec);
continue;
}
ans = solve(k);
printf("%I64d ", ans);
}
puts("");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100013], ans[100013];
long long sum;
int main() {
while (scanf("%d %d", &n, &m) != EOF) {
sum = 0;
int fl = 1;
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
a[i]--;
sum += a[i] + 1;
if (a[i] + 1 > n - i + 1) fl = 0;
}
if (fl == 0) {
printf("-1\n");
continue;
}
memset(ans, 0, sizeof(ans));
if (sum < n) {
printf("-1\n");
continue;
}
ans[1] = 1, sum -= n;
int pre = 0;
if (sum > 0) {
if (sum >= a[1])
pre = ans[1], sum -= a[1];
else
pre = ans[1] + a[1] - sum, sum = 0;
} else
pre = ans[1] + a[1];
for (int i = 2; i <= m; i++) {
ans[i] = pre + 1;
if (sum == 0)
pre = ans[i] + a[i];
else if (sum > 0) {
if (sum >= a[i])
pre = ans[i], sum -= a[i];
else
pre = ans[i] + a[i] - sum, sum = 0;
}
}
for (int i = 1; i <= m; i++) printf("%d ", ans[i]);
printf("\n");
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int tc[300];
int num[350];
int n, id, length, i, j, dif;
int main() {
length = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &tc[i]);
if (i == 0)
dif = tc[i];
else
dif = tc[i] - tc[i - 1];
if (dif > 0) {
for (id = 0; dif > 0; id++) {
length = max(length, id);
while (dif > 0 && num[id] < 9) {
dif--;
num[id]++;
}
}
} else {
for (id = 0;; id++) {
length = max(length, id);
if (dif > 0 && num[id] < 9) {
dif--;
num[id]++;
break;
}
dif += num[id];
num[id] = 0;
}
for (id = 0; dif > 0; id++) {
length = max(length, id);
while (dif > 0 && num[id] < 9) {
dif--;
num[id]++;
}
}
}
for (j = length; j >= 0; j--) printf("%d", num[j]);
printf("\n");
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const double conv = 180 / acos(-1);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
int n, i, x, y;
cin >> n;
cout << fixed;
vector<double> angles;
for (i = 0; i < n; i++) {
cin >> x >> y;
if (x > 0 && y > 0)
angles.push_back(atan(y / double(x)) * conv);
else if (x < 0 && y > 0) {
angles.push_back(180 - atan(y / double(-x)) * conv);
} else if (x < 0 && y < 0) {
angles.push_back(atan(y / double(x)) * conv + 180);
} else if (x > 0 && y < 0) {
angles.push_back(360 - atan(y / double(-x)) * conv);
} else if (x == 0 && y > 0)
angles.push_back(90);
else if (x == 0 && y < 0)
angles.push_back(270);
else if (x < 0 && y == 0)
angles.push_back(180);
else
angles.push_back(0);
}
sort(angles.begin(), angles.end());
double temp = 360 - angles[n - 1] + angles[0];
for (i = 0; i < n - 1; i++) angles[i] = angles[i + 1] - angles[i];
angles[n - 1] = temp;
double maxi = 0;
for (i = 0; i < n; i++) {
if (angles[i] > maxi) maxi = angles[i];
}
cout << setprecision(12) << 360 - maxi << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int tt;
cin >> tt;
while (tt--) {
long long n, a, b;
cin >> n >> a >> b;
auto chk = [&](long long x) {
long long s = x / (a + b) * a;
x %= a + b;
s += min(x, a);
return 2 * s >= n;
};
long long ng = n - 1, ok = 2e18;
while (ok - ng > 1) {
long long mid = (ng + ok) / 2;
(chk(mid) ? ok : ng) = mid;
}
cout << ok << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a;
double abss(double num) {
if (num < 0) return -num;
return num;
}
int main() {
scanf("%d %d", &n, &a);
double ang = 180.0 / n;
int idx = 0;
double diff = 180.0;
for (int i = 1; i <= n - 2; i++) {
if (diff > abss(ang * i - a)) {
idx = i;
diff = abss(ang * i - a);
}
}
printf("%d %d %d", 2, 1, 2 + idx);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[101][101];
int pure[101][101];
bool check() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == 1) continue;
for (int k = 0; k < n; k++) {
pure[i][k] = 1;
pure[k][j] = 1;
}
}
}
bool ans = true;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (pure[i][j] == 0) {
return false;
}
return true;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
char ch;
cin >> ch;
if (ch == '.')
a[i][j] = 0;
else
a[i][j] = 1;
}
if (check() == false) {
cout << -1 << endl;
return 0;
}
memset(pure, 0, sizeof(pure));
int cnt = 0;
vector<pair<int, int> > p1, p2;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == 0) {
p1.push_back(make_pair(i + 1, j + 1));
break;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[j][i] == 0) {
p2.push_back(make_pair(j + 1, i + 1));
break;
}
}
}
if (p1.size() == n) {
for (int i = 0; i < n; i++)
cout << p1[i].first << " " << p1[i].second << endl;
} else {
for (int i = 0; i < n; i++)
cout << p2[i].first << " " << p2[i].second << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int n, k, A;
double ans = 0.0;
int b[10], l[10];
void search(int id, int num) {
if (id == n) {
double slv = 0.0;
int len = 1 << n;
for (int u = 0; u < len; u++) {
int B = 0, count = 0;
double tmp = 1.0;
for (int i = 0; i < n; i++) {
int v = 1 << i;
if (u & v) {
tmp *= l[i] / 100.0;
count++;
} else {
tmp *= 1.0 - l[i] / 100.0;
B += b[i];
}
}
if (count <= n / 2) tmp *= 1.0 * A / (A + B);
slv += tmp;
}
if (slv > ans) {
ans = slv;
}
return;
}
for (int i = l[id]; i <= 100; i += 10) {
int del = (i - l[id]) / 10;
if (del > num) break;
l[id] += del * 10;
search(id + 1, num - del);
l[id] -= del * 10;
}
}
int main() {
scanf("%d %d %d", &n, &k, &A);
for (int i = 0; i < n; i++) scanf("%d %d", &b[i], &l[i]);
search(0, k);
printf("%.9lf\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<int> divisors(int n) {
vector<int> divisors;
divisors.reserve(n);
for (int i = 1; i < n; ++i) {
if (n % i == 0) {
divisors.push_back(i);
}
}
return divisors;
}
template <class T>
T mod(T arg, T mod) {
arg %= mod;
if (arg < 0) {
arg += mod;
}
return arg;
}
template <class T>
T gcd(T a, T b) {
return (a == 0) ? b : gcd(b % a, a);
}
vector<int> good_count(const vector<int>& input, int g) {
int n = input.size();
vector<int> good(g);
for (int r = 0; r < g; ++r) {
for (int j = r; j < n; j += g) {
good[r] = max(input[j], good[r]);
}
}
return good;
}
int64_t count(const vector<int>& input, int g, const vector<int>& gcda) {
int n = input.size();
vector<int> good = good_count(input, g);
int it1 = 0, it2 = 0;
vector<int> suff(n);
bool touched = false;
while (it1 < n) {
if (input[it1] == good[mod(it1, g)] &&
(input[mod(it1 - 1, n)] != good[mod(mod(it1 - 1, n), g)])) {
it2 = it1;
while (it2 - it1 + 1 <= n) {
if (input[mod(it2, n)] == good[mod(mod(it2, n), g)] &&
(input[mod(it2 + 1, n)] != good[mod(mod(it2 + 1, n), g)])) {
int k = it2 - it1 + 1;
for (int i = 1; i <= k; ++i) {
suff[i] += k - i + 1;
}
touched = true;
it1 = it2;
break;
}
++it2;
}
}
++it1;
}
if (!touched) {
for (int i = 1; i < n; ++i) {
suff[i] += n;
}
}
int64_t result = 0;
for (int i = 1; i < n; ++i) {
if (gcda[i] == g) {
result += suff[i];
}
}
return result;
}
int main() {
ios_base::sync_with_stdio(false);
int n = 0;
cin >> n;
vector<int> input(n);
for (int i = 0; i < n; ++i) {
cin >> input[i];
}
vector<int> divs = divisors(n);
int64_t counter = 0;
vector<int> gcda(n);
for (int i = 1; i < n; ++i) {
gcda[i] = gcd(i, n);
}
for (const auto& divisor : divs) {
counter += count(input, divisor, gcda);
}
cout << counter << '\n';
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k, temp[2] = {0};
string s, t;
cin >> s >> t;
n = s.length();
for (i = 0; i < n; i++) {
if (s[i] != t[i]) {
if (s[i] == '4')
temp[0]++;
else
temp[1]++;
}
}
cout << max(temp[0], temp[1]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n * (n - 1) / 2 <= k)
cout << "no solution" << endl;
else {
for (int i = 1; i <= n; i++) cout << 0 << " " << i << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
int x, y, x1, y1, x2, y2;
cin >> x >> y >> x1 >> y1 >> x2 >> y2;
if (y1 == y2) {
if (c || d) {
cout << "NO" << '\n';
continue;
}
}
if (x1 == x2) {
if (a || b) {
cout << "NO" << '\n';
continue;
}
}
if ((x + b - a) < x1 || (x + b - a) > x2 || (y + d - c) < y1 ||
(y + d - c) > y2)
cout << "NO" << '\n';
else
cout << "YES" << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 1000 * 1000 + 24;
long long a, b, p, x, ans;
long long pw(int x, int y, int mod) {
if (y == 0) return 1;
long long t = pw(x, y / 2, mod);
t = 1LL * t * t % mod;
if (y & 1) t = 1LL * t * x % mod;
return t;
}
int main() {
cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false);
cin >> a >> b >> p >> x;
for (int i = 0; i < p - 1; i++) {
long long t = pw(a, i, p), q = (1LL * pw(t, p - 2, p) * b) % p, r;
if (i <= x) {
r = (x - i) / (p - 1);
if (r >= (i - q + p) % (p)) {
r -= (i - q + p) % (p);
r /= p;
r++;
ans += r;
}
}
}
cout << ans << endl;
}
| 13 |
#include <bits/stdc++.h>
int main() {
using namespace std;
int T, a, b, c, d;
int x, y, sum = -1;
char s[100005];
cin >> T >> a >> b >> c >> d;
for (int i = 0; i < T; i++) cin >> s[i];
x = a - c;
y = b - d;
for (int i = 0; i < T; i++) {
if (x >= 0 && s[i] == 'W') {
x--;
if (x <= 0) x = 0;
} else if (x < 0 && s[i] == 'E') {
x++;
if (x >= 0) x = 0;
}
if (y >= 0 && s[i] == 'S') {
y--;
if (y <= 0) y = 0;
} else if (y < 0 && s[i] == 'N') {
y++;
if (y >= 0) y = 0;
}
if (x == 0 && y == 0) {
sum = i + 1;
break;
}
if (x != 0 || y != 0) sum = -1;
}
cout << sum;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100002;
int n, m, k, p, ans, sum, t, tot, cnt, a[N], b[N], d[N], to[N], nxt[N], head[N],
du[N], rt;
inline int read() {
register int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int main() {
n = read();
for (int i = 1; i <= n - 1; i++) {
int x = read(), y = read();
du[x]++;
du[y]++;
}
for (int i = 1; i <= n; i++) {
if (du[i] == 1) {
sum++;
a[sum] = i;
}
if (du[i] > 2) {
rt++;
b[rt] = i;
}
}
if (rt > 1) {
cout << "No" << endl;
return 0;
}
if (rt == 0) {
cout << "Yes" << endl << "1" << endl;
cout << a[1] << " " << a[2] << endl;
return 0;
}
cout << "Yes" << endl << sum << endl;
for (int i = 1; i <= sum; i++) {
cout << b[1] << " " << a[i] << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, a[100005], b[100005][32], t2[35], pos, d, cnt;
string s1, s2;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
for (int i = 0; i <= 100002; i++) {
for (int j = 0; j <= 31; j++) {
b[i][j] = 0;
}
}
t2[0] = 1;
for (int i = 1; i < 33; i++) {
t2[i] = t2[i - 1] * 2;
}
cin >> t;
while (t--) {
d = 1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0;; j++) {
if (t2[j] > a[i]) {
pos = j - 1;
break;
}
}
for (int j = pos; j >= 0; j--) {
if (a[i] >= t2[j]) {
b[i][j] = 1;
a[i] -= t2[j];
}
}
}
for (int j = 30; j >= 0; j--) {
cnt = 0;
for (int i = 0; i < n; i++) {
if (b[i][j]) {
cnt++;
}
}
if (cnt % 2) {
d = 0;
if (cnt % 4 == 1) {
cout << "WIN" << '\n';
} else {
if ((n - cnt) % 2) {
cout << "WIN" << '\n';
} else {
cout << "LOSE" << '\n';
}
}
break;
}
}
if (d) {
cout << "DRAW" << '\n';
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 30; j++) {
b[i][j] = 0;
}
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
int n;
scanf("%d", &n);
map<int, pair<int, int> > mp;
map<int, int> lng;
int ai;
for (int i = 0; i < n; i++) {
scanf("%d", &ai);
lng[ai]++;
}
int m;
scanf("%d", &m);
vector<int> b(m), c(m);
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d", &c[i]);
}
pair<pair<int, int>, int> best, cur;
best = make_pair(make_pair(-1, -1), -1);
for (int i = 0; i < m; i++) {
cur = make_pair(make_pair(lng[b[i]], lng[c[i]]), i + 1);
if (cur > best) {
best = cur;
}
}
printf("%d\n", best.second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, t, el;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
cin >> n >> m;
long long lin[n + 1], col[m + 1];
for (int i = 1; i <= n; ++i) {
lin[i] = 0;
for (int j = 1; j <= m; ++j) {
if (i == 1) col[j] = 0;
cin >> el;
if (el == 1) lin[i] = col[j] = 1;
}
}
long long nr1 = 0, nr2 = 0;
for (int i = 1; i <= n; ++i)
if (!lin[i]) ++nr1;
for (int j = 1; j <= m; ++j)
if (!col[j]) ++nr2;
if (min(nr1, nr2) % 2 == 0)
cout << "Vivek\n";
else
cout << "Ashish\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
int n, m, x, y, i, k, sum = 0;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> x >> y;
sum += (x * y);
v.push_back(sum);
}
for (i = 0; i < m; i++) {
cin >> k;
vector<int>::iterator idx;
idx = lower_bound(v.begin(), v.end(), k);
cout << idx - v.begin() + 1 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long ipow(long long a, long long b) {
long long res = 1;
while (true) {
if (b & 1) res *= a;
b >>= 1;
if (!b) break;
a *= a;
}
return res;
}
void solve() {
long long n, b, d;
cin >> n >> b >> d;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
long long currsum = 0, numcler = 0;
for (long long i = 0; i < n; i++) {
if (a[i] > b)
continue;
else {
currsum += a[i];
if (currsum > d) {
numcler++;
currsum = 0;
}
}
}
cout << numcler;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z;
int a, b, c;
cin >> x >> y >> z;
cin >> a >> b >> c;
int t1 = a + b + c;
int t2 = a + b;
int t3 = a;
t1 -= x + y + z;
if (t1 < 0) {
cout << "NO";
return 0;
}
t2 -= x + y;
if (t2 < 0) {
cout << "NO";
return 0;
}
t3 -= x;
if (t3 < 0) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > vec;
vector<vector<int> > adj;
vector<bool> vst;
bool dfs(int i, int target) {
if (i == target) return true;
vst[i] = true;
for (int j = 0; j < adj[i].size(); ++j) {
int to = adj[i][j];
if (!vst[to])
if (dfs(to, target)) return 1;
}
return false;
}
int main() {
int n, index = 0;
scanf("%d", &n);
adj.assign(100, vector<int>());
for (int k = 0; k < n; ++k) {
int mode, bint, eint;
scanf("%d%d%d", &mode, &bint, &eint);
if (mode == 1) {
pair<int, int> interval = make_pair(bint, eint);
vec.push_back(interval);
index++;
for (int i = 0; i < vec.size() - 1; ++i) {
if ((bint < vec[i].first && vec[i].first < eint) ||
(bint < vec[i].second && vec[i].second < eint)) {
adj[i].push_back(index - 1);
}
if ((vec[i].first < bint && bint < vec[i].second) ||
(vec[i].first < eint && eint < vec[i].second)) {
adj[index - 1].push_back(i);
}
}
} else {
vst.assign(index, false);
vst[0] = 0;
if (dfs(bint - 1, eint - 1))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long ost = 1e9 + 7;
void solve() {
int n, k;
cin >> n >> k;
vector<int> v(n * k);
int pos = n * k;
long long suma = 0;
for (int i = 0; i < n * k; i++) cin >> v[i];
for (int i = 0; i < k; i++) {
pos -= n / 2 + 1;
suma += v[pos];
}
cout << suma << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[10], m;
int Va(int a[]) {
int res = 0;
for (int i = 1; i <= n; i++) {
int mi = a[i];
for (int j = i; j <= n; j++) {
mi = min(mi, a[j]);
res += mi;
}
}
return res;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) a[i] = i;
int mx = 0;
do {
mx = max(mx, Va(a));
} while (next_permutation(a + 1, a + n + 1));
for (int i = 1; i <= n; i++) a[i] = i;
do {
if (Va(a) == mx) m--;
if (m == 0) {
for (int i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
} while (next_permutation(a + 1, a + n + 1));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2147483647;
long long read() {
long long first = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
first = first * 10 + ch - '0';
ch = getchar();
}
return first * f;
}
void print(long long first) {
if (first < 0) putchar('-'), first = -first;
short a[20] = {}, sz = 0;
while (first > 0) a[sz++] = first % 10, first /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
long long dp[55][5][5];
long long a[55];
long long n, k;
long long dfs(long long pos, long long lim1, long long lim2) {
if (pos < n - pos + 1) return 1;
if (dp[pos][lim1][lim2] >= 0) return dp[pos][lim1][lim2];
long long ans = 0;
for (long long i = 0; i <= 1; i++) {
if (a[pos] == i || a[pos] == -1) {
for (long long j = 0; j <= 1; j++) {
if (a[n - pos + 1] == j || a[n - pos + 1] == -1) {
if (lim1 && i > j || lim2 && i > !j || pos == n - pos + 1 && i != j)
continue;
ans = ans + dfs(pos - 1, lim1 && (i == j), lim2 && (i != j));
}
}
}
}
return dp[pos][lim1][lim2] = ans;
}
int main() {
n = read(), k = read();
memset(a, -1, sizeof(a));
memset(dp, -1, sizeof(dp));
k++;
a[n] = 0;
if (dfs(n, 1, 1) < k) {
puts("-1");
return 0;
}
cout << 0;
for (long long i = n - 1; i >= 1; i--) {
a[i] = 0;
memset(dp, -1, sizeof(dp));
long long nw = dfs(n, 1, 1);
if (nw < k) {
a[i] = 1;
cout << 1;
k -= nw;
} else {
cout << 0;
}
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos(-1.0);
const long double eps = 1e-6;
const int mod = 998244353;
const int maxn = 200 + 10;
const int N = 2e5 + 50;
const int M = N * 20;
const long long mm = (1LL << 32);
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
x = f ? -x : x;
}
template <class T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
T y = 1;
int len = 1;
for (; y <= x / 10; y *= 10) ++len;
for (; len; --len, x %= y, y /= 10) putchar(x / y + 48);
}
long long qpow(long long a, long long b, long long MOD) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % MOD;
b >>= 1;
a = (a * a) % MOD;
}
return ans;
}
int n;
int a[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 2; i < n; ++i) {
if (a[i] < a[i - 1] && a[i] < a[i + 1]) {
puts("No");
return 0;
}
}
puts("Yes");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
long long int modexp(long long int base, long long int exp) {
if (exp == 1)
return base;
else if (exp == 0)
return 1;
else {
if (exp % 2 == 0) {
long long int base1 = pow(modexp(base, exp / 2), 2);
if (base1 >= 1000000007)
return base1 % 1000000007;
else
return base1;
} else {
long long int ans = (base * pow(modexp(base, (exp - 1) / 2), 2));
if (ans >= 1000000007)
return ans % 1000000007;
else
return ans;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n;
cin >> n;
string s;
cin >> s;
stack<char> stk;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
stk.push('(');
} else if (s[i] == ')' && stk.size() > 0 && stk.top() == '(') {
stk.pop();
} else {
stk.push(')');
}
}
if (stk.empty())
cout << "Yes";
else {
if (stk.size() > 2)
cout << "No";
else if (stk.size() == 2) {
if (stk.top() == '(') {
stk.pop();
if (stk.top() == ')') {
cout << "Yes";
} else
cout << "No";
} else
cout << "No";
} else
cout << "No";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> even, odd;
map<int, int> m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x & 1) {
odd.push_back(x);
} else {
even.push_back(x);
m[x]++;
}
}
long long e = even.size(), o = odd.size();
if ((e % 2 == 0) && (o % 2 == 0)) {
cout << "YES\n";
return;
}
if ((e % 2) != (o % 2)) {
cout << "NO\n";
return;
}
for (int i = 0; i < o; i++) {
if (m[odd[i] + 1] > 0 || m[odd[i] - 1] > 0) {
cout << "YES\n";
return;
}
}
cout << "NO\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int arr[505000], ans;
void updata(int l, int r) {
int i = l + 1, j = r - 1;
while (i <= j) {
arr[i] = arr[l];
arr[j] = arr[r];
i++, j--;
}
ans = max(ans, (r - l) / 2);
}
int main() {
int n;
scanf("%d", &n);
ans = 0;
int st = 0, ed = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
if (i) {
if (arr[i] != arr[i - 1])
ed++;
else {
updata(st, ed);
st = i;
ed = i;
}
}
}
updata(st, ed);
printf("%d\n", ans);
for (int i = 0; i < n; i++) {
if (i) printf(" ");
printf("%d", arr[i]);
}
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int l = 0, r = 0;
for (char c : s) {
if (c == '-')
l++;
else
r++;
}
if (r == 0 || l % r == 0)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
int MI = -1e6 - 10;
int MA = 1e6 + 10;
int seg_tree[2][(long long)8e6];
int get_mid(int f, int t) { return f + (t - f) / 2; }
int left_child(int id) { return id * 2 + 1; }
void insert(int ID, int n, int v, int f, int t) {
if (v < f || v >= t) return;
++seg_tree[ID][n];
if (f + 1 < t) {
int m = get_mid(f, t);
int c = left_child(n);
insert(ID, c, v, f, m);
insert(ID, c + 1, v, m, t);
}
}
int query(int ID, int n, int f, int t, int from, int to) {
f = max(f, from);
t = min(t, to);
if (f >= t) return 0;
if (f == from && t == to) return seg_tree[ID][n];
int m = get_mid(from, to);
int c = left_child(n);
return query(ID, c, f, t, from, m) + query(ID, c + 1, f, t, m, to);
}
int get_low_point(int ID, int n, int from, int to, int smaller_elements) {
assert(smaller_elements <= -from);
assert(smaller_elements + seg_tree[ID][n] > -to);
if (from == to - 1) {
return from;
} else {
int m = get_mid(from, to);
int c = left_child(n);
if (smaller_elements + seg_tree[ID][c] <= -m)
return get_low_point(ID, c + 1, m, to,
smaller_elements + seg_tree[ID][c]);
else
return get_low_point(ID, c, from, m, smaller_elements);
}
}
int largest_free(int ID, int n, int f, int t, int from, int to) {
if (seg_tree[ID][n] == (to - from)) return MI;
f = max(f, from);
t = min(t, to);
if (f >= t) return MI;
if (from - to < 10) {
}
if (from + 1 == to) {
assert(seg_tree[ID][n] == 0);
return from;
}
int m = get_mid(from, to);
int c = left_child(n);
int res = largest_free(ID, c + 1, f, t, m, to);
if (res == MI) res = largest_free(ID, c, f, t, from, m);
return res;
}
int smallest_free(int ID, int n, int f, int t, int from, int to) {
if (seg_tree[ID][n] == (to - from)) return MA;
f = max(f, from);
t = min(t, to);
if (f >= t) return MA;
if (from - to < 10) {
}
if (from + 1 == to) {
assert(seg_tree[ID][n] == 0);
return from;
}
int m = get_mid(from, to);
int c = left_child(n);
int res = smallest_free(ID, c, f, t, from, m);
if (res == MA) res = smallest_free(ID, c + 1, f, t, m, to);
return res;
}
int main() {
memset(seg_tree, 0, sizeof(seg_tree));
int N;
cin >> N;
for (int ii = (0); ii < (N); ii++) {
int a;
cin >> a;
insert(0, 0, a, MI, MA);
int v = largest_free(1, 0, MI, a + 1, MI, MA);
insert(1, 0, v, MI, MA);
int lowpoint = get_low_point(0, 0, MI, MA, 0);
cout << lowpoint + query(1, 0, lowpoint + 1, MA, MI, MA) << endl;
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
bool dp[55][14 * 4][14 * 4][14 * 4];
int a[55];
int f(char s[]) {
int f, ss;
if (s[0] == 'A')
f = 0;
else if (s[0] == 'K')
f = 12;
else if (s[0] == 'Q')
f = 11;
else if (s[0] == 'J')
f = 10;
else if (s[0] == 'T')
f = 9;
else
f = s[0] - '1';
if (s[1] == 'S')
ss = 0;
else if (s[1] == 'D')
ss = 1;
else if (s[1] == 'H')
ss = 2;
else if (s[1] == 'C')
ss = 3;
return f * 4 + ss;
}
int main() {
int i, j, k, r, n, x, y, z, p;
char s[5];
scanf("%d", &n);
for (i = 0; i < n; ++i) {
scanf("%s", s);
a[i] = f(s);
}
memset(dp, false, sizeof(dp));
x = a[n - 1];
if (n > 1)
y = a[n - 2];
else
y = 0;
if (n > 2)
z = a[n - 3];
else
z = 0;
dp[n - 1][x][y][z] = true;
for (i = n - 1; i > 0; --i) {
for (j = 0; j < 52; ++j) {
for (k = 0; k < 52; ++k) {
for (r = 0; r < 52; ++r) {
if (dp[i][j][k][r]) {
p = j;
x = k;
y = r;
if (i >= 3)
z = a[i - 3];
else
z = 0;
if (i > 0 && (p % 4 == x % 4 || p / 4 == x / 4))
dp[i - 1][p][y][z] = true;
if (i > 2 && (p % 4 == z % 4 || p / 4 == z / 4))
dp[i - 1][x][y][p] = true;
}
}
}
}
}
for (i = 0; i < 52; ++i) {
if (dp[0][i][0][0]) {
printf("YES\n");
return 0;
}
}
printf("NO\n");
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, m, i, j, a, s = 0;
cin >> n >> m;
map<long long, long long> mp;
for (i = 0; i < n; i++) {
cin >> a;
mp[a] = i;
}
j = 0;
for (i = 0; i < m; i++) {
cin >> a;
if (mp[a] <= j) {
s += 1;
} else {
s += (2 * (mp[a] - i) + 1);
j = mp[a];
}
}
cout << s << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6;
int a[N], n;
vector<int> h[N];
set<int> S;
bool check(int mid) {
S.clear();
for (int i = 1; i <= n; i++) {
int x = a[i];
while (x > mid || S.count(x)) x /= 2;
if (!x) return false;
S.insert(x);
}
return true;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d ", a + i);
int l = 1, r = 1e9;
while (l < r) {
int mid = l + r >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
check(l);
for (auto t : S) printf("%d ", t);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int t;
t = 1;
while (t--) {
int n, m;
cin >> n >> m;
int a[n], b[m];
for (long long int(i) = (0); (i) < (n); (i)++) cin >> a[i];
for (long long int(i) = (0); (i) < (m); (i)++) cin >> b[i];
sort(a, a + n);
sort(b, b + m);
int f = 0;
int mn;
for (long long int(i) = (0); (i) < (n); (i)++) {
for (long long int(j) = (0); (j) < (m); (j)++) {
if (a[i] == b[j]) {
mn = a[i];
f = 1;
}
if (f == 1) break;
}
}
if (f)
cout << mn << "\n";
else
cout << min(a[0], b[0]) << max(a[0], b[0]) << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, c, i, prev = INT_MIN, present, ind = 0;
cin >> n >> c;
for (i = 0; i < n; i++) {
cin >> present;
if (c < present - prev) {
ind = i;
}
prev = present;
}
cout << n - ind << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 1000;
const int maxval = 1000 * 1000;
const int levels = 6;
const long long int INF = 1000000LL * 1000000LL * 1000000LL * 2;
long long int dp[levels][maxn];
void deqadd(deque<pair<long long int, long long int> > &dq, long long int idx,
long long int val) {
while (((int)(dq).size()) and dq.back().second <= val) dq.pop_back();
dq.push_back(make_pair(idx, val));
}
void deqrem(deque<pair<long long int, long long int> > &dq, long long int idx) {
while (((int)(dq).size()) and dq.front().first <= idx) dq.pop_front();
}
inline long long int deqget(deque<pair<long long int, long long int> > &dq) {
return ((int)(dq).size()) ? dq.front().second : -INF;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int k;
long long int F[6];
cin >> k;
for (int i = 0; i < 6; i++) cin >> F[i];
for (int j = 0; j <= 9 * (k - 1); j++)
if (j < maxval) dp[0][j] = j / 3 * F[0];
for (int j = 9 * (k - 1) + 1; j <= 9 * k; j++)
if (j < maxval)
if (j % 3 == 0)
dp[0][j] = j / 3 * F[0];
else
dp[0][j] = dp[0][9 * (k - 1)];
for (int j = 9 * k + 1; j < maxval; j++) dp[0][j] = -INF;
long long int mod = 3;
deque<pair<long long int, long long int> > dq[3];
for (int i = 1; i < levels; i++) {
mod *= 10;
for (int start = 0; start < mod; start++) {
for (int _ = 0; _ < 3; _++) dq[_].clear();
for (long long int j = start, step = 0; j < maxval; j += mod, step++) {
long long int addidx = j;
deqadd(dq[0], addidx, dp[i - 1][addidx] - step * F[i]);
long long int remidx = j - (3 * (k - 1) + 1) * mod;
deqrem(dq[0], remidx);
addidx = j - mod / 3;
if (addidx >= 0) deqadd(dq[1], addidx, dp[i - 1][addidx] - step * F[i]);
remidx += mod - mod / 3;
deqrem(dq[1], remidx);
addidx = j - mod / 3 * 2;
if (addidx >= 0) deqadd(dq[2], addidx, dp[i - 1][addidx] - step * F[i]);
remidx -= mod / 3;
deqrem(dq[2], remidx);
dp[i][j] =
step * F[i] + max(max(deqget(dq[0]), deqget(dq[1])), deqget(dq[2]));
for (long long int t = 9 * (k - 1) + 1;
t <= 9 * k and t * (mod / 3) <= j; t++) {
long long int curscore = dp[i - 1][j - t * (mod / 3)];
curscore += 3 * (k - 1) * F[i];
if (t % 9 == 3) curscore += F[i];
if (t % 9 == 6) curscore += F[i] + F[i];
if (t % 9 == 0) curscore += F[i] + F[i] + F[i];
(dp[i][j]) = max((dp[i][j]), (curscore));
}
}
}
}
int q;
cin >> q;
int x, y;
while (q--) {
int n;
cin >> n;
cout << max(0LL, dp[5][n]) << '\n';
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
inline int getInt() {
int x;
scanf("%d", &x);
return x;
}
inline long long getLL() {
long long x;
scanf("%lld", &x);
return x;
};
inline int NUM(char c) { return (int)c - 48; }
inline char CHR(int n) { return (char)(n + 48); }
template <class T>
inline T MAX(T a, T b) {
if (a > b) return a;
return b;
}
template <class T>
inline T MIN(T a, T b) {
if (a < b) return a;
return b;
}
template <class T>
inline T ABS(T a) {
if (a < 0) return -a;
return a;
}
inline void OPEN(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
int Asz, Bsz;
int A[1000000 + 5], B[1000000 + 5];
int IdxA[1000000 + 5], IdxB[1000000 + 5];
int main() {
scanf("%d%d", &Asz, &Bsz);
for (int i = 0, _n = (Asz); i < _n; i++) scanf("%d", &A[i]);
for (int i = 0, _n = (Bsz); i < _n; i++) scanf("%d", &B[i]);
memset(IdxA, -1, sizeof(IdxA));
memset(IdxB, -1, sizeof(IdxB));
for (int i = 0, _n = (Asz); i < _n; i++) IdxA[A[i]] = i;
for (int i = 0, _n = (Bsz); i < _n; i++) IdxB[B[i]] = i;
int jawal = 0;
while (jawal >= -(Asz - 1) && IdxB[A[(jawal + Asz) % Asz]] != -1) jawal--;
jawal++;
int j = jawal;
long long a = -1, b = -1;
if (jawal < 0) {
a = b = IdxB[A[j + Asz]];
while (j < 0) {
long long tmp = IdxB[A[j + Asz]] + b / Bsz * Bsz;
if (tmp < b) tmp += Bsz;
b = tmp;
j++;
}
j = jawal;
}
int ret = 0;
for (int i = 0, _n = (Asz); i < _n; i++) {
if (IdxB[A[i]] == -1) {
j = i + 1;
a = b = -1;
continue;
}
if (a == -1) {
j = i;
a = b = IdxB[A[i]];
ret = MAX(ret, 1);
continue;
}
long long tmp = IdxB[A[i]] + b / Bsz * Bsz;
if (tmp < b) tmp += Bsz;
b = tmp;
while (b - a + 1 > Bsz) {
j++;
long long t2 = IdxB[A[(j + Asz) % Asz]] + a / Bsz * Bsz;
if (t2 < a) t2 += Bsz;
a = t2;
}
ret = MAX(ret, i - j + 1);
}
cout << ret << endl;
return 0;
}
| 12 |