solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int x[100005];
int main() {
int T, temp, i;
scanf("%d", &T);
for (i = 1; i < T; i++) {
scanf("%d", &temp);
x[temp] = 1;
}
for (i = 1; i <= T; i++) {
if (x[i] == 0) {
printf("%d\n", i);
break;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long F[110000] = {0, 1};
int main() {
for (long long i = 2; i < 110000; i++) F[i] = (F[i - 1] + F[i - 2]) % mod;
long long n, m;
cin >> n >> m;
cout << (2 * (F[n + 1] + F[m + 1] - 1)) % mod;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class T2>
inline bool chkmax(T &x, const T2 &y) {
return x < y ? (x = y, 1) : 0;
}
template <class T, class T2>
inline bool chkmin(T &x, const T2 &y) {
return x > y ? (x = y, 1) : 0;
}
const int N = 2e5 + 1;
int n;
long long dp[N][3][2][2], a[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
if (n == 1) {
cout << abs(a[1]) << '\n';
return 0;
}
memset(dp, 0xc0, sizeof dp);
dp[1][1][1][0] = -a[1];
dp[1][0][1][1] = a[1];
for (int i = 2; i <= n; i++)
for (int j = 0; j < 3; j++) {
dp[i][j][0][0] = -a[i] + max(max(dp[i - 1][(j + 2) % 3][0][0],
dp[i - 1][(j + 2) % 3][0][1]),
dp[i - 1][(j + 2) % 3][1][0]);
dp[i][j][0][1] = a[i] + max(max(dp[i - 1][j][0][0], dp[i - 1][j][0][1]),
dp[i - 1][j][1][1]);
dp[i][j][1][0] = -a[i] + dp[i - 1][(j + 2) % 3][1][1];
dp[i][j][1][1] = a[i] + dp[i - 1][j][1][0];
}
cout << max(dp[n][(4 - n % 3) % 3][0][0], dp[n][(4 - n % 3) % 3][0][1])
<< '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
struct {
inline operator int() {
int x;
return scanf("%d", &x), x;
}
inline operator long long() {
long long x;
return scanf("%lld", &x), x;
}
template <class T>
inline void operator()(T &x) {
x = *this;
}
template <class T, class... A>
inline void operator()(T &x, A &...a) {
x = *this;
this->operator()(a...);
}
} read;
const int maxn = 200005, mod = 998244353;
int a[maxn];
long long fac[maxn], ifac[maxn];
long long powk[maxn];
inline long long power(long long x, int k) {
if (k < 0) k += mod - 1;
long long res = 1;
while (k) {
if (k & 1) (res *= x) %= mod;
(x *= x) %= mod;
k >>= 1;
}
return res;
}
void combinator_init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mod;
ifac[n] = power(fac[n], -1);
for (int i = n; i; i--) ifac[i - 1] = ifac[i] * i % mod;
}
int main() {
int n = read, k = read;
if (k == 1) return puts("0"), 0;
for (int i = 1; i <= n; i++) read(a[i]);
a[n + 1] = a[1];
combinator_init(n);
int m = 0;
for (int i = 1; i <= n; i++) m += a[i] != a[i + 1];
powk[0] = 1;
for (int i = 1; i <= m; i++) powk[i] = powk[i - 1] * (k - 2) % mod;
long long ans = 0;
for (int x = 0; x * 2 <= m; x++)
(ans += fac[m] * ifac[x] % mod * ifac[x] % mod * ifac[m - x - x] % mod *
powk[m - x - x]) %= mod;
ans = (power(k, m) + mod - ans) * (mod + 1) / 2 % mod;
(ans *= power(k, n - m)) %= mod;
printf("%lld\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
unsigned int grid1[500][500][16], grid2[500][500][16];
inline void insert(unsigned int grid[][500][16], int x, int y, int bit) {
grid[x][y][bit >> 5] ^= ((unsigned int)1) << (bit & 31);
}
struct Point {
long long x, y;
void scan() { cin >> x >> y; }
} a[500], b[500];
int main() {
int i, j, k, kk, N, M, an = 0;
scanf("%d%d", &N, &M);
if (M == 0) {
printf("%d\n", N * (N - 1) * (N - 2) / 6);
return 0;
}
for (i = 0; i < N; i++) a[i].scan();
for (i = 0; i < M; i++) b[i].scan();
for (i = 0; i < N; i++)
for (j = i + 1; j < N; j++) {
for (k = 0; k < M; k++) {
if ((a[j].x - a[i].x) * (b[k].y - a[i].y) >
(a[j].y - a[i].y) * (b[k].x - a[i].x)) {
insert(grid1, i, j, k);
} else {
insert(grid2, i, j, k);
}
}
}
for (i = 0; i < N; i++)
for (j = i + 1; j < N; j++)
for (k = j + 1; k < N; k++) {
if ((a[j].x - a[i].x) * (a[k].y - a[i].y) >
(a[j].y - a[i].y) * (a[k].x - a[i].x)) {
for (kk = 0; !(kk & 16); kk++)
if (grid1[i][j][kk] & grid1[j][k][kk] & grid2[i][k][kk]) break;
if (kk == 16) an++;
} else {
for (kk = 0; !(kk & 16); kk++)
if (grid2[i][j][kk] & grid2[j][k][kk] & grid1[i][k][kk]) break;
if (kk == 16) an++;
}
}
cout << an << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int maxl = 20;
int num[maxn];
int pai[maxn], peso[maxn], tab[maxn][maxl], n;
int qtd[maxn], ans[maxn], sz[maxn], sub[maxn];
long long soma[maxn][maxl];
vector<int> grafo[maxn];
void build(void) {
for (int i = 1; i <= n; i++) tab[i][0] = pai[i], soma[i][0] = peso[i];
for (int j = 1; j < maxl; j++) {
for (int i = 1; i <= n; i++) {
tab[i][j] = tab[tab[i][j - 1]][j - 1];
soma[i][j] = soma[i][j - 1] + soma[tab[i][j - 1]][j - 1];
}
}
}
void get_last(int u) {
int orig = u;
long long aux = 0LL;
for (int i = maxl - 1; i >= 0; i--)
if (tab[u][i] && aux + soma[u][i] <= num[orig])
aux += soma[u][i], u = tab[u][i];
qtd[u]++;
}
void dfs2(int u, int p) {
sz[u] = 1, sub[u] = qtd[u];
for (auto v : grafo[u]) {
if (v == p) continue;
dfs2(v, u);
sz[u] += sz[v], sub[u] += sub[v];
}
}
void solve(int u, int p) {
for (auto v : grafo[u]) {
if (v == p) continue;
solve(v, u);
}
ans[u] = sz[u] - (sub[u] - qtd[u]) - 1;
}
int main(void) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> num[i];
for (int i = 2; i <= n; i++) {
int p, w;
cin >> p >> w;
grafo[i].push_back(p);
grafo[p].push_back(i);
pai[i] = p, peso[i] = w;
}
build();
for (int i = 1; i <= n; i++) get_last(i);
dfs2(1, 0);
solve(1, 0);
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string first, second, s;
map<char, char> a;
cin >> first >> second;
for (int i = 0; i < 26; i++) a[first[i]] = second[i];
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (isdigit(s[i]))
cout << s[i];
else {
if (isupper(s[i])) {
s[i] = tolower(s[i]);
s[i] = a[s[i]];
s[i] = toupper(s[i]);
cout << s[i];
} else
cout << a[s[i]];
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
void solve(std::istream& in, std::ostream& out) {
int n, k;
in >> n >> k;
std::vector<int> a(n);
for (int i = 0; i < n; ++i) in >> a[i];
std::partial_sort(a.begin(), a.begin() + k, a.end());
out << std::accumulate(a.begin(), a.begin() + k, 0);
}
};
void solve(std::istream& in, std::ostream& out) {
out << std::setprecision(12);
Solution solution;
solution.solve(in, out);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
solve(in, out);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
unsigned long long tmp, a = 128, b = 32768, c = 2147483648,
d = 9223372036854775808;
string s;
cin >> s;
if (s[0] != '-') {
a--, b--, c--, d--;
} else
s.erase(s.begin());
stringstream ss(s);
ss >> tmp;
if (tmp <= a)
cout << "byte\n";
else if (tmp <= b)
cout << "short\n";
else if (tmp <= c)
cout << "int\n";
else if (tmp <= d)
cout << "long\n";
else
cout << "BigInteger\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
map<long long, long long> s;
set<long long> s2;
long long ret = 0;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
ret += x * m;
s[x] += m - 1;
s2.insert(x);
}
vector<long long> a(m);
for (long long i = 0; i < m; i++) {
cin >> a[i];
}
sort(a.rbegin(), a.rend());
for (long long i = 0; i < m; i++) {
if (a[i] < *s2.rbegin()) {
cout << -1 << endl;
return 0;
}
if (!s2.count(a[i])) {
auto it = s.upper_bound(a[i]);
it = (it == s.begin()) ? s.end() : std::prev(it);
if (it == s.end()) {
cout << a[i] << endl;
cout << -1 << endl;
return 0;
}
if (it->first != a[i]) {
it->second--;
ret += (a[i] - it->first);
if (it->second == 0) {
s.erase(it);
}
}
}
}
cout << ret << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<vector<pair<pair<int, int>, pair<int, int> > > > g(n + 1);
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
g[a].push_back({{b, c}, {i, 0}});
g[b].push_back({{a, c}, {i, 1}});
}
vector<int> res(m, -1), val(n + 1);
for (int i = 2; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) val[i] += g[i][j].first.second;
if (i != n) val[i] /= 2;
}
queue<int> q;
q.push(1);
while (q.size()) {
int i = q.front();
q.pop();
for (int j = 0; j < g[i].size(); j++) {
if (res[g[i][j].second.first] == -1) {
res[g[i][j].second.first] = g[i][j].second.second;
val[g[i][j].first.first] -= g[i][j].first.second;
if (!val[g[i][j].first.first]) q.push(g[i][j].first.first);
}
}
}
for (int i = 0; i < m; i++) printf("%d\n", res[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, x, a, b, check = 1;
scanf("%d ", &n);
scanf("%d", &x);
while (n != 0) {
scanf("%d %d", &a, &b);
if (a == x || a == 7 - x || b == x || b == 7 - x) {
check = 0;
}
n--;
}
if (check == 0) {
printf("NO");
} else {
printf("YES");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
const long long int mod = 1e9 + 7;
const int inf = 1e9;
const int lg = 19;
int mn[4 * N], mx[2][4 * N], mx1[2][4 * N], mx2[2][4 * N], mx3[2][4 * N];
int n, q, ti = 0, par[N], H[N], h[N], st[N], fi[N];
bool k[N], lazy[4 * N];
vector<pair<int, int>> e;
vector<pair<int, bool>> adj[N];
void upd(int ind) {
swap(mx[0][ind], mx[1][ind]);
swap(mx1[0][ind], mx1[1][ind]);
swap(mx2[0][ind], mx2[1][ind]);
swap(mx3[0][ind], mx3[1][ind]);
lazy[ind] ^= 1;
return;
}
void merge(int i) {
int lc = i * 2, rc = i * 2 + 1;
mn[i] = min(mn[lc], mn[rc]);
mx[0][i] = max(mx[0][lc], mx[0][rc]);
mx1[0][i] = max(mx1[0][lc], mx1[0][rc]);
mx1[0][i] = max(mx1[0][i], mx[0][lc] - 2 * mn[rc]);
mx2[0][i] = max(mx2[0][lc], mx2[0][rc]);
mx2[0][i] = max(mx2[0][i], mx[0][rc] - 2 * mn[lc]);
mx3[0][i] = max(mx3[0][lc], mx3[0][rc]);
mx3[0][i] = max(mx3[0][i], mx[0][lc] + mx2[0][rc]);
mx3[0][i] = max(mx3[0][i], mx[0][rc] + mx1[0][lc]);
mx[1][i] = max(mx[1][lc], mx[1][rc]);
mx1[1][i] = max(mx1[1][lc], mx1[1][rc]);
mx1[1][i] = max(mx1[1][i], mx[1][lc] - 2 * mn[rc]);
mx2[1][i] = max(mx2[1][lc], mx2[1][rc]);
mx2[1][i] = max(mx2[1][i], mx[1][rc] - 2 * mn[lc]);
mx3[1][i] = max(mx3[1][lc], mx3[1][rc]);
mx3[1][i] = max(mx3[1][i], mx[1][lc] + mx2[1][rc]);
mx3[1][i] = max(mx3[1][i], mx[1][rc] + mx1[1][lc]);
return;
}
void add(int l, int r, int b = 0, int e = ti, int ind = 1) {
if (e <= l || b >= r) return;
if (l <= b && e <= r) {
upd(ind);
return;
}
if (lazy[ind]) {
upd(ind * 2);
upd(ind * 2 + 1);
lazy[ind] = false;
}
int mid = (b + e) / 2;
add(l, r, b, mid, ind * 2);
add(l, r, mid, e, ind * 2 + 1);
merge(ind);
return;
}
void build(int b = 0, int e = ti, int ind = 1) {
if (b + 1 == e) {
int x = k[b];
mx1[x][ind] = mx2[x][ind] = -h[b];
mx[x][ind] = mn[ind] = h[b];
x = !k[b];
mx[x][ind] = mx1[x][ind] = mx2[x][ind] = mx3[x][ind] = -inf;
return;
}
int mid = (b + e) / 2;
build(b, mid, ind * 2);
build(mid, e, ind * 2 + 1);
merge(ind);
}
void dfs(int u, int hh, bool b) {
h[ti] = hh;
k[ti] = b;
st[u] = ti;
ti++;
for (auto x : adj[u]) {
if (x.first != par[u]) {
par[x.first] = u;
dfs(x.first, hh + 1, b ^ x.second);
h[ti] = hh;
k[ti] = b;
ti++;
}
}
fi[u] = ti;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
bool w;
cin >> x >> y >> w;
x--;
y--;
adj[x].push_back({y, w});
adj[y].push_back({x, w});
e.push_back({x, y});
}
dfs(0, 0, 0);
build();
cin >> q;
while (q--) {
int id;
cin >> id;
id--;
int x = e[id].first;
int y = e[id].second;
if (x == par[y]) swap(x, y);
add(st[x], fi[x]);
cout << max(mx3[0][1], mx3[1][1]) << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct p3i {
int u, v, c;
};
const int maxn = 2e5 + 10;
vector<int> G[maxn];
bool vis[maxn];
int deg[maxn];
int par[maxn];
int tmp[maxn];
int dist0[maxn];
int distf[maxn];
int distl[maxn];
vector<p3i> mf;
int fd, ld;
long long ans = 0;
inline void bfs(int source, int dist[]) {
memset(vis, 0, sizeof vis);
queue<int> bq;
vis[source] = true;
dist[source] = 0;
par[source] = source;
bq.push(source);
while (!bq.empty()) {
int t = bq.front();
bq.pop();
for (int u : G[t]) {
if (vis[u]) continue;
vis[u] = true;
dist[u] = dist[t] + 1;
par[u] = t;
bq.push(u);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
G[x].push_back(y);
G[y].push_back(x);
deg[x]++;
deg[y]++;
}
bfs(0, dist0);
fd = max_element(dist0, dist0 + n) - dist0;
bfs(fd, distf);
ld = max_element(distf, distf + n) - distf;
bfs(ld, distl);
queue<int> lfs;
for (int v = 0; v < n; v++)
if (deg[v] == 1) lfs.push(v);
memset(vis, 0, sizeof vis);
while (!lfs.empty()) {
int t = lfs.front();
lfs.pop();
if (t == fd or t == ld) continue;
vis[t] = true;
int x = par[t];
if (--deg[x] == 1) lfs.push(x);
int cand = (distf[t] > distl[t] ? fd : ld);
mf.push_back({t, cand, t});
ans += max(distf[t], distl[t]);
}
int cur = fd;
while (cur != ld) {
mf.push_back({cur, ld, cur});
ans += distl[cur];
cur = par[cur];
}
cout << ans << endl;
for (auto x : mf) cout << x.u + 1 << " " << x.v + 1 << " " << x.c + 1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> x;
int main() {
long long n;
int k;
scanf("%lld%d", &n, &k);
for (long long i = 1; i * i <= n; ++i)
if (n % i == 0) x.push_back(i);
if (x.size() >= k)
printf("%d", x[k - 1]);
else {
int l = x.size();
int rslt = (long long)x[l - 1] * x[l - 1] == n;
if (k > l * 2 - rslt)
printf("-1");
else
printf("%lld", n / (long long)x[2 * l - k - rslt]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[222222];
int main() {
int i, n, na = 0, ni = 0, nf = 0;
scanf("%d", &n);
scanf("%s", s);
n = strlen(s);
for (i = 0; i < n; i++) {
if (s[i] == 'A')
na++;
else if (s[i] == 'I')
ni++;
else if (s[i] == 'F')
nf++;
}
if (ni >= 2)
cout << 0 << endl;
else if (ni == 1)
cout << 1 << endl;
else {
cout << na << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T>
inline T abs(T x) {
return x > T() ? x : -x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const long long mod = 1000000007;
long long get_st(long long a, int st) {
long long res = 1;
while (st) {
if (st & 1) {
(res *= a) %= mod;
}
(a *= a) %= mod;
st >>= 1;
}
return res;
}
const int N = 1000100;
long long d_k[N];
long long cut[N];
long long f[N];
long long revf[N];
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
int n, k;
cin >> n >> k;
f[0] = 1;
revf[0] = 1;
for (int i = int(1); i < int(n + 1); ++i) {
(f[i] = f[i - 1] * i) %= mod;
revf[i] = get_st(f[i], mod - 2);
}
for (int i = int(0); i < int(k + 1); ++i) {
d_k[i] = cut[i] = 0;
}
for (int i = int(k + 1); i < int(n + 1); ++i) {
d_k[i] = (f[i - k - 1] - cut[i - k - 1] + mod) * f[i - 1] % mod *
revf[i - k - 1] % mod;
(cut[i] = cut[i - 1] * i % mod + d_k[i]) %= mod;
}
long long ans = 0;
for (int i = int(1); i < int(n + 1); ++i) {
(ans += d_k[i] * f[n - 1] % mod * revf[i] % mod * (n - i)) %= mod;
}
cout << ans << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long a[100010];
map<long long, bool> f;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%I64d", a + i);
sort(a + 1, a + 1 + n);
int ret = 0;
for (int i = 1; i <= n; i++) {
if (!f[a[i]]) {
ret++;
f[a[i] * k] = 1;
}
}
printf("%d", ret);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int maxN = 1000000;
cin >> n;
vector<bool> primes(maxN, true);
set<int> emirps;
set<int>::iterator it;
for (int i = 2; i * i < maxN; i++) {
if (primes[i]) {
for (int j = i; i * j < maxN; j++) {
primes[i * j] = false;
}
}
}
for (int i = 2; i < maxN; i++) {
if (primes[i]) {
emirps.insert(i);
}
}
int nth = 0;
it = emirps.begin();
while (nth != n && it != emirps.end()) {
int sv = *it;
int rev = 0;
while (sv > 0) {
rev = rev * 10 + sv % 10;
sv /= 10;
}
if (emirps.find(rev) != emirps.end() && *it / 10 > 0 && *it != rev) {
nth++;
}
it++;
}
cout << *(--it);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
string s(100, 'x');
cout << s << endl;
for (int i = 0; i < n; i++) {
int tmp;
cin >> tmp;
s[tmp] = s[tmp] == 'x' ? 'y' : 'x';
cout << s << endl;
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
set<long long> s;
vector<long long> v[10];
long long vbm[10];
long long vbmf[10][41];
vector<long long> vn[10];
void test(long long i, long long b) {
if (i == k) {
bool one = false;
for (long long j = 0; j < n; ++j) {
if (b & ((long long)1 << j)) {
one = true;
} else if (one) {
cout << "REJECTED\n";
exit(0);
}
}
return;
}
for (long long r = 0; r <= (long long)vn[i].size(); ++r) {
long long cnt = r + __builtin_popcountll(b & vbm[i]);
long long c = (b & ~vbm[i]) ^ vbmf[i][cnt];
test(i + 1, c);
}
}
int32_t main() {
cin >> n >> k;
for (long long i = 0; i < k; ++i) {
long long q;
cin >> q;
for (long long j = 0; j < q; ++j) {
long long a;
cin >> a;
a--;
v[i].push_back(a);
vbm[i] |= (long long)1 << a;
for (long long r = q - j; r <= q; ++r) vbmf[i][r] |= (long long)1 << a;
if (s.count(a) == 0) vn[i].push_back(a);
s.insert(a);
}
}
if (n == 1) {
cout << "ACCEPTED\n";
return 0;
}
if ((long long)s.size() != n) {
cout << "REJECTED\n";
return 0;
}
test(0, 0);
cout << "ACCEPTED\n";
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 10;
set<char> v[MAXN];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int m = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
m = ((int)(s).size());
for (int j = 0; j < ((int)(s).size()); j++)
if (s[j] != '?') v[j].insert(s[j]);
}
string ans;
for (int i = 0; i < m; i++) {
if (!((int)(v[i]).size()))
ans.push_back('a');
else if (((int)(v[i]).size()) == 1)
ans.push_back(*v[i].begin());
else
ans.push_back('?');
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
pair<int, int> arr[100001];
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
arr[i] = make_pair(max(a, b), min(a, b));
}
int now = arr[0].first;
for (int i = 1; i < n; ++i) {
if (arr[i].first <= now)
now = arr[i].first;
else {
if (arr[i].second <= now)
now = arr[i].second;
else {
cout << "NO";
return 0;
}
}
}
cout << "YES";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
pair<long long, long long> a[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, w;
cin >> n >> w;
w++;
long long comp = w / 2;
for (long long i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
reverse(a, a + n);
vector<long long> ans;
long long sum = 0;
for (long long i = 0; i < n; i++)
if (sum + a[i].first < w) {
sum += a[i].first;
ans.push_back(a[i].second + 1);
}
if (sum < comp || sum >= w)
cout << -1 << '\n';
else {
cout << ans.size() << '\n';
for (long long i : ans) cout << i << ' ';
cout << '\n';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
const int M = 43210;
const int L = 16;
struct E {
int w, x, p, z;
E() {}
E(int _w, int _x, int _p, int _z) : w(_w), x(_x), p(_p), z(_z) {}
};
bool operator<(E a, E b) { return a.x < b.x; }
int n, m, p, a[N];
map<string, int> A;
int f[N][M];
int g[N][M];
int w[M][L];
bool v[M];
vector<E> B;
int gg(int x, int y) {
int p = x;
for (int i = 0, p2 = p; i < L; i++)
if ((y >> i) & 1) p = w[p2][i], p2 = p + 1;
return p;
}
void writeAns(int x, int y, int z) {
if (g[x][y] == -1)
printf("%d\n", z);
else if (g[x][y] == y)
writeAns(x - 1, y, z);
else {
writeAns(x - 1, g[x][y], z + 1);
int l = w[g[x][y]][0], r = y - 1;
printf("%d %d %02d:%02d %d %02d:%02d\n", B[x - 1].z + 1, l / 1440 + 1,
l % 1440 / 60, l % 60, r / 1440 + 1, r % 1440 / 60, r % 60);
}
}
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 0, t = 0; i < n; i++) {
string s;
cin >> s;
A[s] = t++;
}
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < 4; i++) {
int x0, y0, x1, y1;
scanf("%2d:%2d-%2d:%2d", &x0, &y0, &x1, &y1);
for (int j = 0; j < p; j++)
for (int k = x0 * 60 + y0; k <= x1 * 60 + y1; k++) v[j * 1440 + k] = 1;
}
int P = p * 1440;
for (int j = 0; j < L; j++) w[P][j] = P - 1;
for (int i = P - 1; i >= 0; i--) {
if (v[i])
w[i][0] = w[i + 1][0];
else
w[i][0] = i;
for (int j = 1; j < L; j++) w[i][j] = w[w[i][j - 1] + 1][j - 1];
}
for (int i = 0; i < m; i++) {
string s;
cin >> s;
int z, x, y, p;
scanf("%d%2d:%2d%d", &z, &x, &y, &p), --z;
if (!A.count(s)) continue;
B.push_back(E(A[s], z * 1440 + x * 60 + y, p, i));
}
sort(B.begin(), B.end());
m = (int)(int)(int)B.size();
memset(g, -1, sizeof g);
for (int i = 0; i < m; i++)
for (int j = 0; j < P; j++) {
if (f[i][j] > f[i + 1][j]) f[i + 1][j] = f[i][j], g[i + 1][j] = j;
int z = gg(j, a[B[i].w]);
if (z >= B[i].x) continue;
if (f[i][j] + B[i].p > f[i + 1][z + 1])
f[i + 1][z + 1] = f[i][j] + B[i].p, g[i + 1][z + 1] = j;
}
int S = 0, T = 0;
for (int i = 0; i <= P; i++)
if (f[m][i] > S) S = f[m][i], T = i;
printf("%d\n", S);
writeAns(m, T, 0);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, c, d, e, f, ans = 0;
cin >> a >> b >> c >> d >> e >> f;
if (e <= f) {
if (d <= b && d <= c)
ans = d * f;
else {
ans = min(b, c) * f;
d -= min(b, c);
ans += min(a, d) * e;
}
} else {
if (d <= a)
ans = d * e;
else {
ans = a * e;
d -= a;
ans += min(b, min(c, d)) * f;
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[1010];
int main() {
while (~scanf("%d%d", &n, &m)) {
int sum = 0, minn, maxx;
minn = 0x3f3f3f3f;
maxx = -0x3f3f3f3f;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
minn = min(sum, minn);
maxx = max(sum, maxx);
}
int flag = 0;
if (minn < -m || maxx > m) flag = 1;
if (minn < 0 && maxx > 0 && maxx - minn > m) flag = 1;
if (flag)
printf("0\n");
else {
if (maxx <= 0 && minn <= 0)
printf("%d\n", m - abs(minn) + 1);
else if (maxx >= 0 && minn <= 0)
printf("%d\n", m - abs(minn) - maxx + 1);
else
printf("%d\n", m - maxx + 1);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
int n, m;
int T;
int A[300][300];
int O[300][300];
int deg[300];
int vis[300];
vector<pair<int, int> > e;
void dfs(int u) {
vis[u] = 1;
for (int v = 0; v < n; v++) {
while (A[u][v]) {
A[u][v]--;
A[v][u]--;
if (O[u][v]) {
O[u][v]--;
O[v][u]--;
e.push_back(pair<int, int>(u, v));
}
dfs(v);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> T;
while (T--) {
cin >> n >> m;
memset((A), (0), sizeof(A));
memset((O), (0), sizeof(O));
memset((deg), (0), sizeof(deg));
memset((vis), (0), sizeof(vis));
e.clear();
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
A[u][v] = A[v][u] = 1;
O[u][v] = O[v][u] = 1;
deg[u]++;
deg[v]++;
}
int evens = 0;
for (int i = 0; i < n; i++) {
evens += deg[i] % 2 == 0;
}
memset((vis), (0), sizeof(vis));
for (int i = 0; i < n; i++) {
if (deg[i] % 2) {
for (int j = i + 1; j < n; j++) {
if (deg[j] % 2) {
A[i][j]++;
A[j][i]++;
deg[i]++;
deg[j]++;
break;
}
}
}
}
memset((vis), (0), sizeof(vis));
for (int i = 0; i < n; i++)
if (deg[i] && vis[i] == 0) {
dfs(i);
}
cout << evens << endl;
for (int i = 0; i < e.size(); i++) {
cout << e[i].first + 1 << " " << e[i].second + 1 << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int l[1000005];
int main() {
ios::sync_with_stdio(false);
int n, q, s = 0, x = 0, y = 0;
cin >> n;
cin >> q;
for (int i = 0; i < q; i++) {
int a;
cin >> a;
if (a == 1) {
int b;
cin >> b;
s += b;
s = s % n;
} else {
if ((s + x + y) % 2 == 0) {
x++;
} else {
y++;
}
}
}
for (int i = 1; i <= n; i++) {
int a = i;
a += s;
if (i % 2 == 0) {
a -= x;
a += y;
} else {
a += x;
a -= y;
}
a = a % n;
if (a <= 0) {
a += n;
}
l[a] = i;
}
for (int i = 1; i <= n; i++) {
cout << l[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int ALPHA = 26;
const int MAXN = 300010;
int c[MAXN];
char s[MAXN];
struct node {
int sz = 0;
node* child[ALPHA];
node() {
sz = 1;
for (int i = 0; i < ALPHA; i++) child[i] = NULL;
}
node(char c) {
sz = 1;
child[c - 'a'] = new node();
}
};
node* mrg(node* where, node* what) {
if (what == nullptr) return where;
if (where == nullptr) return what;
where->sz = 1;
for (int letter = 0; letter < ALPHA; letter++) {
where->child[letter] = mrg(where->child[letter], what->child[letter]);
if (where->child[letter] != nullptr) where->sz += where->child[letter]->sz;
}
return where;
}
vector<int> adj[MAXN];
node* trie[MAXN];
int ans[MAXN];
void dfs(int src, int last) {
if (adj[src].size() == 1 && last != -1) {
trie[src] = new node();
ans[src] = trie[src]->sz;
return;
}
for (auto xt : adj[src]) {
if (xt == last) continue;
dfs(xt, src);
}
int mxcd = 0;
int mxcdval = 0;
for (auto xt : adj[src]) {
if (xt == last) continue;
if (trie[xt]->sz > mxcdval) {
mxcdval = trie[xt]->sz;
mxcd = xt;
}
}
trie[src] = new node();
trie[src]->child[s[mxcd] - 'a'] =
mrg(trie[src]->child[s[mxcd] - 'a'], trie[mxcd]);
for (auto xt : adj[src]) {
if (xt == last || xt == mxcd) continue;
trie[src]->child[s[xt] - 'a'] =
mrg(trie[src]->child[s[xt] - 'a'], trie[xt]);
}
for (int i = 0; i < ALPHA; i++)
if (trie[src]->child[i] != NULL) trie[src]->sz += trie[src]->child[i]->sz;
ans[src] = trie[src]->sz;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
scanf("%s", s + 1);
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, -1);
int bests = 0;
int best = 0;
for (int i = 1; i <= n; i++) {
int val = ans[i] + c[i];
if (val > best) {
bests = 1;
best = val;
} else if (val == best)
bests++;
}
printf("%d\n%d\n", best, bests);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool prime[1000000 + 1];
void SieveOfEratosthenes() {
memset(prime, true, sizeof(prime));
prime[1] = false;
for (int p = 2; p * p <= 1000000; p++) {
if (prime[p] == true) {
for (int i = p * 2; i <= 1000000; i += p) prime[i] = false;
}
}
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int modexp(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
class gfg {
public:
long long int gcd(long long int a, long long int b) {
if (a == 0 || b == 0) return 0;
if (a == b) return a;
if (a > b) return gcd(a - b, b);
return gcd(a, b - a);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
};
long long int mypow(long long int b, long long int e) {
long long int ans = 1;
for (; e; b = b * b % 1000000007, e /= 2)
if (e & 1) ans = ans * b % 1000000007;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
if (n % 2 == 0) {
cout << "white" << endl;
cout << 1 << " " << 2 << endl;
} else
cout << "black";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long n, m;
void wr(int i) {
if (i == 0 || i == 2) {
for (long i = 0; i < m; i++) cout << '#';
cout << endl;
return;
}
if (i == 1) {
for (long i = 1; i < m; i++) cout << '.';
cout << '#' << endl;
return;
}
if (i == 3) {
cout << '#';
for (long i = 1; i < m; i++) cout << '.';
cout << endl;
return;
}
}
int main() {
cin >> n >> m;
for (long i = 0; i < n; i++) wr(i % 4);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
ios_base::sync_with_stdio(false);
vector<int> all;
cin >> n >> m;
all.resize(n);
vector<int> dif;
for (int i = 0; i < n; i++) {
cin >> all[i];
}
for (int i = 0; i + 1 < n; i++) {
dif.push_back(all[i + 1] - all[i]);
}
int nn = n - 1;
int l, r;
l = 0;
r = -1;
vector<int> d1(nn);
for (int i = 0; i < nn; i++) {
int k = 0;
if (i > r)
k = 1;
else
k = min(d1[l + r - i], r - i);
while (0 <= i - k && i + k < n && dif[i - k] == dif[i + k]) k++;
d1[i] = k;
if (i + k - 1 > r) {
r = i + k - 1, l = i - k + 1;
}
}
vector<int> d2(nn);
l = 0, r = -1;
for (int i = 0; i < nn; i++) {
int k = 0;
if (i > r)
k = 0;
else
k = min(d2[l + r - i + 1], r - i + 1);
while (i + k < nn && i - k - 1 >= 0 && dif[i + k] == dif[i - k - 1]) k++;
d2[i] = k;
if (i + k - 1 > r) {
l = i - k, r = i + k - 1;
}
}
vector<int> ans;
for (int i = 0; i < n; i++) {
int s1 = all[i] + all[n - 1];
if (i > 0) {
int s2 = all[0] + all[i - 1];
if (s1 - s2 != m) continue;
}
bool ok1 = true;
bool ok2 = true;
if (i >= 2) {
if ((i - 2) % 2 == 1) {
int mid = (i - 1) / 2;
if (d2[mid] != mid) {
ok1 = false;
continue;
}
} else {
int mid = (i - 2) / 2;
if (d1[mid] != mid + 1) {
ok1 = false;
continue;
}
}
}
if (i <= n - 2) {
int len = n - 2 - i + 1;
if (len % 2 == 0) {
int mid = (n - 2 + i + 1) / 2;
if (d2[mid] != n - 1 - mid) {
ok2 = false;
continue;
}
} else {
int mid = (n - 2 + i) / 2;
if (d1[mid] != n - 1 - mid) {
ok2 = false;
continue;
}
}
}
if (ok1 && ok2) ans.push_back(s1 % m);
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (int v : ans) cout << v << " ";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const long long MOD = 1e9 + 7;
int n;
vector<int> graph[MAXN];
long long d[MAXN];
long long ans[MAXN];
int dfs1(int v) {
long long now = 1;
for (int i = 0; i < ((int)(graph[v]).size()); ++i) {
dfs1(graph[v][i]);
now = (now * (d[graph[v][i]] + 1)) % MOD;
}
d[v] = now;
return 0;
}
int dfs2(int v, long long up) {
vector<long long> vec;
for (int i = 0; i < ((int)(graph[v]).size()); ++i) {
vec.push_back(d[graph[v][i]]);
}
vector<long long> pref, suff;
pref.resize(((int)(vec).size()) + 1);
pref[0] = 1;
for (int i = 0; i < ((int)(vec).size()); ++i) {
pref[i + 1] = (pref[i] * (vec[i] + 1)) % MOD;
}
suff.resize(((int)(vec).size()) + 1);
suff[((int)(vec).size())] = 1;
for (int i = ((int)(vec).size()) - 1; i >= 0; --i) {
suff[i] = (suff[i + 1] * (vec[i] + 1)) % MOD;
}
ans[v] = d[v] * (up + 1) % MOD;
for (int i = 0; i < ((int)(graph[v]).size()); ++i) {
dfs2(graph[v][i], (up + 1) * pref[i] % MOD * suff[i + 1] % MOD);
}
return 0;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int num;
cin >> num;
graph[num - 1].push_back(i + 1);
}
dfs1(0);
dfs2(0, 0);
for (int i = 0; i < n; ++i) {
cout << ans[i] % MOD << " ";
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, t = 3, f = 0, i, j, k;
cin >> n;
long long int a[n];
a[2] = 1;
a[3] = 2;
for (i = 4; i <= n; i++) {
for (j = 2; j <= sqrt(i); j++) {
if (i % j == 0) {
a[i] = a[j];
f = 1;
break;
}
}
if (f != 1) {
a[i] = t;
t++;
}
f = 0;
}
for (i = 2; i <= n; i++) cout << a[i] << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const char s0[] =
"What are you doing at the end of the world? Are you busy? Will you save "
"us?";
const char* cau[] = {"What are you doing while sending \"",
"\"? Are you busy? Will you send \"", "\"?"};
long long f[1005];
int main() {
f[0] = strlen(s0);
int len[3];
for (int i = 0; i < 3; i++) len[i] = strlen(cau[i]);
int cs = 0;
while (1) {
++cs;
f[cs] = f[cs - 1] * 2 + len[0] + len[1] + len[2];
if (f[cs] >= 1000000000000000000LL) break;
}
int q;
scanf("%d", &q);
while (q--) {
int n;
long long k;
scanf("%d%lld", &n, &k);
if (n <= cs && k > f[n]) {
putchar('.');
continue;
}
int ans = 0;
while (n > 0) {
if (k <= len[0]) {
ans = cau[0][k - 1];
break;
}
k -= len[0];
if (n - 1 > cs) {
--n;
continue;
}
if (k <= f[n - 1]) {
--n;
continue;
}
k -= f[n - 1];
if (k <= len[1]) {
ans = cau[1][k - 1];
break;
}
k -= len[1];
if (n - 1 > cs) {
--n;
continue;
}
if (k <= f[n - 1]) {
--n;
continue;
}
k -= f[n - 1];
if (k <= len[2]) {
ans = cau[2][k - 1];
break;
}
k -= len[2];
--n;
}
if (ans == 0) ans = s0[k - 1];
putchar(ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, x, y, b;
cin >> n >> x >> y;
b = n;
int t = y - x, i, k;
for (i = n - 1; i >= 1; i--) {
if (t % i == 0) break;
}
n = n - (i - 1) - 2;
k = t / i;
int c = x / k;
c = min(c, n);
n = n - c;
if (x - c * k == 0) c--;
i = 0;
while (i < b) {
cout << (x - c * k) + i * k << " ";
i++;
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
getline(cin, s);
int n = s.length();
if (n == 1) {
cout << 0;
exit(0);
}
for (int i = 0; i <= (s.length() - 2); i++) {
if (s[i] == s[i + 1]) {
cout << 0 << " ";
continue;
} else if (s[i] == 'a' && s[i + 1] == 'b') {
cout << 1 << " ";
string temp = s.substr(0, i + 1);
reverse(temp.begin(), temp.end());
s.replace(0, i + 1, temp);
continue;
} else if (s[i] == 'b' && s[i + 1] == 'a') {
cout << 1 << " ";
string temp = s.substr(0, i + 1);
reverse(temp.begin(), temp.end());
s.replace(0, i + 1, temp);
}
}
string temp = s;
reverse(temp.begin(), temp.end());
if (temp <= s) {
cout << 1;
cout << endl;
} else {
cout << 0;
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int base1 = 119, mod1 = 1000000007;
const int base2 = 301, mod2 = 998244353;
const int N = 1e6 + 100005;
int n;
long long b1[N], b2[N];
char s[N];
int lens;
long long h1[N], h2[N];
char t[N];
int lent;
long long q1[N], q2[N];
pair<long long, long long> hashs(int l, int r) {
return make_pair((h1[r] - h1[l - 1] * b1[r - l + 1] % mod1 + mod1) % mod1,
(h2[r] - h2[l - 1] * b2[r - l + 1] % mod2 + mod2) % mod2);
}
pair<long long, long long> hasht(int l, int r) {
return make_pair((q1[r] - q1[l - 1] * b1[r - l + 1] % mod1 + mod1) % mod1,
(q2[r] - q2[l - 1] * b2[r - l + 1] % mod2 + mod2) % mod2);
}
int main() {
scanf("%d", &n);
b1[0] = b2[0] = 1;
for (int i = 1; i <= 1000002; i++)
b1[i] = b1[i - 1] * base1 % mod1, b2[i] = b2[i - 1] * base2 % mod2;
while (n--) {
scanf("%s", t + 1);
lent = strlen(t + 1);
for (int i = 1; i <= lent; i++) {
q1[i] = (q1[i - 1] * base1 + t[i]) % mod1;
q2[i] = (q2[i - 1] * base2 + t[i]) % mod2;
}
int try_len = min(lent, lens);
for (; try_len; try_len--)
if (hasht(1, try_len) == hashs(lens - try_len + 1, lens)) break;
for (int tt = try_len + 1; tt <= lent; tt++) {
s[++lens] = t[tt];
h1[lens] = (h1[lens - 1] * base1 + t[tt]) % mod1;
h2[lens] = (h2[lens - 1] * base2 + t[tt]) % mod2;
}
}
puts(s + 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
} x[110000], y[110000];
int s[110000], n, m;
long long cross(point k1, point k2, point k3) {
return 1ll * (k1.x - k2.x) * (k1.y - k3.y) -
1ll * (k1.x - k3.x) * (k1.y - k2.y);
}
int compare(point k1, point k2) { return k1.x < k2.x; }
int main() {
scanf("%d%d", &n, &m);
int k1, k2;
scanf("%d%d", &k1, &k2);
for (int i = 1; i <= n; i++) scanf("%d%d", &y[i].x, &y[i].y);
for (int i = 1; i <= m; i++) scanf("%d%d", &x[i].x, &x[i].y);
sort(x + 1, x + m + 1, compare);
int len = 1;
s[1] = 0;
for (int i = 1; i <= m; i++) {
while (len != 1 && cross(x[s[len - 1]], x[s[len]], x[i]) > 0) len--;
s[++len] = i;
}
for (int i = len - 1; i; i--) x[s[i]].y = max(x[s[i + 1]].y, x[s[i]].y);
sort(y + 1, y + n + 1, compare);
int now = 1;
int flag = 0;
for (int i = 1; i <= n; i++) {
while (now <= len && x[s[now]].x <= y[i].x) now++;
if (now > len) {
flag = 1;
break;
}
if (cross(x[s[now - 1]], x[s[now]], y[i]) >= 0) flag = 1;
}
if (flag == 0)
cout << "Min" << endl;
else
cout << "Max" << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool a[100001];
bool uyg(int x) {
if (x == n || a[x + 1] == 1) {
a[x] = 1;
return 1;
}
return 0;
}
int main() {
int q;
vector<int> v;
priority_queue<int> pq;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &q);
v.push_back(q);
}
for (int i = 0; i < n; i++) {
if (uyg(v[i])) {
printf("%d ", v[i]);
if (!pq.empty())
while (uyg(pq.top())) {
printf("%d ", pq.top());
pq.pop();
if (pq.empty()) break;
}
if (i != n - 1) printf("\n");
} else {
printf("\n");
pq.push(v[i]);
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int m = i * (i + 1);
if (m / 2 == n) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops", \
"omit-frame-pointer", "inline", "03")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,avx2,fma,tune=native")
#pragma GCC option("arch=native", "no-zero-upper")
using namespace std;
const long long oo = (long long)(1e9);
int a[(long long)(1e5 + 5)];
int t[(long long)(1e5 + 5)];
vector<int> g[(long long)(1e5 + 5)];
int lvl[(long long)(1e5 + 5)];
bool mk[(long long)(1e5 + 5)];
int li[(long long)(1e5 + 5)], ls[(long long)(1e5 + 5)];
int ip[(long long)(1e5 + 5)];
int cont;
int px[(long long)(1e5 + 5)];
int aa[(long long)(1e5 + 5)];
int lvll[(long long)(1e5 + 5)];
void dfs(int u) {
mk[u] = 1;
li[u] = cont;
ip[cont] = u;
px[cont] = u;
cont++;
for (auto v : g[u])
if (!mk[v]) {
lvl[v] = lvl[u] + 1;
dfs(v);
}
ls[u] = cont - 1;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
int p;
cin >> p;
p--;
g[p].push_back(i);
}
dfs(0);
for (int i = 0; i < n; i++) {
aa[i] = a[ip[i]];
lvll[i] = lvl[ip[i]];
}
for (int i = 0; i < q; i++) {
int r1 = 0;
int r2 = 0;
int u;
cin >> u;
u--;
for (int j = li[u]; j <= ls[u]; j++)
if (t[j] <= i) {
r1++;
r2 += lvll[j];
t[j] = i + aa[j];
}
r2 -= r1 * lvl[u];
cout << r2 << ' ' << r1 << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int arr[50010];
int main() {
int n;
cin >> n;
set<int> st;
priority_queue<int> pq;
for (int i = 0; i < n; i++) cin >> arr[i], st.insert(arr[i]), pq.push(arr[i]);
sort(arr, arr + n);
while (!pq.empty()) {
int x = pq.top();
bool found = false;
while (1) {
if (x == 0) break;
if (st.find(x) == st.end()) {
found = true;
st.erase(st.find(pq.top()));
st.insert(x);
pq.push(x);
break;
}
x /= 2;
}
pq.pop();
}
set<int>::iterator it;
for (it = st.begin(); it != st.end(); it++) cout << *it << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll fen[(int)(1e6 + 7)][3];
void upd(int ind, int val, int fl) {
for (int i = ind; i < (int)(1e6 + 7); i += i & (-i)) {
fen[i][fl] += val;
;
}
}
ll qry(int ind, int fl) {
ll ss = 0;
for (int i = ind; i > 0; i -= i & (-i)) {
ss += fen[i][fl];
}
return ss;
}
vector<int> vec(string s1, string s2) {
string s;
s1.back() = '#';
s.append(s1);
s.append(s2);
int n = s.size(), l = 0, r = 0;
vector<int> vv(n);
for (int i = 1; i < n; i++) {
if (i <= r) {
vv[i] = min(r - i + 1, vv[i - l]);
}
while (s[vv[i]] == s[i + vv[i]]) {
vv[i]++;
}
if (i + vv[i] - 1 > r) {
l = i, r = i + vv[i] - 1;
}
}
vv.erase(vv.begin(), vv.begin() + s1.size());
return vv;
}
int main() {
int n, m;
ll cc = 0;
cin >> n >> m;
string s1, s2, s3;
cin >> s1 >> s2 >> s3;
reverse(s2.begin(), s2.end());
vector<int> v1 = vec(s3, s1);
reverse(s3.begin(), s3.end());
vector<int> v2 = vec(s3, s2);
reverse(v2.begin(), v2.end());
int st = 0, en = 0;
for (int i = 0; i < n; i++) {
while (en < n && i + m - 2 >= en) {
upd(m - v2[en], v2[en], 0);
upd(m - v2[en], 1, 1);
en++;
}
if (st < i) {
upd(m - v2[st], -v2[st], 0);
upd(m - v2[st], -1, 1);
st++;
}
cc += (v1[i] - m + 1) * qry(v1[i] + 1, 1) + qry(v1[i] + 1, 0);
}
cout << cc << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long p[2001];
long long find_size(long long x) {
if (p[x] == -1) return 1;
return 1 + find_size(p[x]);
}
void solve() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
if (x > 0) x--;
p[i] = x;
}
long long ans = 1;
for (long long i = 0; i < n; i++) {
ans = max(ans, find_size(i));
}
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int NN = (int)2e5 + 5;
int n;
int a[NN];
int dp[2][NN];
vector<int> adj[NN];
int ans[NN];
void dfs(int node, int father) {
dp[0][node] = (a[node] == 0);
dp[1][node] = (a[node] == 1);
for (int child : adj[node]) {
if (child == father) continue;
dfs(child, node);
if (dp[1][child] - dp[0][child] > 0) {
dp[1][node] += dp[1][child];
dp[0][node] += dp[0][child];
}
}
return;
}
void reroot(int oldRoot, int seen) {
for (int newRoot : adj[oldRoot]) {
if (newRoot == seen) continue;
int diff = dp[1][newRoot] - dp[0][newRoot];
int old0 = dp[0][oldRoot];
int old1 = dp[1][oldRoot];
int new0 = dp[0][newRoot];
int new1 = dp[1][newRoot];
if (diff > 0) {
dp[1][oldRoot] -= dp[1][newRoot];
dp[0][oldRoot] -= dp[0][newRoot];
}
if (dp[1][oldRoot] - dp[0][oldRoot] > 0) {
dp[1][newRoot] += dp[1][oldRoot];
dp[0][newRoot] += dp[0][oldRoot];
}
reroot(newRoot, oldRoot);
dp[0][oldRoot] = old0;
dp[1][oldRoot] = old1;
dp[0][newRoot] = new0;
dp[1][newRoot] = new1;
}
ans[oldRoot] = dp[1][oldRoot] - dp[0][oldRoot];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(0, -1);
reroot(0, -1);
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<int> pri;
int read() {
int A;
bool K;
char C;
C = A = K = 0;
while (C < '0' || C > '9') K |= C == '-', C = getchar();
while (C > '/' && C < ':') A = (A << 3) + (A << 1) + (C ^ 48), C = getchar();
return (K ? -A : A);
}
int main() {
long long s = 0;
int a, n;
n = read();
while (n--) {
a = read();
pri.push(a);
if (pri.top() > a) {
s += pri.top() - a;
pri.pop();
pri.push(a);
}
}
cout << s;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, m, n, k, temp, sumd = 0, count = 0;
cin >> n;
vector<long long int> vec;
for (i = n; (i >= 0) && (i >= n - 81); --i) {
temp = i;
sumd = 0;
while (temp != 0) {
sumd += temp % 10;
temp = temp / 10;
}
if (sumd + i == n) {
vec.push_back(i);
count++;
}
}
sort(vec.begin(), vec.end());
cout << count;
for (i = 0; i < vec.size(); ++i) {
cout << "\n" << vec[i];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, one = 0, two = 0, three = 0;
cin >> n;
int arr[n];
vector<int> o;
vector<int> t;
vector<int> tt;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
if (arr[i] == 1) {
++one;
o.push_back(i + 1);
}
if (arr[i] == 2) {
++two;
t.push_back(i + 1);
}
if (arr[i] == 3) {
++three;
tt.push_back(i + 1);
}
}
int sz = min(one, two);
sz = min(sz, three);
cout << sz << endl;
for (int i = 0; i < sz; ++i) {
cout << o[i] << " " << t[i] << " " << tt[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 7;
const int lim = 4e5;
const int INF = 0x3f3f3f;
const int MOD = 998244353;
long long fac[N], inv[N];
void init() {
fac[0] = inv[0] = inv[1] = 1;
for (long long i = 1; i <= lim; i++) fac[i] = fac[i - 1] * i % MOD;
for (long long i = 2; i <= lim; i++)
inv[i] = (MOD - MOD / i) * inv[MOD % i] % MOD;
for (long long i = 1; i <= lim; i++) inv[i] = inv[i - 1] * inv[i] % MOD;
}
long long C(long long n, long long m) {
if (m > n) return 0;
return fac[n] * inv[m] % MOD * inv[n - m] % MOD;
}
int n;
long long a[N];
int main() {
init();
long long ans = 0;
scanf("%d", &n);
int m = n + n;
for (int i = 1; i <= m; i++) scanf("%lld", &a[i]);
sort(a + 1, a + 1 + m);
long long s1 = 0, s2 = 0;
for (int i = 1; i <= n; i++) s1 = (s1 + a[i + n] - a[i]) % MOD;
ans = s1 % MOD * C(m, n) % MOD;
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10;
const long long M = 998244353;
const long double PI = acos(-1);
long long n, k;
long long a[N], d[N], mn[N] = {INT_MAX};
signed main() {
long long i, s = 0, ans = 0;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) cin >> d[i], mn[i] = min(mn[i - 1], d[i]);
for (i = n; i >= 1; i--) a[i] += a[i + 1];
if (k == 0) {
for (i = 1; i <= n; i++) ans = max(ans, a[i] - d[i]);
cout << ans;
} else if (k == 1) {
for (i = 2; i <= n; i++)
ans = max(ans, max(0ll, a[1] - a[i] - mn[i - 1]) + max(0ll, a[i] - d[i]));
for (i = 1; i < n; i++)
ans = max(ans, a[1] - (a[i + 1] - a[i + 2]) - d[1] +
max(0ll, a[i + 1] - a[i + 2] - d[i + 1]));
cout << ans;
} else
cout << max({0ll, a[1] - mn[n - 1], a[n] - d[n]});
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inv = numeric_limits<int>::max();
const int minv = numeric_limits<int>::min();
const int max_n = 1000010;
int n, k;
char s[max_n + 10];
int main() {
scanf("%d", &n);
scanf("%d", &k);
if (k == 1) {
if (n == 1)
printf("a\n");
else
printf("-1\n");
} else {
if (n < k)
printf("-1\n");
else {
for (int i = n - k + 2; i <= n - 1; ++i) s[i] = (char('a' + i - n + k));
s[0] = 'a';
for (int i = 1; i <= n - k + 1; ++i) s[i] = (s[i - 1] == 'a' ? 'b' : 'a');
s[n] = '\0';
printf("%s\n", s);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k, m, t;
cin >> n >> k >> m >> t;
int type, i;
int si = 1, ei = n;
while (t--) {
cin >> type >> i;
if (type == 0) {
if (k >= si && k <= si + i - 1) {
ei = si + i - 1;
} else {
si = si + i;
}
} else {
if (si + i - 1 <= k) {
si--;
} else {
ei++;
}
}
cout << ei - si + 1 << " " << k - si + 1 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int c;
const int lim = 1e3 + 2, infy = 1e7;
int match[2][lim];
int ptr;
struct KMP {
const static int maxn = 1e3 + 6;
int f[maxn];
string pattern;
KMP(string& p) {
pattern = p;
initLPS();
}
KMP() {}
void initLPS() {
f[0] = 0;
int l = 0, r = 1;
while (r < pattern.size()) {
while (l != 0 && pattern[r] != pattern[l]) l = f[l - 1];
if (pattern[l] == pattern[r]) {
l++;
f[r] = l;
} else {
f[r] = 0;
l = 0;
}
r++;
}
}
void search(string& s) {
int l = 0, r = 0;
while (r < s.size()) {
while (l != 0 && pattern[l] != s[r]) l = f[l - 1];
if (pattern[l] == s[r]) {
l++;
}
match[ptr][l] = min(match[ptr][l], r);
if (l == pattern.size()) {
c++;
l = f[pattern.size() - 1];
}
r++;
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
string t, trev, s;
int m;
cin >> t;
trev = t;
reverse(trev.rbegin(), trev.rend());
cin >> m;
int ans = 0;
while (m--) {
cin >> s;
if (s.size() == 1 || s.size() > t.size()) continue;
for (int i = 0; i <= s.size(); i++) {
match[0][i] = infy;
match[1][i] = infy;
}
ptr = 0;
KMP k1(s);
k1.search(t);
reverse(s.rbegin(), s.rend());
ptr = 1;
KMP k2(s);
k2.search(trev);
bool can = false;
if (match[0][s.size()] != infy || match[1][s.size()] != infy) can = true;
for (int i = 1; i < s.size() && !can; i++) {
if (match[0][i] == infy || match[1][s.size() - i] == infy) continue;
if (match[0][i] < (t.size() - match[1][s.size() - i] - 1)) can = true;
}
if (can) ans++;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> tree[3010], treeT[3010];
bool vis[3010];
int cost[3010], delta[3010][3010], lineL[3010][3010], dp[3010][3010];
int dfs(int base, int root, int sum, int deep, int dpv, int state) {
if (base == root)
dp[base][root] = 0;
else
dp[base][root] = min(dpv + 1 - state, sum - state);
delta[base][root] = sum;
lineL[base][root] = deep;
vis[root] = 1;
int ret = 0;
for (int i = 0; i < tree[root].size(); i++)
if (vis[tree[root][i]] == 0)
ret += dfs(base, tree[root][i], sum, deep + 1, dp[base][root], 0);
for (int i = 0; i < treeT[root].size(); i++)
if (vis[treeT[root][i]] == 0)
ret +=
dfs(base, treeT[root][i], sum + 1, deep + 1, dp[base][root], 1) + 1;
return ret;
}
int main() {
memset(delta, 0, sizeof delta);
memset(lineL, 0, sizeof lineL);
memset(cost, 0, sizeof cost);
memset(dp, 0, sizeof dp);
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
tree[a].push_back(b);
treeT[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof vis);
cost[i] = dfs(i, i, 0, 0, 0, 0);
}
int ans = 4000;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j) {
int tmp = cost[i] - delta[i][j] + dp[i][j];
if (ans > tmp) ans = tmp;
}
if (n == 1)
printf("%d\n", 0);
else
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int u, v, w;
node() {}
node(int a, int b, int c) : u(a), v(b), w(c) {}
bool operator<(node p) const { return w < p.w; }
};
vector<pair<int, int> > ady_list[2005];
static int pset[4000005], dist[2005][2005], d[2005][2005];
void initSet(int n) {
for (int i = 0; i < n; i++) pset[i] = i;
}
int findSet(int u) {
return ((u == pset[u]) ? u : (pset[u] = findSet(pset[u])));
}
void unionSet(int a, int b) { pset[findSet(a)] = findSet(b); }
bool isSameSet(int a, int b) { return (findSet(a) == findSet(b)); }
bool vis[2005];
void dfs(int t, int s, int sum) {
if (vis[t]) return;
d[s][t] = d[t][s] = sum;
vis[t] = 1;
for (int i = 0; i < ady_list[t].size(); i++) {
pair<int, int> aux = ady_list[t][i];
dfs(aux.first, s, sum + aux.second);
}
}
int main() {
static int n;
bool sol = true;
vector<node> graph;
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
scanf("%d", &dist[i][j]);
graph.push_back(node(i, j, dist[i][j]));
if (i == j && dist[i][j] > 0) sol = false;
}
sort((graph).begin(), (graph).end());
initSet(n * n + 1);
for (int i = 0; i < n * n; i++) {
if (!isSameSet(graph[i].u, graph[i].v)) {
unionSet(graph[i].u, graph[i].v);
ady_list[graph[i].u].push_back(pair<int, int>(graph[i].v, graph[i].w));
ady_list[graph[i].v].push_back(pair<int, int>(graph[i].u, graph[i].w));
}
}
for (int i = 0; i < n; i++) {
memset(vis, false, sizeof vis);
dfs(i, i, 0);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i != j && (dist[i][j] == 0 || d[i][j] == 0)) sol = false;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (dist[i][j] != d[i][j]) sol = false;
printf("%s\n", ((sol) ? "YES" : "NO"));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 30005;
int n, q;
struct xxx {
long long v, id;
} a[N], b[N];
int ida[N], idb[N], c[N];
bool com(xxx a, xxx b) { return a.v < b.v; }
inline long long read() {
long long t = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c <= '9' && c >= '0') t = t * 10LL + c - 48LL, c = getchar();
return t * f;
}
long long f[N], g[N][3];
inline void gx(int i) {
g[i][0] = g[i][1] = g[i][2] = -1e9;
if (c[i] != i) g[i][0] = a[i].v * b[i].v;
if (i > 1 && c[i] != i - 1 && c[i - 1] != i)
g[i][1] = a[i - 1].v * b[i].v + a[i].v * b[i - 1].v;
if (i > 2 && c[i] != i - 2 && c[i - 1] != i && c[i - 2] != i - 1)
g[i][2] =
a[i].v * b[i - 2].v + a[i - 1].v * b[i].v + a[i - 2].v * b[i - 1].v;
if (i > 2 && c[i] != i - 1 && c[i - 1] != i - 2 && c[i - 2] != i)
g[i][2] = max(g[i][2], a[i].v * b[i - 1].v + a[i - 1].v * b[i - 2].v +
a[i - 2].v * b[i].v);
}
int main() {
n = read(), q = read();
for (int i = 1; i <= n; i++) a[i].v = read(), a[i].id = i;
for (int i = 1; i <= n; i++) b[i].v = read(), b[i].id = i;
sort(a + 1, a + n + 1, com);
sort(b + 1, b + n + 1, com);
for (int i = 1; i <= n; i++) ida[a[i].id] = idb[b[i].id] = i;
for (int i = 1; i <= n; i++) c[i] = idb[a[i].id];
for (int i = 1; i <= n; i++) gx(i);
for (; q; q--) {
int x = ida[read()], y = ida[read()];
swap(c[x], c[y]);
f[0] = 0;
for (int i = max(x - 2, 1); i <= min(n, x + 2); i++) gx(i);
for (int i = max(y - 2, 1); i <= min(n, y + 2); i++) gx(i);
for (int i = 1; i <= n; i++) {
f[i] = f[i - 1] + g[i][0];
if (i > 1) f[i] = max(f[i], f[i - 2] + g[i][1]);
if (i > 2) f[i] = max(f[i], f[i - 3] + g[i][2]);
}
printf("%I64d\n", f[n]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<int, int> > ve;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
pair<int, int> tmp;
scanf("%d", &tmp.first);
tmp.second = i;
ve.push_back(tmp);
}
sort(ve.begin(), ve.end());
reverse(ve.begin(), ve.end());
vector<int> tree;
tree.push_back(ve[0].second * 2);
for (int i = 1; i < n; i++) {
printf("%d %d\n", ve[i - 1].second * 2, ve[i].second * 2);
tree.push_back(ve[i].second * 2);
}
for (int i = 0; i < n; i++) {
int k = i + ve[i].first - 1;
printf("%d %d\n", ve[i].second * 2 - 1, tree[k]);
if (k + 1 == tree.size()) {
tree.push_back(ve[i].second * 2 - 1);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int mobius[2000010];
bool iscomp[2000010];
vector<int> primes;
int pows[2000010];
const int mod = 1000000007;
vector<vector<int>> di(2000010);
int exp(int base, int pow) {
if (pow == 0) return 1;
if (pow % 2 == 0) {
return exp((base * 1LL * base) % mod, pow / 2);
}
return (base * 1LL * (exp(base, pow - 1))) % mod;
}
int inv(int u) { return exp(u, mod - 2); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
mobius[1] = 1;
int mx = max(n, k);
fill(iscomp, iscomp + 2000010, false);
for (int i = 1; i <= k; i++) {
for (int j = i; j <= k; j += i) {
di[j].push_back(i);
}
}
iscomp[1] = true;
int ct = 0;
int ct2 = 0;
for (int i = 1; i <= mx; i++) {
if (!iscomp[i]) {
primes.push_back(i);
mobius[i] = -1;
}
for (int j = 0; j < primes.size() && (i * primes[j] <= mx); j++) {
ct2++;
iscomp[i * primes[j]] = true;
mobius[i * primes[j]] = mobius[i] * mobius[primes[j]];
if (i % primes[j] == 0) {
mobius[i * primes[j]] = 0;
break;
}
}
}
for (int i = 1; i <= k; i++) {
pows[i] = exp(i, n);
}
int ans = 0;
int cur = 0;
for (int i = 1; i <= k; i++) {
for (int j = 0; j < di[i].size(); j++) {
int v = di[i][j];
int cp = i / v;
int f = pows[cp];
f = (f + mod - pows[cp - 1]) % mod;
f = (mobius[v] * f + mod) % mod;
cur = (cur + f) % mod;
}
ans = (ans + (cur ^ i)) % mod;
}
cout << ans << endl;
cin >> ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
char a[1000003];
char b[1000003];
int gc(int x, int y) {
while (x > 0 && y > 0)
if (x > y)
x %= y;
else
y %= x;
return x + y;
}
int f[1000003][30];
int main() {
int i;
scanf("%I64d %I64d", &n, &m);
scanf("%s", a);
scanf("%s", b);
int lena, lenb;
for (lena = 0; a[lena]; lena++)
;
for (lenb = 0; b[lenb]; lenb++)
;
int g = gc(lena, lenb);
long long ans = (long long)lena * (long long)lenb / g;
for (i = 0; i < lena; i++) f[i % g][a[i] - 'a']++;
for (i = 0; i < lenb; i++) ans -= f[i % g][b[i] - 'a'];
printf("%I64d\n",
(long long)lena * n / ((long long)lena * (long long)lenb / g) * ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dp[100000 + 1];
int f[100000 + 1];
int last[100000 + 1];
int coin[100000 + 1];
vector<int> temp;
int main() {
int i, n, j, p, q, mx;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &coin[i]);
for (i = 0; i < n; i++) {
mx = 0;
temp.clear();
for (j = 2; j * j <= coin[i]; j++) {
if (coin[i] % j == 0) {
p = coin[i] / j;
f[p]++;
dp[coin[i]] = max(dp[coin[i]], f[p]);
dp[coin[i]] = max(dp[coin[i]], last[p] + 1);
temp.push_back(p);
q = j;
if (p != q) {
f[q]++;
temp.push_back(q);
dp[coin[i]] = max(dp[coin[i]], f[q]);
dp[coin[i]] = max(dp[coin[i]], last[q] + 1);
}
}
}
for (j = 0; j < temp.size(); j++) {
last[temp[j]] = max(last[temp[j]], dp[coin[i]]);
}
if (dp[coin[i]] == 0) {
dp[coin[i]] = 1;
f[coin[i]]++;
last[coin[i]] = 1;
}
}
mx = 0;
for (i = 1; i <= 100000; i++) {
mx = max(mx, dp[i]);
}
cout << mx << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct BIT {
int A[100007];
void init() { fill_n(A, 100007, 0); }
void add(int i, int k) {
for (; i < 100007; i += (i) & (-i)) A[i] += k;
}
int get(int i) {
int s = 0;
for (; i > 0; i -= (i) & (-i)) s += A[i];
return s;
}
int get(int l, int r) { return get(r) - get(l - 1); }
};
struct comp {
bool operator()(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) return a.first > b.first;
return a.second > b.second;
}
};
vector<int> Ko[100007];
int main() {
ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int c;
cin >> c;
Ko[c].push_back(i);
}
BIT X;
X.init();
for (int i = 1; i <= n; i++) X.add(i, 1);
int st = 0;
long long ans = 0;
for (int c = 0; c <= 100000; c++) {
int maxi = Ko[c].size();
for (int i = 0; i < Ko[c].size(); i++) {
if (Ko[c][i] >= st) {
maxi = min(maxi, i);
ans += X.get(st, Ko[c][i]);
X.add(Ko[c][i], -1);
st = Ko[c][i];
}
}
for (int i = 0; i < maxi; i++) {
if (Ko[c][i] >= st) {
ans += X.get(st, Ko[c][i]);
X.add(Ko[c][i], -1);
st = Ko[c][i];
} else {
ans += X.get(st, n);
ans += X.get(1, Ko[c][i]);
X.add(Ko[c][i], -1);
st = Ko[c][i];
}
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class Ty, class Tx>
Ty cast(const Tx &x) {
Ty y;
stringstream ss("");
ss << x;
ss.seekg(0);
ss >> y;
return y;
}
string s;
int cnt[26];
bool deleted[26];
int main() {
int n, k, i, j, m;
cin >> s >> k;
n = ((s).size());
memset((cnt), (0), sizeof(cnt));
memset((deleted), (0), sizeof(deleted));
m = 0;
for ((i) = 0; (i) < (n); (i)++) cnt[s[i] - 'a']++;
while (k > 0) {
j = -1;
for ((i) = 0; (i) < (26); (i)++)
if (!deleted[i] && cnt[i] > 0)
if (j < 0 || cnt[i] < cnt[j]) j = i;
if (j < 0 || cnt[j] > k) break;
deleted[j] = true;
k -= cnt[j];
}
for ((i) = 0; (i) < (26); (i)++)
if (!deleted[i] && cnt[i] > 0) m++;
cout << m << endl;
for ((i) = 0; (i) < (n); (i)++)
if (!deleted[s[i] - 'a']) cout << s[i];
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int func(char c) {
if (c <= '9') return c - '0';
switch (c) {
case 'T':
return 10;
case 'J':
return 11;
case 'Q':
return 12;
case 'K':
return 13;
case 'A':
return 14;
}
}
int main() {
char c;
char s[3], t[3];
scanf("%c%s%s", &c, s, t);
getchar();
if (s[1] == c && t[1] != c)
printf("YES\n");
else if (s[1] != c && t[1] == c)
printf("NO\n");
else {
if (func(s[0]) > func(t[0]) && s[1] == t[1])
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline int read() {
int x = 0;
int f = 0;
char ch = 0;
while (!isdigit(ch)) {
f |= (ch == '-') ? 1 : 0;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return f ? -x : x;
}
const int maxn = 2e5 + 10;
int n, aa[maxn];
long long sum[maxn];
map<long long, int> mp;
int nxt[maxn];
int main() {
n = read();
for (register int i = 1; i <= n; ++i) aa[i] = read();
sum[0] = 0;
for (register int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + aa[i];
for (register int i = n; i >= 0; --i) {
nxt[i] = mp[sum[i]];
mp[sum[i]] = i;
}
int ans = 0;
int mx = 1e9;
for (register int i = 0; i <= n; ++i) {
if (mx == i) {
++ans;
if (nxt[i - 1])
mx = nxt[i - 1];
else
mx = 1e9;
}
if (nxt[i]) mx = min(mx, nxt[i]);
}
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 987654321;
const long long int INF = 123456789987654321;
int N;
vector<int> arr, chk, chk2;
bool f(int l, int r) {
for (int i = 0; i < min(l, N - r - 1); i++) {
if (arr[i] != arr[N - i - 1]) return false;
}
chk = vector<int>(N, 0);
for (int i = min(l, N - r - 1); i <= max(r, N - l - 1); i++) {
chk[arr[i]]++;
}
chk2 = vector<int>(N, 0);
int len = max(r, N - l - 1) - min(l, N - r - 1) + 1;
if (len < 2 * (r - l + 1)) {
for (int i = min(l, N - r - 1); i <= max(r, N - l - 1); i++) {
if (i < l || r < i) {
chk2[arr[i]]++;
if (chk2[arr[i]] > chk[arr[i]] / 2) return false;
}
}
} else {
for (int i = min(l, N - r - 1); i < min(l, N - r - 1) + (r - l + 1); i++) {
chk2[arr[i]]++;
}
for (int i = min(l, N - r - 1); i < min(l, N - r - 1) + (r - l + 1); i++) {
chk2[arr[N - 1 - i]]--;
}
for (int i = 0; i < N; i++) {
if (chk2[i]) return false;
}
for (int i = min(l, N - r - 1) + (r - l + 1);
i <= max(r, N - l - 1) - (r - l + 1); i++) {
if (arr[i] != arr[N - 1 - i]) return false;
}
}
return true;
}
long long int ans = 0;
int main() {
scanf("%d", &N);
arr.resize(N);
chk = vector<int>(N, 0);
for (int i = 0; i < N; i++) {
scanf("%d", &arr[i]);
chk[--arr[i]]++;
}
if (N == 1) {
printf("1");
return 0;
}
int oddcnt = 0;
for (int i = 0; i < N; i++) {
if (chk[i] % 2) oddcnt++;
}
if (oddcnt > 1) {
printf("0");
return 0;
}
int s = 0, e = N - 1;
int idx;
while (s <= e) {
int m = (s + e) >> 1;
if (f(0, m)) {
idx = m;
e = m - 1;
} else
s = m + 1;
}
s = 0, e = N - 1;
int idx2;
while (s <= e) {
int m = (s + e) >> 1;
if (f(m, N - 1)) {
idx2 = m;
s = m + 1;
} else
e = m - 1;
}
int len = 0;
for (int i = 0; i < N / 2; i++) {
if (arr[i] != arr[N - 1 - i]) break;
len++;
}
if (len == N / 2) {
printf("%I64d", (long long int)N * (N + 1) / 2);
return 0;
}
long long int ans = len * len;
if (idx < N - len) ans += (len + 1) * (N - len - idx);
if (len <= idx2) ans += (len + 1) * (idx2 - len + 1);
if (idx < N - len && len <= idx2) ans--;
printf("%I64d", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, N;
vector<int> chore;
while (cin >> n >> a >> b) {
for (int i = 0; i < n; i++) {
cin >> N;
chore.push_back(N);
}
if (a + b != n) cout << 0 << '\n';
sort(chore.begin(), chore.end());
int result;
int x = chore[b - 1];
result = chore[b] - x;
cout << result << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long fun(int n) {
long long ans = 1;
ans = (n * (n - 1)) / 2;
return ans;
}
int main() {
int n;
cin >> n;
char ch;
int row[n];
int col[n];
for (int i = 0; i < n; i++) {
row[i] = 0;
col[i] = 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
cin >> ch;
if (ch == 'C') {
row[i]++;
col[j]++;
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
if (row[i] >= 2) ans = ans + fun(row[i]);
if (col[i] >= 2) ans = ans + fun(col[i]);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
const int mod = 998244353, MAX = 200005, INF = 1 << 30;
const double eps = 1e-8;
const double pi = acos((double)-1.0L);
double torad(int deg) { return (double)(deg)*pi / 180.0; }
double todeg(double ang) { return ang * 180.0 / pi; }
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(a * x, a * y); }
Point operator/(double a) { return Point(x / a, y / a); }
double abs() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const {
return x + eps < p.x || ((fabs((x) - (p.x)) < eps) && y + eps < p.y);
}
bool operator==(const Point &p) const {
return fabs(x - p.x) < eps / 100000 && fabs(y - p.y) < eps / 100000;
}
};
double norm(Point a) { return a.x * a.x + a.y * a.y; }
double abs(Point a) { return sqrt(norm(a)); }
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
struct Segment {
Point p1, p2;
};
bool isOrthogonal(Point a, Point b) {
return (fabs((dot(a, b)) - (0.0)) < eps);
}
bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
return isOrthogonal(a1 - a2, b1 - b2);
}
bool isOrthogonal(Segment s1, Segment s2) {
return (fabs((dot(s1.p2 - s1.p1, s2.p2 - s2.p1)) - (0.0)) < eps);
}
bool isParallel(Point a, Point b) {
return (fabs((cross(a, b)) - (0.0)) < eps);
}
bool isParallel(Point a1, Point a2, Point b1, Point b2) {
return isParallel(a1 - a2, b1 - b2);
}
bool isParallel(Segment s1, Segment s2) {
return (fabs((cross(s1.p2 - s1.p1, s2.p2 - s2.p1)) - (0.0)) < eps);
}
Point project(Segment s, Point p) {
Point base = s.p2 - s.p1;
double r = dot(p - s.p1, base) / norm(base);
return s.p1 + base * r;
}
Point reflect(Segment s, Point p) { return p + (project(s, p) - p) * 2.0; }
Point turn(Point p, Point c, double pi) {
double q = atan2(p.y - c.y, p.x - c.x);
q += pi;
p = c + Point{cos(q) * abs(p - c), sin(q) * abs(p - c)};
return p;
}
static const int counter_clockwise = 1;
static const int clockwise = -1;
static const int online_back = 2;
static const int online_front = -2;
static const int on_segment = 0;
int ccw(Point p0, Point p1, Point p2) {
Point a = p1 - p0;
Point b = p2 - p0;
if (cross(a, b) > eps) return counter_clockwise;
if (cross(a, b) < -eps) return clockwise;
if (dot(a, b) < -eps) return online_back;
if (a.norm() < b.norm()) return online_front;
return on_segment;
}
bool intersect(Point p1, Point p2, Point p3, Point p4) {
return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}
bool intersect(Segment s1, Segment s2) {
return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
bool overlap(Segment s1, Segment s2) {
int a = ccw(s1.p1, s1.p2, s2.p1), b = ccw(s1.p1, s1.p2, s2.p2);
if (a & 1 || b & 1) return 0;
if (a == 2) {
if (b == -2 || (b == 0 && !(s2.p2 == s1.p1)))
return 1;
else
return 0;
}
if (a == -2) {
if (b == 2 || (b == 0 && !(s2.p2 == s1.p2)))
return 1;
else
return 0;
}
if (a == 0) {
if (s1.p1 == s2.p1) {
if (b != 2)
return 1;
else
return 0;
} else if (s1.p2 == s2.p1) {
if (b != -2)
return 1;
else
return 0;
} else
return 1;
}
return 0;
}
double getDistance(Point a, Point b) { return abs(a - b); }
double getDistanceLP(Segment l, Point p) {
return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}
double getDistanceSP(Segment s, Point p) {
if (dot(s.p2 - s.p1, p - s.p1) < 0.0) return abs(p - s.p1);
if (dot(s.p1 - s.p2, p - s.p2) < 0.0) return abs(p - s.p2);
return getDistanceLP(s, p);
}
double getDistance(Segment s1, Segment s2) {
if (intersect(s1, s2)) return 0.0;
return min({getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2),
getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)});
}
Point getCrossPointS(Segment s1, Segment s2) {
Point base = s2.p2 - s2.p1;
double d1 = abs(cross(base, s1.p1 - s2.p1));
double d2 = abs(cross(base, s1.p2 - s2.p1));
double t = d1 / (d1 + d2);
return s1.p1 + (s1.p2 - s1.p1) * t;
}
Point getCrossPointL(Segment l1, Segment l2) {
Point v1 = l1.p2 - l1.p1, v2 = l2.p2 - l2.p1;
return l1.p1 + v1 * cross(v2, l2.p1 - l1.p1) / cross(v2, v1);
}
Segment ParallelSegment(Segment s, double d) {
Point v = {-(s.p2 - s.p1).y, (s.p2 - s.p1).x};
v = v / abs(v);
s.p1 = s.p1 + v * d;
s.p2 = s.p2 + v * d;
return s;
}
Point naisin(Point p1, Point p2, Point p3) {
if (p1 == p2 && p2 == p3 && p3 == p1) return p1;
return (p1 * abs(p2 - p3) + p2 * abs(p1 - p3) + p3 * abs(p1 - p2)) /
(abs(p2 - p3) + abs(p1 - p3) + abs(p1 - p2));
}
Point naisin(Segment l1, Segment l2, Segment l3) {
Point p1 = getCrossPointL(l1, l2), p2 = getCrossPointL(l1, l3),
p3 = getCrossPointL(l2, l3);
return naisin(p1, p2, p3);
}
class Circle {
public:
Point c;
double r;
Circle(Point c = Point(), double r = 0.0) : c(c), r(r) {}
};
Point CircleCenter(Point a, Point b, Point c) {
Point u = a - b, v = a - c;
double m1 = (norm(a) - norm(b)) / 2.0, m2 = (norm(a) - norm(c)) / 2.0;
Point res;
if (cross(u, v) == 0.0) {
res.x = 1e9;
res.y = 1e9;
return res;
}
res.x = (m1 * v.y - m2 * u.y) / cross(u, v);
res.y = (m1 * v.x - m2 * u.x) / cross(v, u);
return res;
}
int intersect(Circle c1, Circle c2) {
double d = getDistance(c1.c, c2.c);
double r1 = c1.r, r2 = c2.r;
if (r1 < r2) {
if (d < (r2 - r1)) return 0;
}
if (r1 > r2) {
if (d < (r1 - r2)) return 1;
}
if (d <= r1 + r2)
return 2;
else
return 3;
}
pair<Point, Point> segCrossPpoints(Circle c, Segment l) {
Point pr = project(l, c.c);
Point e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
double base = sqrt(c.r * c.r - norm(pr - c.c));
return make_pair(pr + e * base, pr - e * base);
}
double arg(Point p) { return atan2(p.y, p.x); }
Point polar(double a, double r) { return Point(cos(r) * a, sin(r) * a); }
pair<Point, Point> getCrossPoints(Circle c1, Circle c2) {
double d = abs(c1.c - c2.c);
double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
double t = arg(c2.c - c1.c);
return make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a));
}
vector<Segment> Commontangent(Circle c1, Circle c2) {
vector<Segment> res;
Point p = c2.c - c1.c;
if (abs(p) >= (c1.r + c2.r)) {
Point a, b;
a.x = c1.r *
(p.x * (c1.r + c2.r) +
p.y * sqrt(norm(p) - (c1.r + c2.r) * (c1.r + c2.r))) /
norm(p);
a.y = c1.r *
(p.y * (c1.r + c2.r) -
p.x * sqrt(norm(p) - (c1.r + c2.r) * (c1.r + c2.r))) /
norm(p);
b.x = c1.r *
(p.x * (c1.r + c2.r) -
p.y * sqrt(norm(p) - (c1.r + c2.r) * (c1.r + c2.r))) /
norm(p);
b.y = c1.r *
(p.y * (c1.r + c2.r) +
p.x * sqrt(norm(p) - (c1.r + c2.r) * (c1.r + c2.r))) /
norm(p);
res.push_back(Segment{a + c1.c, a + c1.c + Point{-a.y, a.x}});
if (!(a == b)) {
res.push_back(Segment{b + c1.c, b + c1.c + Point{-b.y, b.x}});
}
}
if (abs(p) >= abs(c1.r - c2.r)) {
Point a, b;
a.x = c1.r *
(p.x * (c1.r - c2.r) +
p.y * sqrt(norm(p) - (c1.r - c2.r) * (c1.r - c2.r))) /
norm(p);
a.y = c1.r *
(p.y * (c1.r - c2.r) -
p.x * sqrt(norm(p) - (c1.r - c2.r) * (c1.r - c2.r))) /
norm(p);
b.x = c1.r *
(p.x * (c1.r - c2.r) -
p.y * sqrt(norm(p) - (c1.r - c2.r) * (c1.r - c2.r))) /
norm(p);
b.y = c1.r *
(p.y * (c1.r - c2.r) +
p.x * sqrt(norm(p) - (c1.r - c2.r) * (c1.r - c2.r))) /
norm(p);
res.push_back(Segment{a + c1.c, a + c1.c + Point{-a.y, a.x}});
if (!(a == b)) {
res.push_back(Segment{b + c1.c, b + c1.c + Point{-b.y, b.x}});
}
}
return res;
}
int contains(vector<Point> g, Point p) {
int n = int(g.size());
bool x = false;
for (int i = 0; i < n; i++) {
Point a = g[i] - p, b = g[(i + 1) % n] - p;
if (a.y > b.y) swap(a, b);
if (a.y < eps && 0 < b.y && cross(a, b) < 0) x = !x;
if (abs(cross(a, b)) < eps && dot(a, b) < eps) return 1;
}
return (x ? 2 : 0);
}
vector<Point> andrewScan(vector<Point> s, bool ok) {
vector<Point> u, l;
sort((s).begin(), (s).end());
if (int(s.size()) < 3) return s;
int n = int(s.size());
u.push_back(s[0]);
u.push_back(s[1]);
l.push_back(s[n - 1]);
l.push_back(s[n - 2]);
if (ok) {
for (int i = 2; i < n; i++) {
for (int j = int(u.size());
j >= 2 && ccw(u[j - 2], u[j - 1], s[i]) == counter_clockwise; j--) {
u.pop_back();
}
u.push_back(s[i]);
}
for (int i = int(s.size()) - 3; i >= 0; i--) {
for (int j = int(l.size());
j >= 2 && ccw(l[j - 2], l[j - 1], s[i]) == counter_clockwise; j--) {
l.pop_back();
}
l.push_back(s[i]);
}
}
if (!ok) {
for (int i = 2; i < n; i++) {
for (int j = int(u.size());
j >= 2 && ccw(u[j - 2], u[j - 1], s[i]) != clockwise; j--) {
u.pop_back();
}
u.push_back(s[i]);
}
for (int i = int(s.size()) - 3; i >= 0; i--) {
for (int j = int(l.size());
j >= 2 && ccw(l[j - 2], l[j - 1], s[i]) != clockwise; j--) {
l.pop_back();
}
l.push_back(s[i]);
}
}
reverse((l).begin(), (l).end());
for (int i = int(u.size()) - 2; i >= 1; i--) l.push_back(u[i]);
return l;
}
vector<Point> convex_cut(const vector<Point> &P, const Segment &l) {
vector<Point> Q;
for (int i = 0; i < int(P.size()); i++) {
Point A = P[i], B = P[(i + 1) % int(P.size())];
if (ccw(l.p1, l.p2, A) != -1) Q.push_back(A);
if (ccw(l.p1, l.p2, A) * ccw(l.p1, l.p2, B) < 0)
Q.push_back(getCrossPointL(Segment{A, B}, l));
}
return Q;
}
double area(Point a, Point b, Point c) {
b = b - a;
c = c - a;
return abs(b.x * c.y - b.y * c.x) / 2.0;
}
double area(vector<Point> &P) {
if (int(P.size()) == 0) return 0.0;
double res = 0;
Point c = {0.0, 0.0};
for (int i = 0; i < int(P.size()); i++) {
c = c + P[i];
}
c = c / int(P.size());
for (int i = 0; i < int(P.size()); i++) {
res += area(c, P[i], P[(i + 1) % int(P.size())]);
}
return res;
}
struct UF {
int n;
vector<int> par, size;
void init(int n_) {
n = n_;
par.assign(n, -1);
size.assign(n, 1);
for (int i = 0; i < n; i++) {
par[i] = i;
}
}
int root(int a) {
if (par[a] == a)
return a;
else
return par[a] = root(par[a]);
}
void unite(int a, int b) {
if (root(a) != root(b)) {
size[root(a)] += size[root(b)];
par[root(b)] = root(a);
}
}
bool check(int a, int b) { return root(a) == root(b); }
};
int main() {
std::ifstream in("text.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<Circle> C(N);
for (int i = 0; i < N; i++) cin >> C[i].c.x >> C[i].c.y >> C[i].r;
int v = 0, e = 0, c = 0;
vector<Point> SE;
UF uf;
uf.init(N);
for (int i = 0; i < N; i++) {
vector<Point> X;
for (int j = 0; j < N; j++) {
if (i == j) continue;
if (intersect(C[i], C[j]) == 2) {
uf.unite(i, j);
auto p = getCrossPoints(C[i], C[j]);
X.push_back(p.first);
X.push_back(p.second);
}
}
sort((X).begin(), (X).end());
X.erase(unique((X).begin(), (X).end()), X.end());
for (auto p : X) SE.push_back(p);
e += int(X.size());
}
sort((SE).begin(), (SE).end());
SE.erase(unique((SE).begin(), (SE).end()), SE.end());
v += int(SE.size());
for (int i = 0; i < N; i++)
if (uf.root(i) == i) c++;
cout << e - v + c + 1 << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> h[400010];
long long p[400010], num[400010];
long long t, n, k, len, tt;
inline long long rd() {
long long x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x;
}
inline void print(long long x) {
static char s[233];
if (!x) {
putchar('0');
putchar('\n');
return;
}
int tot = 0;
for (; x; x /= 10) s[++tot] = x % 10 + '0';
for (; tot; tot--) putchar(s[tot]);
putchar('\n');
}
inline void work() {
len = rd();
n = rd();
k = rd();
for (int i = 1; i <= n; i++) p[i] = rd();
for (int i = 1; i <= n; i++) num[i] = p[i] - p[i - 1];
num[n + 1] = len - p[n];
n++;
long long l = 1, r = 1000000000000000LL;
while (l < r) {
long long mid = ((l + r) >> 1) + 1, sum = 0;
for (int i = 1; i <= n; i++) sum += num[i] / mid - 1;
if (sum >= k)
l = mid;
else
r = mid - 1;
}
long long L = l;
l = 1, r = 1000000000000000LL;
while (l < r) {
long long mid = (l + r) >> 1, sum = 0;
for (int i = 1; i <= n; i++) sum += (num[i] + mid - 1) / mid - 1;
if (sum <= k)
r = mid;
else
l = mid + 1;
}
long long R = l;
tt = 0;
for (int i = 1; i <= n; i++) {
long long h1 = (num[i] + R - 1) / R, h2 = num[i] / L;
if (h1 <= h2) continue;
h[++tt] = pair<long long, long long>(
num[i] / h1, (h2) ? (num[i] + h2 - 1) / h2
: 1000000000000000LL + 1000000000000000LL);
}
sort(h + 1, h + tt + 1);
long long ans = len + 1, mx = R;
for (int i = 1; i <= tt; i++) {
ans = min(ans, mx - h[i].first);
mx = max(mx, h[i].second);
}
ans = min(ans, mx - L);
print(ans);
}
int main() {
t = rd();
while (t--) work();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int ar[n][m];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &ar[i][j]);
}
}
int max = 0;
for (int i = 0; i < n; ++i) {
int min = INT_MAX;
for (int j = 0; j < m; ++j) {
if (min > ar[i][j]) {
min = ar[i][j];
}
}
if (max < min) {
max = min;
}
}
printf("%d", max);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int oo = int(2e9) + 9;
const double eps = 1e-9;
const double pi = 3.14159265358979323846264338327950;
int main() {
int n;
scanf("%d", &n);
char str[15];
scanf("%s", str);
char names[][15] = {"vaporeon", "jolteon", "flareon", "espeon",
"umbreon", "leafeon", "glaceon", "sylveon"};
for (int i = 0; i < 8; i++) {
bool f = true;
for (int j = 0; j < strlen(str); j++)
if (str[j] != names[i][j] && str[j] != '.') {
f = false;
break;
}
if (f && strlen(names[i]) == strlen(str)) {
printf("%s\n", names[i]);
return 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000001;
const double EPS = 10e-9;
bool czy_pierwsza(int n) {
if (n <= 4) return true;
for (int i = 2; i * i <= n; ++i)
if ((n % i) == 0) return false;
return true;
}
int n;
long long inv(long long a) {
long long inv = 1;
int m = n - 2;
while (m) {
if (m & 1) {
inv *= a;
inv %= n;
}
m /= 2;
a *= a;
a %= n;
}
return inv;
}
int main() {
cin >> n;
if (czy_pierwsza(n)) {
cout << "YES\n";
if (n == 1) {
cout << 1;
return 0;
}
if (n == 4) {
cout << 1 << " " << 3 << " " << 2 << " " << 4;
return 0;
}
cout << 1 << " ";
for (int i = 2; i <= (n - 1); ++i)
cout << (i * inv(i - ((long long)1))) % n << " ";
cout << n;
} else {
cout << "NO";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
template <class T>
inline void read(T &res) {
res = 0; bool bo = 0; char c;
while (((c = getchar()) < '0' || c > '9') && c != '-');
if (c == '-') bo = 1; else res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
template <class T>
inline T Max(const T &a, const T &b) {return a > b ? a : b;}
const int N = 1e5 + 5;
int n, p[N], lex[N], rix[N], ley[N], riy[N], dx[N], maxd, pos;
int main() {
read(n);
for (int i = 1; i <= n; i++) read(p[i]);
for (int i = 1; i <= n; i++) {
lex[i] = i == 1 || p[i - 1] > p[i] ? 0 : 1 + lex[i - 1];
ley[i] = i == 1 || p[i - 1] < p[i] ? 0 : 1 + ley[i - 1];
}
for (int i = n; i >= 1; i--) {
rix[i] = i == n || p[i + 1] > p[i] ? 0 : 1 + rix[i + 1];
riy[i] = i == n || p[i + 1] < p[i] ? 0 : 1 + riy[i + 1];
}
for (int i = 1; i <= n; i++) dx[i] = Max(lex[i], rix[i]),
maxd = Max(maxd, dx[i]);
int cnt = 0;
for (int i = 1; i <= n; i++) if (dx[i] == maxd) cnt++, pos = i;
if (cnt > 1) return puts("0"), 0;
return printf("%d\n", lex[pos] == rix[pos] ? !(maxd & 1) : 0), 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
cout << (n - 1) / 2;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[109][2];
int n, d, k;
int bt(int val, bool good) {
if (val == n && good) {
return 1;
}
if (val >= n) return 0;
if (dp[val][good] != -1) return dp[val][good];
int ret = 0;
for (int f = 1; f <= k; f++)
if (f >= d)
ret = (ret + bt(val + f, 1)) % 1000000007;
else
ret = (ret + bt(val + f, good)) % 1000000007;
return dp[val][good] = ret;
}
int main() {
cin >> n >> k >> d;
memset(dp, -1, sizeof(dp));
cout << bt(0, 0) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 7;
const int MN = 2e5 + 7;
const int MMASK = (1 << 7);
pair<int, int> a[MN];
int s[MN][8], n, p, k;
long long dp[MN][MMASK];
signed main() {
ios::sync_with_stdio(false);
cin.tie();
cin >> n >> p >> k;
for (int i = 0; i < n; i++) cin >> a[i].first, a[i].second = i;
for (int i = 0; i < n; i++) {
for (int j = 0; j < p; j++) {
cin >> s[i][j];
}
}
sort(a, a + n);
for (int i = 0; i < n / 2; i++) swap(a[i], a[n - i - 1]);
for (int i = 0; i < n; i++) {
for (int mask = 0; mask < (1 << p); mask++) {
dp[i][mask] = 0;
if (__builtin_popcount(mask) > i + 1) {
dp[i][mask] = -INF;
continue;
}
if (i) {
dp[i][mask] = dp[i - 1][mask];
if (i - __builtin_popcount(mask) < k && __builtin_popcount(mask) <= i)
dp[i][mask] += a[i].first;
} else {
if (i - __builtin_popcount(mask) < k && __builtin_popcount(mask) <= i)
dp[i][mask] += a[i].first;
}
for (int po = 0; po < p; po++) {
if ((mask >> po) & 1) {
dp[i][mask] = max(dp[i][mask],
dp[i - 1][mask ^ (1 << po)] + s[a[i].second][po]);
}
}
}
}
cout << dp[n - 1][(1 << p) - 1];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dp[2][100005], ans[2][100005];
char s[100005];
int val[100005], cost[100005];
int main() {
int n;
int m;
scanf("%d%s%d", &n, s + 1, &m);
for (int i = 1; i <= n; i++) {
if (s[i] != 'b') {
dp[0][i] = dp[1][i - 1] + 1;
ans[0][i] = ans[1][i - 1] + (s[i] == '?');
while (dp[0][i] > m) {
dp[0][i]--;
if (s[i - dp[0][i]] == '?') ans[0][i]--;
}
}
if (s[i] != 'a') {
dp[1][i] = dp[0][i - 1] + 1;
ans[1][i] = ans[0][i - 1] + (s[i] == '?');
while (dp[1][i] > m) {
dp[1][i]--;
if (s[i - dp[1][i]] == '?') ans[1][i]--;
}
}
}
for (int i = 1; i <= n; i++) {
val[i] = val[i - 1];
cost[i] = cost[i - 1];
if (dp[!(m % 2)][i] == m) {
if (val[i - m] + 1 >= val[i]) {
if (val[i - m] + 1 > val[i]) {
val[i] = val[i - m] + 1;
cost[i] = cost[i - m] + ans[!(m % 2)][i];
}
if (cost[i - m] + ans[!(m % 2)][i] < cost[i])
cost[i] = cost[i - m] + ans[!(m % 2)][i];
}
}
}
printf("%d\n", cost[n]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using cd = complex<double>;
const double PI = acos(-1);
void fft(vector<cd>& a, bool invert) {
int n = a.size();
if (n == 1) return;
vector<cd> a0(n / 2), a1(n / 2);
for (int i = 0; 2 * i < n; i++) {
a0[i] = a[2 * i];
a1[i] = a[2 * i + 1];
}
fft(a0, invert);
fft(a1, invert);
double ang = 2 * PI / n * (invert ? -1 : 1);
cd w(1), wn(cos(ang), sin(ang));
for (int i = 0; 2 * i < n; i++) {
a[i] = a0[i] + w * a1[i];
a[i + n / 2] = a0[i] - w * a1[i];
if (invert) {
a[i] /= 2;
a[i + n / 2] /= 2;
}
w *= wn;
}
}
vector<int> multiply(vector<int> const& a, vector<int> const& b) {
vector<cd> fa(a.begin(), a.end()), fb(b.begin(), b.end());
int n = 1;
while (n < a.size() + b.size()) n <<= 1;
fa.resize(n);
fb.resize(n);
fft(fa, false);
fft(fb, false);
for (int i = 0; i < n; i++) fa[i] *= fb[i];
fft(fa, true);
vector<int> result(n);
for (int i = 0; i < n; i++) result[i] = round(fa[i].real());
return result;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool pali(string s) {
long long l = s.length();
for (int i = 0; i < l / 2; i++) {
if (s[i] != s[l - i - 1]) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n;
long long* a = new long long[n];
long long* m = new long long[n + 1];
for (int i = 0; i < n; i++) {
cin >> a[i];
m[a[i]] = i;
}
long long* dp = new long long[n]();
long long s = 1;
bool ans = true;
while (s <= n) {
long long id = m[s];
if (dp[id] != 0) {
ans = false;
break;
}
while (id < n && dp[id] == 0) {
dp[id] = s;
s++;
id++;
}
}
for (int i = 0; i < n; i++) {
if (dp[i] != a[i]) ans = false;
}
if (ans)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, st, en, tmp, maxh, maxw;
int a[200];
vector<pair<int, int> > ans;
pair<int, int> Q[200];
bool used[200];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
bool check() {
for (int i = 1; i <= n; i++)
if (!used[i]) return false;
return true;
}
int main() {
n = read();
used[1] = 1;
for (int i = 1; i <= n; i++) a[i] = read();
st = en = 1;
Q[1] = (pair<int, int>){1, a[1]};
while (st <= en && Q[st].second == 0) st++;
while (st <= en) {
if (check()) break;
tmp = Q[st].first;
maxh = -1;
for (int i = 1; i <= n; i++)
if (!used[i] && a[i] > maxh) {
maxh = a[i];
maxw = i;
}
used[maxw] = 1;
Q[++en] = (pair<int, int>){maxw, maxh};
ans.push_back((pair<int, int>){tmp, maxw});
Q[st].second--;
while (st <= en && Q[st].second == 0) st++;
}
if (check()) {
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%d %d\n", ans[i].first, ans[i].second);
} else
puts("-1");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long int power(long long int a, long long int b) {
long long int x = 1;
while (b) {
if (b & 1) x *= a;
a *= a;
b >>= 1;
}
return x;
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long int N = 200005;
long long int n, k, d;
long long int mod = 1e9 + 7;
long long int dp[107][2];
long long int help(long long int sum, bool flag) {
if (sum == n && flag == true) return 1;
if (sum == n && flag == false) return 0;
if (sum > n) return 0;
if (dp[sum][flag] != -1) return dp[sum][flag];
long long int total = 0;
for (long long int i = 1; i < k + 1; i++) {
if (i >= d)
total += help(sum + i, flag | true);
else
total += help(sum + i, flag | false);
}
total = total % mod;
return dp[sum][flag] = total;
}
void solve() {
cin >> n >> k >> d;
memset(dp, -1, sizeof(dp));
cout << help(0, false) << "\n";
return;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
clock_t z = clock();
long long int t = 1;
while (t--) {
solve();
}
cerr << "Total Time : " << ((double)(clock() - z) / CLOCKS_PER_SEC);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, d;
scanf("%d %d", &m, &n);
if (m < n)
d = m;
else
d = n;
if (d % 2 == 0)
printf("Malvika");
else
printf("Akshat");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
template <class T>
using PR = pair<T, T>;
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
constexpr int setbits(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 32 - __builtin_clz(x); }
str binary(int x) { return bitset<32>(x).to_string(); }
char upper(char x) { return toupper(x); }
char lower(char x) { return tolower(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class U>
T fstTrue(T lo, T hi, U first) {
hi++;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo) / 2;
first(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U first) {
lo--;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo + 1) / 2;
first(mid) ? lo = mid : hi = mid - 1;
}
return lo;
}
template <class T>
void remDup(vector<T>& v) {
sort(begin(v), end(v));
v.erase(unique(begin(v), end(v)), end(v));
}
template <class T, class U>
void erase(T& t, const U& u) {
auto it = t.find(u);
assert(it != end(t));
t.erase(u);
}
template <class T>
void re(complex<T>& c);
template <class T, class U>
void re(pair<T, U>& p);
template <class T>
void re(vector<T>& v);
template <class T, size_t SZ>
void re(AR<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(db& d) {
str t;
re(t);
d = stod(t);
}
void re(ld& d) {
str t;
re(t);
d = stold(t);
}
template <class T, class... U>
void re(T& t, U&... u) {
re(t);
re(u...);
}
template <class T>
void re(complex<T>& c) {
T a, b;
re(a, b);
c = {a, b};
}
template <class T, class U>
void re(pair<T, U>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& x) {
for (auto& a : x) re(a);
}
template <class T, size_t SZ>
void re(AR<T, SZ>& x) {
for (auto& a : x) re(a);
}
template <class T>
void rv(int& n, vector<T>& x) {
re(n);
x.resize(n);
for (auto& a : x) re(a);
}
str to_string(char c) { return str(1, c); }
str to_string(const char* second) { return (str)second; }
str to_string(str second) { return second; }
str to_string(bool b) { return to_string((int)b); }
template <class T>
str to_string(complex<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
str to_string(vector<bool> v) {
str res = "{";
for (int i = 0; i < (int)(v).size(); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
str to_string(bitset<SZ> b) {
str res = "";
for (int i = 0; i < SZ; ++i) res += char('0' + b[i]);
return res;
}
template <class T, class U>
str to_string(pair<T, U> p);
template <class T>
str to_string(T v) {
bool fst = 1;
str res = "";
for (const auto& x : v) {
if (!fst) res += " ";
fst = 0;
res += to_string(x);
}
return res;
}
template <class T, class U>
str to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
template <class T>
void pr(T x) {
cout << to_string(x);
}
template <class T, class... U>
void pr(const T& t, const U&... u) {
pr(t);
pr(u...);
}
void ps() { pr("\n"); }
template <class T, class... U>
void ps(const T& t, const U&... u) {
pr(t);
if (sizeof...(u)) pr(" ");
ps(u...);
}
void DBG() { cerr << "]" << endl; }
template <class T, class... U>
void DBG(const T& t, const U&... u) {
cerr << to_string(t);
if (sizeof...(u)) cerr << ", ";
DBG(u...);
}
void setIn(str second) { freopen(second.c_str(), "r", stdin); }
void setOut(str second) { freopen(second.c_str(), "w", stdout); }
void unsyncIO() { cin.tie(0)->sync_with_stdio(0); }
void setIO(str second = "") {
unsyncIO();
if ((int)(second).size()) {
setIn(second + ".in"), setOut(second + ".out");
}
}
const int MOD = 1e9 + 7;
const ll INF = 1e18;
const ld PI = acos((ld)-1);
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const int nax = INT_MAX;
const int nim = INT_MIN;
void solve() {
int n;
str second;
re(n, second);
int incr = 1;
str ans = "";
for (int i = 0; i < n;) {
ans += to_string(second[i]);
incr++;
i += incr;
}
ps(ans);
}
int main() {
setIO();
int TC = 1;
while (TC--) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef struct Position {
long double x;
long double y;
} pos;
void tri(long double x, long double y, long double& cos, long double& sin) {
long double c = sqrt(x * x + y * y);
cos = x / c;
sin = y / c;
}
int main() {
pos p, v;
long double a, b, c, d;
long double cos, sin;
pos points[7];
cin >> p.x >> p.y >> v.x >> v.y >> a >> b >> c >> d;
tri(-v.y, v.x, cos, sin);
points[1].x = p.x + (a / 2) * cos;
points[1].y = p.y + (a / 2) * sin;
points[6].x = p.x - (a / 2) * cos;
points[6].y = p.y - (a / 2) * sin;
points[2].x = p.x + (c / 2) * cos;
points[2].y = p.y + (c / 2) * sin;
points[5].x = p.x - (c / 2) * cos;
points[5].y = p.y - (c / 2) * sin;
tri(v.x, v.y, cos, sin);
points[0].x = p.x + b * cos;
points[0].y = p.y + b * sin;
points[3].x = points[2].x - d * cos;
points[3].y = points[2].y - d * sin;
points[4].x = points[5].x - d * cos;
points[4].y = points[5].y - d * sin;
for (int i = 0; i < 7; i++) {
cout << setprecision(15) << fixed << points[i].x << " " << points[i].y
<< endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char s[100010];
int main() {
scanf("%d%d%d", &n, &m, &k);
bitset<22500> a, b, e, c;
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++)
(s[j] == '#' ? b : a).set(i * m + j),
(s[j] == 'E' ? e.set(i * m + j) : 0);
}
scanf("%s", s);
c = a;
for (int i = 0; i < k; i++) {
if (c == e) {
printf("%d\n", i);
return 0;
}
if (s[i] == 'U')
c = ((c >> m) & a) | (c & (b << m));
else if (s[i] == 'L')
c = ((c >> 1) & a) | (c & (b << 1));
else if (s[i] == 'D')
c = ((c << m) & a) | (c & (b >> m));
else if (s[i] == 'R')
c = ((c << 1) & a) | (c & (b >> 1));
}
printf("%d\n", c == e ? k : -1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int k, i, raodl[300005], raodr[300005], mx[300005], ans;
string s, t;
int main() {
cin >> s >> t;
i = -1;
for (k = 0; k < s.size(); k++) {
int b = t.size() - 1;
if (s[k] == t[i + 1] && i < b) i++;
raodl[k] = i + 1;
}
i = t.size();
mx[0] = s.size();
for (k = s.size() - 1; k >= 0; k--) {
if (i >= 1 && s[k] == t[i - 1]) i--;
raodr[k] = s.size() - i;
mx[t.size() - i] = max(mx[t.size() - i], k);
}
for (k = 0; k < s.size(); k++) {
ans = max(mx[t.size() - raodl[k]] - k - 1, ans);
}
ans = max(ans, mx[t.size()]);
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
int main() {
std::string s;
std::cin >> s;
int n = s.size();
std::vector<std::vector<bool> > matrix(n, std::vector<bool>(n));
for (int i = 0; i < n; i++) {
matrix[i][i] = true;
}
for (int diff = 1; diff < n; diff++) {
for (int i = 0; i + diff < n; i++) {
int j = diff + i;
if (diff == 1) {
matrix[i][j] = (s[i] == s[j]);
} else {
matrix[i][j] = matrix[i + 1][j - 1] && (s[i] == s[j]);
}
}
}
std::vector<long long> counts(n);
counts[0] = 1;
for (int i = 1; i < n; i++) {
counts[i] = counts[i - 1];
for (int j = 0; j < n; j++) {
if (matrix[j][i]) {
counts[i]++;
}
}
}
std::vector<long long> answer(n);
for (int j = 0; j < n; j++) {
for (int i = 1; i < n; i++) {
if (matrix[i][j]) {
answer[j] += counts[i - 1];
}
}
if (j > 0) {
answer[j] += answer[j - 1];
}
}
std::cout << answer[n - 1];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
long long k, p, n, m, root = 1, cnt, now = 1, last;
long long s[400010];
struct node {
long long pos, id, v;
} q[400010];
bool cmp(const node &a, const node &b) { return a.pos < b.pos; }
struct matrix {
long long a[3][3];
matrix() { memset(a, 0, sizeof(a)); }
} t[400010], a[400010], b[400010], ans;
matrix operator*(const matrix &a, const matrix &b) {
matrix c;
for (int i = 1; i <= 2; ++i)
for (int j = 1; j <= 2; ++j)
for (int l = 1; l <= 2; ++l)
c.a[i][j] = (c.a[i][j] + a.a[i][l] * b.a[l][j] % p) % p;
return c;
}
matrix qp(matrix x, long long y) {
matrix e;
for (int i = 1; i <= 2; ++i) e.a[i][i] = 1;
while (y) {
if (y & 1) e = e * x;
x = x * x, y >>= 1;
}
return e;
}
void build(int l, int r, int cur) {
if (l == r) {
t[cur] = a[l];
return;
}
build(l, ((l + r) >> 1), (cur << 1)),
build(((l + r) >> 1) + 1, r, (cur << 1 | 1));
t[cur] = t[(cur << 1)] * t[(cur << 1 | 1)];
}
void modify(int l, int r, int pos, matrix v, int cur) {
if (l == r) {
t[cur] = v;
return;
}
if (pos <= ((l + r) >> 1))
modify(l, ((l + r) >> 1), pos, v, (cur << 1));
else
modify(((l + r) >> 1) + 1, r, pos, v, (cur << 1 | 1));
t[cur] = t[(cur << 1)] * t[(cur << 1 | 1)];
}
int main() {
read(k), read(p), read(n), ans.a[1][2] = 1;
for (int i = 0; i < n; ++i) read(s[i]);
for (int i = 1; i <= n; ++i) {
a[i].a[1][2] = s[i - 1], a[i].a[2][1] = 1;
if (i == n)
a[i].a[2][2] = s[0];
else
a[i].a[2][2] = s[i];
b[i] = a[i];
}
read(m), build(1, n, root);
for (int i = 1; i <= m; ++i) {
long long pos, v;
read(pos), read(v), v %= p;
q[++cnt] = (node){pos, 2, v};
q[++cnt] = (node){pos + 1, 1, v};
}
sort(q + 1, q + cnt + 1, cmp);
while (cnt && q[cnt].pos > k) cnt--;
for (int i = 1; i <= cnt; i = ++now) {
long long num = (q[i].pos - 1) / n;
while (now < cnt && num == (q[now + 1].pos - 1) / n) now++;
ans = ans * qp(t[root], num - last), last = num;
for (int j = i; j <= now; ++j) {
long long pos = (q[j].pos - 1) % n + 1;
a[pos].a[q[j].id][2] = q[j].v;
modify(1, n, pos, a[pos], root);
}
if (num == k / n) break;
ans = ans * t[root], last++;
for (int j = i; j <= now; ++j) {
long long pos = (q[j].pos - 1) % n + 1;
modify(1, n, pos, a[pos] = b[pos], root);
}
}
ans = ans * qp(t[root], k / n - last);
for (int i = 1; i <= k % n; ++i) ans = ans * a[i];
printf("%lld", ans.a[1][1]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int nxt[411], inc[411];
bool vis[411];
int cr, n, i, j, k;
long long lm, len[411], gd, ans, x;
bool p[211][211];
void getcir(int st) {
int x;
if (inc[st]) return;
cr++;
x = st;
while (true) {
inc[x] = cr;
len[cr]++;
x = nxt[x];
if (inc[x]) break;
}
}
void work(int x) {
int tc;
tc = 0;
while (true) {
vis[x] = true;
x = nxt[x];
if (vis[x]) break;
}
getcir(x);
}
int getdis(int st) {
int x, ret;
x = st;
ret = 0;
while (true) {
if (inc[x]) break;
x = nxt[x];
ret++;
}
return ret;
}
long long gcd(long long a, long long b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
int main() {
scanf("%d", &n);
memset(p, false, sizeof(p));
for (i = 1; i <= n; i++) {
scanf("%d", &nxt[i]);
p[i][nxt[i]] = true;
}
for (k = 1; k <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (p[i][k] == true && p[k][j] == true) p[i][j] = true;
for (i = 1; i <= n; i++)
if (p[i][i] && !vis[i]) work(i);
lm = 1;
for (i = 1; i <= cr; i++) {
gd = gcd(lm, len[i]);
lm = lm * len[i] / gd;
}
for (i = 1; i <= n; i++) {
x = getdis(i);
if (x % lm == 0)
x /= lm;
else
x = x / lm + 1;
if (x == 0) x++;
ans = max(ans, x * lm);
}
printf("%lld\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cin >> m;
int b[m];
for (int i = 0; i < m; i++) {
cin >> b[i];
}
int ans = 0, x, y, maxdiv = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
y = a[i];
x = b[j];
if (!(x % y)) {
if (x / y == maxdiv) {
ans++;
}
if (x / y > maxdiv) {
ans = 1;
maxdiv = x / y;
}
}
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
const int mod = 1e9 + 7;
long long dp[maxn * 3][maxn * 3];
int n;
int main() {
scanf("%d", &n);
dp[1][1] = 1;
long long res = 0;
for (int i = 1; i <= 2 * n; i++) {
for (int j = 1; j <= 2 * n; j++) {
if (2 * j < i) continue;
if (j > n) continue;
dp[i][j] += dp[i - 1][j] % mod;
dp[i][j] += dp[i - 1][j - 1] % mod;
}
}
for (int i = 2 * n; i >= 1; i -= 2) {
for (int j = 1; j <= n; j++) res = (res + dp[i][j]) % mod;
for (int j = (i - 1) / 2 + 1; j < n; j++)
res = (res + mod - dp[i - 1][j]) % mod;
}
printf("%lld\n", res % mod);
return 0;
}
| 6 |
#include <bits/stdc++.h>
unsigned long long c;
int n, i, j, k, ks, ke, pd, pp, pa;
char s[1000100];
bool f, ff, fff;
int main() {
scanf("%s", s);
n = strlen(s);
for (i = 0; i < n; i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
k = 0, f = 1, ff = 0, fff = 0, ks = 1, ke = 0, pa = 0, pd = 0, pp = 0;
for (j = i + 1; f && j < n; j++) {
if (!k) {
if (s[j] == '@')
++k, pa = j;
else if (!((s[j] >= 'a' && s[j] <= 'z') ||
(s[j] >= '0' && s[j] <= '9') || s[j] == '_'))
f = 0;
else if (s[j] >= 'a' && s[j] <= 'z')
++ks;
} else if (k == 1) {
if (s[j] == '.')
++k, pd = j;
else if ((s[j] >= 'a' && s[j] <= 'z') || (s[j] >= '0' && s[j] <= '9'))
ff = 1;
else
f = 0;
} else {
if (s[j] >= 'a' && s[j] <= 'z')
fff = 1, ++ke, pp = j;
else
f = 0;
}
}
if (ff && fff) c += (unsigned long long)ks * ke;
if (pa)
i = pa;
else if (pd)
i = pd;
else if (pp)
i = pp - 1;
else
i = j - 1;
}
}
printf("%I64u\n", c);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
struct point {
double x, y, ans;
};
const int M = 10;
point p[1111], a[M];
double w, h;
int n;
double dis(point a, point b) {
double x = (a.x - b.x) * (a.x - b.x);
double y = (a.y - b.y) * (a.y - b.y);
return sqrt(x + y);
}
int sgn(double x) {
if (x > 1e-14) return 1;
if (x < -1e-14) return -1;
return 0;
}
double cal(point a) {
double Min1 = 1e10, Min2 = 1e10;
double tmp;
int i;
for (i = 1; i <= n; i++) {
tmp = dis(a, p[i]);
if (sgn(tmp - Min1) == -1)
Min2 = Min1, Min1 = tmp;
else if (sgn(tmp - Min2) == -1)
Min2 = tmp;
}
return Min2;
}
int main() {
scanf("%lf%lf%d", &w, &h, &n);
int i;
for (i = 1; i <= n; i++) scanf("%lf%lf", &p[i].x, &p[i].y);
for (i = 0; i < M; i++) {
a[i].x = 1.0 * (rand() % 100) / 100 * w;
a[i].y = 1.0 * (rand() % 100) / 100 * h;
a[i].ans = cal(a[i]);
}
double L = sqrt(w * w + h * h);
while (L > 1e-11) {
for (i = 0; i < M; i++) {
point pp = a[i];
int j;
for (j = 0; j < 5; j++) {
double ang = rand() % 100 / 100.0 * (2 * acos(-1.0));
double xx = a[i].x + L * cos(ang);
double yy = a[i].y + L * sin(ang);
if (xx < 0 || xx > w || yy < 0 || yy > h) continue;
point b;
b.x = xx;
b.y = yy;
double tmp = cal(b);
if (sgn(tmp - pp.ans) == 1) {
pp = b;
pp.ans = tmp;
}
}
a[i] = pp;
}
L = L * 0.99;
}
double ans = 0;
for (i = 0; i < M; i++)
if (sgn(a[i].ans - ans) == 1) {
ans = a[i].ans;
}
printf("%.12lf\n", ans);
}
| 11 |
#include <bits/stdc++.h>
int is_ab(int a, int b) {
int i;
for (i = 2; i <= a; i++) {
if ((a % i == 0) && (b % i == 0)) {
i = -1;
break;
}
}
return i - 1;
}
int main() {
int n, i;
scanf("%i", &n);
for (i = (n + 1) / 2; i < n; i++) {
if (is_ab(n - i, i) == n - i) break;
}
printf("%i %i\n", n - i, i);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 1001;
const int Mmax = 101;
int order;
int N, M;
vector<pair<int, int> > v;
int A[Nmax][Mmax];
void solve_ascending() {
for (int i = 1; i <= N; ++i) {
for (int k = 0; k < v.size(); ++k) {
int st = v[k].first;
int dr = v[k].second;
if (A[i][st] > A[i][dr]) swap(A[i][st], A[i][dr]);
}
for (int j = 1; j <= M; ++j) {
int minim = 1e9;
;
int pos = 0;
for (int k = j + 1; k <= M; ++k) {
if (A[i][k] < minim) {
minim = A[i][k];
pos = k;
}
}
if (pos && A[i][j] > A[i][pos]) {
swap(A[i][j], A[i][pos]);
v.push_back(make_pair(j, pos));
}
}
}
}
void solve_descending() {
for (int i = 1; i <= N; ++i) {
for (int k = 0; k < v.size(); ++k) {
int st = v[k].first;
int dr = v[k].second;
if (A[i][st] > A[i][dr]) swap(A[i][st], A[i][dr]);
}
for (int j = 1; j <= M; ++j) {
int maxim = 0;
int pos = 0;
for (int k = j + 1; k <= M; ++k) {
if (A[i][k] > maxim) {
maxim = A[i][k];
pos = k;
}
}
if (pos && A[i][j] < A[i][pos]) {
swap(A[i][j], A[i][pos]);
v.push_back(make_pair(pos, j));
}
}
}
}
int main() {
cin >> N >> M >> order;
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= M; ++j) {
cin >> A[i][j];
}
}
if (order == 0)
solve_ascending();
else
solve_descending();
cout << v.size() << "\n";
if (v.size() > M * (M - 1) / 2)
while (1)
;
for (int i = 0; i < v.size(); ++i)
cout << v[i].first << " " << v[i].second << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 5;
const long long INF = 1e18L;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << ": " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
char ar[102][102];
map<long long, long long> r, c;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long T = 1;
while (T--) {
long long n;
cin >> n;
long long m = n;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
char x;
cin >> x;
if (x == 'C') {
r[i]++;
c[j]++;
}
}
}
long long ans = 0;
for (auto i : r) {
ans += (i.second * (i.second - 1)) / 2;
}
for (auto i : c) {
ans += (i.second * (i.second - 1)) / 2;
}
cout << ans << '\n';
}
cerr << "Time Taken : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long solve() {
string s;
cin >> s;
long long res = 0;
long long sum = 0;
for (int i = 0; i < s.size(); ++i) {
res++;
if (s[i] == '-')
--sum;
else
++sum;
if (sum < 0) {
res += i + 1;
++sum;
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) cout << solve() << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T &a, const T &b) {
return (a > b ? a = b, 1 : 0);
}
template <class T>
bool umax(T &a, const T &b) {
return (a < b ? a = b, 1 : 0);
}
void INPUT(bool F = 0) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (F) {
freopen(
"name"
".in",
"r", stdin);
freopen(
"name"
".out",
"w", stdout);
}
}
const int N = 503;
int dp[2][N][N];
int state[N][N];
vector<int> cmp(string a) {
int n = (int)(a).size();
vector<int> p(n);
p[0] = 0;
for (int i = 1; i < n; ++i) {
int j = p[i - 1];
while (a[j] != a[i] && j > 0) j = p[j - 1];
if (a[j] == a[i]) j++;
p[i] = j;
}
return p;
}
const int inf = 1e9;
void clr(int layer) {
for (int x = 0; x < N; ++x) {
for (int y = 0; y < N; ++y) dp[layer][x][y] = inf;
}
}
signed main() {
INPUT();
int n, m;
cin >> n >> m;
string a, b;
cin >> a >> b;
swap(a, b);
for (int i = 0; i <= (int)(a).size(); ++i) {
for (int bt = 0; bt < 2; ++bt) {
string nw = a.substr(0, i) + char('0' + bt);
nw = a + "#" + nw;
vector<int> p = cmp(nw);
state[i][bt] = p.back();
}
}
int bt = 0;
clr(bt);
dp[0][0][0] = 0;
for (int i = 0; i < (int)(b).size(); ++i) {
clr(bt ^ 1);
for (int k = 0; k < (int)(b).size(); ++k) {
for (int first = 0; first <= (int)(b).size(); ++first) {
for (int t = 0; t < 2; ++t) {
int togo = state[first][t];
int dk;
if (togo == (int)(a).size())
dk = 1;
else
dk = 0;
dp[bt ^ 1][k + dk][togo] = min(
dp[bt ^ 1][k + dk][togo], dp[bt][k][first] + (t != (b[i] - '0')));
}
}
}
bt ^= 1;
}
for (int k = 0; k <= n - m + 1; ++k) {
int ans = 1e9;
for (int z = 0; z <= (int)(a).size(); ++z) ans = min(ans, dp[bt][k][z]);
cout << (ans == inf ? -1 : ans) << ' ';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, num;
cin >> p >> n;
bool *x = new bool[1000];
fill_n(x, 1000, false);
for (int i = 1; i <= n; i++) {
cin >> num;
if (x[num % p]) {
cout << i;
return 0;
}
x[num % p] = true;
}
cout << -1;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.