solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int b[31][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 30; j++) {
b[j][i] = a[i] % 2;
a[i] = a[i] / 2;
}
}
int pr[31][n + 1];
for (int i = 0; i <= 30; i++) {
pr[i][0] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 30; j++) {
pr[j][i + 1] = (pr[j][i] + b[j][i]) % 2;
}
}
vector<int> bi(n + 1);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 30; j++) {
int s = pow(2, j);
bi[i] = bi[i] + s * pr[j][i];
}
}
int raz1 = (n + 2) / 2;
int raz2 = (n + 1) / 2;
vector<int> bi1(raz1);
for (int i = 0; i < raz1; i++) {
bi1[i] = bi[i * 2];
}
vector<int> bi2(raz2);
for (int i = 0; i < raz2; i++) {
bi2[i] = bi[i * 2 + 1];
}
sort(bi1.begin(), bi1.end());
long long col = 0;
long long col1 = 1;
for (int i = 1; i < raz1; i++) {
if (bi1[i] != bi1[i - 1]) {
long long col2 = col1 * (col1 - 1) / 2;
col = col + col2;
col1 = 1;
} else {
col1++;
if (i == raz1 - 1) {
long long col2 = col1 * (col1 - 1) / 2;
col = col + col2;
}
}
}
sort(bi2.begin(), bi2.end());
col1 = 1;
for (int i = 1; i < raz2; i++) {
if (bi2[i] != bi2[i - 1]) {
long long col2 = col1 * (col1 - 1) / 2;
col = col + col2;
col1 = 1;
} else {
col1++;
if (i == raz2 - 1) {
long long col2 = col1 * (col1 - 1) / 2;
col = col + col2;
}
}
}
cout << col;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const double eps = 1e-10;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
const int MAXN = 1e6 + 5;
int a[MAXN];
int n, m;
int check(int i) {
if (i % m != 0)
if (abs(a[i] - a[i - 1]) == 1 || abs(a[i] - a[i - 1]) == m) return true;
if (i >= m)
if (abs(a[i] - a[i - m]) == 1 || abs(a[i] - a[i - m]) == m) return true;
return 0;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n * m; i++) a[i] = i + 1;
int ok = 0;
while (clock() < 1.9 * CLOCKS_PER_SEC) {
random_shuffle(a, a + n * m);
int f = 0;
for (int i = 0; i < n * m; i++) {
int cnt = 0;
while (check(i) && cnt <= 100) {
if (i < n * m - 1)
swap(a[i], a[rand() % (n * m - i - 1) + i + 1]);
else
cnt = INF;
cnt++;
}
if (cnt > 100) {
f = 1;
break;
}
}
if (f) continue;
ok = 1;
puts("YES");
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++) printf("%d ", a[(i - 1) * m + j]);
puts("");
}
break;
}
if (!ok) puts("NO");
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int)1e9 + 23111992;
const long long LINF = (long long)1e18 + 23111992;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline unsigned long long isqrt(unsigned long long k) {
unsigned long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int myrand() { return abs((int)mt()); }
void chemthan() {
int n;
cin >> n;
string a, b;
cin >> a >> b;
vector<int> f(n - 1);
for (int i = (0); i < (n - 1); ++i) {
int off = i ? f[i - 1] : 0;
f[i] = b[i] - a[i] - off;
}
if (f[n - 2] ^ b[n - 1] - a[n - 1]) {
cout << -1 << "\n";
return;
}
long long sum = 0;
for (int i = (0); i < (n - 1); ++i) sum += abs(f[i]);
cout << sum << "\n";
vector<pair<int, int> > res;
for (int i = (0); i < (n - 1); ++i) {
while ((a[i] ^ b[i]) && int((res).size()) < 1e5) {
vector<pair<int, int> > tmp;
int sign = a[i] < b[i] ? 1 : -1;
a[i] += sign;
for (int j = (i); j < (n - 1); ++j) {
if (sign == 1) {
tmp.push_back({j, 1});
if (a[j + 1] < '9') {
a[j + 1]++;
break;
}
} else {
tmp.push_back({j, -1});
if (a[j + 1] > '0') {
a[j + 1]--;
break;
}
}
sign *= -1;
}
reverse((tmp).begin(), (tmp).end());
for (pair<int, int> e : tmp) res.push_back(e);
}
}
if (int((res).size()) > 1e5) {
res.resize((int)1e5);
}
for (pair<int, int> e : res) {
cout << e.first + 1 << " " << e.second << "\n";
}
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
chemthan();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int e, w, idx;
node(int ee, int ww, int ii) { e = ee, w = ww, idx = ii; }
node() {}
};
struct p {
int idx;
long long d;
p() {}
p(long long dd, int ii) { d = dd, idx = ii; }
bool operator<(const p &a) const { return d > a.d; }
};
int n, m, u;
vector<node> g[300010];
bool v[300010];
int now[300010], pre[300010];
long long dis[300010], ans;
void init() {
memset(now, -1, sizeof(now));
memset(pre, -1, sizeof(pre));
for (int i = 0; i <= n; i++) {
g[i].clear();
}
ans = 0;
}
void slove() {
int i, j, k;
priority_queue<p> mq;
for (i = 0; i <= n; i++) {
dis[i] = 0x5f5f5f5f5f5f5f5f;
}
dis[u] = 0;
mq.push(p(0, u));
memset(v, false, sizeof(v));
while (!mq.empty()) {
int mark = (mq.top()).idx;
mq.pop();
for (j = 0; j < g[mark].size(); j++) {
node s = g[mark][j];
if (!v[s.e] && dis[s.e] > dis[mark] + s.w) {
dis[s.e] = dis[mark] + s.w;
if (now[s.e] == -1)
ans += s.w;
else {
ans -= pre[s.e];
ans += s.w;
}
now[s.e] = s.idx;
pre[s.e] = s.w;
mq.push(p(dis[s.e], s.e));
} else if (!v[s.e] && dis[s.e] == dis[mark] + s.w && s.w < pre[s.e]) {
ans -= pre[s.e];
ans += s.w;
pre[s.e] = s.w;
now[s.e] = s.idx;
}
}
}
}
int main() {
int i, j, k;
int a, b, c;
while (~scanf("%d%d", &n, &m)) {
init();
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &a, &b, &c);
g[a].push_back(node(b, c, i));
g[b].push_back(node(a, c, i));
}
scanf("%d", &u);
slove();
printf("%I64d\n", ans);
bool flag = false;
for (i = 1; i <= n; i++) {
if (now[i] != -1) {
if (flag) printf(" ");
printf("%d", now[i]);
flag = true;
}
}
puts("");
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[105];
int t;
cin >> t;
while (t--) {
memset(a, 0, sizeof(a));
int n;
int b[105];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> b[i];
a[b[i]]++;
}
int ans = 0;
int len = 2;
for (int i = 0; i < 102; i++) {
if (len == 0) break;
if (a[i] >= 2) continue;
if (a[i] == 1) {
if (len == 2)
ans += i, len--;
else if (len == 1)
continue;
} else if (a[i] == 0) {
if (len == 2)
ans += 2 * i, len -= 2;
else if (len == 1)
ans += i, len--;
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
set<pair<string, string>> s;
while (n--) {
string oldStr, newStr;
cin >> oldStr >> newStr;
auto it = s.lower_bound(make_pair(oldStr, ""));
if (it != s.end() && it->first == oldStr) {
s.insert(make_pair(newStr, it->second));
s.erase(it);
} else {
s.insert(make_pair(newStr, oldStr));
}
}
cout << s.size() << endl;
for (auto ans : s) {
cout << ans.second << " " << ans.first << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long const LIM = 1e6;
long long n, a[LIM], cnt[LIM], answer;
void dfs(long long u) {
if (u > (1 << (n + 1)) - 1) return;
dfs(2 * u);
dfs(2 * u + 1);
cnt[u] = max(cnt[2 * u] + a[2 * u], cnt[2 * u + 1] + a[2 * u + 1]);
long long diff =
cnt[u] - min(cnt[2 * u] + a[2 * u], cnt[2 * u + 1] + a[2 * u + 1]);
answer += diff;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (long long i = 2; i <= (1 << (n + 1)) - 1; ++i) cin >> a[i];
dfs(1);
cout << answer << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long N, x[100005], d[100005];
int main() {
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> x[i] >> d[i];
}
for (int i = 1; i <= N; i++) {
for (int j = i + 1; j <= N; j++) {
if (x[i] + d[i] == x[j] && x[j] + d[j] == x[i]) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
} else
return gcd(b, a % b);
}
int main() {
long long i, n;
string s, h;
cin >> s;
if (s.length() == 1) {
if (s == "4" || s == "8" || s == "0")
cout << 4 << "\n";
else
cout << "0\n";
} else {
h = s.substr(s.length() - 2, s.length());
std::istringstream ss(h);
ss >> i;
if (i % 4 == 0)
cout << 4 << "\n";
else
cout << "0\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> arr;
for (int i = 0; i < n; i++) {
int p;
cin >> p;
arr.emplace_back(p);
}
int anst = -1;
int ansum = INT_MAX;
for (int k = 1; k <= 100; k++) {
int sum = 0;
for (int j = 0; j < arr.size(); j++) {
if ((arr[j] - k) > 1) {
sum += (arr[j] - k) - 1;
} else if ((k - arr[j]) > 1) {
sum += (k - arr[j]) - 1;
}
}
if (sum < ansum) {
ansum = sum;
anst = k;
}
}
cout << anst << " " << ansum;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10, LG = 150;
long long a[N], c[N], p[N], dp[N][2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
c[i] = __builtin_popcountll(a[i]);
}
dp[0][0] = 1;
p[0] = 0;
for (int i = 1; i <= n; ++i) {
dp[i][0] = dp[i - 1][0];
dp[i][1] = dp[i - 1][1];
p[i] = (p[i - 1] + c[i]) % 2;
++dp[i][p[i]];
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
long long sum = 0, mx = 0;
for (int j = i; j <= n and j <= i + LG; ++j) {
sum += c[j];
mx = max(mx, c[j]);
if (sum % 2 == 0 and 2 * mx <= sum) {
++ans;
}
}
}
for (int j = LG + 2; j <= n; ++j) {
ans += dp[j - LG - 2][p[j] & 1];
}
cout << ans << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
string s;
cin >> s;
long long int x = 0, sum = 0;
for (int i = 0; i < n / 2; i++) {
if (s[i] == '?')
x++;
else
sum += s[i] - '0';
}
for (int i = n / 2; i < n; i++) {
if (s[i] == '?')
x--;
else
sum -= s[i] - '0';
}
if (2 * sum == -1 * 9 * x) {
cout << "Bicarp";
return 0;
}
cout << "Monocarp";
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int MAXN = 400010;
const int MAXM = 26;
int n;
char s[MAXN];
int tot;
struct node {
int dis;
node *pre, *next[MAXM];
} sa[MAXN], *root;
node *new_node() { return &sa[++tot]; }
int vertex[MAXN];
void build_sa() {
node *cur = root = new_node();
for (int i = n; i >= 1; --i) {
int x = s[i] - 'a';
node *p = cur;
cur = new_node();
cur->dis = p->dis + 1;
vertex[i] = cur - sa;
for (; p && !p->next[x]; p = p->pre) p->next[x] = cur;
if (!p)
cur->pre = root;
else {
node *q = p->next[x];
if (q->dis == p->dis + 1)
cur->pre = q;
else {
node *r = new_node();
*r = *q;
r->dis = p->dis + 1;
cur->pre = q->pre = r;
for (; p && p->next[x] == q; p = p->pre) p->next[x] = r;
}
}
}
}
vector<int> v[MAXN];
int size[MAXN], son[MAXN], father[MAXN], pre[MAXN], dis[MAXN];
void dfs1(int x) {
size[x] = 1;
if (v[x].empty()) return;
for (auto y : v[x]) {
dfs1(y);
size[x] += size[y];
}
son[x] = *max_element(v[x].begin(), v[x].end(),
[&](int a, int b) { return size[a] < size[b]; });
}
void dfs2(int x) {
if (!father[x]) father[x] = x;
if (v[x].empty()) return;
father[son[x]] = father[x];
dfs2(son[x]);
for (auto y : v[x])
if (y != son[x]) dfs2(y);
}
void build_tree() {
for (int i = 1; i <= tot; ++i) {
pre[i] = sa[i].pre ? sa[i].pre - sa : 0;
dis[i] = sa[i].dis;
if (pre[i]) v[pre[i]].push_back(i);
}
dfs1(1);
dfs2(1);
}
struct point {
int no, len, pos;
};
vector<point> p[MAXN];
void make_vertex(int v) {
int x = vertex[v];
while (x > 1) {
int y = father[x];
p[y].push_back({v, dis[x] - dis[pre[y]], v + dis[pre[y]] + 1});
x = pre[y];
}
}
int q;
struct query {
int id, len, bound;
bool operator<(const query &A) const { return bound < A.bound; }
};
vector<query> q1[MAXN], q2[MAXN];
void make_query(int l, int len, int id) {
int x = vertex[l];
while (x > 1) {
int y = father[x];
if (dis[pre[y]] < len) {
q1[y].push_back({id, min(dis[x], len) - dis[pre[y]], l - 1});
q2[y].push_back({id, min(dis[x], len) - dis[pre[y]], l + len});
}
x = pre[y];
}
}
int w[MAXN];
long long ww[MAXN];
void update(int p) {
for (int x = p; x < MAXN; x += x & -x) {
w[x] += 1;
ww[x] += p;
}
}
void resume(int x) {
for (; x < MAXN; x += x & -x) ww[x] = w[x] = 0;
}
int getnum(int x) {
int p = 0;
for (; x; x -= x & -x) p += w[x];
return p;
}
long long getsum(int x) {
long long p = 0;
for (; x; x -= x & -x) p += ww[x];
return p;
}
long long ans[MAXN];
void solve(vector<point> &p, vector<query> &q1, vector<query> &q2) {
if (p.empty()) return;
if (!q1.empty()) {
sort(p.begin(), p.end(),
[](const point &a, const point &b) { return a.no < b.no; });
sort(q1.begin(), q1.end());
auto j = p.begin();
int all = 0;
for (auto i = q1.begin(); i != q1.end(); ++i) {
for (; j != p.end() && j->no <= i->bound; ++j) {
++all;
update(j->len);
}
int s = getnum(i->len);
long long t = getsum(i->len);
ans[i->id] -= (long long)i->len * (all - s) + t;
}
for (auto j = p.begin(); j != p.end(); ++j) resume(j->len);
}
if (!q2.empty()) {
sort(p.begin(), p.end(), [](const point &a, const point &b) {
return a.pos + a.len < b.pos + b.len;
});
sort(q2.begin(), q2.end());
auto j = p.begin();
int all = 0;
for (auto i = q2.begin(); i != q2.end(); ++i) {
for (; j != p.end() && j->pos + j->len <= i->bound + 1; ++j) {
++all;
update(j->len);
}
int s = getnum(i->len);
long long t = getsum(i->len);
ans[i->id] += (long long)i->len * (all - s) + t;
}
for (auto j = p.begin(); j != p.end(); ++j) resume(j->len);
reverse(p.begin(), p.end());
reverse(q2.begin(), q2.end());
j = p.begin();
for (auto i = q2.begin(); i != q2.end(); ++i) {
for (; j != p.end() && j->pos + j->len > i->bound + 1; ++j)
update(j->pos);
int s = getnum(i->bound);
long long t = getsum(i->bound);
if (i->bound - i->len + 1 <= 0)
ans[i->id] += (long long)(i->bound + 1) * s - t;
else {
int s1 = getnum(i->bound - i->len + 1);
long long t1 = getsum(i->bound - i->len + 1);
ans[i->id] += (long long)i->len * s1 +
(long long)(i->bound + 1) * (s - s1) - (t - t1);
}
}
for (auto j = p.begin(); j != p.end(); ++j) resume(j->pos);
}
}
void solve() {
for (int c = 1; c <= tot; ++c) solve(p[c], q1[c], q2[c]);
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
build_sa();
build_tree();
for (int i = 1; i <= n; ++i) make_vertex(i);
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
int x, y;
scanf("%d%d", &x, &y);
int len = y - x + 1;
make_query(x, len, i);
}
solve();
for (int i = 1; i <= q; ++i) printf("%lld\n", ans[i]);
return 0;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 100;
const int MOD = 1e9 + 7;
int n, pot2, inv[N], comb[N];
map<int, vector<int>> cnt;
void print(int n) {
if (abs(n - MOD) < abs(n)) n -= MOD;
cout << n << ' ';
}
int go(vector<int> &cnt) {
sort(cnt.begin(), cnt.end());
long long res = 0;
int base = n - cnt.size();
for (int i = 0; i < (int)cnt.size(); i++, base++) {
res += (long long)cnt[i] * comb[base] % MOD;
}
res %= MOD;
if (res < 0) res += MOD;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
inv[1] = 1;
for (int i = 2; i <= n; i++)
inv[i] = (long long)(MOD - MOD / i) * inv[MOD % i] % MOD;
comb[0] = 1;
for (int i = 1; i <= n; i++)
comb[i] = (long long)comb[i - 1] * (n + 1 - i) % MOD * inv[i] % MOD;
for (int i = 1; i <= n; i++) {
comb[i] += comb[i - 1];
if (comb[i] >= MOD) comb[i] -= MOD;
}
pot2 = 1;
for (int i = 0; i < n - 1; i++) {
pot2 += pot2;
if (pot2 >= MOD) pot2 -= MOD;
}
pot2 = (MOD - pot2) % MOD;
for (int i = 0; i <= n; i++) {
comb[i] += pot2;
if (comb[i] >= MOD) comb[i] -= MOD;
}
for (int iter = 0; iter < n; iter++) {
int x;
cin >> x;
for (int d = 2; d * d <= x; d++)
if (x % d == 0) {
int pot = 0;
while (x % d == 0) {
x /= d;
pot++;
}
cnt[d].push_back(pot);
}
if (x > 1) cnt[x].push_back(1);
}
long long res = 0;
for (auto &kv : cnt) {
res += go(kv.second);
}
res %= MOD;
cout << res << endl;
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100002;
int n, cnt = 0;
int v[N];
pair<int, int> aux[N];
vector<int> ans[N];
bool vis[N];
void dfs(int u) {
if (vis[u]) return;
vis[u] = 1;
ans[cnt].push_back(u);
dfs(v[u]);
}
int main(void) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &v[i]);
aux[i].first = v[i];
aux[i].second = i;
}
sort(aux + 1, aux + n + 1);
for (int i = 1; i <= n; i++) {
v[aux[i].second] = i;
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cnt++;
dfs(i);
}
}
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) {
printf("%d ", (int)ans[i].size());
for (int j = 0; j < ans[i].size(); j++) {
printf("%d ", ans[i][j]);
}
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = numeric_limits<int>::max();
void read(int &x) {
x = 0;
char ch = getchar();
int f = 1;
while (!isdigit(ch)) (ch == '-' ? f = -1 : 0), ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
const int N = 3e5 + 233;
const int LG = 19;
int n, a[N], b[N], c[N];
int Log[N];
int l[LG][N], r[LG][N];
struct RMQ {
int a[N][LG], val[N], type;
inline int Max(int x, int y) { return (val[x] < val[y]) ? y : x; }
void build(int *b, int n, int _type) {
type = _type;
for (int i = 1; i <= n; ++i) a[i][0] = i, val[i] = type * b[i];
for (int j = 1; j <= Log[n]; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
a[i][j] = Max(a[i][j - 1], a[i + (1 << j - 1)][j - 1]);
}
}
}
inline int query(int l, int r) {
int k = Log[r - l + 1];
return Max(a[l][k], a[r - (1 << k) + 1][k]);
}
} rmq_l, rmq_r;
int main() {
read(n);
for (int i = 2; i <= 3 * n; i++) Log[i] = Log[i >> 1] + 1;
for (int i = 1; i <= n; ++i) read(a[i]), a[i + n] = a[i + n * 2] = a[i];
if (n == 1) return printf("0"), 0;
for (int i = 1; i <= n * 3; ++i)
b[i] = max(1, i - a[i]), c[i] = min(n * 3, i + a[i]);
for (int i = 0; i <= Log[n * 3]; ++i) r[i][3 * n] = 3 * n;
for (int i = 0; i <= Log[n * 3]; ++i) l[i][1] = 1;
for (int i = 1; i <= n * 3; ++i) l[0][i] = b[i], r[0][i] = c[i];
rmq_l.build(l[0], n * 3, -1);
rmq_r.build(r[0], n * 3, 1);
for (int i = 1; i <= Log[n * 3]; ++i) {
for (int j = 1; j <= 3 * n; j++) {
int posl = rmq_l.query(l[i - 1][j], r[i - 1][j]);
int posr = rmq_r.query(l[i - 1][j], r[i - 1][j]);
l[i][j] = min(l[i - 1][posl], l[i - 1][posr]);
r[i][j] = max(r[i - 1][posl], r[i - 1][posr]);
}
}
for (int j = n + 1; j <= n * 2; ++j) {
int u = j, v = j;
int ans = 0;
for (int i = Log[3 * n]; i >= 0; i--) {
if (max(r[i][v], r[i][u]) - min(l[i][u], l[i][v]) + 1 >= n) continue;
int nu = rmq_l.query(l[i][u], r[i][v]);
int nv = rmq_r.query(l[i][u], r[i][v]);
u = nu;
v = nv;
ans += 1 << i;
}
ans++;
printf("%d ", ans);
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v2;
vector<pair<int, int> > v1;
bool used1[3000];
bool used2[3000];
int main() {
long long n, x;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
int t, h, m;
cin >> t >> h >> m;
if (t == 0) {
v1.push_back(make_pair(h, m));
} else {
v2.push_back(make_pair(h, m));
}
}
int ans = 0;
int cur = x;
int t = 0;
while (true) {
int maxx = 0;
int ind = -1;
if (t == 0) {
for (int i = 0; i <= (int)v1.size() - 1; i++) {
if (!used1[i] && v1[i].first <= cur && v1[i].second > maxx) {
maxx = v1[i].second;
ind = i;
}
}
if (ind == -1) {
break;
} else {
used1[ind] = true;
cur += maxx;
ans++;
}
} else {
for (int i = 0; i <= (int)v2.size() - 1; i++) {
if (!used2[i] && v2[i].first <= cur && v2[i].second > maxx) {
maxx = v2[i].second;
ind = i;
}
}
if (ind == -1) {
break;
} else {
used2[ind] = true;
cur += maxx;
ans++;
}
}
t = (t + 1) % 2;
}
int ans1 = ans;
ans = 0;
ans = 0;
cur = x;
t = 1;
for (int i = 0; i <= 2000; i++) {
used1[i] = false;
used2[i] = false;
}
while (true) {
int maxx = 0;
int ind = -1;
if (t == 0) {
for (int i = 0; i <= (int)v1.size() - 1; i++) {
if (!used1[i] && v1[i].first <= cur && v1[i].second > maxx) {
maxx = v1[i].second;
ind = i;
}
}
if (ind == -1) {
break;
} else {
used1[ind] = true;
cur += maxx;
ans++;
}
} else {
for (int i = 0; i <= (int)v2.size() - 1; i++) {
if (!used2[i] && v2[i].first <= cur && v2[i].second > maxx) {
maxx = v2[i].second;
ind = i;
}
}
if (ind == -1) {
break;
} else {
used2[ind] = true;
cur += maxx;
ans++;
}
}
t = (t + 1) % 2;
}
cout << max(ans, ans1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
string chicken =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
void solve() {
int r, c, k;
cin >> r >> c >> k;
vector<string> farm(r);
int rice = 0;
for (int i = 0; i < r; i++) {
cin >> farm[i];
for (int j = 0; j < c; j++) rice += farm[i][j] == 'R';
}
int rice_per_chicken = rice / k;
int lucky_ones = rice % k;
int cur_chicken = 0, cur_rice = 0;
vector<vector<char> > res(r, vector<char>(c));
int seen_rice = 0;
auto do_stuff = [&](int i, int j) {
res[i][j] = chicken[cur_chicken];
if (farm[i][j] == 'R') cur_rice++, seen_rice++;
if ((cur_rice >= rice_per_chicken && cur_chicken >= lucky_ones) ||
(cur_rice >= rice_per_chicken + 1)) {
cur_rice = 0;
if (seen_rice < rice) cur_chicken++;
}
};
for (int i = 0; i < r; i++) {
if (i % 2 == 0) {
for (int j = 0; j < c; j++) do_stuff(i, j);
} else {
for (int j = c - 1; j >= 0; j--) do_stuff(i, j);
}
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cout << res[i][j];
}
cout << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
assert((int)chicken.size() == 62);
int T;
cin >> T;
while (T--) solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main(void) {
int t;
cin >> t;
while (t--) {
cin >> s;
int l = s.length();
vector<int> x;
x.clear();
s = 'p' + s + 'p';
int ans = 0;
for (int i = 1; i <= l; i++) {
if (s[i] == 'o') {
if (i >= 3) {
if (s[i - 1] == 'w' && s[i - 2] == 't') {
if (s[i + 1] != 'o') {
x.push_back(i);
s[i] = '1';
ans++;
} else {
x.push_back(i - 1);
s[i - 1] = '1';
ans++;
}
}
}
if (i <= l - 2) {
if (s[i + 1] == 'n' && s[i + 2] == 'e' && s[i] == 'o') {
if (s[i - 1] != 'o') {
x.push_back(i);
s[i] = '1';
ans++;
} else {
x.push_back(i + 1);
s[i + 1] = '1';
ans++;
}
}
}
}
}
printf("%d\n", ans);
for (int i = 0; i < ans; i++) {
printf("%d ", x[i]);
}
printf("\n");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void chmax(int &x, int y) {
if (x < y) x = y;
}
void chmin(int &x, int y) {
if (x > y) x = y;
}
const int N = 100 + 5;
int n, m, a[N][N];
int cnt_row[N], cnt_col[N];
int k;
void check_row() {
for (int i = 1; i <= n; ++i) {
int x = a[i][1];
for (int j = 2; j <= m; ++j) chmin(x, a[i][j]);
k += x;
cnt_row[i] = x;
for (int j = 1; j <= m; ++j) a[i][j] -= x;
}
}
void check_col() {
for (int j = 1; j <= m; ++j) {
int x = a[1][j];
for (int i = 2; i <= n; ++i) chmin(x, a[i][j]);
k += x;
cnt_col[j] = x;
for (int i = 1; i <= n; ++i) a[i][j] -= x;
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) scanf("%d", a[i] + j);
if (n <= m) {
check_row();
check_col();
} else {
check_col();
check_row();
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (a[i][j]) {
puts("-1");
exit(0);
}
printf("%d\n", k);
for (int i = 1; i <= n; ++i)
while (cnt_row[i]--) printf("row %d\n", i);
for (int j = 1; j <= m; ++j)
while (cnt_col[j]--) printf("col %d\n", j);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200100], tim[200100], query[200100], mx[200100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> n;
memset(tim, 0, sizeof(tim));
for (int i = int(0); i < int(n); ++i) cin >> a[i];
int t, p, x;
cin >> q;
for (int i = 1; i <= q; ++i) {
cin >> t;
if (t == 1) {
cin >> p >> x;
a[p - 1] = x;
tim[p - 1] = i;
} else {
cin >> x;
query[i] = x;
}
}
mx[q + 1] = 0;
for (int i = q; i > 0; --i) mx[i] = max(mx[i + 1], query[i]);
for (int i = 0; i < n; ++i) a[i] = max(a[i], mx[tim[i] + 1]);
for (int i = int(0); i < int(n); ++i) cout << a[i] << " ";
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int lower(vector<int>& ar, int i) {
int l = 0, r = ar.size(), ret = -1;
while (l < r) {
int m = (l + r) / 2;
if (ar[m] < i) {
ret = m;
l = m + 1;
} else
r = m;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<int> a(n), b(n), pre(n);
vector<vector<int>> count(3);
for (int i = 0; i < n; i++) {
cin >> a[i];
count[a[i] + 1].push_back(i);
}
int dif = 0;
for (int i = 0; i < n; i++) {
cin >> b[i];
b[i] -= a[i];
if (b[i]) dif++;
}
for (int i = n - 1; i > 0; --i) {
if (b[i] > 0) {
if (lower(count[2], i) != -1)
dif--;
else
break;
} else if (b[i] < 0) {
if (lower(count[0], i) != -1)
dif--;
else
break;
}
}
if (dif)
cout << "NO\n";
else
cout << "YES\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 200200;
ll a[maxn], b[maxn], ans[maxn];
ll gcd(ll a, ll b) {
return b == 0 ? a : gcd(b, a%b);
}
int main(void) {
int n, m; scanf("%d%d", &n, &m);
for (int i=1; i<=n; i++) scanf("%lld", &a[i]);
for (int i=1; i<=m; i++) scanf("%lld", &b[i]);
ll g = 0;
for (int i=2; i<=n; i++) g = gcd(g, a[i] - a[1]);
for (int i=1; i<=m; i++) {
ans[i] = abs(gcd(a[1] + b[i], g));
}
for (int i=1; i<=m; i++) printf("%lld%c", ans[i], " \n"[i==m]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long FAT_BS(long long a, long long b, long long aa[], long long x) {
while (a <= b) {
long long mid = (a + b) / 2;
if (aa[mid] == x)
return 1;
else if (aa[mid] > x)
b = mid - 1;
else
a = mid + 1;
}
return -1;
}
long long FAT_gcd(long long a, long long b) {
if (a == 0)
return b;
else
return FAT_gcd(b % a, a);
}
long long FAT_prime(long long x) {
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) return 0;
}
return 1;
}
void FAT_swap(char *x, char *y) {
char temp;
temp = *x;
*x = *y;
*y = temp;
}
long long FAT_big_mod(long long b, long long p, long long m) {
if (p == 0)
return 1;
else if (p % 2 == 0) {
long long k = FAT_big_mod(b, p / 2, m);
return (k * k) % m;
} else
return ((b % m) * (FAT_big_mod(b, p - 1, m))) % m;
}
long long FAT_josephus(long long n, long long k) {
if (n == 1) return 1;
return (FAT_josephus(n - 1, k) + k - 1) % n + 1;
}
long long FAT_gcdExtended(long long a, long long b, long long *x,
long long *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
long long x1, y1;
long long gcd = FAT_gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long a1[12];
bool vis[100010];
int main() {
string s1;
cin >> s1;
long long sz = s1.size();
long long cnt = 0;
bool f = 1;
memset(a1, 0, sizeof(a1));
memset(vis, 0, sizeof(vis));
for (long long i = 0; i < sz; i++) {
cnt += s1[i] - '0';
a1[s1[i] - '0']++;
if (s1[i] == '0') f = 0;
}
bool ff = 0;
long long rem = cnt % 3;
if (rem == 0)
cout << s1 << endl;
else {
if (rem == 1) {
long long mx1 = 0, mx2 = 0, p = 1, q = 1;
long long sz1, sz2;
string s2, s3;
if ((a1[1] + a1[4] + a1[7]) >= 1) {
long long c = 0;
for (long long i = sz - 1; i >= 0; i--) {
if (s1[i] == '1' || s1[i] == '4' || s1[i] == '7') {
vis[i] = 1;
c++;
}
if (c == 1) break;
}
for (long long i = 0; i < sz; i++) {
if (!vis[i]) s2 += s1[i];
}
sz1 = s2.size();
long long i = 0;
while (s2[i] == '0' && i < sz1) i++;
if (i < sz1) {
ff = 1;
q = 0;
mx1 = sz1 - i;
}
}
if ((a1[2] + a1[5] + a1[8]) >= 2) {
long long c = 0;
memset(vis, 0, sizeof(vis));
for (long long i = sz - 1; i >= 0; i--) {
if (s1[i] == '2' || s1[i] == '5' || s1[i] == '8') vis[i] = 1, c++;
if (c == 2) break;
}
for (long long i = 0; i < sz; i++) {
if (!vis[i]) s3 += s1[i];
}
sz2 = s3.size();
long long i = 0;
while (s3[i] == '0' && i < sz2) i++;
if (i < sz2) {
ff = 1;
p = 0;
mx2 = sz2 - i;
}
}
if (!p && !q) {
if (mx1 > mx2) {
long long i = sz1 - mx1;
for (; i < sz1; i++) cout << s2[i];
cout << endl;
} else {
long long i = sz2 - mx2;
for (; i < sz2; i++) cout << s3[i];
cout << endl;
}
} else if (!p || !q) {
if (p == 0) {
long long i = sz2 - mx2;
for (; i < sz2; i++) cout << s3[i];
cout << endl;
}
if (q == 0) {
long long i = sz1 - mx1;
for (; i < sz1; i++) cout << s2[i];
cout << endl;
}
}
} else if (rem == 2) {
long long mx1 = 0, mx2 = 0, p = 1, q = 1;
long long sz1, sz2;
string s2, s3;
if ((a1[2] + a1[8] + a1[5]) >= 1) {
long long c = 0;
for (long long i = sz - 1; i >= 0; i--) {
if (s1[i] == '2' || s1[i] == '8' || s1[i] == '5') {
vis[i] = 1;
c++;
}
if (c == 1) break;
}
for (long long i = 0; i < sz; i++) {
if (!vis[i]) s2 += s1[i];
}
sz1 = s2.size();
long long i = 0;
while (s2[i] == '0' && i < sz1) i++;
if (i < sz1) {
ff = 1, q = 0;
mx1 = sz1 - i;
}
}
if ((a1[1] + a1[4] + a1[7]) >= 2) {
long long c = 0;
memset(vis, 0, sizeof(vis));
for (long long i = sz - 1; i >= 0; i--) {
if (s1[i] == '1' || s1[i] == '4' || s1[i] == '7') {
vis[i] = 1;
c++;
}
if (c == 2) break;
}
for (long long i = 0; i < sz; i++) {
if (!vis[i]) s3 += s1[i];
}
sz2 = s3.size();
long long i = 0;
while (s3[i] == '0' && i < sz2) i++;
if (i < sz2) {
ff = 1, p = 0;
mx2 = sz2 - i;
}
}
if (!p && !q) {
if (mx1 > mx2) {
long long i = sz1 - mx1;
for (; i < sz1; i++) cout << s2[i];
cout << endl;
} else {
long long i = sz2 - mx2;
for (; i < sz2; i++) cout << s3[i];
cout << endl;
}
} else if (!p || !q) {
if (p == 0) {
long long i = sz2 - mx2;
for (; i < sz2; i++) cout << s3[i];
cout << endl;
}
if (q == 0) {
long long i = sz1 - mx1;
for (; i < sz1; i++) cout << s2[i];
cout << endl;
}
}
}
if (!ff) {
if (!f)
cout << "0" << endl;
else
cout << "-1" << endl;
}
}
return 0;
}
| 12 |
#include<bits/stdc++.h>
#define mod 1000000007
#define pie (3.141592653589)
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed;
cout.precision(10);
int T = 1;
cin >> T;
while(T--)
{
int n;
cin >> n;
vector<int> c(n);
for(int i = 0; i < n; i++)
{
cin >> c[i];
}
const int INF = 1e9 + 10;
long long up = c[0];
long long right = 0;
int up_min, right_min;
right_min = INF;
up_min = c[0];
long long sol = LLONG_MAX;
for(int i = 1; i < n; i++)
{
if(i & 1)
{
right += c[i];
right_min = min(right_min, c[i]);
}
else
{
up += c[i];
up_min = min(up_min, c[i]);
}
int done = (i + 1) / 2;
int one = 0;
if(i % 2 == 0)
one = 1;
long long cost = right + right_min * 1ll * (n - done);
cost += up + up_min * 1ll * (n - done - one);
sol = min(sol, cost);
}
cout << sol << '\n';
}
return 0;
}
| 7 |
#include<bits/stdc++.h>
const int maxn=105;
using namespace std;
int t,n,k,sum[maxn],x[maxn],y[maxn];
int calc(int i,int j){
return abs(x[i]-x[j])+abs(y[i]-y[j]);
}
int main(){
scanf("%d",&t);
for(;t;t--){
memset(sum,0,sizeof(sum));
scanf("%d %d",&n,&k);
for(int i=1;i<=n;i++)scanf("%d %d",&x[i],&y[i]);
for(int i=1;i<=n;i++)for(int j=i+1;j<=n;j++)if(calc(i,j)<=k)sum[i]++,sum[j]++;
for(int i=1;i<=n;i++){
if(sum[i]==n-1){puts("1");break;}
if(i==n)puts("-1");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e8;
int main() {
long long n, i, k, ans = 0, f = 1, p, s = 1, len = 0;
cin >> n;
p = n;
p = p / 10;
while (p > 0) {
p = p / 10;
s = s * 2;
ans += s;
len++;
}
if (n % 10 == 7) {
ans++;
}
n = n / 10;
while (n > 0) {
f = f * 2;
k = n % 10;
if (k == 7) {
ans += f;
}
n /= 10;
}
cout << ans + 1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, char>> a;
vector<int> gi;
for (int i = 0; i < n; i++) {
int first;
char color;
cin >> first >> color;
a.push_back({first, color});
if (color == 'G') {
gi.push_back(i);
}
}
long long ans = 0;
for (int i = 0; i < (int)gi.size() - 1; i++) {
int leftRed = a[gi[i]].first;
int leftBlue = a[gi[i]].first;
int d = a[gi[i + 1]].first - a[gi[i]].first;
long long redAns = 0, blueAns = 0;
for (int index = gi[i] + 1; index <= gi[i + 1]; index++) {
if (a[index].second == 'R') {
redAns = max(redAns, (long long)a[index].first - leftRed);
leftRed = a[index].first;
} else if (a[index].second == 'B') {
blueAns = max(blueAns, (long long)a[index].first - leftBlue);
leftBlue = a[index].first;
} else {
assert(a[index].second == 'G');
assert(a[index].first == a[gi[i + 1]].first);
blueAns = max(blueAns, (long long)a[index].first - leftBlue);
redAns = max(redAns, (long long)a[index].first - leftRed);
}
}
ans += min((long long)3 * d - redAns - blueAns, (long long)2 * d);
}
if ((int)gi.size() <= 1) {
int lb = -1;
int lr = -1;
for (int i = 0; i < (int)a.size(); i++) {
if (a[i].second == 'B') {
if (lb == -1) {
lb = a[i].first;
} else {
ans += a[i].first - lb;
lb = a[i].first;
}
} else if (a[i].second == 'R') {
if (lr == -1) {
lr = a[i].first;
} else {
ans += a[i].first - lr;
lr = a[i].first;
}
} else {
assert(a[i].second == 'G');
ans += a[i].first - lr;
ans += a[i].first - lb;
lb = a[i].first;
lr = a[i].first;
}
}
} else {
int lb = -1;
int lr = -1;
for (int i = 0; i <= gi[0]; i++) {
if (a[i].second == 'B') {
if (lb == -1) {
lb = a[i].first;
} else {
ans += a[i].first - lb;
lb = a[i].first;
}
} else if (a[i].second == 'R') {
if (lr == -1) {
lr = a[i].first;
} else {
ans += a[i].first - lr;
lr = a[i].first;
}
} else {
assert(a[i].second == 'G');
if (lr != -1) {
ans += a[i].first - lr;
}
if (lb != -1) {
ans += a[i].first - lb;
}
}
}
lb = a[gi.back()].first;
lr = a[gi.back()].first;
for (int i = gi.back() + 1; i < (int)a.size(); i++) {
if (a[i].second == 'B') {
if (lb == -1) {
lb = a[i].first;
} else {
ans += a[i].first - lb;
lb = a[i].first;
}
} else if (a[i].second == 'R') {
if (lr == -1) {
lr = a[i].first;
} else {
ans += a[i].first - lr;
lr = a[i].first;
}
}
}
}
cout << ans;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
const int MX = 3e3 + 5;
int r, c, n;
int fa[MX * MX * 2];
bool G[MX][MX * 2];
stack<pair<int, int> > stk;
inline int id(int x, int y) { return (x - 1) * c * 2 + y; }
void I() {
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= 2 * c; j++) {
int k = id(i, j);
fa[k] = k;
G[i][j] = false;
}
}
}
int F(int x) {
if (x == fa[x]) return x;
stk.push(pair<int, int>(x, fa[x]));
return fa[x] = F(fa[x]);
}
void U(int a, int b) {
a = F(a), b = F(b);
if (a == b) return;
stk.push(pair<int, int>(a, fa[a]));
stk.push(pair<int, int>(b, fa[b]));
fa[b] = a;
}
int DIR[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1},
{0, 1}, {1, -1}, {1, 0}, {1, 1}};
bool check(int x, int y) {
while (!stk.empty()) stk.pop();
int p[2][2] = {{x, y}, {x, y + c}};
for (int z = 0; z < 2; z++) {
for (int i = 0; i < 8; i++) {
int xx = p[z][0] + DIR[i][0];
int yy = p[z][1] + DIR[i][1];
if (xx < 1 || xx > r) continue;
if (yy < 1)
yy = 2 * c;
else if (yy > 2 * c)
yy = 1;
if (G[xx][yy] == false) continue;
U(id(p[z][0], p[z][1]), id(xx, yy));
}
}
if (F(id(p[0][0], p[0][1])) == F(id(p[1][0], p[1][1]))) {
while (!stk.empty()) {
pair<int, int> tp = stk.top();
stk.pop();
fa[tp.first] = tp.second;
}
return false;
}
G[x][y] = G[x][y + c] = true;
return true;
}
int main() {
int x, y, ans = 0;
scanf("%d %d %d", &r, &c, &n);
I();
while (n--) {
scanf("%d %d", &x, &y);
if (check(x, y)) ans++;
}
if (c <= 1) ans = 0;
printf("%d\n", ans);
return 0;
}
| 21 |
#include <bits/stdc++.h>
#define maxn 105
#define maxN 10086
using namespace std;
const int p = 1e9 + 7;
int n, q, x;
int b[maxn], c[maxn], f[maxN], g[maxN], sb[maxn];
int cal(int x){
for(int i = 0;i < maxN;i++) g[i] = 1;
for(int i = 1;i <= n;i++){
for(int j = 0;j < maxN;j++) f[j] = 0;
for(int j = max(0, i * x + sb[i]);j < maxN;j++) f[j] = (g[j] + p - (j - c[i] - 1 >= 0 ? g[j - c[i] - 1] : 0)) % p;
for(int j = 0;j < maxN;j++) g[j] = (f[j] + (j ? g[j - 1] : 0)) % p, f[j] = 0;
}
return g[maxN - 1];
}
map<int, int> mp;
int main(){
scanf("%d", &n);
int sum = 1;
for(int i = 1;i <= n;i++) scanf("%d", &c[i]), sum = 1ll * sum * (c[i] + 1) % p;
for(int i = 1;i < n;i++) scanf("%d", &b[i]);
for(int i = 2;i <= n;i++) for(int j = 1;j < i;j++) sb[i] += (i - j) * b[j];
int l = -((sb[n] + n - 1) / n), r = (n * maxn - sb[n] + n - 1) / n;
for(int i = l;i <= r;i++) mp[i] = cal(i);
scanf("%d", &q);
while(q--){
scanf("%d", &x);
if(x < l) printf("%d\n", sum);
else if(x > r) puts("0");
else printf("%d\n", mp[x]);
}
} | 19 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 9;
long long dp[2][maxn];
long long q[maxn];
int main() {
long long n, m, d;
cin >> n >> m >> d;
long long t1 = 0, p = 0;
for (long long i = 1; i <= m; i++) {
long long a, b, t;
cin >> a >> b >> t;
long long h = (t - t1) * d;
int l = 1, r = 0;
t1 = t;
for (long long j = 1; j <= n; j++) {
while (l <= r && q[l] < j - h) l++;
while (l <= r && dp[p][q[r]] < dp[p][j]) r--;
q[++r] = j;
dp[p ^ 1][j] = dp[p][q[l]];
}
l = 1, r = 0;
for (long long j = n; j >= 1; j--) {
while (l <= r && q[l] > j + h) l++;
while (l <= r && dp[p][q[r]] < dp[p][j]) r--;
q[++r] = j;
dp[p ^ 1][j] = max(dp[p][q[l]], dp[p ^ 1][j]);
}
for (int j = 1; j <= n; j++) dp[p ^ 1][j] += b - abs(a - j);
p = p ^ 1;
}
long long ans = -1e17;
for (int i = 1; i <= n; i++) {
ans = max(ans, dp[p][i]);
}
cout << ans << "\n";
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long MOD2 = 998244353;
const long long N = 5e5 + 5;
const long double pi = 3.14159265359;
void SRAND() {
auto duration = std::chrono::system_clock::now().time_since_epoch();
auto millis =
std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
srand(millis);
}
long long n, k, x, y, we, dp[N][2], t;
vector<pair<long long, long long> > v[N];
void reset(long long nn) {
for (long long i = 1; i <= nn; i++) {
dp[i][0] = dp[i][1] = 0;
v[i].clear();
}
}
void DFS(long long w, long long p) {
vector<long long> tmp;
for (pair<long long, long long> i : v[w]) {
if (i.first == p) continue;
DFS(i.first, w);
tmp.push_back(dp[i.first][1] + i.second - dp[i.first][0]);
dp[w][0] += dp[i.first][0];
dp[w][1] += dp[i.first][0];
}
sort(tmp.rbegin(), tmp.rend());
for (long long i = 0; i < k; i++) {
if (i >= (long long)tmp.size()) break;
if (i < k) dp[w][0] += max(tmp[i], 0LL);
if (i < k - 1) dp[w][1] += max(tmp[i], 0LL);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> k;
reset(n);
for (long long i = 0; i < n - 1; i++) {
cin >> x >> y >> we;
v[x].push_back(make_pair(y, we));
v[y].push_back(make_pair(x, we));
}
DFS(1, 0);
cout << max(dp[1][0], dp[1][1]) << "\n";
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
int ddx[] = {-1, -2, 1, -2, 2, -1, 2, 1}, ddy[] = {-2, -1, -2, 1, -1, 2, 1, 2};
int c, n;
int cnt[200001], parent[200001];
int find(int x) {
if (parent[x] < 0) return x;
return parent[x] = find(parent[x]);
}
void merge(int x, int y) {
x = find(x), y = find(y);
if (x != y) parent[y] = x;
}
int main() {
memset((parent), -1, sizeof(parent));
scanf("%d%d", &c, &n);
for (int(i) = (1); (i) <= (n); (i) += (1)) {
int x;
scanf("%d", &x);
cnt[x]++;
}
for (int(i) = (1); (i) <= (c); (i) += (1))
if (!cnt[i]) merge(i - 1, i);
for (int(k) = (1); (k) <= (c); (k) += (1)) {
bool ok = 0;
int now = c, rem = c;
while (1) {
now = find(now);
if (now <= k && rem >= k && !ok) {
rem -= k;
ok = 1;
now = min(now, rem);
continue;
}
if (now == 0) break;
int t = min(rem / now, cnt[now]);
rem -= t * now;
now = min(now - 1, rem);
}
if (rem > 0) return !printf("%d\n", k);
}
puts("Greed is good");
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
set<string> wines;
wines.insert("ABSINTH");
wines.insert("BEER");
wines.insert("BRANDY");
wines.insert("CHAMPAGNE");
wines.insert("GIN");
wines.insert("RUM");
wines.insert("SAKE");
wines.insert("TEQUILA");
wines.insert("VODKA");
wines.insert("WHISKEY");
wines.insert("WINE");
vector<string> coll;
copy(istream_iterator<string>(cin), istream_iterator<string>(),
back_inserter(coll));
int count = 0;
vector<string>::iterator pos;
for (pos = coll.begin(); pos != coll.end(); ++pos)
if (find(wines.begin(), wines.end(), *pos) != wines.end())
count++;
else if (atoi((*pos).c_str()) < 18 && atoi((*pos).c_str()) > 0)
count++;
else if (*pos == "0")
count++;
cout << count << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long> q1, q2, q3;
int main() {
int n, cnt = 0;
scanf("%d", &n);
long long sum = 0;
for (int i = 0; i < n; i++) {
int a;
long long b;
scanf("%d%lld", &a, &b);
if (a == 11)
sum += b, cnt++;
else if (a == 10)
q1.push(b);
else if (a == 1)
q2.push(b);
else
q3.push(b);
}
while (!q1.empty() && !q2.empty()) {
sum += q1.top();
q1.pop();
sum += q2.top();
q2.pop();
}
while (!q1.empty()) {
q3.push(q1.top());
q1.pop();
}
while (!q2.empty()) {
q3.push(q2.top());
q2.pop();
}
while (cnt-- && !q3.empty()) {
sum += q3.top();
q3.pop();
}
printf("%lld\n", sum);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
n--;
cout << n / 2 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int F, I, T;
cin >> F >> I >> T;
int a[100];
for (int i = 0; i < 100; i++) a[i] = 0;
for (int i = 0; i < F; i++) {
string q;
cin >> q;
for (int j = 0; j < I; j++) {
if (q[j] == 'Y') a[j]++;
}
}
int ans = 0;
for (int i = 0; i < I; i++)
if (a[i] >= T) ans++;
cout << ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, x, b, y;
cin >> n >> a >> x >> b >> y;
while (a != x && b != y) {
if (a == b) {
cout << "YES";
return 0;
}
if (a != n) {
a++;
} else {
a = 1;
}
if (b != 1) {
b--;
} else {
b = n;
}
}
if (a == b) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, minmove;
char arr[105][10005];
int search(int y) {
int i, j, summove = 0;
for (i = 0; i < n; i++) {
int move;
for (move = 0, j = 0; j < m; move++, j++) {
if (y + j >= m) {
if (arr[i][y + j - m] == '1') break;
} else if (arr[i][y + j] == '1')
break;
if (y - j < 0) {
if (arr[i][y - j + m] == '1') break;
} else if (arr[i][y - j] == '1')
break;
}
move = move < m - move ? move : m - move;
summove += move;
}
return summove;
}
int judge(int y) {
int i;
for (i = 0; i < n; i++)
if (arr[i][y] == '1') return 0;
return 1;
}
void run() {
int i, j, flag = 0;
int move = 0;
for (i = 0; i < n; i++) {
int f = 0;
for (j = 0; j < m; j++)
if (arr[i][j] == '1') {
f = 1;
break;
}
if (f == 0) {
flag = 1;
break;
}
}
if (flag == 0) {
int x;
for (j = 0; j < m; j++) {
if (judge(j)) continue;
x = search(j);
if (minmove == -1)
minmove = x;
else
minmove = minmove < x ? minmove : x;
}
printf("%d\n", minmove);
} else
puts("-1");
}
void get_data() {
minmove = -1;
int i;
for (i = 0; i < n; i++) scanf("%s", arr[i]);
}
int main() {
while (~scanf("%d%d", &n, &m)) {
get_data();
run();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1ll << 40;
char Char[1000001];
unordered_map<long long, bool> Mp;
unordered_map<long long, int> Edge;
int main(void) {
ios::sync_with_stdio(false);
register char First;
register long long Digit = 0;
register int Length = 0, Ans = 0, P = 0, Q = 0;
while (1 == scanf("%c", &First)) {
if (First >= 'a' && First <= 'z') {
Digit = (Digit * 65539ll + First * 65537ll) % MOD;
Char[++Length] = First;
if (Mp[Digit]) P = Length;
if (Edge[Digit] >= 2) Q = Length;
} else {
Ans += Length - P + min(P, Q + 2) + 1;
if (!Mp[Digit]) {
register int i;
Mp[Digit] = true, Digit = 0;
for (i = 1; i <= Length; i++)
Digit = (Digit * 65539ll + Char[i] * 65537ll) % MOD, Edge[Digit]++;
}
Digit = P = Q = Length = 0;
}
}
cout << Ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int a, b, n, m;
cin >> a >> b >> n >> m;
long long int mn = min(a, b);
if (mn < m)
cout << "No" << endl;
else {
long long int left = (a + b) - m;
if (left < n)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000007;
long long prost1 = 36028797018963913;
long long prost2 = 35184372088777;
long long n, m, now_k = 1;
vector<vector<long long> > v;
vector<char> used;
vector<long long> path, cmp;
void init() {
v.resize(m * 2 + 5);
used.resize(m * 2 + 5);
cmp.resize(m * 2 + 5);
}
void dfs(long long ver) {
used[ver] = true;
for (auto i : v[ver])
if (!used[i]) dfs(i);
path.push_back(ver);
}
void dfs2(long long ver) {
used[ver] = true;
cmp[ver] = now_k;
for (auto to : v[ver]) {
if (!used[to]) dfs2(to);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
init();
vector<long long> now(n);
for (long long c = 0; c < n; c++) cin >> now[c];
vector<vector<long long> > dop(n);
for (long long c = 0; c < m; c++) {
long long kol;
cin >> kol;
for (long long i = 0; i < kol; i++) {
long long e;
cin >> e;
e--;
dop[e].push_back(c);
}
}
vector<long long> start(m * 2 + 5);
vector<long long> answ(m + m);
for (long long c = 0; c < n; c++) {
if (now[c]) {
if (dop[c].size() == 0) continue;
if (dop[c].size() == 1)
answ[dop[c][0]] = 1;
else {
v[dop[c][0]].push_back(dop[c][1]);
v[dop[c][0] + m].push_back(dop[c][1] + m);
v[dop[c][1]].push_back(dop[c][0]);
v[dop[c][1] + m].push_back(dop[c][0] + m);
}
} else {
if (dop[c].size() == 0) {
cout << "NO";
return 0;
}
if (dop[c].size() == 1) {
if (answ[dop[c][0]] == 1) {
cout << "NO";
return 0;
}
answ[dop[c][0]] = 2;
} else {
v[dop[c][0]].push_back(m + dop[c][1]);
v[dop[c][0] + m].push_back(dop[c][1]);
v[dop[c][1]].push_back(m + dop[c][0]);
v[dop[c][1] + m].push_back(dop[c][0]);
}
}
}
for (long long c = 0; c < m * 2; c++) {
if (!used[c]) dfs(c);
}
memset(&used[0], 0, sizeof(used[0]) * used.size());
reverse(path.begin(), path.end());
for (auto i : path) {
if (!used[i]) {
dfs2(i);
now_k++;
}
}
for (long long c = 0; c < n; c++) {
if (now[c] == 1) {
if (dop[c].size() == 0) {
continue;
}
if (dop[c].size() == 1) {
if (cmp[dop[c][0]] == cmp[dop[c][0] + m]) {
cout << "NO";
return 0;
}
} else {
if (cmp[dop[c][0] + m] == cmp[dop[c][0]] ||
cmp[dop[c][0] + m] == cmp[dop[c][1]] ||
cmp[dop[c][1] + m] == cmp[dop[c][0]] ||
cmp[dop[c][1] + m] == cmp[dop[c][1]]) {
cout << "NO";
return 0;
}
}
} else {
if (dop[c].size() == 1) {
if (cmp[dop[c][0]] == cmp[dop[c][0] + m]) {
cout << "NO";
return 0;
}
} else {
if (cmp[dop[c][0] + m] == cmp[dop[c][1] + m] ||
cmp[dop[c][0]] == cmp[dop[c][1]] ||
cmp[dop[c][0] + m] == cmp[dop[c][0]] ||
cmp[dop[c][1] + m] == cmp[dop[c][1]]) {
cout << "NO";
return 0;
}
}
}
}
cout << "YES";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, p;
cin >> n >> p;
for (int i = 1; i <= 40; ++i) {
int x = n - p * i;
if (x <= 0) continue;
if (__builtin_popcount(x) <= i && x >= i) {
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 123;
const int mod = 1e9 + 7;
const int INF = 1e9 + 1;
const double eps = 1e-9;
const double pi = acos(-1.0);
long long n, a[N], k, ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1;; i++) {
if (ans + i <= k)
ans++;
else
break;
}
for (int i = 1; i <= ans; i++) {
if (k > i)
k -= i;
else {
break;
}
}
cout << a[k];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
const int mod = 1000000007;
int powmod(int x, int p) {
if (p == 0) return 1;
if (p & 1) return x * (long long)powmod(x, p - 1) % mod;
long long t = powmod(x, p >> 1);
return t * t % mod;
}
int main() {
int a[50] = {2, 3, 5, 7, 13, 17, 19,
31, 61, 89, 107, 127, 521, 607,
1279, 2203, 2281, 3217, 4253, 4423, 9689,
9941, 11213, 19937, 21701, 23209, 44497, 86243,
110503, 132049, 216091, 756839, 859433, 1257787, 1398269,
2976221, 3021377, 6972593, 13466917, 20996011, 24036583};
int n;
scanf("%d", &n);
printf("%d\n", powmod(2, a[n - 1] - 1) - 1);
return 0;
long long pp = 2;
int pr = 0;
for (long long i = 1; i <= 100; ++i) {
bool ok = true;
for (long long t = 1; t < i; ++t) {
if ((i - t) % (1 + 2 * t) == 0) {
ok = false;
break;
}
}
if (ok) {
cout << i << " " << i - pr << endl;
pr = i;
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
int main() {
scanf("%d %d", &n, &x);
bool f = true;
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (a == x || a + x == 7 || b == x || b + x == 7) {
f = false;
break;
}
}
if (f)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int MAXC = int(1e5) + 10;
int n, k;
int p[N], c[N], l[N];
bool isprime[2 * MAXC];
struct MaxFlow {
const int INF = int(1e6);
int n;
vector<vector<int>> adj;
MaxFlow(int n) : n(n) { adj.resize(n, vector<int>(n, 0)); }
int findAugmentedPath(vector<vector<int>> &resd) {
vector<int> from(n, -1);
vector<bool> vis(n, false);
queue<int> q;
q.push(0);
vis[0] = true;
while (!q.empty()) {
int at = q.front();
q.pop();
if (at == n - 1) break;
for (int nxt = 0; nxt < n; nxt++) {
if (!vis[nxt] && resd[at][nxt] > 0) {
from[nxt] = at;
vis[nxt] = true;
q.push(nxt);
}
}
}
int path_capacity = INF;
int at = n - 1;
while (from[at] != -1) {
path_capacity = min(path_capacity, resd[from[at]][at]);
at = from[at];
}
at = n - 1;
while (from[at] != -1) {
resd[from[at]][at] -= path_capacity;
resd[at][from[at]] += path_capacity;
at = from[at];
}
return path_capacity;
}
int solve() {
vector<vector<int>> resd = adj;
int flow = 0;
while (true) {
int path_capacity = findAugmentedPath(resd);
if (path_capacity == INF) break;
flow += path_capacity;
}
return flow;
}
};
bool check(int L) {
if (L == 0) return true;
vector<int> ps, cs;
int max_p1 = 0;
for (int i = 1; i <= n; i++) {
if (l[i] <= L) {
if (c[i] == 1)
max_p1 = max(max_p1, p[i]);
else {
ps.push_back(p[i]);
cs.push_back(c[i]);
}
}
}
if (max_p1 > 0) {
ps.push_back(max_p1);
cs.push_back(1);
}
MaxFlow maxFlow = MaxFlow(ps.size() + 2);
for (int i = 0; i < ps.size(); i++) {
int pi = ps[i], ci = cs[i];
if (ci & 1)
maxFlow.adj[0][i + 1] = pi;
else
maxFlow.adj[i + 1][ps.size() + 1] = pi;
if (ci & 1)
for (int j = 0; j < ps.size(); j++) {
if (cs[j] % 2 == 0 && isprime[cs[i] + cs[j]]) {
maxFlow.adj[i + 1][j + 1] = maxFlow.INF;
}
}
}
return accumulate(ps.begin(), ps.end(), 0) - maxFlow.solve() >= k;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d %d %d", &p[i], &c[i], &l[i]);
}
fill(isprime + 2, isprime + 2 * MAXC, 1);
for (int i = 2; i < 2 * MAXC; i++)
if (isprime[i]) {
for (int j = 2 * i; j < 2 * MAXC; j += i) isprime[j] = false;
}
int L = 1, R = n;
while (L != R) {
int mid = (L + R) / 2;
if (check(mid))
R = mid;
else
L = mid + 1;
}
if (check(L))
printf("%d\n", L);
else
puts("-1");
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, d;
cin >> n >> d;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int ans = arr[0];
for (int i = 1; i < n; i++) {
int temp = arr[i];
while (temp > 0 && d >= i) {
temp--;
ans++;
d = d - i;
}
if (d < i) {
break;
}
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
long long mod = 1e9 + 7;
long long mod2;
long long inf = 2e18;
long long n, d, k, M;
long long mul2(long long a, long long b) {
a %= mod2;
b %= mod2;
return (a * b) % mod2;
}
long long add2(long long a, long long b) {
a %= mod2;
b %= mod2;
return (a + b + mod2) % mod2;
}
long long mul(long long a, long long b) {
a %= mod;
b %= mod;
return (a * b) % mod;
}
long long add(long long a, long long b) {
a %= mod;
b %= mod;
return (a + b + mod) % mod;
}
long long fastpow(long long b, long long p) {
if (p == 0) return 1;
long long ans = fastpow(b, p / 2);
ans = mul(ans, ans);
if (p % 2) ans = mul(ans, b);
return ans;
}
struct matrix {
long long sz;
long long arr[105][105];
matrix(int s) {
sz = s;
for (int i = 0; i < sz; i++)
for (int j = 0; j < sz; j++) arr[i][j] = 0;
}
matrix operator*(matrix x) {
matrix ans(sz);
for (int i = 0; i < sz; i++)
for (int j = 0; j < sz; j++)
for (int k = 0; k < sz; k++)
ans.arr[i][k] = add(ans.arr[i][k], mul(arr[i][j], x.arr[j][k]));
return ans;
}
void print() {
cout << "------------------------\n";
for (int i = 0; i < sz; i++) {
for (int j = 0; j < sz; j++) cout << arr[i][j] << " ";
cout << "\n";
}
cout << "------------------------\n";
}
};
matrix matrix_I(long long s) {
matrix ans(s);
for (int i = 0; i < s; i++) ans.arr[i][i] = 1;
return ans;
}
matrix fastpow(matrix b, long long p) {
if (p == 0) return matrix_I(d);
matrix ans = fastpow(b, p / 2);
ans = ans * ans;
if (p % 2) ans = ans * b;
return ans;
}
long long co[N], co1[N], co2[N];
long long arr[N], arr2[N];
long long dp[N];
long long solve(long long n, long long l, long long m) {
matrix M(d);
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) M.arr[i][j] = co[add2(j, -i)];
M = fastpow(M, l - 2);
for (int i = 0; i < m; i++) {
if (co1[i] != 0) {
for (int j = 0; j < m; j++) dp[j] = add(dp[j], mul(co1[i], M.arr[i][j]));
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
long long val = add2(m, -arr2[i]);
ans = add(ans, dp[add2(val, -arr[i])]);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, l;
cin >> n >> l >> m;
d = m;
mod2 = m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x %= m;
co1[x]++;
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x %= m;
arr[i] = x;
co[x]++;
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x %= m;
arr2[i] = x;
co2[x]++;
}
cout << solve(n, l, m);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, seed = 131, MAXN = 1e5 + 1;
vector<int> primes;
bool sieve[MAXN];
void gen() {
memset(sieve, 1, sizeof sieve);
sieve[0] = sieve[1] = 0;
for (long long i = 2; i < MAXN; ++i) {
if (sieve[i]) primes.push_back(i);
for (long long j = i * i; j < MAXN; j += i) sieve[j] = 0;
}
}
int main() {
cin.tie(0)->sync_with_stdio(0);
gen();
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int temp = n;
vector<int> pf, f;
set<int> vis;
vis.insert(n);
f.push_back(1);
for (int x : primes) {
while (temp % x == 0) temp /= x, pf.push_back(x);
}
if (temp != 1) pf.push_back(temp);
for (int x : pf) {
for (int i = f.size() - 1; i >= 0; --i) {
if (vis.count(x * f[i])) continue;
vis.insert(x * f[i]);
f.push_back(x * f[i]);
}
}
f.push_back(n);
for (int i = 1; i < f.size(); ++i) cout << f[i] << " ";
cout << '\n';
if (pf.size() == 1)
cout << 0 << '\n';
else if (pf.size() == 2 && pf[0] != pf[1])
cout << 1 << '\n';
else
cout << 0 << '\n';
}
}
| 13 |
#include <bits/stdc++.h>
const int maxn = 2e5 + 10;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
using namespace std;
int f[maxn], n, m, u, v, cnt[maxn], s, fa[maxn], vis[maxn], dep[maxn];
long long w[maxn], dp[maxn], ans = -1;
vector<int> g[maxn];
int find(int x) { return f[x] == -1 ? x : f[x] = find(f[x]); }
void dfs(int now, int pre) {
vis[now] = true;
dep[now] = dep[pre] + 1;
for (int i = 0; i < g[now].size(); ++i) {
int to = g[now][i];
if (to == pre) continue;
if (!vis[to]) {
fa[to] = now;
dfs(to, now);
} else if (dep[to] <= dep[now]) {
cnt[to]++;
cnt[now]--;
}
}
}
void _dfs(int now) {
for (int i = 0; i < g[now].size(); ++i) {
int to = g[now][i];
if (fa[to] == now) {
_dfs(to);
cnt[now] += cnt[to];
}
}
}
bool __dfs(int now) {
bool flg = false;
for (int i = 0; i < g[now].size(); ++i) {
int to = g[now][i];
if (fa[to] == now) {
if (__dfs(to)) {
flg = true;
int fu = find(now), fv = find(to);
if (fu != fv) {
dp[fu] += dp[fv];
f[fv] = fu;
}
}
}
}
return flg || cnt[now] != 0;
}
void ___dfs(int now, long long sum) {
ans = max(ans, sum);
for (int i = 0; i < g[now].size(); ++i) {
int to = g[now][i];
if (fa[to] == now) {
if (find(to) != s)
___dfs(to, sum + w[to]);
else
___dfs(to, sum);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
f[i] = -1;
cnt[i] = 0;
vis[i] = 0;
cin >> w[i];
dp[i] = w[i];
}
for (int i = 1; i <= m; ++i) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
cin >> s;
dfs(s, 0);
_dfs(s);
__dfs(s);
___dfs(s, 0);
cout << dp[s] + ans << endl;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int N;
bool f[3000][3000];
bool v[3000][3000];
vector<pair<int, int> > akt;
queue<pair<int, int> > qu;
void visit(int x, int y) {
if (v[x][y]) return;
v[x][y] = true;
qu.push(pair<int, int>(x, y));
while (!qu.empty()) {
int x = qu.front().first, y = qu.front().second;
qu.pop();
akt.push_back(pair<int, int>(x, y));
for (int xs = max(0, x - 1); xs <= N && xs <= x + 1; xs++)
for (int ys = max(0, y - 1); ys <= N && ys <= y + 1; ys++) {
if (!v[xs][ys] && f[xs][ys]) {
v[xs][ys] = true;
qu.push(pair<int, int>(xs, ys));
}
}
}
}
int main() {
scanf("%d", &N);
for (int y = 0; y < (N + 10); y++)
for (int x = 0; x < (N + 10); x++) f[x][y] = false;
for (int y = 0; y < (N); y++)
for (int x = 0; x < (N); x++) {
int h;
scanf("%d", &h);
f[x + 1][y + 1] = h;
}
int ergkreis = 0, ergquadrat = 0;
for (int xs = 0; xs < (N); xs++) {
for (int ys = 0; ys < (N); ys++) {
if (v[xs][ys] || !f[xs][ys]) continue;
akt.clear();
visit(xs, ys);
long long d2 = 0;
for (typeof((akt).begin()) it = (akt).begin(); it != (akt).end(); it++) {
int x = it->first, y = it->second;
if (f[x + 1][y] && f[x - 1][y]) continue;
if (f[x][y + 1] && f[x][y - 1]) continue;
for (typeof((akt).begin()) jt = (akt).begin(); jt != (akt).end();
jt++) {
int xx = jt->first, yy = jt->second;
d2 = max(d2, (long long)(xx - x) * (xx - x) +
(long long)(yy - y) * (yy - y));
}
}
long double ve = (long double)d2 / akt.size();
if (fabs(ve - 2) < fabs(ve - M_PI / 4))
ergquadrat++;
else
ergkreis++;
}
}
printf("%d %d\n", ergkreis, ergquadrat);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int n, m, iTime;
stack<int> st;
vector<bool> inSt;
vector<int> disc, low, szScc, inScc;
vector<vector<int> > gr, adj;
void dfs(int u) {
disc[u] = low[u] = ++iTime;
st.emplace(u);
inSt[u] = true;
for (int v : gr[u]) {
if (!disc[v]) {
dfs(v);
low[u] = min(low[u], low[v]);
} else if (inSt[v])
low[u] = min(low[u], disc[v]);
}
if (disc[u] == low[u]) {
szScc.emplace_back(0);
while (st.top() != u) {
++szScc.back();
inScc[st.top()] = ((int)(szScc).size()) - 1;
inSt[st.top()] = false;
st.pop();
}
++szScc.back();
inScc[st.top()] = ((int)(szScc).size()) - 1;
inSt[st.top()] = false;
st.pop();
}
}
void dfs2(int u, bool& tmp, int& cnt) {
disc[u] = 1;
++cnt;
if (szScc[inScc[u]] > 1) tmp = false;
for (int v : adj[u])
if (!disc[v]) dfs2(v, tmp, cnt);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
gr.assign(n, {});
adj.assign(n, {});
while (m--) {
int u, v;
cin >> u >> v;
--u;
--v;
gr[u].emplace_back(v);
adj[u].emplace_back(v);
adj[v].emplace_back(u);
}
disc.assign(n, 0);
low.assign(n, 0);
inSt.assign(n, false);
inScc.assign(n, -1);
for (int u = 0; u < n; ++u)
if (!disc[u]) dfs(u);
int ans = 0;
disc.assign(n, 0);
for (int u = 0; u < n; ++u)
if (!disc[u]) {
bool tmp = true;
int nV = 0;
dfs2(u, tmp, nV);
ans += nV - tmp;
}
cout << ans << '\n';
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
long long n, s, res;
int a[200005];
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
while (cin >> n >> s) {
res = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
int mid = n / 2 + 1;
for (int i = mid; i <= n; i++) {
if (a[i] < s)
res += (s - a[i]);
else
break;
}
for (int i = mid; i >= 1; i--) {
if (a[i] > s)
res += (a[i] - s);
else
break;
}
cout << res << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, m, t;
cin >> n >> k >> m >> t;
while (t--) {
int a, b;
cin >> a >> b;
if (a == 1) {
if (b <= k) k++;
n++;
} else {
if (b <= k - 1) {
k -= b;
n -= b;
} else {
n = b;
}
}
cout << n << " " << k << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long solve() {
long long n, maxi = INT_MIN, sum = 0;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
if (n == 1) return arr[0];
sort(arr, arr + n);
for (long long i = 0; i < n; i++) {
maxi = max(maxi, arr[i] - sum);
sum = arr[i];
}
return maxi;
}
signed main() {
long long t;
cin >> t;
while (t--) {
cout << solve() << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> out;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
bool is = true;
for (int j = 0, a; j < n; j++) {
cin >> a;
if (a == 3 || a == 1) is = false;
}
if (is) out.push_back(i + 1);
}
cout << (int)out.size() << endl;
for (int i = 0; i < (int)out.size(); i++) cout << out[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long distance(int a, int b, int n) {
long long d = 0;
if (a <= b) {
d += b - a;
} else {
long long temp = (n - a) + 1;
d += temp + b - 1;
}
return d;
}
void solve() {
int n, m;
cin >> n >> m;
vector<int> a(m);
vector<int> b(m);
int i, j;
for (int i = 0; i < int(m); i++) {
cin >> a[i] >> b[i];
}
vector<long long> p(n + 1, INT_MAX);
vector<long long> out(n + 1);
for (i = 0; i < m; i++) {
out[a[i]]++;
}
for (i = 1; i <= n; i++) {
if (out[i] > 0) {
for (j = 0; j < m; j++) {
if (a[j] == i) {
long long temp = n * (out[i] - 1) + distance(i, b[j], n);
p[i] = min(p[i], temp);
}
}
}
}
for (i = 1; i <= n; i++) {
long long ans = -1;
for (j = 1; j <= n; j++) {
if (out[j] > 0) {
long long temp = p[j] + distance(i, j, n);
ans = max(ans, temp);
}
}
cout << ans << " ";
}
cout << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const char nl = '\n';
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
const long long MOD = 1e9 + 7;
const long double EPS = 1e-10;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 2e3;
const int M = 1e6;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
int k;
cin >> k;
for (int len = 1; len <= N; len++) {
for (int m = 1; m < len; m++) {
if ((k + len) % (len - m) == 0 && (k + len) / (len - m) <= m * M) {
cout << len << nl;
for (int i = 0; i < len - m - 1; i++) {
cout << 0 << " ";
}
cout << -1 << " ";
int cur = (k + len) / (len - m);
for (int i = 0; i < m; i++) {
cout << min(cur, M) << " ";
cur -= min(cur, M);
}
cout << nl;
return 0;
}
}
}
cout << -1 << nl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> L(n);
for (int i = 0; i < n; i++) cin >> L[i];
reverse(L.begin(), L.end());
int lastKill = -1;
int live = 0;
for (int i = 0; i < n; i++) {
if (lastKill < i) live++;
lastKill = max(lastKill, i + L[i]);
}
cout << live << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200100, oo = 2e9;
inline int read() {
int x = 0, c = getchar(), f = 0;
for (; c > '9' || c < '0'; f = c == '-', c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) + c - '0';
return f ? -x : x;
}
inline void write(long long x) {
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
int n, m, fa[N], L, h[N], ne[N], to[N];
void addl(int x, int y) {
ne[++L] = h[x];
h[x] = L;
to[L] = y;
}
int lv[N], sz[N], son[N], top[N], len[N], ti, dfn[N], id[N];
void dfs(int x) {
lv[x] = lv[fa[x]] + 1;
sz[x] = 1;
for (int y, k = h[x]; k; k = ne[k]) {
dfs(y = to[k]);
sz[x] += sz[y];
if (sz[y] > sz[son[x]]) son[x] = y;
}
}
void dfs(int x, int tp) {
dfn[x] = ++ti;
id[ti] = x;
top[x] = tp;
len[tp]++;
if (son[x] <= n) dfs(son[x], tp);
for (int k = h[x]; k; k = ne[k])
if (to[k] != son[x]) dfs(to[k], to[k]);
}
struct cqz {
int x, t, i;
} q[N];
inline bool operator<(cqz i, cqz j) {
if (i.t + lv[i.x] == j.t + lv[j.x])
return i.x < j.x;
else
return i.t + lv[i.x] < j.t + lv[j.x];
}
struct seg {
int tu, ps;
} tr[N * 4];
int ls[N * 4], rs[N * 4], cv[N * 4], sm, rt[N], ans[N];
void build(int& i, int l, int r) {
i = ++sm;
tr[i].ps = r;
tr[i].tu = -1;
cv[i] = -oo;
if (l == r) return;
build(ls[i], l, ((l + r) >> 1));
build(rs[i], ((l + r) >> 1) + 1, r);
}
void down(int i, int l, int r);
seg max(seg x, seg y) {
if (x.tu - (y.ps - x.ps) > y.tu)
return x;
else
return y;
}
void cov(int i, int l, int r, int x, int y, int k) {
if (l >= x && r <= y) {
cv[i] = k;
tr[i].ps = r;
tr[i].tu = k + r;
return;
}
down(i, l, r);
if (x <= ((l + r) >> 1)) cov(ls[i], l, ((l + r) >> 1), x, y, k);
if (y > ((l + r) >> 1)) cov(rs[i], ((l + r) >> 1) + 1, r, x, y, k);
tr[i] = max(tr[ls[i]], tr[rs[i]]);
}
void down(int i, int l, int r) {
if (cv[i] == -oo) return;
cov(ls[i], l, ((l + r) >> 1), l, ((l + r) >> 1), cv[i]);
cov(rs[i], ((l + r) >> 1) + 1, r, ((l + r) >> 1) + 1, r, cv[i]);
cv[i] = -oo;
}
bool can(seg& w, int x, int t) {
t += x - w.ps;
return w.tu > t;
}
int get(int i, int l, int r, int x, int t) {
if (l > x) return 0;
if (!can(tr[i], x, t)) return 0;
if (l == r) return l;
down(i, l, r);
int re = get(rs[i], ((l + r) >> 1) + 1, r, x, t);
if (re) return re;
return get(ls[i], l, ((l + r) >> 1), x, t);
}
void solve(int X, int T, int I) {
int x, y, t, p, r;
for (x = X, t = T; x >= 0; x = fa[y]) {
y = top[x];
p = lv[x] - lv[y] + 1;
r = get(rt[y], 1, len[y], p, t);
if (r) {
r = id[dfn[y] + r - 1];
break;
}
t += p;
}
t = T + lv[X] + lv[X] - lv[r] - lv[r];
ans[I] = t;
for (x = X; top[x] != top[r]; x = fa[y]) {
y = top[x];
p = lv[x] - lv[y] + 1;
t -= p;
cov(rt[y], 1, len[y], 1, p, t);
}
y = top[x];
r = lv[r] - lv[y] + 1;
p = lv[x] - lv[y] + 1;
t -= p;
if (r < p) cov(rt[y], 1, len[y], r + 1, p, t);
}
int main() {
register int i;
n = read();
m = read();
fa[0] = -1;
for (i = 1; i <= n; i++) fa[i] = read(), addl(fa[i], i);
for (i = 0; i <= n; i++) son[i] = n + 1;
dfs(0);
dfs(0, 0);
for (i = 0; i <= n; i++)
if (top[i] == i) build(rt[i], 1, len[i]);
cov(rt[0], 1, len[0], 1, 1, oo);
for (i = 1; i <= m; i++) q[i].x = read(), q[i].t = read(), q[i].i = i;
sort(q + 1, q + m + 1);
for (i = 1; i <= m; i++) solve(q[i].x, q[i].t, q[i].i);
for (i = 1; i < m; i++) printf("%d ", ans[i]);
printf("%d\n", ans[m]);
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 1e9 + 7;
int prime[N];
int ans[N];
int nums[N];
vector<int> factor[N];
void SIEVE() {
for (int i = 2; i < N; i++) {
if (prime[i] != 0) continue;
for (int j = i; j < N; j += i) {
prime[j] = i;
}
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
SIEVE();
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> nums[i], ans[i] = 1;
for (int i = 0; i < n; i++) {
int x = nums[i];
while (x > 1) {
int y = prime[x];
int z = factor[y].size() - 1;
if (z >= 0) ans[i] = max(ans[i], ans[factor[y][z]] + 1);
while (x % y == 0) x = x / y;
factor[y].push_back(i);
}
}
cout << *max_element(ans, ans + n);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long ADD(long long a, long long b, long long mod) {
return (a + b + mod + mod) % mod;
}
inline long long SUBS(long long a, long long b, long long mod) {
return (a - b + mod + mod) % mod;
}
inline long long MUL(long long a, long long b, long long mod) {
return (a * b + mod) % mod;
}
long long bigMod(long long base, long long power, long long mod) {
if (!power) return 1;
if (!base) return 0;
long long temp = bigMod(base, power / 2, mod);
if (power % 2 == 0) {
return (temp * temp) % mod;
} else
return (((temp * temp) % mod) * base) % mod;
}
inline long long modInverse(long long a, long long modp) {
return bigMod(a, modp - 2, modp);
}
inline long long modInverseExtended(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
void autoinput() {}
long long cnt, even_options, odd_options, total_options;
const long long MOD = 998244353LL;
long long even_count(long long n) {
if (n == 1) return even_options;
if (n == 0) return 0;
long long x = even_count(n / 2);
long long t = bigMod(total_options, n / 2, MOD);
long long o;
if (n > 0)
o = SUBS(t, x, MOD);
else
o = 0;
if (n % 2 == 0) {
long long ans = 0;
ans += MUL(x, x, MOD);
ans %= MOD;
ans += MUL(o, o, MOD);
ans %= MOD;
return ans;
} else {
long long ans = 0;
ans += MUL(even_options, MUL(x, x, MOD), MOD);
ans %= MOD;
ans += MUL(even_options, MUL(o, o, MOD), MOD);
ans %= MOD;
ans += MUL(2LL, MUL(odd_options, MUL(x, o, MOD), MOD), MOD);
ans %= MOD;
return ans;
}
}
int main() {
autoinput();
long long L, R, N, M;
scanf("%lld", &N);
;
scanf("%lld", &M);
;
scanf("%lld", &L);
;
scanf("%lld", &R);
;
cnt = N * M;
total_options = R - L + 1;
even_options;
if (R % 2 == 0 && L % 2 == 0)
even_options = (total_options / 2) + 1;
else
even_options = total_options / 2;
odd_options = total_options - even_options;
long long ans;
if (cnt % 2 == 1) {
ans = bigMod(total_options, cnt, MOD);
cout << ans << "\n";
} else {
ans = even_count(cnt);
cout << ans << "\n";
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k, t[101000], a[101000], res, act, mact;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> t[i];
if (i < k) act += ((t[i] ^ 1) * a[i]);
res += a[i] * t[i];
}
mact = act;
for (int i = k; i < n; i++) {
act += ((t[i] ^ 1) * a[i]);
act -= ((t[i - k] ^ 1) * a[i - k]);
mact = max(act, mact);
}
cout << res + mact;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class Pattern {
public:
vector<vector<char> > V;
bool operator<(const Pattern &P) const { return V > P.V; }
};
int main() {
vector<string> s(6);
for (int i = 0; i < 6; i++) cin >> s[i];
sort((s).begin(), (s).end());
Pattern ANS;
bool first = false;
do {
if (s[0].length() + s[5].length() - 1 != s[3].length()) continue;
if (s[1].length() + s[4].length() - 1 != s[2].length()) continue;
if (s[0][0] != s[1][0]) continue;
if (s[0][s[0].length() - 1] != s[2][0]) continue;
if (s[1][s[1].length() - 1] != s[3][0]) continue;
if (s[3][s[0].length() - 1] != s[2][s[1].length() - 1]) continue;
if (s[3][s[3].length() - 1] != s[4][0]) continue;
if (s[2][s[2].length() - 1] != s[5][0]) continue;
if (s[4][s[4].length() - 1] != s[5][s[5].length() - 1]) continue;
vector<vector<char> > V(s[2].length());
for (int i = 0; i < s[2].length(); i++) {
V[i] = vector<char>(s[3].length(), '.');
V[i][s[0].length() - 1] = s[2][i];
}
for (int j = 0; j < s[3].length(); j++) {
if (j < s[0].length()) V[0][j] = s[0][j];
}
for (int j = 0; j < s[3].length(); j++) {
V[s[1].length() - 1][j] = s[3][j];
}
for (int i = 0; i < s[1].length(); i++) {
V[i][0] = s[1][i];
}
for (int i = 0; i < s[2].length(); i++) {
if (i >= s[1].length() - 1) {
V[i][s[3].length() - 1] = s[4][i - s[1].length() + 1];
}
}
for (int i = s[0].length(); i < s[3].length(); i++) {
V[s[2].length() - 1][i] = s[5][i - s[0].length() + 1];
}
Pattern p;
p.V = V;
if (!first)
ANS = p;
else
ANS = max(p, ANS);
first = true;
} while (next_permutation((s).begin(), (s).end()));
if (!first) {
cout << "Impossible" << endl;
return 0;
}
Pattern p = ANS;
for (int i = 0; i < p.V.size(); i++) {
for (int j = 0; j < p.V[i].size(); j++) {
cout << p.V[i][j];
}
cout << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 5000;
long long coins[N], wts[N];
bool check[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
if (0) cin >> t;
while (t--) {
long long n;
cin >> n;
long long ans;
if (n >= 0)
ans = n;
else if (n <= -10) {
n = abs(n);
long long d1 = n % 10, d2 = (n / 10) % 10;
if (d1 > d2)
ans = n / 10;
else
ans = (n / 100) * 10 + d1;
ans = ans * -1;
} else
ans = 0;
cout << ans;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e8 + 5e4 + 1;
long long int mod2 = 1e9 + 87;
const double error = 1e-8;
const double PI = acos(-1);
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
inline long long int MOD(long long int x, long long int m = mod) {
long long int y = x % m;
return (y >= 0) ? y : y + m;
}
const int inf = 0x3f3f3f3f;
const unsigned long long int infl = 1e18 + 1;
const int nmax = 5e5 + 5;
int nxt[nmax];
int tree[4 * nmax];
void build(int i, int l, int r) {
if (l == r) {
tree[i] = l;
return;
}
int mid = (l + r) / 2;
build(2 * i, l, mid);
build(2 * i + 1, mid + 1, r);
tree[i] = (nxt[tree[2 * i + 1]] > nxt[tree[2 * i]]) ? (tree[2 * i + 1])
: (tree[2 * i]);
;
}
int query(int i, int l, int r, int L, int R) {
if (R < l || r < L) return 0;
if (L <= l && r <= R) return tree[i];
int mid = (l + r) / 2;
int p = query(2 * i, l, mid, L, R);
int q = query(2 * i + 1, mid + 1, r, L, R);
return (nxt[q] > nxt[p]) ? (q) : (p);
;
}
void update(int i, int l, int r, int k, int x) {
if (l == r) {
nxt[l] = x;
return;
}
int mid = (l + r) / 2;
if (k <= mid)
update(2 * i, l, mid, k, x);
else
update(2 * i + 1, mid + 1, r, k, x);
tree[i] = (nxt[tree[2 * i + 1]] > nxt[tree[2 * i]]) ? (tree[2 * i + 1])
: (tree[2 * i]);
;
}
int ans[nmax];
int n;
bool solve(int st, int en, int n1, int n2) {
if (en < st) return true;
if (nxt[en] != en + 1) {
if (nxt[en] == -1)
update(1, 1, n, en, en + 1);
else
return false;
}
int k = query(1, 1, n, st, en);
if (nxt[k] > en + 1) return false;
ans[k] = n2--;
bool ok = true;
if (k > st) ok &= solve(st, k - 1, n1, n1 + k - 1 - st);
if (k < en) ok &= solve(k + 1, en, n1 + k - st, n2);
return ok;
}
int main() {
int tc;
scanf("%d", &tc);
for (int cs = 1; cs <= tc; cs++) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &nxt[i]);
}
build(1, 1, n);
if (solve(1, n, 1, n)) {
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
} else
printf("-1\n");
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, p, x, f[100000], a;
int main() {
cin >> n;
cin >> p;
int pp[p + 1];
for (int i = 1; i <= p; i++) {
cin >> pp[i];
f[pp[i]]++;
}
cin >> x;
int xx[x + 1];
for (int i = 1; i <= x; i++) {
cin >> xx[i];
f[xx[i]]++;
}
for (int i = 1; i <= n; i++) {
if (f[i] >= 1) {
a++;
} else {
cout << "Oh, my keyboard!";
return 0;
}
}
if (a >= n) {
cout << "I become the guy.";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void afill(T *arr, int size, T val) {
fill(arr, arr + size, val);
}
long long mod = 1e9 + 7;
double eps = 1e-9;
int n, t, m, q, k;
int tree[1 << 20];
void update(int pos, int lo, int hi, int li, int ri, int win) {
if (li > ri || lo > ri || hi < li || tree[pos]) return;
if (lo >= li && hi <= ri) {
tree[pos] = win;
return;
}
int mid = (lo + hi) >> 1, l = pos << 1, r = l + 1;
update(l, lo, mid, li, ri, win);
update(r, mid + 1, hi, li, ri, win);
}
void print_results(int pos, int lo, int hi, int prev) {
if (lo == hi) {
if (tree[pos]) prev = tree[pos];
cout << prev << " ";
return;
}
int mid = (lo + hi) >> 1, l = pos << 1, r = l + 1;
if (tree[pos]) prev = tree[pos];
print_results(l, lo, mid, prev);
print_results(r, mid + 1, hi, prev);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int li, ri, win;
cin >> li >> ri >> win;
update(1, 1, n, li, win - 1, win);
update(1, 1, n, win + 1, ri, win);
}
print_results(1, 1, n, 0);
cin >> n;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ld = long double;
mt19937_64 rng(
(unsigned)chrono::system_clock::now().time_since_epoch().count());
const ld PI = acosl(-1);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n;
cin >> n;
map<pair<int, int>, ll> mp;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
pair<int, int> p = {x % 4, y % 4};
mp[p]++;
}
ll ans = 0;
for (auto [p, c] : mp) {
ans += c * (c - 1) * (c - 2) / 6;
ans += c * (c - 1) / 2 * (n - c);
}
cout << ans << "\n";
return 0;
}
| 15 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10240000,10240000")
using namespace std;
const double R = 0.5772156649015328606065120900;
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1.0);
vector<int> G[N];
int num[N];
void dfs(int root, int fa) {
num[root] = 1;
int n = G[root].size();
for (int i = 0; i < n; i++) {
int v = G[root][i];
if (v == fa) continue;
dfs(v, root);
num[root] += num[v];
}
}
double dp[N];
void solve(int root, int fa) {
int sum = 0;
int n = G[root].size();
int x = 0;
for (int i = 0; i < n; i++) {
int v = G[root][i];
if (v == fa) continue;
sum += num[v];
x++;
}
for (int i = 0; i < n; i++) {
int v = G[root][i];
if (v == fa) continue;
double tmp = sum - num[v];
tmp /= 2;
tmp += dp[root] + 1;
dp[v] = tmp;
solve(v, root);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int u;
scanf("%d", &u);
G[i].push_back(u);
G[u].push_back(i);
}
dfs(1, -1);
dp[1] = 1;
solve(1, -1);
printf("%.8lf", dp[1]);
for (int i = 2; i <= n; i++) printf(" %.8lf", dp[i]);
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
const int maxs = 100010;
int dp[maxs];
const int maxn = 310;
int indeg[maxn];
int outdeg[maxn];
int a[maxn];
int To[maxn];
int u[maxn];
const int mod = 1000000007;
int main() {
int n, q, t;
scanf("%d%d%d", &n, &q, &t);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
memset(To, -1, sizeof(To));
for (int iter = 0; iter < q; ++iter) {
int fr, to;
scanf("%d%d", &fr, &to);
--fr, --to;
outdeg[fr]++;
indeg[to]++;
To[fr] = to;
}
long long rem = 0;
for (int i = 0; i < n; ++i) {
if (indeg[i] == 0) {
int cursum = 0;
int cur = i;
vector<int> vv;
while (cur != -1) {
u[cur] = 1;
vv.push_back(a[cur]);
cursum += a[cur];
a[cur] = cursum;
cur = To[cur];
}
reverse(vv.begin(), vv.end());
for (int j = 0; j < int((vv).size()); ++j) rem += vv[j] * (long long)j;
}
}
for (int i = 0; i < n; ++i)
if (!u[i]) printf("0\n"), exit(0);
if (t < rem) printf("0\n"), exit(0);
t -= rem;
dp[0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < t + 1; ++j) {
if (!dp[j]) continue;
int to = j + a[i];
if (to <= t) {
dp[to] = dp[to] + dp[j];
if (dp[to] >= mod) dp[to] -= mod;
}
}
}
printf("%d\n", dp[t]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 10;
const int M = 1e9 + 7;
const int inf = 1e9 + 7;
const long long INF = 1e18;
int a[N];
int n;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
int x;
long long ans = INF;
int lx, rx;
for (int i = 1; i <= n; i++) {
cin >> x;
if (a[x] && ans > x) {
ans = x;
lx = a[x];
rx = i;
}
a[x] = i;
}
for (int i = 1; i < N; i++) {
if (i >= ans) break;
int l = -1, r;
for (int j = i; j < N; j += i) {
if (!a[j]) continue;
if (l == -1) {
l = j;
} else {
r = j;
long long tmp = l / i;
tmp *= r;
if (tmp < ans) {
ans = tmp;
lx = a[l];
rx = a[r];
}
}
}
}
printf("%d %d\n", min(lx, rx), max(lx, rx));
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int g[N][26], f[N], e[N], nc;
int ID[N], K[N], ans[N], L[N];
int gn() {
int p = nc++;
f[p] = e[p] = 0;
memset(g[p], 0, sizeof(g[p]));
return p;
}
void clr() {
nc = 0;
gn();
}
void ins(const string& s, int k, int id) {
int p = 0;
for (int i = 0; i != s.size(); ++i) {
int o = s[i] - 'a';
if (!g[p][o]) g[p][o] = gn();
L[g[p][o]] = L[p] + 1;
p = g[p][o];
}
e[p] = 1;
ID[p] = id;
K[p] = k;
ans[p] = INT_MAX;
}
int nex[N];
void build() {
queue<int> q;
for (int o = 0; o != 26; ++o)
if (g[0][o]) q.push(g[0][o]);
while (!q.empty()) {
int u = q.front();
q.pop();
if (e[f[u]])
nex[u] = f[u];
else
nex[u] = nex[f[u]];
for (int o = 0; o != 26; ++o) {
int& v = g[u][o];
if (!v)
v = g[f[u]][o];
else {
f[v] = g[f[u]][o];
q.push(v);
}
}
}
}
int n;
string s, temp;
vector<int> vc[N];
int res[N];
int main() {
cin >> s;
clr();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int k;
cin >> k >> temp;
ins(temp, k, i);
}
build();
int len = s.size();
int u = 0;
for (int i = 0; i < len; i++) {
u = g[u][s[i] - 'a'];
for (int p = u; p; p = nex[p]) {
if (ID[p]) {
vc[p].push_back(i);
if (vc[p].size() >= K[p]) {
int sz = vc[p].size(), k = K[p];
ans[p] = min(ans[p], i - (vc[p][sz - k] - L[p]));
}
}
}
}
for (int i = 0; i <= nc; i++)
if (e[i]) res[ID[i]] = ans[i] == INT_MAX ? -1 : ans[i];
for (int i = 1; i <= n; i++) printf("%d\n", res[i]);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
srand(time(NULL));
string s;
while (cin >> s) {
int n = ((int)((s).size()));
if (!count(&s[0], &s[0] + n, 'Q')) {
printf("Yes\n");
continue;
}
int i0 = 0;
while (i0 < n && s[i0] != 'Q') i0++;
if (i0 & 1) {
printf("No\n");
continue;
}
i0 = i0 / 2;
int cnt = 0, r = 0;
bool found = 0;
for (int i = i0; i < n; i++) {
cnt += s[i] == 'Q';
r += s[i] == 'H';
int now = cnt * (i - i0 + 1) + r;
if (now == n) {
string cur = "";
for (int j = i0; j <= i; j++)
if (s[j] == 'H')
cur += 'H';
else
cur += string(s, i0, i - i0 + 1);
if (cur == s) {
printf("Yes\n");
found = 1;
break;
}
}
if (now >= n) break;
}
if (!found) printf("No\n");
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int temp = m;
if (m == 1)
cout << n;
else if (n == m) {
while (m--) cout << '1' << " ";
} else if ((n % m) == 0) {
while (temp != 0) {
cout << n / m << " ";
temp--;
}
} else {
int a[m];
for (int i = 0; i < m; i++) a[i] = n / m;
n -= (n / m) * m;
while (n != 0 && m != 0) {
if (n >= m) {
n = n - (n / m) * m;
for (int i = 0; i < m; i++) {
a[i]++;
}
} else {
for (int i = 0; i < n; i++) {
a[i]++;
}
n -= n;
}
}
for (int i = 0; i < m; i++) cout << a[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
int ar[50][20];
bool check(int vx, int y, int vy) {
memset(ar, 0, sizeof ar);
for (int i = 0; i < y; i++) {
vy -= 25;
ar[i][1] = 25;
}
for (int i = y; i < y + 3; i++) {
if (i == 4) {
ar[i][0] = 15;
vx -= 15;
} else {
ar[i][0] = 25;
vx -= 25;
}
}
if (vx < 0 || vy < 0) return false;
if (vy >= ar[y + 2][0] - 2) {
vy -= ar[y + 2][0] - 2;
ar[y + 2][1] = ar[y + 2][0] - 2;
int p = ((vx) < (vy) ? (vx) : (vy));
ar[y + 2][0] += p;
ar[y + 2][1] += p;
vx -= p;
vy -= p;
}
for (int i = 0; i < y; i++) {
int lft = ar[i][1] - 2 - ar[i][0];
if (vx >= lft) {
vx -= lft;
ar[i][0] += lft;
} else {
ar[i][0] += vx;
vx = 0;
}
}
for (int i = y; i < y + 3; i++) {
int lft = ar[i][0] - 2 - ar[i][1];
if (vy >= lft) {
vy -= lft;
ar[i][1] += lft;
} else {
ar[i][1] += vy;
vy = 0;
}
}
return vx == 0 && vy == 0;
}
bool check2(int vx, int y, int vy) {
memset(ar, 0, sizeof ar);
for (int i = 0; i < y; i++) {
vy -= 25;
ar[i][1] = 25;
}
for (int i = y; i < y + 3; i++) {
if (i == 4) {
ar[i][0] = 15;
vx -= 15;
} else {
ar[i][0] = 25;
vx -= 25;
}
}
if (vx < 0 || vy < 0) return false;
if (y > 0 && vx >= ar[0][1] - 2) {
vx -= ar[0][1] - 2;
ar[0][0] = ar[0][1] - 2;
int p = ((vx) < (vy) ? (vx) : (vy));
ar[0][0] += p;
ar[0][1] += p;
vx -= p;
vy -= p;
}
for (int i = 0; i < y; i++) {
int lft = ar[i][1] - 2 - ar[i][0];
if (vx >= lft) {
vx -= lft;
ar[i][0] += lft;
} else {
ar[i][0] += vx;
vx = 0;
}
}
for (int i = y; i < y + 3; i++) {
int lft = ar[i][0] - 2 - ar[i][1];
if (vy >= lft) {
vy -= lft;
ar[i][1] += lft;
} else {
ar[i][1] += vy;
vy = 0;
}
}
return vx == 0 && vy == 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
for (int ts = (1); ts < (T + 1); ++ts) {
int x, y;
cin >> x >> y;
bool found = false;
for (int i = 0; i <= 2; i++) {
if (found) continue;
if (check(x, i, y)) {
cout << 3 << ":" << i << endl;
for (int j = (0); j < (3 + i); ++j) {
if (j) cout << " ";
cout << ar[j][0] << ":" << ar[j][1];
}
cout << endl;
found = true;
} else if (check2(x, i, y)) {
cout << 3 << ":" << i << endl;
for (int j = (0); j < (3 + i); ++j) {
if (j) cout << " ";
cout << ar[j][0] << ":" << ar[j][1];
}
cout << endl;
found = true;
}
}
for (int i = 2; i >= 0; i--) {
if (found) continue;
if (check(x, i, y) != check2(x, i, y)) {
printf(">>>%d %d\n", x, y);
assert(0);
}
if (check(y, i, x)) {
cout << i << ":" << 3 << endl;
for (int j = (0); j < (3 + i); ++j) {
if (j) cout << " ";
cout << ar[j][1] << ":" << ar[j][0];
}
cout << endl;
found = true;
} else if (check2(y, i, x)) {
cout << i << ":" << 3 << endl;
for (int j = (0); j < (3 + i); ++j) {
if (j) cout << " ";
cout << ar[j][1] << ":" << ar[j][0];
}
cout << endl;
found = true;
}
}
if (!found) cout << "Impossible" << endl;
}
}
| 14 |
#include<bits/stdc++.h>
#define llong long long
#define mkpr make_pair
#define x first
#define y second
#define iter iterator
#define riter reverse_iterator
#define y1 Lorem_ipsum_
#define tm dolor_sit_amet_
using namespace std;
inline int read()
{
int x = 0,f = 1; char ch = getchar();
for(;!isdigit(ch);ch=getchar()) {if(ch=='-') f = -1;}
for(; isdigit(ch);ch=getchar()) {x = x*10+ch-48;}
return x*f;
}
const int mxN = 1e5;
const int P = 998244353;
llong fact[10000003],facti[10000003],inv[10000003];
llong quickpow(llong x,llong y)
{
llong cur = x,ret = 1ll;
for(int i=0; y; i++)
{
if(y&(1ll<<i)) {y-=(1ll<<i); ret = ret*cur%P;}
cur = cur*cur%P;
}
return ret;
}
llong comb(llong x,llong y) {return x<0ll||y<0ll||x<y?0ll:fact[x]*facti[y]%P*facti[x-y]%P;}
void initfact(int n)
{
fact[0] = 1ll; for(int i=1; i<=n; i++) fact[i] = fact[i-1]*i%P;
facti[n] = quickpow(fact[n],P-2); for(int i=n-1; i>=0; i--) facti[i] = facti[i+1]*(i+1ll)%P;
for(int i=1; i<=n; i++) inv[i] = facti[i]*fact[i-1]%P;
}
int n;
char a[mxN+3];
int len[mxN+3];
int main()
{
initfact(mxN);
int T = read(); while(T--)
{
n = read();
scanf("%s",a+1); for(int i=1; i<=n; i++) a[i] -= '0';
int cnt = 0,cnt0 = 0;
for(int i=1; i<=n; i++)
{
len[i] = (a[i]==0?0:len[i-1]+1);
if(i==n||a[i+1]==0) {cnt0+=len[i]/2;}
if(a[i]==0) {cnt++;}
}
// printf("c(%d,%d)\n",cnt,cnt0);
llong ans = comb(cnt+cnt0,cnt0);
printf("%lld\n",ans);
}
return 0;
} | 11 |
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
long long POW(long long n, long long p) {
if (p == 0) return 1;
long long t = POW(n, p / 2);
if (p & 1) return n * t * t;
return t * t;
}
long long POW_MOD(long long n, long long p, long long M) {
if (p == 0) return 1;
long long t = POW(n, p / 2);
if (p & 1) return ((((n % M) * (t % M)) % M) * (t % M)) % M;
return ((t % M) * (t % M)) % M;
}
long long GCD(long long a, long long b) {
if (b > a) swap(a, b);
return b == 0 ? a : GCD(b, a % b);
}
long long C(long long n, long long r) {
if (r == 0) return 1;
if (r == 1) return n;
if (r > (n / 2)) r = n - r;
long long res = 1;
for (int i = 1; i <= r; i++) {
res *= (n - i + 1);
res /= i;
}
return res;
}
bool out(int x, int y, int r, int c) {
if (x < 0 || x >= r) return 1;
if (y < 0 || y >= c) return 1;
return 0;
}
long long x[1000006];
int main() {
int n;
scanf("%d", &n);
long long res = 0;
for (int i = 0; i < n; i++) {
long long a;
scanf("%I64d", &a);
res ^= a;
}
x[1] = 1;
x[0] = 0;
for (int i = 2; i <= 1000000; i++) {
x[i] = i ^ x[i - 1];
}
for (int i = 2; i <= n; i++) {
if (n % i == 0) {
if ((n / i) % 2 == 1) res ^= x[i - 1];
} else {
long long d = n / i;
if (d % 2 == 1)
res ^= x[i - 1] ^ x[n % i];
else
res ^= x[n % i];
}
}
printf("%I64d", res);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int matrix[maxn][maxn];
int pow_mod(int a, int b, int p) {
int ans = 1;
while (b) {
if (b & 1) ans = (long long)ans * a % p;
a = (long long)a * a % p;
b >>= 1;
}
return ans;
}
int main() {
int n, m, k, a, b, c, p;
cin >> n >> m >> k;
if ((n - m) & 1) {
printf("0\n");
return 0;
}
for (int i = 1; i <= k; ++i) {
cin >> a >> b >> c;
if (n < m) swap(a, b);
matrix[a][b] = c;
}
cin >> p;
if (n < m) swap(n, m);
int ans = (n - 1) * (m - 1) - k;
for (int i = 1; i <= n; ++i) {
int temp = 1;
int j;
for (j = 1; j <= m; ++j) {
if (matrix[i][j] != 0)
temp *= matrix[i][j];
else
break;
}
if (temp != -1 && j == (m + 1)) {
printf("0\n");
return 0;
} else if (temp == -1 && j == (m + 1))
ans++;
}
printf("%d\n", pow_mod(2, ans, p));
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int bas = 233;
int n;
char s1[1001000], s2[1001000];
unsigned long long p[1001000], h1[1001000], h2[1001000];
char chg(char x) {
if (x == 'N') return 'S';
if (x == 'S') return 'N';
if (x == 'W') return 'E';
if (x == 'E') return 'W';
}
int main() {
scanf("%d%s%s", &n, s1 + 1, s2 + 1);
n--;
p[0] = 1;
for (int i = 1; i <= n; i++) p[i] = p[i - 1] * bas;
for (int i = n; i >= 1; i--) h1[i] = s1[i] * p[n - i] + h1[i + 1];
for (int i = n; i >= 1; i--) h2[i] = h2[i + 1] * bas + chg(s2[i]);
for (int i = 1; i <= n; i++)
if (h1[i] == h2[i]) return puts("NO"), 0;
puts("YES");
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T>
void prContain(const T& x) {
pr("{");
bool fst = 1;
for (auto& a : x) pr(!fst ? ", " : "", a), fst = 0;
pr("}");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
template <typename T>
int remin(T& a, const T& b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T>
int remax(T& a, const T& b) {
if (b > a) {
a = b;
return true;
}
return false;
}
int X[3], Y[3];
int N = -1;
int main(int argc, const char** argv) {
int total = 0;
for (int i = 0; i < 3; ++i) {
scanf("%d%d", &X[i], &Y[i]);
total += X[i] * Y[i];
}
for (int n = 1; n <= 100; ++n) {
if (n * n == total) {
N = n;
break;
}
}
if (N == -1) return 0 * printf("-1\n");
for (int r1 = 0; r1 < 2; ++r1) {
for (int r2 = 0; r2 < 2; ++r2) {
for (int r3 = 0; r3 < 2; ++r3) {
bool ok = true;
for (int i = 0; i < 3; ++i) {
if (X[i] != N) {
ok = false;
break;
}
}
if (ok) {
ps(N);
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < Y[i]; ++j) {
for (int k = 0; k < N; ++k) {
printf("%c", 'A' + i);
}
printf("\n");
}
}
return 0;
}
if (X[0] + X[1] + X[2] == 2 * N) {
for (int i = 0; i < 3; ++i) {
int j = (i + 1) % 3;
int k = (i + 2) % 3;
if (X[i] == N && X[j] + X[k] == N && Y[i] + Y[j] == N &&
Y[i] + Y[k] == N) {
ps(N);
for (int r = 0; r < Y[i]; ++r) {
for (int c = 0; c < N; ++c) {
printf("%c", 'A' + i);
}
printf("\n");
}
for (int r = 0; r < Y[j]; ++r) {
for (int c = 0; c < N; ++c) {
printf("%c", 'A' + (c < X[j] ? j : k));
}
printf("\n");
}
return 0;
}
}
}
swap(X[2], Y[2]);
}
swap(X[1], Y[1]);
}
swap(X[0], Y[0]);
}
printf("-1\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int x = 0, f = 1;
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;
}
int n, a[300005], b[300005];
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = n; i >= 1; --i) b[i] = max(b[i + 1], a[i]);
for (int i = 1; i <= n; ++i) printf("%d ", i - n + b[i]);
puts("1");
}
| 7 |
#include <bits/stdc++.h>
int main() {
int T;
scanf("%d", &T);
for (int t = 0; t < T; ++t) {
int A, B;
scanf("%d%d", &A, &B);
int d = round(pow(1LL * A * B, 1. / 3.));
if (1LL * d * d * d == 1LL * A * B && A % d == 0 && B % d == 0)
puts("Yes");
else
puts("No");
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long long INF64 = 1000LL * 1000LL * 1000LL * 1000LL * 1000LL * 1000LL;
char a[2100][2100];
int need[2100];
int n;
void Load() {
scanf("%d", &n);
{
int c;
while ((c = getchar()) != 10 && c != EOF)
;
};
for (int i = 0; i < n; i++) gets(a[i]);
}
void Solve() {
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) a[i][j] -= '0';
for (int i = 0; i < n; i++) {
int x = 1;
for (int j = n - 1; j > i; j--)
if ((a[i][j] ^ need[j]) == x) {
a[i][i] ^= 1;
x ^= 1;
need[j] ^= 1;
ans++;
}
}
for (int i = 0; i < n; i++) a[i][i] ^= need[i];
memset(need, 0, sizeof(need));
for (int i = n - 1; i >= 0; i--) {
int x = 1;
for (int j = 0; j < i; j++)
if ((a[i][j] ^ need[j]) == x) {
a[i][i] ^= 1;
x ^= 1;
need[j] ^= 1;
ans++;
}
}
for (int i = 0; i < n; i++) a[i][i] ^= need[i];
for (int i = 0; i < n; i++) ans += a[i][i];
cout << ans;
}
int main() {
Load();
Solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
bool check(long long int n, long long int k) {
long long int s = 0, p = n;
while (n > 0) {
if (n <= k) {
s += n;
n = 0;
} else {
s += k;
n -= k;
n -= n / 10;
}
}
if (s >= (p - p / 2)) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
{
long long int n, i, Min = 4e18, l, r, m, f = 0;
cin >> n;
l = 0;
r = n;
if (n == 1) {
cout << 1;
return 0;
}
while (l <= r) {
m = (l + r) / 2;
if (m == 0) break;
if (check(n, m)) {
Min = min(Min, m);
r = m - 1;
} else
l = m + 1;
}
for (i = max(1LL * 1, Min - 10); i < Min; i++) {
if (check(n, i)) Min = min(Min, i);
}
cout << Min;
cout << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
if (n == 1 || m == 1) {
cout << "YES\n";
} else if (n == 2 && m == 2) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
long long ans = 0;
std::stack<std::pair<int, int>> st;
auto getCost = [&](int f, int id) {
if (f <= 0) return 0LL;
id -= f - 1;
if (st.empty()) return (long long)f * (f + 1) / 2 + (long long)f * id;
assert(st.top().first > f && st.top().second < id);
int id2 = st.top().second - (f - 1);
return (long long)f * (id - id2);
};
long long sum = 0;
int f = 0;
int n;
std::string str;
std::cin >> n >> str;
int id = 0;
for (auto ch : str) {
if (ch == '0') {
f = 0;
} else {
f++;
while (!st.empty() && st.top().first <= f) {
auto got = st.top();
st.pop();
sum -= getCost(got.first, got.second);
}
sum += getCost(f, id);
st.push({f, id});
}
ans += sum;
id++;
}
std::cout << ans << '\n';
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
bool check(int x1, int y1, int x2, int y2, int x3, int y3) {
int a = pow(x1 - x2, 2) + pow(y1 - y2, 2);
int b = pow(x2 - x3, 2) + pow(y2 - y3, 2);
int c = pow(x1 - x3, 2) + pow(y1 - y3, 2);
if ((a == b + c && a != 0 && b != 0 && c != 0) ||
(b == a + c && a != 0 && b != 0 && c != 0) ||
(c == a + b && a != 0 && b != 0 && c != 0)) {
return true;
}
return false;
}
int main() {
int n, m, i, j, a, b, mx;
mx = 1e9;
cin >> n >> m >> i >> j >> a >> b;
int bx[] = {1, n, n, 1};
int by[] = {m, 1, m, 1};
for (int t = 0; t < 4; t++) {
if (abs(bx[t] - i) % a == 0 && abs(by[t] - j) % b == 0) {
int l = abs(bx[t] - i) / a;
int r = abs(by[t] - j) / b;
if ((l - r) % 2 == 0) {
mx = min(max(l, r), mx);
}
}
}
if (mx == 1e9 || mx != 0 && (n <= a || m <= b)) {
cout << "Poor Inna and pony!";
} else
cout << mx;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
char f[105][105] = {0};
int dir[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1},
{0, 1}, {1, -1}, {1, 0}, {1, 1}};
int main(int argc, const char* argv[]) {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%s", f[i] + 1);
}
bool ok = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if ((f[i][j] <= '8' && f[i][j] >= '0') || f[i][j] == '.') {
int y = f[i][j] - '0';
if (f[i][j] == '.') y = 0;
int x = 0;
for (int k = 0; k < 8; k++) {
if (f[i + dir[k][0]][j + dir[k][1]] == '*') x++;
}
if (x != y) {
ok = 0;
break;
}
}
}
if (!ok) break;
}
if (ok)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, arr[300030], res = 0, f[20];
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
for (int i = 0; i < 20; i++) f[i] = 0;
f[0] = -k;
for (int i = 1; i <= n; i++) {
arr[i] += arr[i - 1];
for (int j = 0; j < m; j++) {
if (j >= i % m) {
res = max(res, arr[i] - f[j] - k * (i / m + 1));
} else {
res = max(res, arr[i] - f[j] - k * (i / m + 2));
}
}
f[i % m] = min(f[i % m], arr[i] - k * (i / m + 1));
}
cout << res << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long int t, n, arr[102];
int main() {
long long int i, a;
scanf("%lld", &t);
while (t--) {
scanf("%lld", &n);
long long int ans = 1;
for (i = 1; i <= 100; i++) arr[i] = 0;
for (i = 0; i < n; i++) {
scanf("%lld", &a);
arr[a] = 1;
}
for (i = 1; i < 100; i++)
if (arr[i] == 1 && arr[i + 1] == 1) ans = 2;
printf("%lld\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
vector<int> ans;
int nans = 0;
int i = 0;
int j = (n - (n % 2)) / 2;
while (ans.size() < n) {
if (n % 2 and j == n - 1) {
ans.push_back(a[j]);
} else {
ans.push_back(a[j]);
ans.push_back(a[i]);
}
i++;
j++;
}
for (int i = 1; i < n - 1; i++) {
if (ans[i - 1] > ans[i] and ans[i] < ans[i + 1]) {
nans++;
}
}
cout << nans << endl;
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long dp[505][505];
long long f[505][505];
long long kpow(long long x, int y) {
long long ans = 1;
while (y) {
if (y & 1) {
ans = (ans * x) % mod;
}
x = (x * x) % mod;
y >>= 1;
}
return ans;
}
long long ff[505][505];
void pre() {
f[0][0] = 1;
for (int i = 1; i <= 500; i++) {
f[i][0] = 1;
ff[i][0] = 1;
for (int j = 1; j < i; j++) {
f[i][j] = (f[i - 1][j] % mod + f[i - 1][j - 1] % mod) % mod;
ff[i][j] = (f[i][j] % mod + ff[i][j - 1] % mod) % mod;
}
f[i][i] = 1;
ff[i][i] = (ff[i][i - 1] % mod + 1) % mod;
}
}
int main() {
int n, x;
scanf("%d%d", &n, &x);
pre();
dp[0][0] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= x; j++) {
if (j < i) {
dp[i][j] = (kpow(j, i) % mod - kpow(j - 1, i) % mod + mod) % mod;
}
if (j == i) {
dp[i][j] = (kpow(j, i) - kpow(j - 1, i) + mod) % mod;
dp[i][j] = (dp[i][j] - f[i][1] * kpow(j - 1, i - 1) % mod + mod) % mod;
}
if (j > i) {
for (int k = 2; k <= i; k++) {
dp[i][j] = (dp[i][j] +
f[i][k] * dp[k][j - i + 1] % mod * kpow(i - 1, i - k)) %
mod;
}
}
}
}
long long ans = 0;
for (int i = 1; i <= x; i++) {
ans = (ans + dp[n][i]) % mod;
}
printf("%lld\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 3505;
int a[MX];
void solve() {
int n, m, k;
ignore = scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) {
ignore = scanf("%d", a + i);
}
int len = n - m + 1;
int ans = 1;
int L = 1, R = 1000000000;
while (L <= R) {
int M = (L + R) / 2;
bool good = false;
for (int l = 0; l <= min(m - 1, k); l++) {
int r = min(k - l, m - 1 - l);
bool ok = true;
for (int i = l; i + len - 1 < n - r; i++) {
ok = ok && (a[i] >= M || a[i + len - 1] >= M);
}
if (ok) {
good = true;
break;
}
}
if (good) {
ans = M;
L = M + 1;
} else {
R = M - 1;
}
}
printf("%d\n", ans);
}
int main() {
int tests;
ignore = scanf("%d", &tests);
while (tests--) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long mxp2(long long a) {
long long ans = pow(2, 60);
while (a % ans) ans /= 2;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, q, u, temp;
cin >> n >> q;
string s;
while (q--) {
cin >> u >> s;
for (char c : s) {
temp = mxp2(u);
if (c == 'L')
u -= temp / 2;
else if (c == 'R')
u += temp / 2;
else if (u != (n + 1) / 2) {
if ((u + temp) % (4 * temp))
u += temp;
else
u -= temp;
}
}
cout << u << '\n';
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 20;
int arr[N];
int main() {
int n, k, ans = 0;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
sort(arr, arr + n);
for (int i = 0; i < n; i++) {
if (arr[i] <= k * 2) continue;
int last = k;
if (i) last = max(k, arr[i - 1]);
while (arr[i] > last * 2) ans++, last *= 2;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 550;
const int MOD = 1e9 + 7;
const double eps = 1e-8;
const long long INF = 0x3f3f3f3f;
long long maxs(long long x1, long long x2) { return (x1 > x2) ? x1 : x2; }
int main() {
int n, m;
scanf("%d %d", &n, &m);
int hotel, restaurant;
scanf("%d", &hotel);
long long tmp1, tmp2;
int first = 1;
long long ff, zz, fz, zf;
for (int i = 0; i < hotel; ++i) {
scanf("%lld %lld", &tmp1, &tmp2);
if (first) {
ff = -tmp1 - tmp2;
zz = tmp1 + tmp2;
fz = -tmp1 + tmp2;
zf = tmp1 - tmp2;
first = 0;
} else {
ff = maxs(ff, -tmp1 - tmp2);
zz = maxs(zz, tmp1 + tmp2);
fz = maxs(fz, -tmp1 + tmp2);
zf = maxs(zf, tmp1 - tmp2);
}
}
scanf("%d", &restaurant);
long long result = INF << 32;
int flag;
for (int i = 0; i < restaurant; i++) {
scanf("%lld %lld", &tmp1, &tmp2);
long long tmp = maxs(maxs(tmp1 + tmp2 + ff, tmp1 - tmp2 + fz),
maxs(-tmp1 + tmp2 + zf, -tmp1 - tmp2 + zz));
if (tmp < result) {
result = tmp;
flag = i + 1;
}
}
printf("%lld\n%d\n", result, flag);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1000006], f[1000005];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
f[0] = 0;
for (int i = 1; i <= n; i++) f[i] = f[i - 1] ^ i;
int ans = 0;
for (int i = 1; i <= n; i++)
if ((n / i) % 2)
ans = ans ^ (f[i - 1]) ^ f[n % i] ^ a[i];
else
ans = ans ^ f[n % i] ^ a[i];
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy[] = {0, -1, 0, 1, -1, 1, 1, -1};
template <class T>
inline bool get(T& n) {
char c, mul = 1;
n = 0;
while (!isdigit(c = getchar_unlocked()) && (c != EOF) && (c != '-'))
;
if (c == EOF) return false;
if (c == '-') {
c = getchar_unlocked();
mul = -1;
}
for (; isdigit(c); c = getchar_unlocked()) n = n * 10 + c - '0';
n *= mul;
return true;
}
inline void get(char& c) {
while (isspace(c = getchar_unlocked()))
;
}
int main() {
long long n, m, k;
get(n);
get(m);
get(k);
if (n - 1 + m - 1 < k) {
printf("-1\n");
return 0;
}
long long ans = 0;
if (k <= m - 1)
ans = m / (k + 1) * n;
else
ans = n / (k - m + 2);
if (k <= n - 1)
(ans) = max((ans), (n / (k + 1) * m));
else
(ans) = max((ans), (m / (k - n + 2)));
printf("%I64d\n", ans);
return 0;
}
| 9 |
Subsets and Splits