solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 1; i < n; i++) v[i] += v[i - 1];
long long ma = 0, mi = 10e17;
for (int i = 0; i < n; i++) ma = max(ma, v[i]), mi = min(mi, v[i]);
long long ans = 0;
if (mi < 0) {
ans = k - ma + 1 - abs(mi);
} else {
ans = k - ma + 1;
}
cout << max(ans, 1ll * 0) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n >= 0) {
cout << n;
return 0;
} else {
n = n * (-1);
if (n <= 10) {
n = 0;
cout << n;
return 0;
} else {
int a = n % 10, b = n % 100;
if (a == b) {
n = n / 10;
n = n * (-1);
cout << n;
return 0;
} else {
int s = b / 10;
if (a >= s) {
n = n / 10;
n = n * (-1);
cout << n;
return 0;
} else {
n = n / 10;
n = n - s;
n = n + a;
n = n * (-1);
cout << n;
return 0;
}
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int check(int y) {
if (y % 400 == 0 || (y % 4 == 0 && y % 100 != 0)) {
return 1;
} else
return 0;
}
int main() {
int y;
scanf("%d", &y);
int d = 0, is_leap = check(y);
while (1) {
d++;
if (check(y)) d++;
y++;
d %= 7;
if (d == 0 && is_leap == check(y)) {
printf("%d\n", y);
return 0;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f3f;
const double esp = 1e-8;
const int msz = 1000;
int dp[msz + 1][msz + 1];
char s1[msz + 1], s2[msz + 1];
int l1, l2;
int main() {
scanf("%s %s", s1, s2);
l1 = strlen(s1);
l2 = strlen(s2);
for (int i = 0; i <= l1; ++i) dp[i][0] = i;
for (int i = 0; i <= l2; ++i) dp[0][i] = i;
for (int i = 1; i <= l1; ++i)
for (int j = 1; j <= l2; ++j)
dp[i][j] = min((s1[i - 1] != s2[j - 1]) + dp[i - 1][j - 1],
1 + min(dp[i - 1][j], dp[i][j - 1]));
printf("%d\n", dp[l1][l2]);
while (l1 > 0 || l2 > 0) {
if (l2 && dp[l1][l2] == 1 + dp[l1][l2 - 1]) {
printf("INSERT %d %c\n", l1 + 1, s2[--l2]);
} else if (l1 && dp[l1][l2] == 1 + dp[l1 - 1][l2]) {
printf("DELETE %d\n", l1--);
} else if (s1[--l1] != s2[--l2]) {
printf("REPLACE %d %c\n", l1 + 1, s2[l2]);
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, a[55][55], tmp[55], c;
bool mark[55][55];
int main() {
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
cin >> c;
a[i][j] = c;
if (!mark[i][c] && c != 0) {
++tmp[i];
mark[i][c] = 1;
}
}
for (int i = 0; i < n; ++i)
if (tmp[i] == n - 1) {
tmp[i] = n;
break;
}
for (int i = 0; i < n; ++i) cout << tmp[i] << ' ';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 11;
int n;
int mi[N], f[N];
int head[N], nex[N << 1], to[N << 1], wei[N << 1], size;
int id[N], dep[N], fa[N];
int U[N], V[N], X[N];
void add(int x, int y, int z) {
to[++size] = y;
nex[size] = head[x];
wei[size] = z;
head[x] = size;
}
void dfs(int u) {
dep[u] = dep[fa[u]] + 1;
for (int i = head[u]; i; i = nex[i]) {
int v = to[i];
if (v == fa[u]) continue;
id[v] = wei[i];
fa[v] = u;
dfs(v);
}
}
int main() {
cin >> n;
int u, v, x;
for (int i = 1; i < n; i++) {
cin >> u >> v;
add(u, v, i);
add(v, u, i);
}
for (int i = 1; i <= n; i++) mi[i] = 1;
dfs(1);
int m;
cin >> m;
for (int t = 1; t <= m; t++) {
cin >> u >> v >> x;
U[t] = u;
V[t] = v;
X[t] = x;
if (dep[u] < dep[v]) swap(u, v);
while (dep[u] > dep[v]) {
mi[u] = max(mi[u], x);
u = fa[u];
}
while (u != v) {
mi[u] = max(mi[u], x);
mi[v] = max(mi[v], x);
v = fa[v];
u = fa[u];
}
}
for (int i = 1; i <= m; i++) {
bool flag = 0;
u = U[i];
v = V[i];
if (dep[u] < dep[v]) swap(u, v);
while (dep[u] > dep[v]) {
if (mi[u] == X[i]) flag = 1;
u = fa[u];
}
while (u != v) {
if (mi[u] == X[i] || mi[v] == X[i]) flag = 1;
v = fa[v];
u = fa[u];
}
if (!flag) {
puts("-1");
return 0;
}
}
for (int i = 2; i <= n; i++) {
f[id[i]] = mi[i];
}
for (int i = 1; i < n; i++) {
printf("%d ", f[i]);
}
puts("");
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int in() {
int n;
scanf("%d", &n);
return n;
}
long long Lin() {
long long n;
scanf("%lld", &n);
return n;
}
double Din() {
double n;
scanf("%lf", &n);
return n;
}
const long long inf = 1e17;
const int mod = 1e9 + 7;
const int N = 1e5 + 5;
vector<int> a, b;
int main() {
int n = in();
string s;
cin >> s;
for (int i = 0; i < 2 * n; i++) {
if (i < n)
a.push_back(s[i] - '0');
else
b.push_back(s[i] - '0');
}
sort(a.begin(), a.end()), sort(b.begin(), b.end());
int gr = 0, ls = 0;
for (int i = 0; i < n; i++) {
if (a[i] > b[i])
gr++;
else if (a[i] < b[i])
ls++;
}
if (max(gr, ls) == n)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
constexpr int kN = int(5E2 + 10);
string s, t;
int n, dp[kN][kN], m;
vector<int> v[26];
bool can(int pos) {
int npos = -1, lnxt, rnxt, l = 0, r = pos;
for (int i = 0; i <= pos; i++)
for (int j = pos; j <= m; j++) dp[i][j] = n;
dp[0][pos] = -1;
for (int i = 0; i < pos; i++) {
if (v[t[i] - 'a'].empty() || v[t[i] - 'a'].back() <= dp[i][pos])
dp[i + 1][pos] = n;
else
dp[i + 1][pos] =
*upper_bound(v[t[i] - 'a'].begin(), v[t[i] - 'a'].end(), dp[i][pos]);
}
for (int i = pos; i < m; i++) {
if (v[t[i] - 'a'].empty() || v[t[i] - 'a'].back() <= dp[0][i])
dp[0][i + 1] = n;
else
dp[0][i + 1] =
*upper_bound(v[t[i] - 'a'].begin(), v[t[i] - 'a'].end(), dp[0][i]);
}
for (int i = 1; i <= pos; i++)
for (int j = pos + 1; j <= m; j++) {
if (v[t[i - 1] - 'a'].empty() || v[t[i - 1] - 'a'].back() <= dp[i - 1][j])
lnxt = n;
else
lnxt = *upper_bound(v[t[i - 1] - 'a'].begin(), v[t[i - 1] - 'a'].end(),
dp[i - 1][j]);
if (v[t[j - 1] - 'a'].empty() || v[t[j - 1] - 'a'].back() <= dp[i][j - 1])
rnxt = n;
else
rnxt = *upper_bound(v[t[j - 1] - 'a'].begin(), v[t[j - 1] - 'a'].end(),
dp[i][j - 1]);
dp[i][j] = min(lnxt, rnxt);
}
if (dp[pos][m] < n)
return true;
else
return false;
while (l < pos && r < n) {
if (v[t[l] - 'a'].empty() || v[t[l] - 'a'].back() <= npos) return false;
if (v[t[r] - 'a'].empty() || v[t[r] - 'a'].back() <= npos) return false;
lnxt = *upper_bound(v[t[l] - 'a'].begin(), v[t[l] - 'a'].end(), npos);
rnxt = *upper_bound(v[t[r] - 'a'].begin(), v[t[r] - 'a'].end(), npos);
if (lnxt <= rnxt) {
l++;
npos = lnxt;
} else {
r++;
npos = rnxt;
}
}
while (l < pos) {
if (v[t[l] - 'a'].empty() || v[t[l] - 'a'].back() <= npos) return false;
npos = *upper_bound(v[t[l] - 'a'].begin(), v[t[l] - 'a'].end(), npos);
l++;
}
while (r < n) {
if (v[t[r] - 'a'].empty() || v[t[r] - 'a'].back() <= npos) return false;
npos = *upper_bound(v[t[r] - 'a'].begin(), v[t[r] - 'a'].end(), npos);
r++;
}
return true;
}
void solve() {
cin >> s >> t;
n = int(s.size());
m = int(t.size());
for (int i = 0; i < 26; i++) v[i].clear();
for (int i = 0; i < n; i++) v[s[i] - 'a'].push_back(i);
for (int i = 0; i < m; i++)
if (can(i)) {
cout << "YES" << endl;
return;
}
cout << "NO" << endl;
return;
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int seed = 131;
const long long LLMAX = 2e18;
const int MOD = 1e9 + 7;
const double eps = 1e-8;
const int MAXN = 5e3 + 10;
const int hmod1 = 0x48E2DCE7;
const int hmod2 = 0x60000005;
inline long long sqr(long long x) { return x * x; }
inline int sqr(int x) { return x * x; }
inline double sqr(double x) { return x * x; }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long exgcd(long long a, long long b, long long &x, long long &y) {
long long d;
(b == 0 ? (x = 1, y = 0, d = a)
: (d = exgcd(b, a % b, y, x), y -= a / b * x));
return d;
}
long long qpow(long long a, long long n) {
long long sum = 1;
while (n) {
if (n & 1) sum = sum * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return sum;
}
inline int dcmp(double x) {
if (fabs(x) < eps) return 0;
return (x > 0 ? 1 : -1);
}
int dp[MAXN][MAXN];
int l[MAXN], s[MAXN], c[MAXN];
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, ans = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> l[i];
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= n + m; i++) cin >> c[i];
memset(dp, -0x3f3f3f3f, sizeof(dp));
for (int i = 0; i <= n + m; i++) dp[i][0] = 0;
for (int i = n; i >= 1; i--) {
for (int j = n; j >= 1; j--)
dp[l[i]][j] = max(dp[l[i]][j], dp[l[i]][j - 1] - s[i] + c[l[i]]);
for (int j = n; j >= 1; j--) {
for (int k = l[i] + 1, bit = j; k <= n + m; k++, bit /= 2) {
dp[k][bit / 2] = max(dp[k][bit / 2], dp[k - 1][bit] + bit / 2 * c[k]);
if (bit == 0) break;
}
}
for (int j = 1; j <= n + m; j++) dp[j][0] = max(dp[j][0], dp[j - 1][0]);
}
for (int i = 0; i <= n + m; i++) ans = max(ans, dp[i][0]);
cout << ans << endl;
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umax(T &x, T y) {
return (x < y) ? x = y, true : false;
}
template <class T>
bool umin(T &x, T y) {
return (x > y) ? x = y, true : false;
}
struct SAM {
struct state {
int fa, len;
vector<int> nxt;
};
vector<state> m;
vector<int> R, idx, cnt;
void init() {
m.assign(2, {0, 0, vector<int>(26)});
R.assign(2, 0);
}
int add() {
m.resize(m.size() + 1);
R.push_back(0);
return m.size() - 1;
}
int touch(int x, int c) {
int y = m[x].nxt[c], len = m[x].len + 1;
if (y) {
if (m[y].len == len) return y;
int z = add();
m[z] = {m[y].fa, len, m[y].nxt};
for (m[y].fa = z; m[x].nxt[c] == y; x = m[x].fa) m[x].nxt[c] = z;
return z;
} else {
y = add();
for (; x && !m[x].nxt[c]; x = m[x].fa) m[x].nxt[c] = y;
int fa = (!x) ? 1 : touch(x, c);
m[y] = {fa, len, m[0].nxt};
return y;
}
}
int extend(int x, int c) {
int res = touch(x, c);
return R[res]++, res;
}
void index() {
idx.assign(m.size(), 0);
cnt.assign(m.size(), 0);
for (int i = 0; i < (m.size()); i++) cnt[m[i].len]++;
for (int i = (1); i < (m.size()); i++) cnt[i] += cnt[i - 1];
for (int i = (m.size()) - 1; i >= 0; i--) idx[--cnt[m[i].len]] = i;
}
void calcR() {
for (int i = (m.size()) - 1; i >= (2); i--) R[m[idx[i]].fa] += R[idx[i]];
}
struct KMP {
int n;
string s;
vector<int> len;
vector<bool> suf;
void init(string &s_) {
s = s_, n = s.size();
len.assign(n, 0);
for (int j = 0, i = 1; i < n; i++) {
while (j > 0 && s[j] != s[i]) j = len[j - 1];
if (s[j] == s[i]) ++j;
len[i] = j;
}
}
void suffix() {
suf.assign(n + 1, 0);
suf[n] = suf[0] = true;
for (int i = len[n - 1]; i; i = len[i - 1]) suf[i] = true;
}
int trans(int k, int c) {
while (k == n || (k > 0 && s[k] != c)) k = len[k - 1];
if (s[k] == c) ++k;
return k;
}
} kmp;
int solve(string &s) {
int sx = -1, x = 1, len = 0, res = 0, n = ((int)(s).length());
kmp.init(s);
int foo = n - kmp.len.back();
int q = n % foo == 0 ? foo : n;
for (int i = 0; i < (n + q); i++) {
int c = s[i >= n ? i - n : i] - 'a';
while (x && !m[x].nxt[c]) x = m[x].fa, len = m[x].len;
if (!x)
x = 1, len = 0;
else
x = m[x].nxt[c], ++len;
if (m[m[x].fa].len >= ((int)(s).length())) x = m[x].fa, len = m[x].len;
if (len >= ((int)(s).length())) {
if (x == sx) break;
if (sx == -1) sx = x;
res += R[x];
}
}
return res;
}
} sam;
void input() {
string s;
cin >> s;
sam.init();
int last = 1;
for (auto c : s) last = sam.extend(last, c - 'a');
sam.index();
sam.calcR();
}
void output() {
int q;
for (cin >> q; q--;) {
string t;
cin >> t;
cout << sam.solve(t) << endl;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
input();
output();
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int dp[30005][500];
int gem[30005];
int d;
int f(int x, int y) {
if (dp[x][y] != -1) return dp[x][y];
int res = gem[x];
int step = y - 250 + d;
if (step - 1 > 0 && x + step - 1 <= 30000) {
res = max(res, gem[x] + f(x + step - 1, y - 1));
}
if (x + step <= 30000) {
res = max(res, gem[x] + f(x + step, y));
}
if (x + step + 1 <= 30000) {
res = max(res, gem[x] + f(x + step + 1, y + 1));
}
return dp[x][y] = res;
}
int main() {
int n;
scanf("%d %d", &n, &d);
memset(gem, 0, sizeof gem);
for (int i = 0; i < n; i++) {
int index;
scanf("%d", &index);
gem[index]++;
}
memset(dp, -1, sizeof dp);
printf("%d\n", f(d, 250));
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, que, a[2005][2005], f[2005][2005], a1, a2, b1, b2, ans, nn, mm;
char ch[2005];
long long gets() {
long long v = 0;
char ch;
bool f = 0;
while (!isdigit(ch = getchar()))
if (ch == '-') f = 1;
v = ch - 48;
while (isdigit(ch = getchar())) v = (v << 1) + (v << 3) + ch - 48;
return f ? -v : v;
}
long long gsiz(long long x) {
long long sum = 0;
while (x) sum += x & 1, x >>= 1;
return sum;
}
long long getans(long long x, long long y) {
long long t1, t2, x1, y1, sum, tim;
t1 = x % nn, t2 = y % mm;
x1 = x / nn, y1 = y / mm;
sum = x1 * y1 * f[nn][mm];
if (gsiz(x1) % 2 == 1)
tim = (t2 * nn - f[nn][t2]);
else
tim = f[nn][t2];
sum += x1 * tim;
if (gsiz(y1) % 2 == 1)
tim = (t1 * mm - f[t1][mm]);
else
tim = f[t1][mm];
sum += y1 * tim;
if ((gsiz(y1) + gsiz(x1)) % 2 == 1)
tim = (t1 * t2 - f[t1][t2]);
else
tim = f[t1][t2];
sum += tim;
return sum;
}
int main() {
n = gets();
m = gets();
que = gets();
for (int i = 1; i <= n; i++) {
scanf("%s", ch + 1);
for (int j = 1; j <= m; j++)
a[i][j] = a[i + n][j + m] = ch[j] - '0',
a[i + n][j] = a[i][j + m] = 1 - a[i][j];
}
nn = n * 2, mm = m * 2;
for (int i = 1; i <= nn; i++)
for (int j = 1; j <= mm; j++)
f[i][j] = f[i - 1][j] + f[i][j - 1] - f[i - 1][j - 1] + a[i][j];
for (int o = 1; o <= que; o++) {
a1 = gets(), b1 = gets(), a2 = gets(), b2 = gets();
ans = getans(a2, b2) - getans(a2, b1 - 1) - getans(a1 - 1, b2) +
getans(a1 - 1, b1 - 1);
cout << ans << endl;
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 2 * 1e3 + 20;
int dp[maxn][maxn];
int main() {
int n, k;
cin >> n >> k;
long long res = 0;
dp[0][1] = 1;
for (int i = 0; i <= k; i++) {
for (int j = 1; j <= n; j++) {
for (int l = j; l <= n; l += j) {
dp[i + 1][l] = (dp[i + 1][l] + dp[i][j]) % mod;
}
}
}
for (int i = 0; i <= n; i++) {
res = (res + dp[k][i]) % mod;
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double _eps = 1e-6;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<int> adj[2000 + 100];
int arr[2000 + 100];
int f = 1;
void dfs(int root, vector<int> &v) {
vector<int> nv;
for (int x : adj[root]) {
dfs(x, nv);
}
if (arr[root] <= nv.size()) {
nv.insert(nv.begin() + arr[root], root);
} else
f = 0;
for (int x : nv) v.push_back(x);
}
int main() {
int n;
cin >> n;
int root;
for (int i = 1; i <= n; i++) {
int a, b;
cin >> a >> arr[i];
if (a == 0)
root = i;
else {
adj[a].push_back(i);
}
}
vector<int> v;
dfs(root, v);
if (!f)
cout << "NO\n";
else {
cout << "YES\n";
for (int i = 1, k = 0; i <= n; ++i, k++) {
arr[v[k]] = i;
}
for (int i = 1; i <= n; ++i) {
cout << arr[i] << " ";
}
puts("");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-12;
const double eps2 = 1e-7;
const int INF = 0x3f3f3f3f;
vector<int> v[300005], d[300005], val[300005];
long long ans[300005];
long long sub[300005];
int n;
void dfs(int a, int nowd, int pa) {
for (int i = 0; i < d[a].size(); i++) {
int k = min(nowd + d[a][i] + 1, n + 1);
sub[k] += val[a][i];
ans[a] += val[a][i];
}
ans[a] += ans[pa];
ans[a] -= sub[nowd];
for (int i = 0; i < v[a].size(); i++) {
if (v[a][i] == pa) continue;
dfs(v[a][i], nowd + 1, a);
}
for (int i = 0; i < d[a].size(); i++) {
int k = min(nowd + d[a][i] + 1, n + 1);
sub[k] -= val[a][i];
}
}
int main() {
while (scanf("%d", &n) == 1) {
memset(ans, 0, sizeof(ans));
memset(sub, 0, sizeof(sub));
for (int i = 0; i < 300005; i++) {
v[i].clear();
d[i].clear();
val[i].clear();
}
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
d[a].push_back(b);
val[a].push_back(c);
}
dfs(1, 1, 0);
for (int i = 1; i <= n; i++) {
printf("%lld", ans[i]);
if (i != n)
printf(" ");
else
printf("\n");
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
char str[500002], op[500001];
int left[500001], right[500001], corr[500001];
int stack[500000], sp;
int main(void) {
int i;
int n, m, p;
for (i = 0; i < 500001; i++) {
left[i] = i - 1;
right[i] = i + 1;
}
scanf("%d %d %d %s %s", &n, &m, &p, str + 1, op);
for (i = 1; i <= n; i++)
if (str[i] == '(')
stack[sp++] = i;
else {
corr[stack[sp - 1]] = i;
corr[i] = stack[sp - 1];
sp--;
}
for (i = 0; i < m; i++)
if (op[i] == 'D') {
if (str[p] == ')') p = corr[p];
right[left[p]] = right[corr[p]];
left[right[corr[p]]] = left[p];
p = right[corr[p]] <= n ? right[corr[p]] : left[p];
} else
p = op[i] == 'L' ? left[p] : right[p];
for (i = right[0]; i <= n; i = right[i]) putchar(str[i]);
putchar('\n');
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
struct node {
int t, x, id, q;
} t[4040045];
int v[2020022];
int ans[2020022];
bool cmp1(node a, node b) { return a.t < b.t; }
bool cmp(node a, node b) { return a.id < b.id; }
map<int, int> s;
void cdq(int l, int r) {
if (l == r) return;
int mid = l + r >> 1;
cdq(l, mid);
cdq(mid + 1, r);
sort(t + l, t + r + 1, cmp1);
for (int i = l; i <= r; i++) {
node x = t[i];
if (x.id <= mid) {
if (x.q == 1) s[x.x]++;
if (x.q == 2) s[x.x]--;
} else if (x.q == 3) {
ans[x.id] += s[x.x];
}
}
for (int i = l; i <= r; i++) {
node x = t[i];
if (x.id <= mid) {
if (x.q == 1) s[x.x]--;
if (x.q == 2) s[x.x]++;
}
}
sort(t + l, t + r + 1, cmp);
}
int main() {
int n = read();
for (int i = 1; i <= n; i++) {
t[i].q = read();
t[i].t = read();
t[i].x = read();
t[i].id = i;
if (t[i].q == 3) v[i] = 1;
}
cdq(1, n);
for (int i = 1; i <= n; i++) {
if (v[i]) {
cout << ans[i] << endl;
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int v[510][510], sol[510];
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &v[i][j]);
for (int i = 1; i <= n; i++) {
int rez = 0, s = 0;
for (int j = 1; j <= m; j++) {
if (v[i][j])
s++;
else
s = 0;
rez = max(rez, s);
}
sol[i] = rez;
}
for (int i = 1; i <= q; i++) {
int x, y, s = 0, rez = 0;
scanf("%d%d", &x, &y);
v[x][y] ^= 1;
for (int j = 1; j <= m; j++) {
if (v[x][j])
s++;
else
s = 0;
rez = max(rez, s);
}
sol[x] = rez;
rez = 0;
for (int j = 1; j <= n; j++) rez = max(rez, sol[j]);
printf("%d\n", rez);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r, avg;
cin >> n >> r >> avg;
vector<pair<int, int> > v;
int a, b;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back(pair<int, int>(b, a));
sum += a;
}
sort(v.begin(), v.end());
long long req = 1ll * avg * n - sum;
long long ans = 0;
for (int i = 0; i < v.size(); i++) {
long long x = v[i].second;
long long y = v[i].first;
if ((r - x) <= req) {
ans += 1ll * y * (r - x);
req -= r - x;
} else {
ans += 1ll * req * y;
break;
}
}
if (ans < 0)
cout << 0;
else
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 50010;
const int Maxs = 35;
int tot;
int n, P;
int F[Maxs][Maxs][Maxn];
int hIndex, hXor, hMod;
int toHash(int i0, int x0, int m0) {
int Ret = 0;
Ret = i0 * (P + 10) * 35 + x0 * (P + 10) + m0;
return Ret;
}
void getHash(int Hash) {
hIndex = Hash / ((P + 10) * 35);
Hash -= hIndex * ((P + 10) * 35);
hXor = Hash / (P + 10);
Hash -= hXor * (P + 10);
hMod = Hash % (P + 10);
}
int num[Maxs];
int loc[Maxs];
int Ans;
int pos[Maxs];
int tmp;
int main() {
scanf("%d%d", &n, &P);
tot = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &tmp);
if (tmp <= 25) {
++tot;
num[tot] = tmp;
loc[tot] = i;
}
}
memset(F, -1, sizeof(F));
F[0][0][0] = 0;
for (int i = 1; i <= tot; i++) {
for (int j = 0; j < i; j++) {
for (int xo = 0; xo <= 25; xo++) {
for (int mo = 0; mo < P; mo++) {
if (F[j][xo][mo] != -1) {
F[i][xo ^ num[i]][(mo * (num[i] >= 10 ? 100 : 10) + num[i]) % P] =
toHash(j, xo, mo);
}
}
}
}
}
for (int i = 1; i <= tot; i++)
if (F[i][0][0] != -1) {
Ans = 1;
getHash(F[i][0][0]);
while (hIndex != 0) {
Ans++;
getHash(F[hIndex][hXor][hMod]);
}
pos[Ans] = loc[i];
getHash(F[i][0][0]);
for (int j = Ans - 1; j >= 1; j--) {
pos[j] = loc[hIndex];
getHash(F[hIndex][hXor][hMod]);
}
printf("Yes\n");
printf("%d\n", Ans);
for (int j = 1; j <= Ans; j++) printf("%d ", pos[j]);
printf("\n");
return 0;
}
printf("No\n");
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int n, cost[5], dp[4][1000][1 << 12];
char g[4][1001];
int who[4][4], col[1000];
int calc(int r, int c, int mask) {
if (r == 4) {
if (col[c] & ~mask) return 1e9;
return calc(0, c + 1, mask >> 4);
}
if (c == n) return 0;
int &ret = dp[r][c][mask];
if (ret != -1) return ret;
ret = calc(r + 1, c, mask);
for (int s = 1; s <= 4 && r + s <= 4 && c + s <= n; ++s) {
if (s == 4)
ret = min(ret, cost[s] + calc(0, c + 1, (1 << 12) - 1));
else
ret = min(ret, cost[s] + calc(r + 1, c, mask | who[r][s]));
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= 4; ++i) scanf("%d", cost + i);
for (int i = 0; i < 4; ++i) {
for (int s = 1; s < 4 && i + s <= 4; ++s) {
for (int dr = 0; dr < s; ++dr)
for (int dc = 0; dc < s; ++dc) {
int r = i + dr;
int c = dc;
who[i][s] |= 1 << (c * 4 + r);
}
}
}
for (int i = 0; i < 4; ++i) {
scanf("%s", g[i]);
for (int j = 0; j < n; ++j)
if (g[i][j] == '*') col[j] |= 1 << i;
}
memset(dp, -1, sizeof(dp));
printf("%d\n", calc(0, 0, 0));
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
int n, k;
int a[200005], b[200005], c[200005];
int main() {
while (~scanf("%d", &n)) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
memset(c, 0, sizeof(c));
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
scanf("%d", &k);
b[k] = i;
}
for (int i = 1; i <= n; i++) c[i] = b[a[i]];
bool tag = true;
for (int i = 1; i < n; i++) {
if (c[i] > c[i + 1]) {
printf("%d\n", n - i);
tag = false;
break;
}
}
if (tag) printf("0\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e6;
const int M = 4e3;
int a[N], b[N], k[N], r[N];
bool cmp(int x, int y) { return b[x] > b[y]; }
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
k[i] = i;
}
sort(a, a + n);
sort(k, k + n, cmp);
for (int i = 0; i < n; i++) r[k[i]] = a[i];
for (int i = 0; i < n; i++) printf("%d ", r[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long Inf = LONG_LONG_MAX;
const double long PI = 3.1415926535;
long long sqr(long long a) { return a * a; }
long long qb(long long a) { return a * a * a; }
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long binpow(long long a, long long b, long long mod) {
return b ? (b % 2 ? (a * (sqr(binpow(a, b / 2, mod)) % mod)) % mod
: sqr(binpow(a, b / 2, mod)) % mod)
: 1;
}
long long binmult(long long a, long long b, long long mod) {
return b ? (b % 2 ? (2 * binmult(a, b / 2, mod) + a) % mod
: (2 * binmult(a, b / 2, mod)) % mod)
: 0;
}
int t, n, a[200100], b[200100], k;
bool first(int i) {
if (i == 0) return false;
if (i == n - 1) return false;
return (a[i - 1] < a[i] && a[i] > a[i + 1]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(7);
cout.setf(ios::fixed);
;
cin >> t;
while (t--) {
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) b[i] = first(i);
for (long long i = 1; i < n; i++) b[i] += b[i - 1];
int li = 0, mx = 0;
for (long long i = 0; i < n - k + 1; i++)
if (b[i + k - 2] - b[i] > mx) {
mx = b[i + k - 2] - b[i];
li = i;
}
cout << mx + 1 << ' ' << li + 1 << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int cu = 0, cg = 0;
string s;
cin >> s;
map<char, int> mp;
for (int i = 0; i < s.length(); i++) {
mp[s[i]]++;
}
for (auto i : mp) {
if (i.second > 1) {
cg++;
} else if (i.second == 1) {
cu++;
}
}
cout << ((cu / 2) + cg) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void output(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x == 0) {
putchar('0');
return;
}
int a[20], num = 0;
while (x) a[++num] = x % 10, x /= 10;
while (num > 0) putchar('0' + a[num--]);
}
inline long long myInt() {
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
int flag = 1;
if (c == '-') flag = -1, c = getchar();
long long x = 0;
while (isdigit(c)) {
x = (x * 10) + (c - '0');
c = getchar();
}
if (flag == -1) return -x;
return x;
}
const int N = 100005;
const int M = 5005;
int a[N], f[N][20];
int n, m;
struct node {
int L, R, Max;
double p;
};
node b[M];
void init() {
for (int i = 1; i <= n; i++) f[i][0] = a[i];
for (int j = 1; (1 << j) <= n; j++)
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
f[i][j] = max(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);
}
}
int get(int L, int R) {
int k = log2(R - L + 1);
return max(f[L][k], f[R - (1 << k) + 1][k]);
}
int cmp(node a, node b) {
if (a.L != b.L) return a.L < b.L;
return a.R > b.R;
}
double dp[M][M];
int visit[M];
vector<int> g[M];
void DFS(int u) {
if (visit[u]) return;
visit[u] = 1;
for (int i = 0; i < g[u].size(); i++) DFS(g[u][i]);
for (int i = 0; i < M; i++) {
double tmp1 = i > 0 ? 1 : 0;
double tmp2 = 1;
for (int j = 0; j < g[u].size(); j++) {
int t = g[u][j];
int k = b[u].Max - b[t].Max + i - 1;
if (k >= 0)
tmp1 *= dp[t][min(k, M - 1)];
else
tmp1 = 0;
k++;
if (k >= 0)
tmp2 *= dp[t][min(k, M - 1)];
else
tmp2 = 0;
}
dp[u][i] = b[u].p * tmp1 + (1 - b[u].p) * tmp2;
}
}
int main() {
n = myInt();
m = myInt();
for (int i = 1; i <= n; i++) a[i] = myInt();
init();
for (int i = 1; i <= m; i++) {
scanf("%d%d%lf", &b[i].L, &b[i].R, &b[i].p);
b[i].Max = get(b[i].L, b[i].R);
}
m++;
b[m].L = 1;
b[m].R = n;
b[m].p = 0;
b[m].Max = get(1, n);
sort(b + 1, b + m + 1, cmp);
for (int i = 1; i <= m; i++)
for (int j = i - 1; j >= 0; j--) {
if (b[i].L >= b[j].L && b[i].R <= b[j].R) {
g[j].push_back(i);
break;
}
}
DFS(1);
double ans = dp[1][0] * b[1].Max;
for (int i = 1; i < M; i++) {
ans += (dp[1][i] - dp[1][i - 1]) * (b[1].Max + i);
}
printf("%.10lf\n", ans);
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1000006;
const int mod = 1000000007;
long long dp[MaxN][2];
int num[MaxN];
int N;
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) scanf("%d", num + i);
dp[1][0] = num[1] - 1;
dp[1][1] = num[2] - 1;
long long ans = dp[1][0];
for (int i = 2; i <= N; ++i) {
dp[i][0] = num[i] - 1;
dp[i][1] = num[i + 1] - 1;
if (num[i] >= num[i - 1]) {
(dp[i][0] += (dp[i - 1][0] * (num[i - 1] - 1LL)) % mod) %= mod;
(dp[i][1] +=
(dp[i - 1][0] * (min(num[i - 1], num[i + 1]) - 1LL)) % mod) %= mod;
} else {
(dp[i][0] += (dp[i - 1][1]) * (num[i] - 1LL) % mod) %= mod;
(dp[i][1] += (dp[i - 1][1] * (num[i + 1] - 1LL)) % mod) %= mod;
}
(ans += dp[i][0]) %= mod;
}
cout << ans << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int maxn = 1e5 + 3;
int n, m, k;
vector<int> adj[maxn];
void read() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
}
int depth[maxn], par[maxn];
int a = -1, b = -1;
void dfs(int ver) {
for (auto i : adj[ver]) {
if (!depth[i]) {
depth[i] = depth[ver] + 1;
par[i] = ver;
dfs(i);
} else if (depth[i] < depth[ver] - 1) {
if (a == -1 || (depth[ver] - depth[i] + 1 < depth[a] - depth[b] + 1))
a = ver, b = i;
}
}
}
vector<int> v1, v2;
void dfs1(int ver, int par, int d) {
if (d % 2 == 0)
v1.push_back(ver);
else
v2.push_back(ver);
for (auto i : adj[ver])
if (i != par) dfs1(i, ver, d + 1);
}
void solve() {
par[1] = -1;
depth[1] = 1;
dfs(1);
if (a == -1) {
dfs1(1, -1, 1);
if ((int)v1.size() < (int)v2.size()) swap(v1, v2);
cout << 1 << '\n';
for (int i = 0; i < k / 2 + k % 2; i++) cout << v1[i] << " ";
cout << '\n';
return;
}
vector<int> cycle;
while (a != b) {
cycle.push_back(a);
a = par[a];
}
cycle.push_back(b);
if ((int)cycle.size() <= k) {
cout << 2 << '\n';
cout << (int)cycle.size() << '\n';
for (auto i : cycle) cout << i << " ";
cout << '\n';
return;
}
int p = k / 2 + k % 2;
cout << 1 << '\n';
for (int i = 0; p > 0; i += 2) {
cout << cycle[i] << " ";
p--;
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
read();
solve();
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 111111;
int n, d;
long long x;
int a[NMAX];
int ag[NMAX];
int b[NMAX];
int bg[NMAX];
int c[NMAX];
int cg[NMAX];
long long getNextX() {
x = (x * 37 + 10007) % 1000000007;
return x;
}
void myswap(int &x, int &y) {
int tmp = x;
x = y;
y = tmp;
}
void initAB() {
int i;
for (i = 0; i < n; i = i + 1) {
a[i] = i + 1;
}
for (i = 0; i < n; i = i + 1) {
myswap(a[i], a[getNextX() % (i + 1)]);
}
for (i = 0; i < n; i = i + 1) {
if (i < d)
b[i] = 1;
else
b[i] = 0;
}
for (i = 0; i < n; i = i + 1) {
myswap(b[i], b[getNextX() % (i + 1)]);
}
}
int myfind(int *a, int x) {
static stack<int> s;
while (a[x] != x) {
s.push(x);
x = a[x];
}
while (!s.empty()) {
a[s.top()] = x;
s.pop();
}
return x;
}
void mymerge(int *a, int x, int y) {
x = myfind(a, x);
y = myfind(a, y);
a[x] = y;
}
int main() {
int i, j, nextj, pos;
scanf("%d%d%I64d", &n, &d, &x);
initAB();
b[n] = 1;
for (i = 0; i < n; i++) {
ag[a[i]] = i;
}
for (i = 0; i <= n; i++) {
bg[i] = cg[i] = i;
}
for (i = 0; i < n; i++) {
if (b[i] == 0) mymerge(bg, i, i + 1);
}
for (i = n; i > 0; i--) {
pos = ag[i];
j = 0;
while (true) {
while (j + pos < n && (b[j] == 0 || c[j + pos] != 0)) {
nextj = myfind(bg, j);
nextj = max(nextj, myfind(cg, j + pos) - pos);
j = nextj;
}
if (j + pos >= n) break;
c[j + pos] = i;
mymerge(cg, j + pos, j + pos + 1);
j++;
}
}
for (i = 0; i < n; i++) {
printf("%d\n", c[i]);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000009;
const int Mod = 1e9 + 9;
int n, f[maxn], g[maxn];
int main() {
scanf("%d", &n);
f[0] = 0;
f[1] = 4;
for (int i = 2; i <= n / 2 - 2; i++) f[i] = (4 + 2 * f[i - 1]) % Mod;
g[n / 2] = 1;
for (int i = n / 2 - 1; i >= 1; i--)
g[i] = (3LL * f[i - 1] + 1LL * g[i + 1] * (f[i - 1] + 1) + 4) % Mod;
printf("%I64d\n", 2LL * (1LL * g[1] * g[1] + 2 * g[1] + 2) % Mod);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
void func(void) {
freopen("input.c", "r", stdin);
freopen("output.c", "w", stdout);
}
struct trie {
trie *left, *right;
bool endMark;
trie() {
left = NULL;
right = NULL;
endMark = false;
}
} * root;
int f, A, yo, id;
vector<pair<int, string> > ans;
void rAdd(int len, string v, trie *cur) {
if (A == len) {
f = 1;
ans.push_back({id, v});
cur->endMark = true;
return;
}
if (f) return;
if (cur->left == NULL) {
cur->left = new trie();
rAdd(len + 1, v + "0", cur->left);
}
if (f)
return;
else if (cur->right == NULL) {
cur->right = new trie();
rAdd(len + 1, v + "1", cur->right);
}
if (f)
return;
else if (cur->left->endMark == false) {
rAdd(len + 1, v + "0", cur->left);
}
if (f)
return;
else if (cur->right->endMark == false) {
rAdd(len + 1, v + "1", cur->right);
}
}
pair<int, int> a[1002];
int main() {
long long n, q, i, j = 0, temp, t, k, sum = 0, x, y, cnt = 0, m, fg = 0,
mx = 0, mx1 = 0, mn = 8000000000000000000,
mn1 = 8000000000000000000;
cin >> n;
root = new trie();
for (i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
for (i = 0; i < n; i++) {
f = 0;
id = a[i].second;
trie *cur = root;
A = a[i].first;
rAdd(0, "", cur);
if (!f) {
cout << "NO\n";
return 0;
}
}
sort(ans.begin(), ans.end());
cout << "YES\n";
int sz = ans.size();
for (i = 0; i < sz; i++) cout << ans[i].second << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
const int N = 300005;
int n, m, q, k;
int bh[N], bel[N];
struct Graph {
static const int M = N * 2;
int cnt, y[M], nxt[M], fst[N];
void clear() { cnt = 1, memset(fst, 0, sizeof fst); }
void clear(vector<int> &id) {
cnt = 1;
for (auto i : id) fst[i] = 0;
}
void add(int a, int b) { y[++cnt] = b, nxt[cnt] = fst[a], fst[a] = cnt; }
} g, g2;
map<int, int> Map[N];
namespace TJ {
int dfn[N], low[N], st[N], inst[N];
int vise[N];
int Time = 0, top = 0, cnt = 0;
void init(vector<int> &id, int ec) {
Time = top = cnt = 0;
for (auto i : id) dfn[i] = low[i] = inst[i] = bh[i] = 0;
for (int i = (1); i <= (ec >> 1); i++) vise[i] = 0;
}
void Tarjan(int x) {
dfn[x] = low[x] = ++Time;
inst[x] = 1;
st[++top] = x;
for (int i = g.fst[x]; i; i = g.nxt[i]) {
if (vise[i >> 1]) continue;
vise[i >> 1] = 1;
int y = g.y[i];
if (!dfn[y]) {
Tarjan(y);
low[x] = min(low[x], low[y]);
} else if (inst[y])
low[x] = min(low[x], low[y]);
}
if (dfn[x] == low[x]) {
bh[st[top]] = ++cnt;
inst[st[top]] = 0;
while (st[top--] != x) {
bh[st[top]] = cnt;
inst[st[top]] = 0;
}
}
}
void Main() {
g.clear();
for (int i = (1); i <= (m); i++) {
int x = read(), y = read();
g.add(x, y), g.add(y, x);
}
for (int i = (1); i <= (n); i++)
if (!dfn[i]) Tarjan(i);
k = cnt;
}
} // namespace TJ
int fa[N][20], depth[N], I[N], CI = 0, ct[N], cntt = 0, root[N];
void dfs(int x, int pre, int d) {
depth[x] = d, fa[x][0] = pre, I[x] = ++CI, ct[x] = cntt;
for (int i = (1); i <= (19); i++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = g2.fst[x]; i; i = g2.nxt[i]) {
int y = g2.y[i];
if (y != pre) dfs(y, x, d + 1);
}
}
int LCA(int x, int y) {
if (depth[x] < depth[y]) swap(x, y);
for (int i = (19); i >= (0); i--)
if (depth[x] - (1 << i) >= depth[y]) x = fa[x][i];
if (x == y) return x;
for (int i = (19); i >= (0); i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
int lastans = 0;
int getv() {
int v = read();
v = (v + lastans) % n;
if (v == 0) v = n;
return v;
}
bool cmpI(int a, int b) { return I[a] < I[b]; }
int visrt[N];
int st[N], top;
int main() {
n = read(), m = read(), q = read();
TJ::Main();
g2.clear();
for (int i = (2); i <= (g.cnt); i++) {
int x = bh[g.y[i ^ 1]], y = bh[g.y[i]];
if (x != y && !Map[x][y]) {
Map[x][y] = 1;
g2.add(x, y);
}
}
for (int i = (1); i <= (k); i++)
if (!I[i]) root[++cntt] = i, dfs(i, 0, 0);
swap(bh, bel);
for (int T = (1); T <= (q); T++) {
int ni = read(), mi = read();
vector<int> id, x, vid, tmp;
vector<pair<int, int> > p;
for (int i = (1); i <= (ni); i++) {
int v = bel[getv()];
x.push_back(v), id.push_back(v);
}
for (int i = (1); i <= (mi); i++) {
int x = bel[getv()], y = bel[getv()];
p.push_back(make_pair(x, y));
id.push_back(x), id.push_back(y);
}
sort(id.begin(), id.end(), cmpI);
id.resize(unique(id.begin(), id.end()) - id.begin());
for (auto i : id)
if (i == root[ct[i]]) visrt[i] = T;
for (auto i : id)
if (visrt[root[ct[i]]] != T) visrt[i] = T, tmp.push_back(root[ct[i]]);
for (auto i : tmp) id.push_back(i);
sort(id.begin(), id.end(), cmpI);
vid = id;
top = 0;
for (int _ = (0); _ <= ((int)id.size() - 1); _++) {
int x = id[_];
if (top > 0) {
int y = LCA(x, st[top]);
while (top > 1 && depth[st[top - 1]] >= depth[y]) {
p.push_back(make_pair(st[top], st[top - 1]));
top--;
}
if (y != st[top]) {
vid.push_back(y);
p.push_back(make_pair(st[top], y));
st[top] = y;
}
}
st[++top] = x;
if (_ == (int)id.size() - 1 || ct[x] != ct[id[_ + 1]]) {
while (top > 1) {
p.push_back(make_pair(st[top], st[top - 1]));
top--;
}
top = 0;
}
}
g.clear(vid);
for (auto e : p) {
g.add(e.first, e.second);
g.add(e.second, e.first);
}
TJ::init(vid, g.cnt);
for (auto i : vid)
if (!TJ::dfn[i]) TJ::Tarjan(i);
int flag = 0;
for (auto i : x)
if (bh[i] != bh[x.back()]) {
flag = 1;
break;
}
if (flag)
puts("NO");
else
puts("YES"), lastans = (lastans + T) % n;
}
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2020;
const int vx[4] = {1, -1, 0, 0};
const int vy[4] = {0, 0, 1, -1};
int n, m, a[N][N], s[N][N], id[N][N], cnt, ans[N * N / 100];
bool ry[N][N];
int area(int x1, int y1, int x2, int y2) {
return s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1];
}
int see(int x, int y) { return area(x - 3, y - 3, x + 3, y + 3); }
void dfs(int i, int j, int w) {
if (i < 1 || i > n || j < 1 || j > m || !a[i][j] || id[i][j]) return;
id[i][j] = w;
for (int l = 0; l <= 3; ++l) dfs(i + vx[l], j + vy[l], w);
}
void getRay(int i, int j) {
if (i < 1 || i > n || j < 1 || j > m || !ry[i][j]) return;
ry[i][j] = 0;
for (int l = 0; l <= 3; ++l) getRay(i + vx[l], j + vy[l]);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
char c = getchar();
while (c != '1' && c != '0') c = getchar();
a[i + 10][j + 10] = c - '0';
}
n += 20, m += 20;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
s[i][j] = a[i][j] + s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (a[i][j] && !id[i][j]) {
dfs(i, j, ++cnt);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
ry[i][j] = (a[i][j] && see(i, j) <= 15);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (ry[i][j]) {
getRay(i, j);
ans[id[i][j]]++;
}
printf("%d\n", cnt);
sort(ans + 1, ans + cnt + 1);
for (int i = 1; i <= cnt; ++i) printf("%d ", ans[i]);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long countDig(long long s) { return floor(log10(s) + 1); }
int main() {
long long num;
int luckyNums = 0;
string n;
cin >> num;
int digits = countDig(num);
n = to_string(num);
for (int i = 0; i < digits; i++) {
if (n[i] == '4' || n[i] == '7') luckyNums++;
}
if (luckyNums == 4 || luckyNums == 7)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mark[1000016];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, p, flag = 0, n;
string second;
cin >> n >> p >> second;
for (i = 0; i < second.size() - p; i++) {
if ((second[i] == '.' || second[i + p] == '.') ||
(second[i] != second[i + p]))
flag = 1;
if (second[i] == '.' && second[i + p] == '.') {
mark[i + p] = 1;
if (!mark[i]) mark[i] = -1;
} else if (second[i] == '.' && !mark[i]) {
if (second[i + p] == '0')
mark[i] = 1;
else
mark[i] = -1;
} else if (second[i + p] == '.') {
if (second[i] == '0')
mark[i + p] = 1;
else
mark[i + p] = -1;
}
}
if (!flag)
cout << "No\n";
else {
for (i = 0; i < second.size(); i++) {
if (!mark[i]) {
if (second[i] == '.')
cout << "0";
else
cout << second[i];
} else if (mark[i] == 1)
cout << "1";
else
cout << "0";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int LEN = 2000100 * 3;
int r[LEN], sa[LEN];
int wa[LEN], wb[LEN], wv[LEN], ss[LEN];
int c0(int *r, int a, int b) {
return r[a] == r[b] && r[a + 1] == r[b + 1] && r[a + 2] == r[b + 2];
}
int c12(int k, int *r, int a, int b) {
if (k == 2) return r[a] < r[b] || r[a] == r[b] && c12(1, r, a + 1, b + 1);
return r[a] < r[b] || r[a] == r[b] && wv[a + 1] < wv[b + 1];
}
void sort(int *r, int *a, int *b, int n, int m) {
for (int i = 0; i < n; i++) wv[i] = r[a[i]];
for (int i = 0; i < m; i++) ss[i] = 0;
for (int i = 0; i < n; i++) ss[wv[i]]++;
for (int i = 1; i < m; i++) ss[i] += ss[i - 1];
for (int i = n - 1; i >= 0; i--) b[--ss[wv[i]]] = a[i];
}
void DC3(int *r, int *sa, int n, int m) {
int i, j, p;
int *san = sa + n, *rn = r + n;
int ta = 0, tb = (n + 1) / 3, tbc = 0;
r[n] = r[n + 1] = 0;
for (i = 0; i < n; i++)
if (i % 3 != 0) wa[tbc++] = i;
sort(r + 2, wa, wb, tbc, m);
sort(r + 1, wb, wa, tbc, m);
sort(r, wa, wb, tbc, m);
for (p = 1, rn[((wb[0]) / 3 + ((wb[0]) % 3 == 1 ? 0 : tb))] = 0, i = 1;
i < tbc; i++)
rn[((wb[i]) / 3 + ((wb[i]) % 3 == 1 ? 0 : tb))] =
c0(r, wb[i - 1], wb[i]) ? p - 1 : p++;
if (p < tbc)
DC3(rn, san, tbc, p);
else
for (i = 0; i < tbc; i++) san[rn[i]] = i;
for (i = 0; i < tbc; i++)
if (san[i] < tb) wb[ta++] = san[i] * 3;
if (n % 3 == 1) wb[ta++] = n - 1;
sort(r, wb, wa, ta, m);
for (i = 0; i < tbc; i++)
wv[wb[i] = ((san[i]) < tb ? (san[i]) * 3 + 1 : ((san[i]) - tb) * 3 + 2)] =
i;
for (i = 0, j = 0, p = 0; i < ta && j < tbc; p++)
sa[p] = c12(wb[j] % 3, r, wa[i], wb[j]) ? wa[i++] : wb[j++];
for (; i < ta; p++) sa[p] = wa[i++];
for (; j < tbc; p++) sa[p] = wb[j++];
}
char s[2000100];
int val[2000100];
int rmq[20][1000100];
int query(int l, int r) {
int cnt = r - l + 1, i;
for (i = 0; (1 << i) <= cnt; i++)
;
i--;
return ((rmq[i][l]) < (rmq[i][r - (1 << i) + 1])
? (rmq[i][l])
: (rmq[i][r - (1 << i) + 1]));
}
int main() {
scanf("%s", s);
int len = strlen(s);
for (int i = 0; i < len; i++) r[i] = r[i + len] = s[i];
r[len << 1] = 0;
DC3(r, sa, len << 1 | 1, 256);
int cur = 0;
int ca = 0, cb = 0;
for (int i = 0; i < len; i++) {
if (s[i] == '(')
cur++;
else
cur--;
val[i] = cur;
}
if (cur > 0)
ca = 0, cb = cur;
else
ca = -cur, cb = 0;
for (int i = 0; i < len; i++) rmq[0][i] = val[i];
for (int j = 1; (1 << j) <= len; j++) {
int k = 1 << (j - 1);
for (int i = 0; i + (1 << j) <= len; i++) {
rmq[j][i] = ((rmq[j - 1][i]) < (rmq[j - 1][i + k]) ? (rmq[j - 1][i])
: (rmq[j - 1][i + k]));
}
}
int pos;
for (int j = 0; j <= len + len; j++)
if (sa[j] < len) {
int i = sa[j];
int init = val[i] - ((s[i] == '(') ? 1 : -1);
int Min = query(i, len - 1) - init;
if (Min + ca < 0) continue;
if (i >= 1) {
init = val[len - 1] - init;
Min = query(0, i - 1) + init + ca;
if (Min < 0) continue;
}
pos = i;
break;
}
for (int i = 0; i < ca; i++) putchar('(');
for (int i = pos; i < len; i++) putchar(s[i]);
for (int i = 0; i < pos; i++) putchar(s[i]);
for (int i = 0; i < cb; i++) putchar(')');
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
unsigned long int min(unsigned long int a, unsigned long int b) {
if (a < b)
return a;
else
return b;
}
unsigned long int max(unsigned long int a, unsigned long int b) {
if (a > b)
return a;
else
return b;
}
unsigned long int func(unsigned long int a, unsigned long int b,
unsigned long int c, unsigned long int d,
unsigned long int e, unsigned long int f) {
unsigned long int cost = 0;
if (f > e) {
unsigned long int x = min(b, min(c, d));
cost += x * f;
if (x == d) return cost;
return cost + (min(a, d - x)) * e;
} else if (e == f) {
unsigned long int x1 = min(b, min(c, d));
unsigned long int x2 = min(a, d);
return min(d, x1 + x2) * e;
} else {
unsigned long int x = min(a, d);
cost += x * e;
if (x == d) return cost;
return cost + min(b, min(c, (d - a))) * f;
}
}
int main() {
unsigned long int a, b, c, d, e, f, res;
cin >> a >> b >> c >> d >> e >> f;
res = func(a, b, c, d, e, f);
cout << res;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
long long x, y, cost = 0, seg = 0;
string str;
cin >> n >> x >> y;
cin >> str;
for (int i = 0; i <= n - 1; i++) {
if (str[i] == '0' && (i == n - 1 || str[i + 1] == '1')) seg++;
}
cost = seg * y;
for (int i = 0; i < seg - 1; i++) {
long long c1 = cost - y + x;
if (c1 < cost) cost = c1;
}
cout << cost << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<string, int>> v;
for (int i = 0; i < n; i++) {
string a;
int b;
cin >> a >> b;
v.push_back({a, b});
}
sort(v.begin(), v.end(), [](pair<string, int> a, pair<string, int> b) {
return a.second < b.second;
});
vector<string> ans;
for (int i = 0; i < n; i++) {
if (v[i].second > i) {
cout << -1;
return 0;
}
ans.insert(ans.begin() + (ans.size() - v[i].second), v[i].first);
}
int h = 1;
map<string, int> vi;
for (int i = 0; i < n; i++) {
vi[ans[i]] = h;
++h;
}
for (int i = 0; i < n; i++) {
cout << v[i].first << ' ' << vi[v[i].first] << '\n';
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 666013;
const long long int mod2 = 1e9 + 9;
const long long int maxn = 1e6 + 5;
const long long int maxn1 = 1e7 + 1;
const int root = 1e5 + 5;
const long long inf = 1e18 + 18;
double pie4 = 3.1415926535;
long long int a[maxn], b[maxn];
int main() {
long long int n, cnt = 0, x, j, i;
cin >> n >> x;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 1; i <= n; i++) {
cin >> b[i];
}
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
reverse(a + 1, a + n + 1);
for (i = 1, j = 1; i <= n && j <= n;) {
if (a[i] + b[j] >= x) {
cnt++;
i++;
j++;
} else
j++;
}
cout << "1 " << cnt << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int N, deg[100010], cnt[100010];
;
vector<int> g[100010];
bool v[100010];
bool ans = 1;
void dfs1(int nod, int p) {
int i;
for (i = 0; i < g[nod].size(); i++)
if (g[nod][i] != p) dfs1(g[nod][i], nod);
cnt[nod] = 0;
for (i = 0; i < g[nod].size(); i++) {
if (g[nod][i] != p) {
cnt[nod] += cnt[g[nod][i]];
if (deg[g[nod][i]] > 2) cnt[nod]++;
}
}
}
void dfs2(int nod, int p) {
int aux1 = cnt[nod], aux2 = cnt[p];
if (!ans) return;
cnt[p] -= cnt[nod];
if (deg[nod] > 2) cnt[p]--;
cnt[nod] += cnt[p];
if (deg[p] > 2) cnt[nod]++;
int i, nr = 0;
for (i = 0; i < g[nod].size(); i++) {
if (deg[g[nod][i]] > 3 || cnt[g[nod][i]]) nr++;
}
if (nr > 2) {
ans = 0;
return;
}
for (i = 0; i < g[nod].size(); i++)
if (g[nod][i] != p) {
dfs2(g[nod][i], nod);
if (!ans) return;
}
cnt[nod] = aux1;
cnt[p] = aux2;
}
int main() {
cin >> N;
int i, x, y;
for (i = 1; i < N; i++) {
cin >> x >> y;
deg[x]++, deg[y]++;
g[x].push_back(y);
g[y].push_back(x);
}
dfs1(1, 0);
int nod = 1, nr = 0;
for (i = 0; i < g[nod].size(); i++)
if (deg[g[nod][i]] > 3 || cnt[g[nod][i]]) {
nr++;
}
if (nr > 2) {
ans = 0;
}
for (i = 0; i < g[1].size(); i++) dfs2(g[1][i], 1);
if (ans)
cout << "Yes";
else
cout << "No";
cout << "\n";
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
int n, m;
bool used[MAXN];
pair<pair<int, int>, int> interval[MAXN];
bool cmp(const pair<pair<int, int>, int> &a,
const pair<pair<int, int>, int> &b) {
return a.first.first < b.first.first ||
(a.first.first == b.first.first && a.first.second > b.first.second);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (0); i < (m); i++) {
int a, l;
scanf("%d%d", &a, &l);
interval[i] = make_pair(make_pair(a, a + l - 1), i);
}
sort(interval, interval + m, cmp);
int prevEnd = -1;
for (int i = 0; i < m;) {
if (interval[i].first.first <= prevEnd) {
int useIdx = -1;
for (; i < m && interval[i].first.first <= prevEnd; i++)
if (useIdx == -1 ||
interval[useIdx].first.second < interval[i].first.second)
useIdx = i;
if (useIdx != -1 && prevEnd <= interval[useIdx].first.second) {
used[interval[useIdx].second] = true;
prevEnd = interval[useIdx].first.second + 1;
}
} else {
used[interval[i].second] = true;
prevEnd = interval[i++].first.second + 1;
}
}
printf("%d\n", m - accumulate(used, used + m, 0));
for (int i = (0); i < (m); i++)
if (!used[i]) printf("%d ", i + 1);
putchar('\n');
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[5123456];
int main(int argc, char *argv[]) {
scanf("%d%d", &n, &m);
fgets(s, 5123456, stdin);
vector<time_t> lgs;
while (fgets(s, 5123456, stdin)) {
tm shijian;
shijian.tm_year = 2012 - 1900;
shijian.tm_mon = ((s[5] - '0') * 10 + s[5 + 1] - '0') - 1;
shijian.tm_mday = ((s[8] - '0') * 10 + s[8 + 1] - '0');
shijian.tm_hour = ((s[11] - '0') * 10 + s[11 + 1] - '0');
shijian.tm_min = ((s[14] - '0') * 10 + s[14 + 1] - '0');
shijian.tm_sec = ((s[17] - '0') * 10 + s[17 + 1] - '0');
lgs.push_back(mktime(&shijian));
}
time_t ans = 0;
for (int i = 0; i + m - 1 < (int)lgs.size(); i++) {
if (lgs[i + m - 1] - lgs[i] + 1 <= n) {
ans = lgs[i + m - 1];
break;
}
}
if (ans == 0)
cout << -1 << endl;
else {
tm *lt = localtime(&ans);
printf("2012-%.2d-%.2d %.2d:%.2d:%.2d\n", lt->tm_mon + 1, lt->tm_mday,
lt->tm_hour, lt->tm_min, lt->tm_sec);
}
return EXIT_SUCCESS;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long answer = 0;
struct state {
int len, link;
map<char, int> next;
int c = 0;
int d = 0;
};
const int MAXLEN = 200005;
state st[MAXLEN * 2];
int sz, last;
void sa_init() {
sz = last = 0;
st[0].len = 0;
st[0].link = -1;
++sz;
}
void sa_extend(char c) {
int cur = sz++;
st[cur].len = st[last].len + 1;
int p;
for (p = last; p != -1 && !st[p].next.count(c); p = st[p].link)
st[p].next[c] = cur;
if (p == -1)
st[cur].link = 0;
else {
int q = st[p].next[c];
if (st[p].len + 1 == st[q].len)
st[cur].link = q;
else {
int clone = sz++;
st[clone].len = st[p].len + 1;
st[clone].next = st[q].next;
st[clone].link = st[q].link;
for (; p != -1 && st[p].next[c] == q; p = st[p].link)
st[p].next[c] = clone;
st[q].link = st[cur].link = clone;
}
}
last = cur;
}
int solve(int node) {
if (st[node].c) return st[node].c;
for (auto it : st[node].next) {
if (it.first == '$') {
st[node].c++;
} else {
st[node].c += solve(st[node].next[it.first]);
}
}
return st[node].c;
}
vector<int> adj[2 * MAXLEN];
int go(int node) {
for (int child : adj[node]) {
st[node].d += go(child);
}
if (node > 0) {
answer = max(answer, 1LL * (st[node].c - st[node].d) * st[node].len);
}
return st[node].d;
}
int main(int argc, const char* argv[]) {
int n;
string second, t;
sa_init();
cin >> n >> second >> t;
for (char c : second) {
sa_extend(c);
}
sa_extend('$');
solve(0);
for (int i = 1; i < sz; i++) {
adj[st[i].link].push_back(i);
}
int myNode = 0;
for (int i = 0; i < n; ++i) {
myNode = st[myNode].next[second[i]];
if (t[i] == '1') {
st[myNode].d++;
}
}
go(0);
cout << answer << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
int reverse(int c) {
int rev = 0;
for (int i = 0; i < 7; ++i) {
rev |= (c >> i) & 1;
rev <<= 1;
}
return rev;
}
int main() {
std::string text;
std::getline(std::cin, text);
int prev = 0;
for (int i = 0; i < text.size(); ++i) {
int c = reverse(text[i]);
if (prev - c < 0)
std::cout << prev - c + 256 << std::endl;
else
std::cout << prev - c << std::endl;
prev = c;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct pi {
double x, y;
} q[10];
int a[12];
double dis(int x, int y) {
return (q[x].x - q[y].x) * (q[x].x - q[y].x) +
(q[x].y - q[y].y) * (q[x].y - q[y].y);
}
double ver(int x, int y, int z) {
double k1 = q[x].x - q[y].x;
double k2 = q[x].y - q[y].y;
double c1 = q[z].x - q[y].x;
double c2 = q[z].y - q[y].y;
if (fabs(k1 * c1 + k2 * c2) < 1e-6) return false;
return true;
}
bool judge1(int x1, int x2, int x3, int x4) {
double tmp = dis(x1, x2);
if (fabs(tmp) < 1e-6) return 0;
if (fabs(dis(x2, x3) - tmp) > 1e-6) return false;
if (fabs(dis(x3, x4) - tmp) > 1e-6) return false;
if (fabs(dis(x4, x1) - tmp) > 1e-6) return false;
if (ver(x1, x2, x3)) return false;
if (ver(x2, x3, x4)) return false;
if (ver(x3, x4, x1)) return false;
if (ver(x4, x1, x2)) return false;
return true;
}
bool judge2(int x1, int x2, int x3, int x4) {
double tmp = dis(x1, x2), tp2 = dis(x2, x3);
if (fabs(tmp) < 1e-6 || fabs(tp2) < 1e-6) return 0;
if (fabs(dis(x3, x4) - tmp) > 1e-6) return false;
if (fabs(dis(x4, x1) - tp2) > 1e-6) return false;
if (ver(x1, x2, x3)) return false;
if (ver(x2, x3, x4)) return false;
if (ver(x3, x4, x1)) return false;
if (ver(x4, x1, x2)) return false;
return true;
}
int main() {
for (int i = 0; i < 8; i++) {
scanf("%lf %lf", &q[i].x, &q[i].y);
a[i] = i;
}
do {
if (judge1(a[0], a[1], a[2], a[3]) && judge2(a[4], a[5], a[6], a[7])) {
puts("YES");
printf("%d %d %d %d\n", a[0] + 1, a[1] + 1, a[2] + 1, a[3] + 1);
printf("%d %d %d %d\n", a[4] + 1, a[5] + 1, a[6] + 1, a[7] + 1);
return 0;
}
} while (next_permutation(a, a + 8));
puts("NO");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
const long long MOD = 998244353;
const int INF = 0x3f3f3f3f;
long long read() {
long long x = 0, f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - 48;
ch = getchar();
} while (ch >= '0' && ch <= '9');
return x * f;
}
int N, M;
int a[MAXN];
long long ans;
long long fac[MAXN], rev[MAXN];
long long qpow(long long x, long long n) {
long long ans = 1;
while (n) {
if (n & 1) {
ans *= x;
ans %= MOD;
}
n >>= 1;
x *= x;
x %= MOD;
}
return ans;
}
long long inv(long long x) { return qpow(x, MOD - 2); }
void mark() {
fac[0] = 1;
for (int i = 1; i < MAXN; i++) {
fac[i] = fac[i - 1] * i % MOD;
}
rev[MAXN - 1] = inv(fac[MAXN - 1]);
for (int i = MAXN - 2; i >= 0; i--) {
rev[i] = rev[i + 1] * (i + 1) % MOD;
}
}
long long C(int n, int m) {
if (n < m || m < 0) {
return 0;
}
return fac[n] * rev[m] % MOD * rev[n - m] % MOD;
}
void solve() {
int cnt;
int temp;
long long ans;
mark();
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%d", &a[i]);
}
a[N + 1] = a[1];
cnt = 0;
for (int i = 1; i <= N; i++) {
cnt += (a[i] == a[i + 1]);
}
temp = N - cnt;
ans = 0;
for (int i = 0; i <= temp / 2; ++i) {
ans += C(temp, i) * C(temp - i, i) % MOD * qpow(M - 2, temp - 2 * i) % MOD;
ans %= MOD;
}
ans = (qpow(M, temp) - ans + MOD) % MOD * rev[2] % MOD;
ans *= qpow(M, cnt);
ans %= MOD;
printf("%lld\n", ans);
}
int main() {
int T;
T = 1;
while (T--) {
solve();
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
#pragma GCC omptimize("unroll-loops")
#pragma optimize("SEX_ON_THE_BEACH")
#pragma GCC optimize("no-stack-protector")
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
using ll = unsigned long long int;
using ull = unsigned long long int;
using dd = long double;
using ldd = long double;
using si = short int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
ll get_seed(string s) {
ll ans = 0;
for (int i = 0; i < s.size(); ++i) ans += s[i];
return ans;
}
int popcount(int x) { return __builtin_popcount(x); }
ll popcountll(ll x) { return __builtin_popcount(x); }
void solve(int ii) {
ll n, m, k;
cin >> n >> m >> k;
vector<ll> arr(m);
for (int i = 0; i < m; ++i) {
cin >> arr[i];
--arr[i];
}
ll mi = 0;
ll ans = 0;
int l = 0;
while (l < m) {
int r = l + 1;
while (r < m && (arr[r] - mi) / k == (arr[l] - mi) / k) ++r;
++ans;
mi += r - l;
l = r;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int t;
t = 1;
for (int i = 0; i < t; ++i) solve(i);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
char ch;
bool flag = false;
while (ch = getchar(), ch < '!')
;
if (ch == '-') ch = getchar(), flag = true;
while (x = 10 * x + ch - '0', ch = getchar(), ch > '!')
;
if (flag) x = -x;
}
inline int cat_max(const int &a, const int &b) { return a > b ? a : b; }
inline int cat_min(const int &a, const int &b) { return a < b ? a : b; }
const int maxn = 10010;
const int maxnode = 40005;
const int maxedge = 200010;
const int inf = 0x3f3f3f3f;
struct Edge {
int to, next, cap;
} G[maxedge << 1];
int head[maxnode], cnt = 1;
void add(int u, int v, int c) {
G[++cnt].to = v;
G[cnt].next = head[u];
head[u] = cnt;
G[cnt].cap = c;
}
inline void insert(int u, int v, int c) {
add(u, v, c);
add(v, u, 0);
}
int S, T;
int dis[maxnode], q[maxnode], l, r;
bool bfs() {
memset(dis, -1, sizeof dis);
dis[S] = 0;
l = 0;
r = -1;
q[++r] = S;
while (l <= r) {
int u = q[l++];
for (int i = head[u]; i; i = G[i].next) {
if (dis[G[i].to] == -1 && G[i].cap) {
dis[G[i].to] = dis[u] + 1;
q[++r] = G[i].to;
}
}
}
return dis[T] != -1;
}
int cur[maxnode];
int dfs(int u, int f) {
if (u == T || f == 0) return f;
int ret = 0;
for (int &i = cur[u]; i; i = G[i].next) {
if (dis[G[i].to] == dis[u] + 1 && G[i].cap) {
int x = dfs(G[i].to, cat_min(f, G[i].cap));
ret += x;
f -= x;
G[i].cap -= x;
G[i ^ 1].cap += x;
if (f == 0) break;
}
}
if (ret == 0) dis[u] = -1;
return ret;
}
inline int dinic() {
int ret = 0;
while (bfs()) {
memcpy(cur, head, sizeof head);
ret += dfs(S, inf);
}
return ret;
}
int upto[maxn], quan[maxn], p[maxn];
inline bool cmp(const int &i, const int &j) {
return upto[i] == upto[j] ? quan[i] < quan[j] : upto[i] < upto[j];
}
int nodecnt;
int main() {
int n, b, q;
read(n);
read(b);
read(q);
S = maxnode - 5;
T = S + 1;
for (int i = 1; i <= q; ++i) {
read(upto[i]);
read(quan[i]);
p[i] = i;
}
upto[++q] = b;
quan[q] = n;
p[q] = q;
sort(p + 1, p + q + 1, cmp);
nodecnt = b;
for (int num = 0; num <= 4; ++num) {
++nodecnt;
for (int i = num; i <= b; i += 5) {
if (i == 0) continue;
insert(i, nodecnt, 1);
}
insert(nodecnt, T, n / 5);
}
int lastval = 0, lastpos = 0;
for (int i = 1; i <= q; ++i) {
if (upto[p[i]] == upto[p[i - 1]] && quan[p[i]] != quan[p[i - 1]] && i != 1)
return puts("unfair"), 0;
int tmp = quan[p[i]] - quan[p[i - 1]];
if (tmp < 0) return puts("unfair"), 0;
if (tmp > upto[p[i]] - upto[p[i - 1]]) return puts("unfair"), 0;
++nodecnt;
insert(S, nodecnt, tmp);
for (int j = upto[p[i - 1]] + 1; j <= upto[p[i]]; ++j) {
insert(nodecnt, j, 1);
}
}
int ans = dinic();
if (ans == n)
puts("fair");
else
puts("unfair");
getchar();
getchar();
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y;
long long dp[3];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> x;
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> y;
dp[0] = max(dp[0] + y, 0ll);
dp[1] = max(dp[1] + x * y, dp[0]);
dp[2] = max(dp[2] + y, dp[1]);
ans = max(ans, dp[2]);
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500010;
const int N = 500000;
int n, ans;
multiset<int> s0, sn, sp;
multiset<int>::iterator it;
struct pii {
int x, v;
pii() {}
pii(int a, int b) { x = a, v = b; }
bool operator<(const pii &a) const {
return (v == a.v) ? (x < a.x) : (v < a.v);
}
bool operator>(const pii &a) const {
return (v == a.v) ? (x < a.x) : (v > a.v);
}
};
struct node {
int val;
pii sm, sn;
node() {}
node(int a, pii b, pii c) { val = a, sm = b, sn = c; }
node operator+(const node &a) const {
return node(0, max(sm, a.sm), min(sn, a.sn));
}
} s[maxn << 2];
int v[maxn], p[maxn], rnk[maxn], efc[maxn], val[maxn << 2];
void build(int l, int r, int x) {
s[x] = node(0, pii(l, -N), pii(l, N));
if (l == r) return;
int mid = (l + r) >> 1;
build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
}
inline void add(int x, int v) { s[x].val += v, s[x].sm.v += v, s[x].sn.v += v; }
inline void pushdown(int x) {
if (s[x].val) add(x << 1, s[x].val), add(x << 1 | 1, s[x].val), s[x].val = 0;
}
void modify(int l, int r, int x, int a, node v) {
if (l == r) {
s[x] = v;
return;
}
pushdown(x);
int mid = (l + r) >> 1;
if (a <= mid)
modify(l, mid, x << 1, a, v);
else
modify(mid + 1, r, x << 1 | 1, a, v);
s[x] = s[x << 1] + s[x << 1 | 1];
}
void updata(int l, int r, int x, int a, int b, int v) {
if (a > b) return;
if (a <= l && r <= b) {
add(x, v);
return;
}
pushdown(x);
int mid = (l + r) >> 1;
if (a <= mid) updata(l, mid, x << 1, a, b, v);
if (b > mid) updata(mid + 1, r, x << 1 | 1, a, b, v);
s[x] = s[x << 1] + s[x << 1 | 1];
}
node query(int l, int r, int x, int a, int b) {
if (a <= l && r <= b) return s[x];
pushdown(x);
int mid = (l + r) >> 1;
if (b <= mid) return query(l, mid, x << 1, a, b);
if (a > mid) return query(mid + 1, r, x << 1 | 1, a, b);
return query(l, mid, x << 1, a, b) + query(mid + 1, r, x << 1 | 1, a, b);
}
inline int rd() {
int ret = 0, f = 1;
char gc = getchar();
while (gc < '0' || gc > '9') {
if (gc == '-') f = -f;
gc = getchar();
}
while (gc >= '0' && gc <= '9') ret = ret * 10 + (gc ^ '0'), gc = getchar();
return ret * f;
}
bool cmp(const int &a, const int &b) {
return (v[a] == v[b]) ? (a < b) : (v[a] < v[b]);
}
int main() {
n = rd();
int i, val;
for (i = 1; i <= n; i++) v[i] = rd(), p[i] = i;
sort(p + 1, p + n + 1, cmp);
for (i = 1; i <= n; i++) rnk[p[i]] = i;
build(1, n, 1);
for (i = 1; i <= n; i++) {
val = query(1, n, 1, rnk[i], rnk[i]).val;
if (val > v[i]) {
updata(1, n, 1, rnk[i] + 1, n, -1), ans--, efc[rnk[i]]--;
pii t = query(1, n, 1, rnk[i], n).sn;
if (t.v < 0) {
updata(1, n, 1, t.x + 1, n, 1), ans++, efc[t.x]++;
if (efc[t.x] == 1)
modify(1, n, 1, t.x,
node(v[p[t.x]] - efc[t.x], pii(t.x, 0), pii(t.x, N)));
else
modify(1, n, 1, t.x,
node(v[p[t.x]] - efc[t.x], pii(t.x, -N), pii(t.x, 0)));
}
modify(1, n, 1, rnk[i],
node(val, pii(rnk[i], -N), pii(rnk[i], val - v[i] + efc[rnk[i]])));
} else if (val < v[i]) {
updata(1, n, 1, rnk[i] + 1, n, 1), ans++, efc[rnk[i]]++;
pii t = query(1, n, 1, rnk[i], n).sm;
if (t.v > 0) {
updata(1, n, 1, t.x + 1, n, -1), ans--, efc[t.x]--;
modify(1, n, 1, t.x,
node(v[p[t.x]] - efc[t.x], pii(t.x, -N), pii(t.x, 0)));
}
modify(1, n, 1, rnk[i],
node(val, pii(rnk[i], val - v[i] + efc[rnk[i]]), pii(rnk[i], N)));
} else
modify(1, n, 1, rnk[i], node(val, pii(rnk[i], -N), pii(rnk[i], 0)));
printf("%d\n", ans);
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int *a, *b;
a = new int[n];
b = new int[m];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] == b[j]) {
cout << a[i] << " ";
}
}
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#include <string>
#include <cmath>
#include <sstream>
//#include <unordered_map>
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define FORD(i, a, b) for (int i = (a - 1); i >= (b); i--)
#define pb(a) push_back(a)
#define mp(a, b) make_pair(a, b)
typedef long long int ll;
using namespace std;
ll mod = 1000000007;
//ll mod=67280421310721;
//ll mod=998244353;
ll powmod(ll a, ll b)
{
ll res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1)
{
if (b & 1)
res = res * a % mod;
a = a * a % mod;
}
return res;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const int MAXN=1000005;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin>>t;
while (t--)
{
ll n,m,flag= 0,y=0,x,k=0,c=0,ans=MAXN,r=0;
cin>>x;
k=1;
while(y<x)
{
y+=k;
k++;
}
m=y-x;
if(m==1) cout<<k<<endl;
else cout<<k-1<<endl;
}
// your code goes here
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200200;
void Fix(string& s) {
reverse(s.begin(), s.end());
s.resize(N, '0');
for (long long i = N - 1; i > 0; i--)
while (i < N - 1 && s[i] == '1' && s[i - 1] == '1')
s[i] = s[i - 1] = '0', s[i + 1] = '1', i++, i++;
reverse(s.begin(), s.end());
}
int main() {
string s1;
cin >> s1;
Fix(s1);
string s2;
cin >> s2;
Fix(s2);
if (s1 == s2) cout << "=";
if (s1 > s2) cout << ">";
if (s1 < s2) cout << "<";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 10;
const double pi = acos(-1);
int n, m, k;
int r[N];
int a, b;
complex<double> A[N], B[N];
int c[N], p[N], ans[N];
void FFT(complex<double> A[], int n, int inv) {
for (int i = 0; i < n; ++i) {
if (i < r[i]) swap(A[i], A[r[i]]);
}
for (int mid = 1; mid < n; mid <<= 1) {
complex<double> wn = complex<double>(cos(pi / mid), inv * sin(pi / mid));
for (int i = 0; i < n; i += mid * 2) {
complex<double> w(1, 0);
for (int k = 0; k < mid; ++k, w *= wn) {
complex<double> x = A[i + k], y = w * A[i + k + mid];
A[i + k] = x + y;
A[i + k + mid] = x - y;
}
}
}
if (inv == -1) {
for (int i = 0; i < n; ++i) {
A[i] /= n;
}
}
}
int main() {
int d, Q;
cin >> d >> Q;
for (int i = 1; i <= d; ++i) {
int y;
scanf("%d", &y);
p[y]++;
ans[y]++;
}
for (int i = 0; i <= Q; ++i)
if (p[i]) {
A[i].real(1);
}
a = b = Q;
m = a + b + 1;
int bit = 0;
while ((1 << bit) < m) bit++;
n = (1 << bit);
for (int i = 0; i < n; ++i) r[i] = (r[i >> 1] >> 1) | ((i & 1) << (bit - 1));
FFT(A, n, 1);
for (int i = 0; i < n; ++i) A[i] = A[i] * A[i];
FFT(A, n, -1);
for (int i = 1; i <= Q; ++i) {
long long t = A[i].real() + 0.49;
if (t >= 1) {
if (p[i] == 0) {
cout << "NO" << endl;
return 0;
}
ans[i] = 0;
}
}
cout << "YES" << endl;
int sum = 0;
for (int i = 1; i <= Q; ++i)
if (ans[i]) sum++;
cout << sum << endl;
for (int i = 1; i <= Q; ++i)
if (ans[i]) printf("%d ", i);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int di[8] = {1, -1, 0, 0, 1, 1, -1, -1};
int dj[8] = {0, 0, 1, -1, 1, -1, 1, -1};
const long long N = 1e5 + 5, MOD = 1e9 + 7, oo = 1e18;
int t, i, j, n, m, k, mex, mey, curx, cury;
string s;
map<char, int> mpx, mpy;
bool valid(int x, int y) { return (x >= 1 && x <= n && y >= 1 && y <= m); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
mpy['L'] = -1, mpy['R'] = 1, mpx['U'] = -1, mpx['D'] = 1;
cin >> t;
while (t--) {
cin >> n >> m >> s;
k = s.length();
curx = cury = 0;
int mnx = 0, mxx = 0, mny = 0, mxy = 0;
for (i = 0; i < k; i++) {
if (s[i] == 'L') {
cury--;
mny = min(mny, cury);
if (-mny + mxy == m) {
mny++;
break;
}
}
if (s[i] == 'R') {
cury++;
mxy = max(mxy, cury);
if (-mny + mxy == m) {
mxy--;
break;
}
}
if (s[i] == 'U') {
curx--;
mnx = min(mnx, curx);
if (-mnx + mxx == n) {
mnx++;
break;
}
}
if (s[i] == 'D') {
curx++;
mxx = max(mxx, curx);
if (-mnx + mxx == n) {
mxx--;
break;
}
}
}
cout << -mnx + 1 << " " << -mny + 1 << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int MAXN = 2010;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int n;
vector<int> a;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
a.push_back(x);
}
if (n == 1 && a[0] != 1) {
puts("-1");
return 0;
}
int num = 0, cnt = 0;
int ok = 0;
for (int i = 0; i < a.size(); i++) {
if (a[i] == 1) {
ok++;
}
}
if (ok) {
printf("%d\n", n + max(cnt - 1, 0) - ok);
return 0;
}
while (num < 2010) {
num++;
vector<int> ret;
if (a[0] == 1) {
printf("%d\n", n + max(0, cnt - 1));
return 0;
}
for (int i = 1; i < a.size(); i++) {
if (a[i] == 1) {
printf("%d\n", n + max(0, cnt - 1));
return 0;
}
ret.push_back(gcd(a[i], a[i - 1]));
}
if (ret.size() == 1 && ret[0] != 1) {
puts("-1");
return 0;
}
cnt++;
a.clear();
for (int i = 0; i < ret.size(); i++) {
a.push_back(ret[i]);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T1, typename T2>
void ckmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
void ckmax(T1 &a, T2 b) {
if (a < b) a = b;
}
int read() {
int x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();
return f ? -x : x;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void print(T x, char let) {
print(x), putchar(let);
}
const int N = 400005;
const int lim = 100000;
const unsigned long long inv = 6723469279985657373ull;
struct num {
unsigned long long a[5];
num() { memset(a, 0, sizeof(a)); }
unsigned long long calc() { return a[0] - a[2]; }
} ans[N], omega[10], tmp[N], zero;
num operator+(num a, num b) {
for (int i = 0; i < 5; i++) a.a[i] += b.a[i];
return a;
}
num operator*(num a, num b) {
static unsigned long long tmp[10];
memset(tmp, 0, sizeof(tmp));
num c;
for (int i = 0; i < 5; i++)
if (a.a[i])
for (int j = 0; j < 5; j++) tmp[i + j] += a.a[i] * b.a[j];
for (int i = 0; i < 5; i++) c.a[i] = tmp[i] - tmp[5 + i];
return c;
}
num operator^(num a, int b) {
num res;
memset(res.a, 0, sizeof(res.a));
res.a[0] = 1;
while (b) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
void fwt(num *a, int opt) {
for (int mid = 1; mid < lim; mid *= 10) {
for (int i = 0; i < lim; i += 10 * mid) {
for (int j = 0; j < mid; j++) {
for (int k = 0; k < 10; k++) {
tmp[i + k * mid + j] = a[i + k * mid + j];
a[i + k * mid + j] = zero;
}
for (int k = 0; k < 10; k++) {
for (int t = 0; t < 10; t++) {
a[i + k * mid + j] =
a[i + k * mid + j] +
omega[(opt + 10) * k * t % 10] * tmp[i + t * mid + j];
}
}
}
}
}
}
int n;
int main() {
for (int i = 0; i < 10; i++) omega[i].a[i % 5] = (i >= 5 ? -1 : 1);
n = read();
for (int i = 1; i <= n; i++) {
int x = read();
ans[x].a[0]++;
}
fwt(ans, 1);
for (int i = 0; i < lim; i++) ans[i] = ans[i] ^ n;
fwt(ans, -1);
for (int i = 0; i < n; i++) {
print(((ans[i].calc() * inv) >> 5) % (1ull << 58), '\n');
}
return 0;
}
| 26 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long INF = 1e7;
double EPS = 1e-12;
double tick() {
static clock_t oldt;
clock_t newt = clock();
double diff = 1.0 * (newt - oldt) / CLOCKS_PER_SEC;
oldt = newt;
return diff;
}
long long int powP(long long int a, long long int b) {
if (b == 0) return 1 % mod;
long long int k;
k = powP(a, b / 2);
k = k * k % mod;
if (b % 2 == 0)
return k;
else
return a * k % mod;
}
bool bitSet(long long int n, long long int i) {
if ((n & (1LL << i)) != 0)
return true;
else
return false;
}
long long int findGcd(long long int a, long long int b) {
if (a == 0)
return b;
else
return findGcd(b % a, a);
}
long long int A[500010], B[500010];
double Result[500010];
int main() {
double T, i, m, n, p, j, l, e, r, b, c, k, q, a, d, w, x, y, v, z, t, curr,
prev, sum, ans, pos, val, countA, indicator;
double h;
scanf("%lf%lf", &n, &h);
double base = 1;
double tot, req, remain;
tot = h / 2;
req = tot / n;
EPS = 1e-9;
for (long long int i = (1); i <= (n - 1); ++i) {
double low = EPS, high = h, mid;
while (low <= high + EPS) {
mid = (low + high) / 2;
curr = base / h * mid;
remain = (h * base - curr * mid) / 2;
if (remain <= req + EPS && remain >= req - EPS) {
ans = mid;
break;
} else if (remain >= req + EPS)
low = mid;
else
high = mid;
}
Result[i] = mid;
base = base / h * mid;
h = mid;
}
for (long long int i = (n - 1); i >= (1); --i) printf("%0.9lf ", Result[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200010];
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n * 2; i++) scanf("%d", &a[i]);
sort(a + 1, a + n * 2 + 1);
ans = 1ll * (a[n * 2] - a[n + 1]) * (a[n] - a[1]);
for (int i = 2; i <= n; i++)
ans = min(ans, 1ll * (a[n * 2] - a[1]) * (a[i + n - 1] - a[i]));
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double dp[202][202][402];
vector<pair<int, int> > tourList;
int n, l, k;
void solve(int tourId, int needToWin, int Bag) {
int bag = Bag - 200;
if (tourId == n) {
if (needToWin == 0 && bag >= 0) {
dp[tourId][needToWin][Bag] = 1.0;
} else {
dp[tourId][needToWin][Bag] = 0.0;
}
}
if (dp[tourId][needToWin][Bag] != -1) return;
int prize = tourList[tourId].first;
double prob = tourList[tourId].second / 100.0;
double ret = 0;
solve(tourId + 1, max(needToWin - 1, 0), min(bag + prize + 200, 400));
ret =
prob * dp[tourId + 1][max(needToWin - 1, 0)][min(bag + prize + 200, 400)];
solve(tourId + 1, needToWin, bag + 200);
ret = ret + (1 - prob) * dp[tourId + 1][needToWin][bag + 200];
dp[tourId][needToWin][bag + 200] = ret;
}
int main() {
for (int i = 0; i < 202; i++) {
for (int j = 0; j < 202; j++) {
for (int k = 0; k < 402; k++) {
dp[i][j][k] = -1;
}
}
}
scanf("%d%d%d", &n, &l, &k);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
tourList.push_back(pair<int, int>(0, a));
}
for (int i = 0; i < n; i++) {
int b;
scanf("%d", &b);
tourList[i].first = b;
}
k = min(k, n);
solve(0, l, k + 200);
printf("%.9lf\n", dp[0][l][k + 200]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
double prob[20][20];
double dp[(1 << 19)];
double pmove(int previous_bitmask, int must_die, int &n) {
int total_fishes = __builtin_popcount(previous_bitmask);
long long deno = ((total_fishes) * (total_fishes - 1)) / 2;
double move_prob = 0;
for (int fish = 0; fish < n; fish++) {
if (previous_bitmask & (1 << fish)) {
move_prob += prob[fish + 1][must_die + 1];
}
}
return move_prob / (1.0 * deno);
}
double solve(int bitmask, int n) {
if (__builtin_popcount(bitmask) == n) {
return 1;
}
if (dp[bitmask] > -0.9) {
return dp[bitmask];
}
double answer = 0;
for (int fish = 0; fish < n; fish++) {
bool alive = bitmask & ((1 << fish));
if (!alive) {
int previous_bitmask = bitmask ^ (1 << fish);
double previous_day = solve(previous_bitmask, n);
answer += previous_day * pmove(previous_bitmask, fish, n);
}
}
return dp[bitmask] = answer;
}
int main() {
int n;
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> prob[i][j];
}
}
for (int i = 0; i < n; i++) {
cout << fixed << setprecision(10) << solve((1 << i), n) << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, p;
cin >> a >> b >> p;
string s;
cin >> s;
long long start = 0;
long long ans = -1;
long long end = s.length() - 1;
while (start <= end) {
long long mid = (start + end) / 2;
long long calcmoney = 0;
for (long long i = mid; i < s.length() - 1;) {
if (s[i] == 'A') {
calcmoney += a;
while (i < s.length() - 1 && s[i] == 'A') i++;
}
if (i == s.length() - 1) break;
if (s[i] == 'B') {
calcmoney += b;
while (i < s.length() - 1 && s[i] == 'B') i++;
}
if (i == s.length() - 1) break;
}
if (calcmoney > p) {
start = mid + 1;
} else {
ans = mid;
end = mid - 1;
}
}
cout << ans + 1 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
struct node {
int x, y;
};
long long fac[200005], inv[200005], ans[2005];
int n, m, k;
node f[2005];
long long fp(long long x, int y) {
return (y % 2 ? x : 1ll) * (y / 2 ? fp(x * x % 1000000007, y / 2) : 1ll) %
1000000007;
}
void pre(int n) {
fac[0] = inv[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % 1000000007;
for (int i = 1; i <= n; i++) inv[i] = fp(fac[i], 1000000007 - 2);
}
long long c(int x, int y) {
return fac[x] * inv[y] % 1000000007 * inv[x - y] % 1000000007;
}
int cmp(node x, node y) { return x.x != y.x ? x.x < y.x : x.y < y.y; }
int main() {
scanf("%d%d%d", &n, &m, &k);
pre(n + m);
for (int i = 1; i <= k; i++) scanf("%d%d", &f[i].x, &f[i].y);
f[++k] = node{n, m};
std::sort(f + 1, f + k + 1, cmp);
for (int i = 1; i <= k; i++) {
long long s = c(f[i].x + f[i].y - 2, f[i].x - 1);
for (int j = 1; j <= i - 1; j++)
if (f[j].x <= f[i].x && f[j].y <= f[i].y)
s = (s -
ans[j] * c(f[i].x + f[i].y - f[j].x - f[j].y, f[i].x - f[j].x) %
1000000007 +
1000000007) %
1000000007;
ans[i] = s;
}
printf("%lld\n", ans[k]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
void sc(char &c) {
char temp[4];
scanf("%s", temp);
c = temp[0];
}
void debugvi(vector<int> arr, int n = (int)1e9) {
for (int i = 0; i < min(((int)(arr.size())), n); i++) printf("%d ", arr[i]);
printf("\n");
}
int testnum;
char temp[100005];
int m, n;
int freq[2][15];
void preprocess() {}
void solve() {
int best = 0;
int bests = -1;
int bestx = -1;
for (int i = 1; i <= 9; i++) {
int j = 0;
if (i > 0) j = 10 - i;
if (freq[0][i] == 0 || freq[1][j] == 0) continue;
freq[0][i]--;
freq[1][j]--;
int cur = 1;
for (int j = 0; j <= 9; j++) cur += min(freq[0][j], freq[1][9 - j]);
int z = 0;
if (freq[0][0] > freq[1][9] && freq[1][0] > freq[0][9])
z = min(freq[0][0] - freq[1][9], freq[1][0] - freq[0][9]);
cur += z;
if (cur > best) {
best = cur;
bests = i;
bestx = z;
}
freq[0][i]++;
freq[1][j]++;
}
if (bests < 0) {
for (int k = 0; k < 2; k++) {
for (int i = 9; i >= 0; i--)
for (int j = 0; j < freq[k][i]; j++) printf("%c", (char)('0' + i));
printf("\n");
}
return;
}
string a = "", b = "";
for (int i = 0; i < bestx; i++) {
a += '0';
b += '0';
freq[0][0]--;
freq[1][0]--;
}
int bestt = 0;
if (bests > 0) bestt = 10 - bests;
a += ((char)('0' + bests));
b += ((char)('0' + bestt));
freq[0][bests]--;
freq[1][bestt]--;
for (int j = 0; j <= 9; j++) {
int z = min(freq[0][j], freq[1][9 - j]);
for (int k = 0; k < z; k++) {
a += ((char)('0' + j));
b += ((char)('0' + 9 - j));
}
freq[0][j] -= z;
freq[1][9 - j] -= z;
}
for (int k = 0; k < 2; k++) {
for (int i = 0; i <= 9; i++)
for (int j = 0; j < freq[k][i]; j++) {
if (k == 0)
a += ((char)('0' + i));
else
b += ((char)('0' + i));
}
}
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
printf("%s\n", a.c_str());
printf("%s\n", b.c_str());
}
bool input() {
memset(freq, 0, sizeof freq);
scanf("%s", temp);
m = strlen(temp);
for (int i = 0; i < m; i++) freq[0][temp[i] - '0']++;
for (int i = 0; i < 10; i++) freq[1][i] = freq[0][i];
return true;
}
int main() {
preprocess();
int T = 1;
for (testnum = 1; testnum <= T; testnum++) {
if (!input()) break;
solve();
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
int n;
char s[maxn], p[maxn];
struct Suffix_Automaton {
int nxt[maxn * 2][26], fa[maxn * 2], l[maxn * 2];
int last, cnt;
int cntA[maxn * 2], A[maxn * 2];
long long num[maxn * 2];
Suffix_Automaton() { clear(); }
void clear() {
last = cnt = 1;
fa[1] = l[1] = 0;
memset(nxt[1], 0, sizeof nxt[1]);
}
void init(char *s) {
while (*s) {
add(*s - 'a');
s++;
}
}
void add(int c) {
int p = last;
int np = ++cnt;
memset(nxt[cnt], 0, sizeof nxt[cnt]);
l[np] = l[p] + 1;
last = np;
while (p && !nxt[p][c]) nxt[p][c] = np, p = fa[p];
if (!p)
fa[np] = 1;
else {
int q = nxt[p][c];
if (l[q] == l[p] + 1)
fa[np] = q;
else {
int nq = ++cnt;
l[nq] = l[p] + 1;
memcpy(nxt[nq], nxt[q], sizeof(nxt[q]));
fa[nq] = fa[q];
fa[np] = fa[q] = nq;
while (nxt[p][c] == q) nxt[p][c] = nq, p = fa[p];
}
}
}
void build() {
memset(cntA, 0, sizeof cntA);
memset(num, 0, sizeof num);
for (int i = 1; i <= cnt; i++) cntA[l[i]]++;
for (int i = 1; i <= cnt; i++) cntA[i] += cntA[i - 1];
for (int i = cnt; i >= 1; i--) A[cntA[l[i]]--] = i;
int now = 1;
for (int i = 0; i < n; i++) {
now = nxt[now][s[i] - 'a'];
if (p[i] == '0') num[now] = 1;
}
for (int i = cnt; i >= 1; i--) {
int x = A[i];
num[fa[x]] += num[x];
}
long long ans = 0;
for (int i = 2; i <= cnt; i++) {
ans = max(ans, 1ll * l[i] * num[i]);
}
printf("%lld\n", ans);
}
void debug() {
for (int i = cnt; i >= 1; i--) {
printf("num[%d]=%d l[%d]=%d fa[%d]=%d\n", i, num[i], i, l[i], i, fa[i]);
}
}
} sam;
int main() {
scanf("%d %s %s", &n, s, p);
sam.init(s);
sam.build();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
void find(string A, string B, int n) {
int same0 = 0;
int same1 = 0;
int dif0 = 0;
int dif1 = 0;
if (A == B) {
cout << "0\n";
return;
}
for (int i = 0; i < n; i++) {
if (A[i] == B[i]) {
if (A[i] == '0') {
same0++;
} else {
same1++;
}
} else {
if (A[i] == '1') {
dif1++;
} else {
dif0++;
}
}
}
if ((same0 + same1) == 1 && same1 == 1) {
cout << "1\n";
return;
}
int mi = INT_MAX;
if (dif0 == dif1) {
mi = min(2 * dif0, mi);
}
if (same1 == (same0 + 1)) {
mi = min(mi, 2 * same0 + 1);
}
if (mi == INT_MAX) {
cout << "-1\n";
} else {
cout << mi << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
for (int tt = 0; tt < t; tt++) {
int n;
cin >> n;
string A;
string B;
cin >> A;
cin >> B;
find(A, B, n);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000,100000000000")
using namespace std;
const double eps = 1E-9;
const double Exp = 2.718281828459045;
const double Pi = 3.1415926535897932;
const int NMAX = 100000 + 5;
const int MMAX = 100000 + 5;
const int INF = 1000000000;
const int BS = 1000000007;
template <typename T>
inline T abs(const T a) {
if (a < 0) return -a;
return a;
}
template <typename T>
inline T sqr(const T& a) {
return a * a;
}
struct frac {
int num, denom;
bool operator<(const frac& a) const {
return this->num * 1ll * a.denom < a.num * 1ll * this->denom;
}
};
vector<int> e[NMAX];
int bad[NMAX];
int nbad[NMAX];
frac d[NMAX];
int main() {
ios::sync_with_stdio(false);
int n, m;
int i, j;
int u, v;
int k;
cin >> n >> m >> k;
for (i = 1; i <= k; i++) {
cin >> u;
bad[u] = 1;
nbad[u] = 1;
}
for (i = 1; i <= m; i++) {
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
}
for (int BigStep = 0; BigStep <= 1; BigStep++) {
set<pair<frac, int> > st;
for (i = 1; i <= n; i++) {
bad[i] = nbad[i];
}
vector<int>::iterator it;
for (i = 1; i <= n; i++) {
d[i].num = 0;
d[i].denom = int((e[i]).size());
for (it = e[i].begin(); it != e[i].end(); it++) {
if (!bad[*it]) {
d[i].num++;
}
}
if (!bad[i]) {
st.insert(make_pair(d[i], i));
}
}
static int mstep = 0;
static frac mx = st.begin()->first;
int step = 0;
int cur;
while (!st.empty()) {
if (BigStep == 1) {
if (step == mstep) {
cout << int((st).size()) << endl;
for (set<pair<frac, int> >::iterator sit = st.begin();
sit != st.end(); sit++) {
cout << sit->second << " ";
}
cout << endl;
return 0;
}
}
cur = st.begin()->second;
bad[cur] = 1;
if (BigStep == 0) {
if (mx < d[cur]) {
mx = d[cur];
mstep = step;
}
}
st.erase(st.begin());
for (it = e[cur].begin(); it != e[cur].end(); it++) {
if (!bad[*it]) {
st.erase(make_pair(d[*it], *it));
d[*it].num--;
st.insert(make_pair(d[*it], *it));
}
}
step++;
}
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
set<long long> v;
char str[10];
const int M = 1000000000 + 7;
int main() {
int n;
scanf("%d", &n);
long long x;
long long m = -1;
const long long MX = 308983067;
long long u = MX, d = -1;
set<long long>::iterator it;
int c = 0;
for (int i = 0; i < n; ++i) {
scanf("%s", str);
scanf("%lld", &x);
if (str[1] == 'D') {
v.insert(x);
} else if (m == -1 || (x >= d && x <= u)) {
if (x > d && x < u) ++c;
m = x;
it = v.upper_bound(x);
if (it != v.end())
u = *it;
else
u = MX;
it = v.lower_bound(x);
if (it != v.begin())
d = *(--it);
else
d = -1;
v.erase(x);
} else {
puts("0");
return 0;
}
}
it = v.upper_bound(d);
int t = 1;
while (it != v.end() && (*it) < u) {
++t;
++it;
}
if (m == -1) {
printf("%d\n", n + 1);
return 0;
}
int ans = 1;
while (c--) ans = (2ll * ans) % M;
ans = (1ll * t * ans) % M;
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
long long int a[n], b[n];
long long int sum = 0;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < n; i++) {
sum += a[i];
}
sort(b, b + n, greater<int>());
long long int rem = 0;
rem = b[0] + b[1];
if (rem >= sum)
cout << "YES\n";
else
cout << "NO\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, M, ans;
int fr, to, cnt;
int fa[1000005], pp[1000005];
int out[1000005], sum[1000005], num[1000005];
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
int main() {
int i, j;
scanf("%d %d", &N, &M);
for (i = 1; i <= N; i++) fa[i] = i;
for (i = 1; i <= M; i++) {
scanf("%d %d", &fr, &to);
out[fr] ^= 1, out[to] ^= 1;
if (find(fr) != find(to)) {
pp[fa[to]] += pp[fa[fr]];
fa[fa[fr]] = fa[to];
}
pp[fa[to]]++;
}
for (i = 1; i <= N; i++)
if (find(i) == i && (i == 1 || pp[i])) num[i] = ++cnt;
for (i = 1; i <= N; i++)
if (out[i] == 1) sum[num[find(i)]]++;
if (cnt == 1)
ans = sum[1] / 2;
else {
for (i = 1; i <= cnt; i++) ans += max(sum[i] - 2, 0) / 2;
ans += cnt;
}
printf("%d\n", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int maxn = 2e5 + 5;
template <class T>
inline void In(T &ret) {
char c;
ret = 0;
while ((c = getchar()) < '0' || c > '9')
;
while (c >= '0' && c <= '9') {
ret = ret * 10 + (c - '0'), c = getchar();
}
}
int add(int x, int y) {
if ((x += y) >= mod) x -= mod;
return x;
}
int mul(int x, int y) {
long long z = 1LL * x * y;
return z - z / mod * mod;
}
struct node {
int s, a, b;
void update(int x, int y, int z = 0) {
b = mul(b, y);
a = add(mul(a, y), x);
if (z)
s = add(mul(s, y), z);
else
s = add(mul(s, y), x);
}
void clear() {
b = 1;
a = 0;
}
} f[maxn << 2];
void push_down(int t, int l, int r) {
int mid = (l + r) >> 1;
f[t << 1].update(f[t].a, f[t].b, mul(f[t].a, mid - l + 1));
f[t << 1 | 1].update(f[t].a, f[t].b, mul(f[t].a, r - mid));
f[t].clear();
}
void update(int t, int l, int r, int ll, int rr, int a, int b) {
if (ll <= l && r <= rr) {
f[t].update(a, b, mul(a, r - l + 1));
return;
}
push_down(t, l, r);
int mid = (l + r) >> 1;
if (ll <= mid) update(t << 1, l, mid, ll, rr, a, b);
if (rr > mid) update(t << 1 | 1, mid + 1, r, ll, rr, a, b);
f[t].s = add(f[t << 1].s, f[t << 1 | 1].s);
}
int query(int t, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) return f[t].s;
push_down(t, l, r);
int mid = (l + r) >> 1, res = 0;
if (ll <= mid) res = add(res, query(t << 1, l, mid, ll, rr));
if (rr > mid) res = add(res, query(t << 1 | 1, mid + 1, r, ll, rr));
return res;
}
set<pair<int, int> > g[maxn];
vector<pair<int, int> > u;
int main() {
int n, q, op, l, r, x, d;
In(n);
In(q);
while (q--) {
In(op);
In(l);
In(r);
if (op == 1) {
In(x);
u.clear();
auto e = g[x].lower_bound(pair<int, int>(l, 0));
if (e != g[x].begin()) {
auto ee = e;
ee--;
if ((*ee).second >= l) u.push_back((*ee));
}
auto ee = g[x].lower_bound(pair<int, int>(r + 1, 0));
while (e != ee) {
u.push_back((*e));
e++;
}
d = l;
for (auto c : u) {
if (d < c.first) update(1, 1, n, d, c.first - 1, 1, 1);
update(1, 1, n, max(c.first, l), min(c.second, r), 0, 2);
d = c.second + 1;
}
if (d <= r) update(1, 1, n, d, r, 1, 1);
for (auto c : u) {
l = min(l, c.first);
r = max(r, c.second);
g[x].erase(c);
}
g[x].insert(pair<int, int>(l, r));
} else
printf("%d\n", query(1, 1, n, l, r));
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int len;
long long sum;
long long lmax, rmax;
long long dmax;
friend node operator+(const node &a, const node &b) {
node ret;
ret.len = a.len + b.len;
ret.sum = a.sum + b.sum;
ret.lmax = max(a.lmax, a.sum + b.lmax);
ret.rmax = max(b.rmax, b.sum + a.rmax);
if (ret.len == 2) {
ret.dmax = a.rmax + b.lmax;
} else {
ret.dmax = a.rmax + b.lmax;
ret.dmax = max(ret.dmax, max(a.dmax, b.dmax));
}
return ret;
}
} tree[200010 << 2];
int x[200010];
int per[200010];
int n, m, c;
void init(int p, int tl, int tr) {
if (tl == tr) {
tree[p].len = 1;
tree[p].sum = (long long)x[tl] * 50 - (long long)per[tl] * c;
tree[p].lmax = tree[p].rmax = max(tree[p].sum, 0ll);
tree[p].dmax = max(tree[p].sum, 0ll);
return;
}
int m = (tl + tr) >> 1;
init(p << 1, tl, m);
init((p << 1) + 1, m + 1, tr);
tree[p] = tree[p << 1] + tree[(p << 1) + 1];
}
node get(int p, int tl, int tr, int l, int r) {
if (tl == l && tr == r) return tree[p];
int m = (tl + tr) >> 1;
if (l <= m) {
if (r > m) {
return get(p << 1, tl, m, l, m) + get((p << 1) + 1, m + 1, tr, m + 1, r);
} else
return get(p << 1, tl, m, l, r);
} else
return get((p << 1) + 1, m + 1, tr, l, r);
}
int main() {
scanf("%d%d%d", &n, &m, &c);
for (int i = 0; i < n; i++) scanf("%d", x + i);
for (int i = n - 1; i > 0; i--) x[i] -= x[i - 1];
for (int i = 1; i < n; i++) scanf("%d", per + i);
n--;
init(1, 1, n);
long long ans = 0;
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
r--;
node tmp = get(1, 1, n, l, r);
if (l == r)
ans += max(0ll, tmp.sum);
else {
ans += tmp.dmax;
}
}
printf("%.8lf\n", ans * 1.0 / 100.0);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
struct node {
long long v;
int id;
node(long long v = 0, long long id = 0) : v(v), id(id) {}
bool operator<(const node &b) const { return v < b.v; }
};
bool cmp(node a, node b) { return a.id < b.id; }
node p[200010];
int n, A, c1, c2;
long long m, sum[200010];
bool check(long long v, bool ok) {
bool flag = 0;
for (int i = n; i >= 0; --i) {
int len = n - i;
long long left = v - 1LL * len * c1, k = m - (1LL * len * A - sum[i]);
if (left <= 0 && k >= 0) {
flag = 1;
if (ok) {
for (int j = n - 1; j >= i; --j) p[j].v = A;
}
break;
}
if (k < 0) break;
long long mn = (left + c2 - 1) / c2;
if (mn > A) continue;
int pos = lower_bound(p, p + n, node(mn, 0x3f3f3f3f)) - p;
if (pos == 0) {
flag = 1;
if (ok) {
for (int j = n - 1; j >= i; --j) p[j].v = A;
}
break;
}
pos--;
if (pos >= i) pos = i - 1;
len = pos + 1;
long long yong = mn * len - (sum[0] - sum[pos + 1]);
if (yong <= k) {
if (ok) {
for (int j = n - 1; j >= i; --j) p[j].v = A;
for (int j = 0; j <= pos; ++j) p[j].v = mn;
}
flag = 1;
break;
}
}
return flag;
}
int main() {
scanf("%d%d%d%d%I64d", &n, &A, &c1, &c2, &m);
for (int i = 0; i < n; ++i) {
scanf("%I64d", &p[i].v);
p[i].id = i;
}
sort(p, p + n);
sum[n] = 0;
for (int i = n - 1; i >= 0; --i) sum[i] += sum[i + 1] + p[i].v;
long long L = 0, R = 1LL * n * c1 + 1LL * A * c2;
while (L < R) {
long long mid = (L + R) / 2;
if (!check(mid, 0))
R = mid;
else
L = mid + 1;
}
if (!check(L, 0)) L--;
cout << L << endl;
check(L, 1);
sort(p, p + n, cmp);
for (int i = 0; i < n; ++i) printf("%I64d ", p[i].v);
puts("");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
using ll = long long;
struct Cmp {
int m, d[N], ds[N], dt[N], nd[N], nds[N], ndt[N];
void proc(int d[], int n, int nd[]) {
for (int i = 0; i < n; i++) nd[i] = n;
for (int i = n - 1; i >= 0; --i) {
if (i < n - 1) nd[i] = nd[i + 1];
if (d[i]) nd[i] = i;
}
}
void init(const string &s, const string &t) {
m = s.size();
for (int i = 0; i < m; i++) d[i] = s[i] - t[i];
for (int i = 0; i < m - 1; i++) ds[i] = s[i + 1] - t[i];
for (int i = 0; i < m - 1; i++) dt[i] = s[i] - t[i + 1];
proc(d, m, nd);
proc(ds, m - 1, nds);
proc(dt, m - 1, ndt);
}
inline int sgn(int x) { return x < 0 ? -1 : 1; }
int calc(int i, int j) {
int x = min(i, j);
if (nd[0] < x) return sgn(d[nd[0]]);
if (i == j) {
if (i + 1 == m || nd[i + 1] == m) return 0;
return sgn(d[nd[i + 1]]);
}
if (i < j) {
if (nds[i] < j) return sgn(ds[nds[i]]);
if (j + 1 == m || nd[j + 1] == m) return 0;
return sgn(d[nd[j + 1]]);
}
if (ndt[j] < i) return sgn(dt[ndt[j]]);
if (i + 1 == m || nd[i + 1] == m) return 0;
return sgn(d[nd[i + 1]]);
}
} cmp[4];
const int P = 1000000007;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
string s = "#";
vector<int> ds = {1};
for (int i = 0; i < n; i++) {
string t;
cin >> t;
t.push_back('#');
vector<int> dt(t.size());
while (s.size() < t.size()) {
s.push_back('#');
ds.push_back(0);
}
while (s.size() > t.size()) {
t.push_back('#');
dt.push_back(0);
}
int m = s.size();
cmp[0].init(s, s);
cmp[1].init(s, t);
cmp[2].init(t, s);
cmp[3].init(t, t);
vector<pair<int, int>> vp;
for (int i = 0; i < m; i++) vp.push_back({i, 0}), vp.push_back({i, 1});
sort(vp.begin(), vp.end(), [](pair<int, int> a, pair<int, int> b) {
int ret = cmp[a.second * 2 + b.second].calc(a.first, b.first);
return ret ? ret < 0 : a.second < b.second;
});
ll sum = 0;
for (auto &i : vp) {
int x = i.first, y = i.second;
if (!y)
sum = (sum + ds[x]) % P;
else
dt[x] = (dt[x] + sum) % P;
}
swap(s, t);
swap(ds, dt);
while (s.size() > 1 && s[s.size() - 2] == '#') s.pop_back(), ds.pop_back();
}
ll ans = 0;
for (auto &i : ds) ans = (ans + i) % P;
cout << ans << endl;
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
const long long base = 31;
const long long maxn = 3e5 + 9;
const long long mod = 1e9 + 7;
long long n, A, B, i, a[maxn], sum;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> A >> B;
for (i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
sort(a + 2, a + n + 1);
i = n;
long long cnt = 0;
while (true) {
if (a[1] * A / sum >= B) break;
sum -= a[i];
i--;
cnt++;
}
cout << cnt;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> arr[110];
int n;
int find(int x) {
for (int i = 0; i < n; i++)
if (arr[i].first == x) return i;
return -1;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &arr[i].first, &arr[i].second);
bool b = 0;
for (int i = 0; i < n; i++) {
int pos = find(arr[i].first + arr[i].second);
if (pos == -1) continue;
if (arr[pos].first + arr[pos].second == arr[i].first) {
b = 1;
break;
}
}
printf((b) ? "YES\n" : "NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
int ddx[] = {-1, -2, 1, -2, 2, -1, 2, 1}, ddy[] = {-2, -1, -2, 1, -1, 2, 1, 2};
const int MAXN = 1428;
struct edg {
int pos, cap, rev, cost;
};
vector<edg> gph[MAXN];
void clear() {
for (int i = 0; i < MAXN; i++) gph[i].clear();
}
void add_edge(int s, int e, int x, int c) {
gph[s].push_back({e, x, (int)gph[e].size(), c});
gph[e].push_back({s, 0, (int)gph[s].size() - 1, -c});
}
int phi[MAXN], inque[MAXN], dist[MAXN];
void prep(int src, int sink) {
memset(phi, 0x3f, sizeof(phi));
memset(dist, 0x3f, sizeof(dist));
queue<int> que;
que.push(src);
inque[src] = 1;
while (!que.empty()) {
int x = que.front();
que.pop();
inque[x] = 0;
for (auto &i : gph[x]) {
if (i.cap > 0 && phi[i.pos] > phi[x] + i.cost) {
phi[i.pos] = phi[x] + i.cost;
if (!inque[i.pos]) {
inque[i.pos] = 1;
que.push(i.pos);
}
}
}
}
for (int i = 0; i < MAXN; i++) {
for (auto &j : gph[i]) {
if (j.cap > 0) j.cost += phi[i] - phi[j.pos];
}
}
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pq;
pq.push(pair<int, int>(0, src));
dist[src] = 0;
while (!pq.empty()) {
auto l = pq.top();
pq.pop();
if (dist[l.second] != l.first) continue;
for (auto &i : gph[l.second]) {
if (i.cap > 0 && dist[i.pos] > l.first + i.cost) {
dist[i.pos] = l.first + i.cost;
pq.push(pair<int, int>(dist[i.pos], i.pos));
}
}
}
}
bool vis[MAXN];
int ptr[MAXN];
int dfs(int pos, int sink, int flow) {
vis[pos] = 1;
if (pos == sink) return flow;
for (; ptr[pos] < gph[pos].size(); ptr[pos]++) {
auto &i = gph[pos][ptr[pos]];
if (!vis[i.pos] && dist[i.pos] == i.cost + dist[pos] && i.cap > 0) {
int ret = dfs(i.pos, sink, min(i.cap, flow));
if (ret != 0) {
i.cap -= ret;
gph[i.pos][i.rev].cap += ret;
return ret;
}
}
}
return 0;
}
int match(int src, int sink, int sz) {
prep(src, sink);
for (int i = 0; i < sz; i++) dist[i] += phi[sink] - phi[src];
int ret = 0;
while (true) {
memset(ptr, 0, sizeof(ptr));
memset(vis, 0, sizeof(vis));
int tmp = 0;
while ((tmp = dfs(src, sink, 1e9))) {
ret += dist[sink] * tmp;
memset(vis, 0, sizeof(vis));
}
tmp = 1e9;
for (int i = 0; i < sz; i++) {
if (!vis[i]) continue;
for (auto &j : gph[i]) {
if (j.cap > 0 && !vis[j.pos]) {
tmp = min(tmp, (dist[i] + j.cost) - dist[j.pos]);
}
}
}
if (tmp > 1e9 - 200) break;
for (int i = 0; i < sz; i++) {
if (!vis[i]) dist[i] += tmp;
}
}
return ret;
}
char s[105];
int a[100], cnt[26];
int cc = 27;
int main() {
int n;
scanf("%d%s", &n, s);
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) scanf("%d", a + i);
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) cnt[s[i] - 'a']++;
for (int(i) = (0); (i) <= (25); (i) += (1)) {
add_edge(0, i + 1, cnt[i], 0);
for (int(j) = (0); (j) <= (n / 2 - 1); (j) += (1)) {
add_edge(i + 1, cc, 1, 0);
add_edge(cc, 1327 + j, 1, s[j] == ('a' + i) ? -a[j] : 0);
add_edge(cc, 1327 + n - 1 - j, 1,
s[n - 1 - j] == ('a' + i) ? -a[n - 1 - j] : 0);
cc++;
}
}
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) add_edge(1327 + i, 1427, 1, 0);
printf("%d\n", -match(0, MAXN - 1, MAXN));
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > q;
set<pair<int, int> >::iterator it;
int x[200100], y[200100];
int i, j, n, m;
char s[5];
int main() {
scanf("%d%d", &n, &m);
x[0] = 0;
y[0] = 0;
x[m + 1] = 0;
y[m + 1] = 0;
q.insert(make_pair(0, m + 1));
q.insert(make_pair(n + 1, m + 1));
for (i = 1; i <= m; i++) {
scanf("%d%d", &x[i], &y[i]);
scanf("%s", s + 1);
if (s[1] == 'U') {
it = q.lower_bound(make_pair(x[i], -1));
} else {
it = q.upper_bound(make_pair(x[i], m + 1));
it--;
}
if (it->first == x[i]) {
printf("0\n");
continue;
}
q.insert(make_pair(x[i], i));
if (s[1] == 'U') {
printf("%d\n", y[i] - y[it->second]);
y[i] = y[it->second];
} else {
printf("%d\n", x[i] - x[it->second]);
x[i] = x[it->second];
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int from;
int to;
double length;
Edge(int f, int t, double l) : from(f), to(t), length(l) {}
};
struct Node {
vector<int> out;
};
struct Graph {
vector<Node> nodes;
vector<Edge> edges;
Graph(int nr_nodes, int nr_edges) {
nodes.resize(nr_nodes);
edges.reserve(nr_edges);
}
void add_edge(int from, int to, double length) {
Edge e = Edge(from, to, length);
edges.push_back(e);
nodes[from].out.push_back(edges.size() - 1);
}
double Dijkstra() {
set<pair<double, int> > q;
vector<double> distances(nodes.size(), INFINITY);
vector<int> used_edges(nodes.size(), -1);
distances[0] = 0;
q.insert(make_pair(0, 0));
while (!q.empty()) {
long d = q.begin()->first;
int n = q.begin()->second;
q.erase(q.begin());
for (unsigned int i = 0; i < nodes[n].out.size(); i++) {
Edge& e = edges[nodes[n].out[i]];
if ((d + e.length) < distances[e.to]) {
q.erase(make_pair(distances[e.to], e.to));
distances[e.to] = d + e.length;
used_edges[e.to] = nodes[n].out[i];
q.insert(make_pair(distances[e.to], e.to));
}
}
}
return distances[nodes.size() - 1];
}
void print_all() {
for (unsigned int i = 0; i < nodes.size(); i++) {
Node n = nodes[i];
cout << "Node " << i << " has edges to: ";
for (unsigned int j = 0; j < n.out.size(); ++j) {
cout << edges[n.out[j]].to << "(" << edges[n.out[j]].length << ")"
<< " ";
}
cout << endl;
}
}
};
double p2pdistance(int x1, int y1, int x2, int y2) {
double distx = x1 - x2;
double disty = y1 - y2;
return sqrt(distx * distx + disty * disty);
}
struct Trench {
int node_id;
int x1, y1, x2, y2;
bool horizontal;
Trench(int nid, int x1p, int y1p, int x2p, int y2p)
: node_id(nid),
x1(min(x1p, x2p)),
y1(min(y1p, y2p)),
x2(max(x1p, x2p)),
y2(max(y1p, y2p)),
horizontal(y1p == y2p){};
double distance(int x, int y) {
double result = min(p2pdistance(x, y, x1, y1), p2pdistance(x, y, x2, y2));
if (horizontal && (x1 <= x) && (x <= x2))
result = min(result, fabs(y - y1));
if (!horizontal && (y1 <= y) && (y <= y2))
result = min(result, fabs(x - x1));
return result;
}
double distance(Trench& t) {
double result = INFINITY;
result = min(result, p2pdistance(x1, y1, t.x1, t.y1));
result = min(result, p2pdistance(x1, y1, t.x2, t.y2));
result = min(result, p2pdistance(x2, y2, t.x1, t.y1));
result = min(result, p2pdistance(x2, y2, t.x2, t.y2));
if (horizontal && t.horizontal) {
if (!((x1 > t.x2) || (x2 < t.x1))) result = min(result, fabs(y1 - t.y1));
} else if (!horizontal && !t.horizontal) {
if (!((y1 > t.y2) || (y2 < t.y1))) result = min(result, fabs(x1 - t.x1));
} else {
if (horizontal) {
if ((t.y1 <= y1) && (y1 <= t.y2)) {
result = min(result, fabs(x1 - t.x1));
result = min(result, fabs(x2 - t.x1));
}
if ((x1 <= t.x1) && (t.x1 <= x2)) {
result = min(result, fabs(y1 - t.y1));
result = min(result, fabs(y1 - t.y2));
}
} else {
result = min(result, t.distance(*this));
}
}
return result;
}
};
int main(void) {
ios::sync_with_stdio(false);
int a, b;
cin >> a >> b;
int startx, starty, endx, endy;
cin >> startx >> starty >> endx >> endy;
int n;
cin >> n;
vector<Trench> trenches;
for (int i = 0; i < n; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
trenches.push_back(Trench(i + 1, x1, y1, x2, y2));
}
if (p2pdistance(startx, starty, endx, endy) <= a) {
cout << p2pdistance(startx, starty, endx, endy);
cout << "\n";
return 0;
}
Graph g(n + 2, (n + 2) * (n + 2));
for (auto& trench1 : trenches) {
if (trench1.distance(startx, starty) <= a) {
g.add_edge(0, trench1.node_id, a + b);
}
if (trench1.distance(endx, endy) <= a) {
g.add_edge(trench1.node_id, n + 1, trench1.distance(endx, endy));
}
for (auto& trench2 : trenches) {
if (trench1.distance(trench2) <= a) {
g.add_edge(trench1.node_id, trench2.node_id, a + b);
}
}
}
double time = g.Dijkstra();
if (time == INFINITY)
cout << -1;
else {
cout << fixed << setprecision(9);
cout << time;
}
cout << "\n";
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
short n, m, k;
int main() {
scanf("%hd%hd%hd", &n, &m, &k);
(n <= m && n <= k ? puts("Yes") : puts("No"));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string a[12] = {"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"};
int main() {
string s;
cin >> s;
int n;
cin >> n;
int i;
for (i = 0; i < 12; i++)
if (s == a[i]) break;
cout << a[(i + n) % 12];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 20, M = 1e4 + 20;
const long long int OO = 1e15;
long long int n, m, l, s, t, adj[N][N], bestTS[N], bestST[N], U[M], V[M], W[M];
void solve() {
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int> >,
greater<pair<long long int, long long int> > >
pq;
memset(bestST, -1, sizeof bestST), memset(bestTS, -1, sizeof bestTS);
pq.push(pair<long long int, long long int>(0, t));
while (pq.size()) {
long long int dist = pq.top().first, u = pq.top().second;
pq.pop();
if (~bestTS[u]) continue;
bestTS[u] = dist;
for (int i = 0; i < n; i++)
if (adj[u][i] > 0)
pq.push(pair<long long int, long long int>(dist + adj[u][i], i));
}
while (pq.size()) pq.pop();
pq.push(pair<long long int, long long int>(0, s));
while (pq.size()) {
long long int dist = pq.top().first, u = pq.top().second;
pq.pop();
if (~bestST[u]) continue;
bestST[u] = dist;
for (int i = 0; i < n; i++) {
if (adj[u][i] > 0)
pq.push(pair<long long int, long long int>(dist + adj[u][i], i));
else if (adj[u][i] == 0 && bestTS[i] != -1 && l - dist - bestTS[i] > 0) {
adj[u][i] = adj[i][u] = l - dist - bestTS[i];
} else if (adj[u][i] == 0)
adj[u][i] = adj[i][u] = 1;
if (~adj[u][i])
pq.push(pair<long long int, long long int>(dist + adj[u][i], i));
}
}
memset(bestST, -1, sizeof bestST);
pq.push(pair<long long int, long long int>(0, s));
while (pq.size()) {
long long int dist = pq.top().first, u = pq.top().second;
pq.pop();
if (~bestST[u]) continue;
bestST[u] = dist;
for (int i = 0; i < n; i++)
if (adj[u][i] >= 0)
pq.push(pair<long long int, long long int>(dist + adj[u][i], i));
}
if (bestST[t] != l) {
cout << "NO\n";
return;
} else {
cout << "YES\n";
for (int i = 0; i < m; i++) {
W[i] = adj[U[i]][V[i]];
cout << U[i] << ' ' << V[i] << ' ' << W[i] << '\n';
}
}
}
int main() {
cin >> n >> m >> l >> s >> t;
memset(adj, -1, sizeof adj);
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
U[i] = u, V[i] = v, W[i] = w;
adj[u][v] = adj[v][u] = w;
}
solve();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> k;
string s;
getline(cin, s);
vector<vector<string> > str;
for (int i = 0; i < k; ++i) {
vector<string> tmp;
getline(cin, s);
int u = s.find("void") + 4;
string t = "";
while (u < s.length()) {
if ((s[u] == ' ' || s[u] == '(' || s[u] == ')' || s[u] == ',') &&
t.size() > 0) {
tmp.push_back(t);
t = "";
} else if (s[u] != ' ' && s[u] != '(' && s[u] != ')' && s[u] != ',')
t += s[u];
u++;
}
if (t.size() > 0) tmp.push_back(t);
str.push_back(tmp);
}
cin >> n;
getline(cin, s);
map<string, string> m;
for (int i = 0; i < n; ++i) {
getline(cin, s);
int u = 0;
string t = "";
string t1[5];
int cnt = 0;
while (u < s.length()) {
if (s[u] == ' ' && t.size() > 0) {
t1[cnt] = t;
t = "";
cnt++;
} else if (s[u] != ' ')
t += s[u];
u++;
}
if (t.size() > 0) t1[cnt] = t;
m[t1[1]] = t1[0];
}
cin >> n;
getline(cin, s);
for (int i = 0; i < n; ++i) {
getline(cin, s);
vector<string> tmp;
int u = 0;
string t = "";
while (u < s.length() && s[u] != '(') {
if (s[u] != ' ') t += s[u];
u++;
}
tmp.push_back(t);
t = "";
while (s[u] != ')') {
if ((s[u] == ',' || s[u] == '(' || s[u] == ' ') && t.size() > 0) {
tmp.push_back(m[t]);
t = "";
} else if (s[u] != ' ' && s[u] != ',' && s[u] != '(')
t += s[u];
u++;
}
if (t.size() > 0) tmp.push_back(m[t]);
int ans = 0;
for (int j = 0; j < k; ++j) {
if (tmp.size() != str[j].size()) continue;
if (tmp[0] != str[j][0]) continue;
bool tr = 1;
for (int p = 1; p < tmp.size(); ++p) {
if (str[j][p] == "T") continue;
if (str[j][p] != tmp[p]) {
tr = 0;
break;
}
}
if (tr) ans++;
}
cout << ans << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int a[N];
vector<int> vi;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m, ans1 = 0, ans2 = 0;
cin >> n >> m;
for (;;) {
if (n >= 1 && m >= 1) {
n--;
m--;
ans1++;
} else if (n >= 2 && m == 0) {
n -= 2;
ans2++;
} else if (m >= 2 && n == 0) {
m -= 2;
ans2++;
} else if (m == 1 && n == 0 || n == 1 && m == 0 || n == 0 && m == 0)
break;
}
cout << ans1 << " " << ans2;
}
| 0 |
#include <bits/stdc++.h>
const long long mod = 998244353;
using namespace std;
const long long N = 2005;
long long n, a[N], cnt[5005], suf[5005];
vector<long long> v;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
long double ans = 0.00;
for (long long i = 1; i <= n; i++) {
for (long long j = i + 1; j <= n; j++) {
cnt[a[j] - a[i]]++;
}
}
for (long long dif = 5000; dif >= 0; dif--) {
suf[dif] = suf[dif + 1] + cnt[dif];
}
long double x = (n * (n - 1)) / 2.0;
long long done = 0;
for (long long i = 0; i <= 5000; i++) {
for (long long j = 0; j < 5000; j++) {
if (i + j >= 5000) continue;
ans += cnt[i] * cnt[j] * suf[i + j + 1];
}
}
ans /= x;
ans /= x;
ans /= x;
cout << setprecision(25) << fixed << ans << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
scanf("%d %d", &n, &m);
int i, j, k;
string passStrings[n];
for (i = 0; i < n; i++) {
cin >> passStrings[i];
}
int nearestOnes[n][3];
memset(nearestOnes, -1, sizeof(nearestOnes));
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (passStrings[i][j] >= 97 && passStrings[i][j] <= 122) {
if (j < (m - j)) {
if (nearestOnes[i][0] == -1 || nearestOnes[i][0] > j)
nearestOnes[i][0] = j;
} else {
if (nearestOnes[i][0] == -1 || nearestOnes[i][0] > (m - j))
nearestOnes[i][0] = m - j;
}
} else if (passStrings[i][j] >= 48 && passStrings[i][j] <= 57) {
if (j < (m - j)) {
if (nearestOnes[i][1] == -1 || nearestOnes[i][1] > j)
nearestOnes[i][1] = j;
} else {
if (nearestOnes[i][1] == -1 || nearestOnes[i][1] > (m - j))
nearestOnes[i][1] = m - j;
}
} else {
if (j < (m - j)) {
if (nearestOnes[i][2] == -1 || nearestOnes[i][2] > j)
nearestOnes[i][2] = j;
} else {
if (nearestOnes[i][2] == -1 || nearestOnes[i][2] > (m - j))
nearestOnes[i][2] = m - j;
}
}
}
}
int minm;
minm = INT_MAX;
k = 0;
int x;
int sum1 = 0, sum2 = 0, sum3 = 0;
for (i = 0; i < n; i++) {
if (nearestOnes[i][0] == -1) continue;
sum1 = nearestOnes[i][0];
for (j = 0; j < n; j++) {
if (i == j || nearestOnes[j][1] == -1) continue;
sum2 = sum1 + nearestOnes[j][1];
for (k = 0; k < n; k++) {
if (k == i || k == j || nearestOnes[k][2] == -1) continue;
sum3 = sum2 + nearestOnes[k][2];
if (sum3 < minm) minm = sum3;
}
}
}
cout << minm;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = LLONG_MAX;
const long long base = 1e9;
const double PI = acos(-1);
const long long MOD = 1e9 + 7;
const long long N = 1e5 + 10;
void logic() {
long long v1, v2, v3, vm;
cin >> v1 >> v2 >> v3 >> vm;
for (long long i = v1; i <= 2 * v1; i++) {
for (long long j = v2; j <= 2 * v2; j++) {
for (long long k = v3; k <= 2 * v3; k++) {
if (i >= v1 and 2 * v1 >= i and j >= v2 and 2 * v2 >= j and k >= v3 and
2 * v3 >= k and vm <= k and 2 * vm >= k and i > j and j > k) {
if (2 * vm < j and 2 * vm < i) {
cout << i << endl << j << endl << k << endl;
return;
}
}
}
}
}
cout << "-1" << endl;
}
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (long long i = 0; i < t; i++) {
logic();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100001;
static int N, K, deg[MAXN], vis[MAXN];
static vector<int> edge[MAXN];
int main() {
scanf("%d%d", &N, &K);
for (int i = 0, u, v; i < N - 1; i++) {
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
deg[u]++;
deg[v]++;
}
set<int> work;
for (int i = 1; i <= N; i++)
if (deg[i] == 1) work.insert(i), vis[i] = 1;
for (int k = 0; k < K; k++) {
set<int> tmp;
for (int u : work) {
if (k && deg[u] < 4) return puts("No"), 0;
bool flag = false;
for (int v : edge[u])
if (!vis[v]) {
if (flag) return puts("No"), 0;
flag = true;
tmp.insert(v);
}
if (!flag) return puts("No"), 0;
}
if (tmp.empty()) return puts("No"), 0;
for (int v : tmp) vis[v] = 1;
work = tmp;
}
if (work.size() != 1u || deg[*work.begin()] < 3) return puts("No"), 0;
puts("Yes");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n, x, k, m;
vector<int> arr;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
cin >> x;
arr.push_back(x);
}
sort(arr.begin(), arr.end());
int64_t a, b;
a = m / (k + 1);
b = m % (k + 1);
cout << a * (k * arr[n - 1] + arr[n - 2]) + b * arr[n - 1];
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int n, a[N];
pair<int, int> b[N];
map<int, int> init_pos, fin_pos;
bool covered[N];
vector<vector<int> > seqs;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> b[i].first;
b[i].second = i;
a[i] = b[i].first;
}
sort(b, b + n);
for (int i = 0; i < n; ++i) {
init_pos[b[i].first] = b[i].second;
fin_pos[b[i].first] = i;
}
for (int i = 0; i < n; ++i) {
vector<int> seq;
int num = b[i].first;
int was_at = init_pos[num];
while (!covered[was_at]) {
covered[was_at] = true;
seq.push_back(was_at);
int who_was_at_fin = a[fin_pos[num]];
was_at = init_pos[who_was_at_fin];
num = who_was_at_fin;
}
if (seq.size()) seqs.push_back(seq);
}
cout << seqs.size() << "\n";
for (int i = 0; i < seqs.size(); ++i) {
cout << seqs[i].size() << " ";
for (int j = 0; j < seqs[i].size(); ++j) {
cout << seqs[i][j] + 1 << " ";
}
cout << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long a[n + 1], b[n + 1], k, cnt = 0, sum = 0, res = 0;
bool vis[n + 1];
memset(vis, false, sizeof(vis));
for (long long i = 1; i <= n; ++i) cin >> a[i];
for (long long i = 1; i <= n; ++i) cin >> b[i];
for (long long i = 1; i <= n; ++i) {
if (!vis[i]) cnt++;
k = a[i];
vis[k] = true;
while (!vis[a[k]] && a[i] != a[k]) {
vis[k] = true;
k = a[k];
}
}
if (cnt == 1) cnt--;
res += cnt;
for (auto x : b) sum += x;
res += (sum % 2 == 0);
cout << res << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 3e6 + 10, MOD = 1e9 + 7;
long long n, q, F[M], I[M];
long long A[M], B[M];
long long _pow(long long a, long long x = MOD - 2) {
long long ret = 1;
while (x) {
if (x & 1) ret = ret * a % MOD;
x /= 2;
a = a * a % MOD;
}
return ret;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> q;
F[0] = 1;
for (int i = 1; i <= 3 * n; i++) {
F[i] = F[i - 1] * i % MOD;
}
I[3 * n] = _pow(F[3 * n]);
for (int i = 3 * n; i >= 1; i--) {
I[i - 1] = I[i] * i % MOD;
}
for (int i = 0; i < 3 * n; i++) {
A[i] = F[3 * n] * I[i] % MOD * I[3 * n - i] % MOD;
}
for (int i = 0; i <= 3 * n - 3; i++) {
B[i] = A[i];
A[i + 1] = (A[i + 1] + 3 * (MOD - A[i])) % MOD;
A[i + 2] = (A[i + 2] + 3 * (MOD - A[i])) % MOD;
}
for (int i = 0; i <= 3 * n; i++) {
A[i] = B[i];
if (i >= 1) A[i] = (A[i] + 3 * B[i - 1]);
if (i >= 2) A[i] = (A[i] + 3 * B[i - 2]);
if (i >= 3) A[i] = (A[i] + B[i - 3]);
A[i] %= MOD;
}
while (q--) {
int x;
cin >> x;
cout << A[3 * n - x] << '\n';
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[110], b[110], res;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i];
}
res = -1;
for (int i = 1; i <= 100; i++) {
bool isOK = true;
for (int j = 0; j < m; j++) {
if ((a[j] / i) + (a[j] % i > 0) != b[j]) {
isOK = false;
break;
}
}
if (isOK) {
if (res != -1 && res != (n / i) + (n % i > 0)) {
res = -1;
break;
}
res = (n / i) + (n % i > 0);
}
}
if (res != -1) {
cout << res << endl;
} else
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, k;
cin >> m >> n >> k;
int a, b;
b = 1 + (k - 1) / (2 * n);
a = 1 + ((k - 1) % (2 * n)) / 2;
cout << b << " " << a << " ";
if (k % 2 == 0)
cout << "R";
else
cout << "L";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int s[1000006];
int c[1000006];
int e[1000006];
long long cost[100006];
vector<vector<long long>> O, E, A;
int N, L, M;
vector<vector<long long>> operator*(const vector<vector<long long>> &A,
const vector<vector<long long>> &B) {
vector<vector<long long>> C = O;
for (int k = 0; k < M; k++) {
for (int i = 0; i < M; i++) {
for (int j = 0; j < M; j++) {
C[i][j] += A[i][k] * B[k][j] % mod;
C[i][j] %= mod;
}
}
}
return C;
}
vector<long long> mul(const vector<long long> &A,
const vector<vector<long long>> &B) {
vector<long long> ret(M);
for (int i = 0; i < M; i++) {
for (int j = 0; j < M; j++) {
ret[(i + j) % M] += B[0][j] * A[i];
ret[(i + j) % M] %= mod;
}
}
return ret;
}
void print(vector<vector<long long>> &A) {
for (int i = 0; i < M; i++) {
for (int j = 0; j < M; j++) {
printf("%lld ", A[i][j]);
}
puts("");
}
puts("");
}
vector<vector<long long>> matpow(vector<vector<long long>> A, int L) {
vector<vector<long long>> ret = E;
while (L) {
if (L & 1) {
ret = ret * A;
}
A = A * A;
L >>= 1;
}
return ret;
}
long long modpow(long long a, long long L) {
long long ret = 1;
while (L) {
if (L & 1) {
ret = ret * a % mod;
}
a = a * a % mod;
L >>= 1;
}
return ret;
}
int main() {
scanf("%d %d %d", &N, &L, &M);
A = E = O = vector<vector<long long>>(M, vector<long long>(M));
for (int i = 0; i < M; i++) {
E[i][i] = 1;
}
for (int i = 1; i <= N; i++) {
scanf("%d", s + i);
}
for (int i = 1; i <= N; i++) {
scanf("%d", c + i);
cost[c[i] % M]++;
}
for (int i = 1; i <= N; i++) {
scanf("%d", e + i);
}
for (int i = 0; i < M; i++) {
for (int j = 0; j < M; j++) {
A[i][(i + j) % M] = cost[j];
}
}
auto B = matpow(A, L - 2);
vector<long long> base(M), base2(M), ret(M);
for (int i = 1; i <= N; i++) {
base[s[i] % M]++;
}
base = mul(base, B);
for (int i = 1; i <= N; i++) {
base2[(e[i] + c[i]) % M]++;
}
for (int i = 0; i < M; i++) {
for (int j = 0; j < M; j++) {
ret[(i + j) % M] += base2[j] * base[i];
ret[(i + j) % M] %= mod;
}
}
printf("%lld\n", ret[0]);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s[1010];
for (int i = 0; i < n; i++) {
cin >> s[i];
string ss;
cin >> ss;
s[i] += ss[1];
s[i] += ss[0];
cin >> ss;
}
int st[1111] = {};
bool used[1111] = {};
int res = 0;
for (int i = 0; i < n; i++) {
if (!used[i]) {
res++;
used[i] = true;
for (int u = i + 1; u < n; u++) {
bool fnd = false;
for (int t = 0; t < 4; t++) {
s[u] += s[u][0];
s[u].erase(s[u].begin());
if (s[u] == s[i]) {
fnd = true;
}
}
if (fnd) used[u] = true;
}
}
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, N, K, M, tc;
int main() {
int ans = 0;
scanf("%d", &N);
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
int x = 0, y = 0;
for (int j = i; j < s.size(); j++) {
if (s[j] == 'U') y++;
if (s[j] == 'D') y--;
if (s[j] == 'L') x--;
if (s[j] == 'R') x++;
if (x == 0 && y == 0) ans++;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
const int N = 301000;
int n, q;
char ch[N];
struct data {
int t1, t2;
int t3, t4;
int t5, t6;
int t7, t8;
int t9;
} T[N << 2];
data merge(data u, data v) {
data re;
if (u.t2 <= v.t1) {
re.t1 = u.t1 + v.t1 - u.t2;
re.t2 = v.t2;
} else {
re.t1 = u.t1;
re.t2 = v.t2 - v.t1 + u.t2;
}
re.t3 = max(u.t3, max(u.t1 + u.t2 + v.t7, u.t1 - u.t2 + v.t3));
re.t4 = max(v.t4, max(v.t1 + v.t2 + u.t6, v.t2 - v.t1 + u.t4));
re.t5 = max(u.t5, u.t1 - u.t2 + v.t5);
re.t6 = max(v.t6, v.t1 - v.t2 + u.t6);
re.t7 = max(u.t7, u.t2 - u.t1 + v.t7);
re.t8 = max(v.t8, v.t2 - v.t1 + u.t8);
re.t9 = max(max(u.t9, v.t9), max(u.t4 + v.t7, u.t6 + v.t3));
return re;
}
void build(int u, int l, int r) {
if (l == r) {
if (ch[l] == '(')
T[u] = (data){0, 1, 1, 1, 0, 0, 1, 1, 1};
else
T[u] = (data){1, 0, 1, 1, 1, 1, 0, 0, 1};
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
T[u] = merge(T[u << 1], T[u << 1 | 1]);
}
void updata(int u, int l, int r, int p, char v) {
if (l == r) {
if (v == '(')
T[u] = (data){0, 1, 1, 1, 0, 0, 1, 1, 1};
else
T[u] = (data){1, 0, 1, 1, 1, 1, 0, 0, 1};
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
updata(u << 1, l, mid, p, v);
else
updata(u << 1 | 1, mid + 1, r, p, v);
T[u] = merge(T[u << 1], T[u << 1 | 1]);
}
int main() {
n = read(), q = read();
scanf("%s", ch + 1);
n = strlen(ch + 1);
build(1, 1, n);
printf("%d\n", T[1].t9);
while (q--) {
int u = read(), v = read();
updata(1, 1, n, u, ch[v]);
updata(1, 1, n, v, ch[u]);
swap(ch[u], ch[v]);
printf("%d\n", T[1].t9);
}
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> graph[26];
map<char, long long int> charToint;
map<long long int, char> intTochar;
long long int cnt;
void find(string &a, string &b) {
long long int n = min(a.size(), b.size());
for (long long int i = 0; i < n; i++)
if (a[i] != b[i]) {
graph[charToint[a[i]]].push_back(charToint[b[i]]);
return;
}
if (a.size() > b.size()) {
cout << "IMPOSSIBLE";
exit(0);
}
}
void topologicalSort() {
long long int V = cnt;
vector<long long int> in_degree(V, 0);
for (long long int u = 0; u < V; u++) {
vector<long long int>::iterator itr;
for (itr = graph[u].begin(); itr != graph[u].end(); itr++)
in_degree[*itr]++;
}
queue<long long int> q;
for (long long int i = 0; i < V; i++)
if (in_degree[i] == 0) q.push(i);
long long int count = 0;
vector<long long int> top_order;
while (!q.empty()) {
long long int u = q.front();
q.pop();
top_order.push_back(u);
vector<long long int>::iterator itr;
for (itr = graph[u].begin(); itr != graph[u].end(); itr++)
if (--in_degree[*itr] == 0) q.push(*itr);
count++;
}
if (count != V) {
cout << "IMPOSSIBLE";
return;
}
for (long long int i = 0; i < top_order.size(); i++)
cout << intTochar[top_order[i]];
}
void ETA() {
long long int n, k, num;
cin >> n >> k;
vector<string> vec[n];
string str, str1, str2;
long long int letters[26] = {};
for (long long int i = 0; i < n; i++) {
cin >> num;
for (long long int j = 0; j < k; j++) {
cin >> str;
vec[num].push_back(str);
for (char ch : str) letters[ch - 'a']++;
}
}
for (long long int i = 0; i < 26; i++) {
if (letters[i]) {
charToint[char(i + 'a')] = cnt;
intTochar[cnt] = char(i + 'a');
cnt++;
}
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < k; j++) {
if (i == 0 and j == 0) continue;
str2 = vec[i][j];
if (j == 0)
str1 = vec[i - 1][k - 1];
else
str1 = vec[i][j - 1];
find(str1, str2);
}
}
topologicalSort();
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) ETA();
return 0;
}
| 14 |
Subsets and Splits