solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void solve() {
string a, b, c;
cin >> a >> b >> c;
for (int i = 0; i < a.length(); i++) {
if (c[i] != a[i] && c[i] != b[i]) {
cout << "NO" << endl;
return;
}
}
cout << "YES" << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 1e5 + 10;
int a[maxn];
int s[maxn], g[maxn], dp[maxn];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
s[i] = s[i - 1] + a[i];
}
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
g[x] = max(g[x], y);
}
for (int i = 1; i <= k; i++) {
for (int j = 0; j < i; j++) {
dp[i] = max(dp[i], dp[j] + s[j + g[i - j]] - s[j]);
}
}
cout << s[k] - dp[k];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5;
long long d[N], e[N];
long long d_pref_min[N], e_pref_min[N];
long long dn = 0, en = 0;
pair<long long, long long> d_gadgets_pref_sum[N], e_gadgets_pref_sum[N];
long long n, m, k, s;
bool f(long long days, long long *d_cnt = nullptr, long long *e_cnt = nullptr) {
long long d_mn = d_pref_min[days - 1];
long long e_mn = e_pref_min[days - 1];
if (k <= dn && d_gadgets_pref_sum[k - 1].first * d_mn <= s) {
if (d_cnt && e_cnt) *d_cnt = k, *e_cnt = 0;
return true;
}
if (k <= en && e_gadgets_pref_sum[k - 1].first * e_mn <= s) {
if (d_cnt && e_cnt) *d_cnt = 0, *e_cnt = k;
return true;
}
for (long long i = 0, j = en - 1; i < dn && j >= 0; i++) {
while (d_gadgets_pref_sum[i].first * d_mn +
e_gadgets_pref_sum[j].first * e_mn >
s &&
j >= 0)
j--;
if (d_gadgets_pref_sum[i].first * d_mn +
e_gadgets_pref_sum[j].first * e_mn <=
s &&
i + j + 2 >= k && j >= 0) {
if (d_cnt && e_cnt) {
*d_cnt = i + 1;
*e_cnt = j + 1;
}
return true;
}
}
return false;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m >> k >> s;
for (long long i = 0; i < n; i++) {
cin >> d[i];
d_pref_min[i] = d[i];
if (i) d_pref_min[i] = min(d_pref_min[i], d_pref_min[i - 1]);
}
for (long long i = 0; i < n; i++) {
cin >> e[i];
e_pref_min[i] = e[i];
if (i) e_pref_min[i] = min(e_pref_min[i], e_pref_min[i - 1]);
}
for (long long i = 0; i < m; i++) {
long long t, c;
cin >> t >> c;
if (t == 1) {
d_gadgets_pref_sum[dn++] = make_pair(c, i);
} else {
e_gadgets_pref_sum[en++] = make_pair(c, i);
}
}
sort(d_gadgets_pref_sum, d_gadgets_pref_sum + dn);
sort(e_gadgets_pref_sum, e_gadgets_pref_sum + en);
for (long long i = 1; i < dn; i++) {
d_gadgets_pref_sum[i].first += d_gadgets_pref_sum[i - 1].first;
}
for (long long i = 1; i < en; i++) {
e_gadgets_pref_sum[i].first += e_gadgets_pref_sum[i - 1].first;
}
long long l = 1, r = n + 1;
while (r - l > 2) {
long long mid = (l + r) / 2;
if (f(mid))
r = mid + 1;
else
l = mid;
}
while (l < r) {
if (f(l)) break;
l++;
}
if (l == r)
cout << -1 << endl;
else {
cout << l << endl;
long long id = min_element(d, d + l) - d;
long long ie = min_element(e, e + l) - e;
long long *d_cnt = new long long;
long long *e_cnt = new long long;
f(l, d_cnt, e_cnt);
for (long long i = 0; i < *d_cnt; i++) {
cout << d_gadgets_pref_sum[i].second + 1 << " " << id + 1 << endl;
}
for (long long i = 0; i < *e_cnt; i++) {
cout << e_gadgets_pref_sum[i].second + 1 << " " << ie + 1 << endl;
}
delete d_cnt;
delete e_cnt;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300043;
bool is_bridge[N];
int w[N];
int c[N];
int v[N];
vector<pair<int, int> > g[N];
vector<pair<int, int> > g2[N];
int comp[N];
long long sum[N];
long long dp[N];
int cnt[N];
int fup[N];
int tin[N];
int T = 0;
long long ans[N];
int v1[N], v2[N];
int n, m, k;
int dfs1(int x, int e) {
tin[x] = T++;
fup[x] = tin[x];
for (int t = 0; t < g[x].size(); ++t) {
pair<int, int> p = g[x][t];
int y = p.first;
int i = p.second;
if (i == e) continue;
if (tin[y] != -1)
fup[x] = min(fup[x], tin[y]);
else {
fup[x] = min(fup[x], dfs1(y, i));
if (fup[y] > tin[x]) is_bridge[i] = true;
}
}
return fup[x];
}
void dfs2(int x, int cc) {
if (comp[x] != -1) return;
comp[x] = cc;
cnt[cc] += v[x];
sum[cc] += c[x];
for (int t = 0; t < g[x].size(); ++t) {
pair<int, int> y = g[x][t];
if (!is_bridge[y.second]) dfs2(y.first, cc);
}
}
void process_edge(int x, int y, int m, int weight) {
long long add_dp = dp[y];
if (cnt[y] > 0 && cnt[y] < k) add_dp = max(0ll, add_dp - weight);
cnt[x] += m * cnt[y];
dp[x] += m * add_dp;
}
void link(int x, int y, int weight) { process_edge(x, y, 1, weight); }
void cut(int x, int y, int weight) { process_edge(x, y, -1, weight); }
void dfs3(int x, int p) {
dp[x] = sum[x];
for (int t = 0; t < g2[x].size(); ++t) {
pair<int, int> e = g2[x][t];
int i = e.second;
int y = e.first;
if (y == p) continue;
dfs3(y, x);
link(x, y, w[i]);
}
}
void dfs4(int x, int p) {
ans[x] = dp[x];
for (int t = 0; t < g2[x].size(); ++t) {
pair<int, int> e = g2[x][t];
int i = e.second;
int y = e.first;
if (y == p) continue;
cut(x, y, w[i]);
link(y, x, w[i]);
dfs4(y, x);
cut(y, x, w[i]);
link(x, y, w[i]);
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
--x;
v[x] = 1;
}
for (int i = 0; i < n; i++) scanf("%d", &c[i]);
for (int i = 0; i < m; i++) scanf("%d", &w[i]);
for (int i = 0; i < m; i++) {
scanf("%d %d", &v1[i], &v2[i]);
--v1[i];
--v2[i];
g[v1[i]].push_back(make_pair(v2[i], i));
g[v2[i]].push_back(make_pair(v1[i], i));
}
for (int i = 0; i < n; i++) {
tin[i] = -1;
comp[i] = -1;
}
dfs1(0, -1);
int cc = 0;
for (int i = 0; i < n; i++)
if (comp[i] == -1) dfs2(i, cc++);
for (int i = 0; i < m; i++)
if (is_bridge[i]) {
g2[comp[v1[i]]].push_back(make_pair(comp[v2[i]], i));
g2[comp[v2[i]]].push_back(make_pair(comp[v1[i]], i));
}
dfs3(0, 0);
dfs4(0, 0);
for (int i = 0; i < n; i++) printf("%lld ", ans[comp[i]]);
puts("");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, t;
cin >> s >> t;
string p;
long long cnt = 0;
for (long long i = 0; i < s.size(); i++) {
if (s[i] != t[i]) {
p.push_back('a');
cnt += 1;
} else
p.push_back(s[i]);
}
if (cnt % 2 != 0) {
cout << "impossible";
return 0;
}
long long sz = cnt / 2;
for (long long i = 0; i < p.size(); i++) {
if (p[i] == 'a') {
if (sz > 0) {
p[i] = s[i];
sz -= 1;
} else {
if (s[i] == '1')
p[i] = '0';
else
p[i] = '1';
}
}
}
cout << p;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> b, a;
int main() {
long long p, k;
scanf("%lld %lld", &p, &k);
for (long long pre = p; pre;) {
long long now = (k - pre) / k;
if (now * k >= k - pre) --now;
b.push_back(pre = now);
}
a.push_back(p);
for (int i = 0; i < b.size(); ++i) {
if ((a[i] += b[i] * k) >= k) {
printf("-1\n");
return 0;
}
a.push_back(b[i]);
}
while (!a.back()) a.pop_back();
printf("%d\n", a.size());
for (int i = 0; i < a.size(); ++i) {
printf("%lld", a[i]);
if (i < a.size() - 1)
printf(" ");
else
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int size = 2100000, mod = 1000000007, inf = 0x3f3f3f3f;
const long long llmod = 4294967296, llinf = 0x3f3f3f3f3f3f3f3f;
const double pi = acos(-1.0), eps = 1e-6;
int month[2][13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int nex[2][8] = {-1, 0, 1, 0, -1, 1, 1, -1, 0, 1, 0, -1, 1, 1, 0, 0};
template <class T>
void inc(T& a, T b) {
a = (a + b) % mod;
}
template <class T>
T modu(T a) {
return (a % mod + mod) % mod;
}
template <class T>
void crl(T* l, T* r, int step) {
T tmp = *l;
for (T* i = l; i < r; i += step) *i = *(i + step);
*(r - 1) = tmp;
}
template <class T>
void crr(T* l, T* r, int step) {
T tmp = *(r - 1);
for (T* i = r - 1; i > l; i -= step) *i = *(i - step);
*l = tmp;
}
bool dbeq(double a, double b) { return fabs(a - b) < eps; }
template <class T>
void cmin(T& a, T b) {
a = min(a, b);
}
template <class T>
void cmax(T& a, T b) {
a = max(a, b);
}
int n, a, one, two;
long long dp[size], ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a, a == 1 ? one++ : two++;
dp[0] = dp[1] = 1;
for (int i = 2; i < one + 1; i++)
dp[i] = (dp[i - 1] + dp[i - 2] * (i - 1)) % mod;
ans = 1;
for (int i = 0; i < two; i++) ans = (ans * (one + 1 + i)) % mod;
printf("%I64d\n", ans * dp[one] % mod);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int k;
int p1[100005];
int p2[100005];
int u1;
int bs(int a) {
int n = 1;
int c1 = 0, c2 = 0;
while (n <= k) {
int p = lower_bound(p1 + n, p1 + k + 2, p1[n - 1] + a) - p1;
int q = lower_bound(p2 + n, p2 + k + 2, p2[n - 1] + a) - p2;
if (p == k + 1 && q == k + 1) return -1;
if (p < q) {
n = p + 1;
c1++;
} else {
c2++;
n = q + 1;
}
}
if (c1 > c2 && u1 == 1) {
return c1;
}
if (c2 > c1 && u1 == 2) {
return c2;
}
return -1;
}
int main() {
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> u1;
if (u1 == 1) {
p1[i] = p1[i - 1] + 1;
p2[i] = p2[i - 1];
} else {
p1[i] = p1[i - 1];
p2[i] = p2[i - 1] + 1;
}
}
p1[k + 1] = p2[k + 1] = 1000000000;
set<pair<int, int> > s1;
for (int t = 1; t <= k; t++) {
int g = bs(t);
if (g > 0) s1.insert(make_pair(g, t));
}
cout << s1.size() << endl;
set<pair<int, int> >::iterator it;
for (it = s1.begin(); it != s1.end(); ++it)
cout << it->first << " " << it->second << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int n, u, v, ans[N], mx[N], best[N];
vector<int> g[N];
map<int, int> mp[N];
int tmpval = 0;
map<int, int>::iterator it, it2;
inline void add(int node, int d, int val) {
mp[node][d] += val;
if (mp[node][d] > mx[node] || (mp[node][d] == mx[node] && d < best[node])) {
mx[node] = mp[node][d];
best[node] = d;
}
}
void DFS(int node, int prnt, int d) {
int mx2 = -1, idx = -1;
for (int i = 0; i < g[node].size(); i++) {
if (g[node][i] == prnt) continue;
DFS(g[node][i], node, d + 1);
if ((int)mp[g[node][i]].size() > mx2) {
mx2 = mp[g[node][i]].size();
idx = i;
}
}
if (idx == -1) {
ans[node] = 0;
mx[node] = 1;
best[node] = d;
mp[node][d] = 1;
return;
}
swap(mp[node], mp[g[node][idx]]);
mx[node] = mx[g[node][idx]];
best[node] = best[g[node][idx]];
add(node, d, 1);
for (int i = 0; i < g[node].size(); i++) {
if (g[node][i] == prnt || i == idx) continue;
for (it2 = mp[g[node][i]].begin(); it2 != mp[g[node][i]].end(); it2++) {
add(node, it2->first, it2->second);
}
}
ans[node] = best[node] - d;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
DFS(1, -1, 0);
for (int i = 1; i <= n; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int NN = 2000, N0 = 1010;
bool flag[N0];
int a[N0 * N0];
bitset<2020> s[2];
int main() {
int k, n, f = 0;
scanf("%d %d", &k, &n);
for (; n; n--) {
int x;
scanf("%d", &x);
if (x == k) puts("1"), exit(0);
flag[x] = 1;
}
for (int i = 1001; i--;)
if (flag[i]) {
s[f].set(N0 + (a[n++] = k - i));
}
for (int i = 1, c; i < NN; i++, f = c) {
c = f ^ 1;
if (s[f][N0]) printf("%d", i), exit(0);
s[c].reset();
for (int j = n; j--;) {
if (a[j] > 0)
s[c] = s[c] | s[f] << a[j];
else
s[c] = s[c] | s[f] >> -a[j];
}
}
puts("-1");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string arr[110];
bool graph[26][26];
bool visited[26];
bool current[26];
string ans;
bool fail;
void topo(int n) {
visited[n] = 1;
current[n] = 1;
for (int i = 0; i < 26; ++i) {
if (graph[n][i]) {
if (!visited[i])
topo(i);
else if (current[i]) {
fail = true;
return;
}
}
}
ans = (char)(n + 'a') + ans;
current[n] = 0;
}
int main() {
int n, l1, l2;
scanf("%d", &n);
for (int i = 0; i < n; ++i) cin >> arr[i];
fail = false;
for (int i = 0; i < n - 1; ++i) {
bool flag = false;
l1 = arr[i].length();
l2 = arr[i + 1].length();
for (int j = 0; j < min(l1, l2); ++j) {
if (arr[i][j] != arr[i + 1][j]) {
graph[arr[i][j] - 'a'][arr[i + 1][j] - 'a'] = 1;
flag = true;
break;
}
}
if (!flag && l1 > l2) fail = true;
}
if (fail) {
printf("Impossible\n");
return 0;
}
ans = "";
for (int i = 0; i < 26; ++i) {
if (!visited[i]) topo(i);
}
if (fail)
printf("Impossible\n");
else
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
int T;
cin >> T;
while (T--) {
int x, y, p;
string s;
cin >> x >> y >> p >> s;
int cur = s.size() - 2;
if (s[cur] == 'B') swap(x, y);
for (; cur >= 0; cur--) {
if (p >= x) {
p -= x;
} else {
break;
}
while (cur - 1 >= 0 && s[cur - 1] == s[cur]) cur--;
swap(x, y);
}
cout << cur + 2 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
long long dp[10];
dp[0] = 0;
for (int i = 1; i < 10; ++i) {
dp[i] = -1e18;
}
while (n-- > 0) {
int k;
cin >> k;
multiset<long long> us[3];
for (int i = 0; i < k; ++i) {
long long a, b;
cin >> a >> b;
--a;
b = -b;
us[a].insert(b);
}
long long temp[10];
for (int i = 0; i < 10; ++i) {
temp[i] = dp[i];
}
if (us[2].size()) {
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 1) % 10;
if (to) {
temp[to] = max(temp[to], dp[i] - *us[2].begin());
} else {
temp[to] = max(temp[to], dp[i] - (*us[2].begin()) * (long long)2);
}
}
}
if (us[1].size()) {
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 1) % 10;
if (to) {
temp[to] = max(temp[to], dp[i] - *us[1].begin());
} else {
temp[to] = max(temp[to], dp[i] - (*us[1].begin()) * (long long)2);
}
}
}
if (us[1].size() && us[0].size()) {
long long kek = 0;
kek -= *us[1].begin();
kek -= *us[0].begin();
long long mx = max(-*us[1].begin(), -*us[0].begin());
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 2) % 10;
if (to > i) {
temp[to] = max(temp[to], dp[i] + kek);
} else {
temp[to] = max(temp[to], dp[i] + kek + mx);
}
}
}
if (us[0].size()) {
if (us[0].size() >= 1) {
long long kek = -*us[0].begin();
long long mx = kek;
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 1) % 10;
if (to) {
temp[to] = max(temp[to], dp[i] + kek);
} else {
temp[to] = max(temp[to], dp[i] + kek + mx);
}
}
}
if (us[0].size() >= 2) {
long long kek = -*us[0].begin();
long long mx = kek;
long long last = *us[0].begin();
us[0].erase(us[0].begin());
kek -= *us[0].begin();
mx = max(mx, -*us[0].begin());
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 2) % 10;
if (to > i) {
temp[to] = max(temp[to], dp[i] + kek);
} else {
temp[to] = max(temp[to], dp[i] + kek + mx);
}
}
us[0].insert(last);
}
if (us[0].size() >= 3) {
long long kek = -*us[0].begin();
long long mx = kek;
us[0].erase(us[0].begin());
kek -= *us[0].begin();
mx = max(mx, -*us[0].begin());
us[0].erase(us[0].begin());
kek -= *us[0].begin();
mx = max(mx, -*us[0].begin());
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 3) % 10;
if (to > i) {
temp[to] = max(temp[to], dp[i] + kek);
} else {
temp[to] = max(temp[to], dp[i] + kek + mx);
}
}
}
}
for (int i = 0; i < 10; ++i) {
dp[i] = temp[i];
}
}
long long ans = -1e18;
for (int i = 0; i < 10; ++i) {
ans = max(ans, dp[i]);
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 2;
const int inf = 1e9;
const int maxSQRT = 1500;
const int SZ = 9;
const int blockSize = 1 << SZ;
const int MOD = blockSize - 1;
struct event {
int x, type, id, p;
event() {}
event(int x, int type, int id) : x(x), type(type), id(id) {}
void Epr() { fprintf(stderr, "x type id p %d %d %d %d \n", x, type, id, p); }
};
event a[maxn];
int t[maxn];
int b[maxSQRT];
int preCalc[maxSQRT][maxSQRT];
int c[maxn];
int l[maxn];
int r[maxn];
vector<vector<int> > q;
int n, m;
int blockCnt;
inline bool cmp(const event& a, const event& b) {
return a.x < b.x || (a.x == b.x && a.type > b.type);
}
inline int query(int l, int r) {
int ll, rr, lb, rb, ans = 0;
int N = n * 2;
ll = lower_bound(a, a + N, event(l, 10, 10), cmp) - a;
rr = lower_bound(a, a + N, event(r, 10, 10), cmp) - a;
lb = (ll >> SZ) + 1;
rb = (rr >> SZ);
int rrr = min(rr, lb * blockSize);
for (int i = ll; i < rrr; i++) ans += (a[i].type == 1 && a[i].p < rr);
ans += preCalc[lb][rb];
if (lb <= rb)
for (int i = rb * blockSize; i < rr; i++)
ans += (a[i].type == -1 && a[i].p >= (lb << SZ));
return ans;
}
void read() {
int k, x;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d%d", &l[i], &r[i]);
}
q.resize(m);
for (int i = 0; i < m; i++) {
scanf("%d", &k);
for (int j = 0; j < k; j++) {
scanf("%d", &x);
q[i].push_back(x);
}
}
}
vector<int> solve() {
int k, res, N;
vector<int> ans;
for (int i = 0; i < n; i++) {
a[i * 2] = event(l[i], 1, i);
a[i * 2 + 1] = event(r[i], -1, i);
}
N = n * 2;
sort(a, a + N, cmp);
cerr << "1 time: " << clock() * 1.0 / CLOCKS_PER_SEC << endl;
blockCnt = (N + blockSize - 1) / blockSize;
for (int i = 0; i < N; i++) {
if (a[i].type == 1) t[a[i].id] = i;
if (a[i].type == -1) {
a[i].p = t[a[i].id];
a[t[a[i].id]].p = i;
}
}
cerr << "2 time: " << clock() * 1.0 / CLOCKS_PER_SEC << endl;
for (int i = 0; i < blockCnt; i++) {
memset(b, 0, sizeof(b));
for (int j = i * blockSize; j < N; j++)
b[a[j].p / blockSize] += (a[j].type == 1);
int cnt = 0;
for (int j = i; j < blockCnt; j++) {
cnt += b[j];
preCalc[i][j + 1] = cnt;
}
}
cerr << "3 time: " << clock() * 1.0 / CLOCKS_PER_SEC << endl;
for (int tt = 0; tt < m; tt++) {
k = q[tt].size();
c[0] = -100;
for (int i = 0; i < k; i++) c[i + 1] = q[tt][i];
c[k + 1] = inf;
k += 2;
res = N / 2;
for (int i = 0; i < k - 1; i++) res -= query(c[i] + 1, c[i + 1]);
ans.push_back(res);
}
cerr << "4 time: " << clock() * 1.0 / CLOCKS_PER_SEC << endl;
return ans;
}
void gen() {
n = 3e5;
m = 1e5;
for (int i = 0; i < n; i++) {
l[i] = rand() % 1000000;
r[i] = rand() % 1000000;
if (l[i] > r[i]) swap(l[i], r[i]);
}
q.resize(m);
for (int j = 0; j < m; j++) {
q[j].clear();
int k = rand() % 5 + 1;
for (int i = 0; i < k; i++) q[j].push_back(rand() % 1000000);
sort(q[j].begin(), q[j].end());
}
}
vector<int> stupid() {
vector<pair<int, int> > a;
vector<int> ans;
for (int i = 0; i < n; i++) {
a.push_back(make_pair(l[i], r[i] + 1));
a.push_back(make_pair(r[i] + 1, l[i]));
}
sort(a.begin(), a.end());
int prev = -1;
int res = 0;
int cnt = 0;
int cur = 0;
for (int i = 0; i < (int)a.size(); i++) {
assert(cnt >= 0);
for (; cur < (int)q[0].size() && q[0][cur] < a[i].first; cur++) {
prev = q[0][cur];
res += cnt;
cnt = 0;
cerr << "res i: " << res << " " << i << endl;
}
if (a[i].first < a[i].second) {
cnt++;
} else {
if (a[i].second > prev) cnt--;
}
}
res += cnt;
ans.push_back(res);
return ans;
}
void stress() {
vector<int> ans1, ans2;
for (int t = 0; t < 10000; t++) {
cerr << "test Id: " << t << endl;
gen();
ans1 = solve();
ans2 = stupid();
assert(ans1.size() == ans2.size());
bool flag = 1;
for (int i = 0; i < (int)ans1.size(); i++) flag &= ans1[i] == ans2[i];
for (int i = 0; i < (int)ans1.size(); i++) cerr << ans1[i] << " ";
for (int i = 0; i < (int)ans1.size(); i++) cerr << ans2[i] << " ";
cerr << endl;
if (!flag) {
cerr << "fail\n";
cout << "n m " << n << " " << m << endl;
for (int i = 0; i < n; i++) cout << l[i] << " " << r[i] << "\n";
for (int i = 0; i < m; i++, cout << endl)
for (int j = 0; j < (int)q[i].size(); j++) cout << q[i][j] << " ";
return;
}
}
}
int main() {
vector<int> ans;
if (1) {
if (0)
stress();
else {
read();
ans = solve();
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
}
return 0;
}
gen();
cout << n << " " << m << endl;
for (int i = 0; i < n; i++) cout << l[i] << " " << r[i] << "\n";
for (int i = 0; i < m; i++, cout << endl) {
cout << q[i].size() << " ";
for (int j = 0; j < (int)q[i].size(); j++) cout << q[i][j] << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mn = (1 << 17) + 10;
const int mod = 1 * (int)(1e9) + 7;
const int mm = 1 * (int)(1e3) + 10;
const int base = 1 * (int)(1e9);
const bool aNs = 0;
int tt, ntest = 1;
void docfile() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
if (ifstream("test.inp")) {
freopen("test.inp", "r", stdin);
if (!aNs)
freopen("test.out", "w", stdout);
else
freopen("test.ans", "w", stdout);
} else if (ifstream("1315e.inp")) {
freopen("1315e.inp", "r", stdin);
freopen("1315e.out", "w", stdout);
}
}
template <typename T>
void read(T& x) {
x = 0;
T f = 1;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-' ? -f : f, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
template <typename T>
void write(T a) {
if (a < 0) {
putchar('-');
write(-a);
return;
}
if (a < 10) {
putchar('0' + a);
return;
}
write(a / 10);
putchar((char)('0' + (a % 10)));
}
bool ok[mn];
int f[18][mn][2][2];
void enter() {
int n, k;
cin >> n >> k;
memset(f, -1, sizeof(f));
for (int i = 0; i < k; ++i) {
int x;
cin >> x;
ok[--x] = 1;
}
for (int i = 0; i < (1 << n); ++i) f[0][i][ok[i]][0] = 0;
int sol = 0;
for (int t = 1; t <= n; ++t)
for (int k = 0; k < (1 << (n - t)); ++k)
for (int u1 = 0; u1 < 2; ++u1)
for (int d1 = 0; d1 < 2; ++d1)
for (int u2 = 0; u2 < 2; ++u2)
for (int d2 = 0; d2 < 2; ++d2)
for (int w1 = 0; w1 < 2; ++w1)
for (int w2 = 0; w2 < 2; ++w2)
for (int w3 = 0; w3 < 2; ++w3)
if (f[t - 1][2 * k][u1][d1] != -1)
if (f[t - 1][2 * k + 1][u2][d2] != -1) {
int res = f[t - 1][2 * k][u1][d1] +
f[t - 1][2 * k + 1][u2][d2];
if (d1 || d2) ++res;
int d31 = (w1 ? d2 : d1);
if (u1 || u2) ++res;
int d32 = (w2 ? u2 : u1);
int U = (w2 ? u1 : u2);
if ((d31 || d32) && (t != 1)) ++res;
int D = (w3 ? d31 : d32);
f[t][k][U][D] = max(f[t][k][U][D], res);
if (t == n) sol = max(sol, f[t][k][U][D] + (U || D));
}
cout << sol;
}
void solve() {}
void print_result() {}
int main() {
docfile();
for (tt = 1; tt <= ntest; ++tt) {
enter();
solve();
print_result();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<string> v(1002);
vector<string> t(1002);
long long n, m;
long long sx, sy;
long long px, py;
vector<pair<int, int> > getd(long long x, long long y) {
sx = x;
sy = y;
px = sx;
py = sy;
vector<pair<int, int> > result;
long long a = 0, b = 0;
for (int i = x; i < n; i++) {
if (v[i][y] == '.') break;
a++;
}
for (int j = y; j < m; j++) {
if (v[x][j] == '.') break;
b++;
}
if (y + b < m) {
for (int i = x; i < x + a; i++) {
if (v[i][y + b] == 'X') {
result.push_back(pair<int, int>(x + a - i, b));
break;
}
}
}
if (x + a < n) {
for (int i = y; i < y + b; i++) {
if (v[x + a][i] == 'X') {
result.push_back(pair<int, int>(a, y + b - i));
break;
}
}
}
if (result.empty()) {
if (a < b) {
result.push_back(pair<int, int>(a, 1));
} else {
result.push_back(pair<int, int>(1, b));
}
}
return result;
}
bool check(int a, int b) {
sx = px;
sy = py;
for (int i = 0; i < n; i++) t[i] = v[i];
bool flag = true;
for (int i = sx; i < sx + a; i++)
for (int j = sy; j < sy + b; j++) {
if (t[i][j] == '.') return false;
t[i][j] = '.';
}
while (true) {
if (sy + b < m && t[sx][sy + b] == 'X') {
for (int i = sx; i < sx + a; i++) {
if (t[i][sy + b] == '.') return false;
t[i][sy + b] = '.';
}
sy++;
} else if (sx + a < n && t[sx + a][sy] == 'X') {
for (int j = sy; j < sy + b; j++) {
if (t[sx + a][j] == '.') return false;
t[sx + a][j] = '.';
}
sx++;
} else {
break;
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (t[i][j] == 'X') return false;
return true;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> v[i];
vector<pair<int, int> > c;
bool valid = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (v[i][j] == 'X') {
c = getd(i, j);
valid = false;
break;
}
}
if (!valid) break;
}
long long area = -1;
for (int i = 0; i < (int)c.size(); i++) {
if (check(c[i].first, c[i].second)) {
if (area == -1 || area > c[i].first * c[i].second) {
area = c[i].first * c[i].second;
}
}
}
cout << area << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long dp[1001][1001][2][2][2][2];
int ln = 1000, k;
string arr, brr;
long long fun(int pos, int prev, int choto, int boro, int suru, int status) {
if (pos < 0) {
return status;
}
long long &ret = dp[pos][prev][choto][boro][suru][status];
if (ret != -1 && choto && boro) return ret;
int lo = 0, hi = 9;
if (choto == 0) hi = brr[pos] - '0';
if (boro == 0) lo = arr[pos] - '0';
ret = 0;
for (int i = lo; i <= hi; i++) {
int n_prev = prev;
int n_status = status;
int n_suru = suru;
if (i == 4 || i == 7) {
if (n_suru == 1) {
if (abs(pos - n_prev) <= k) n_status |= 1;
}
n_suru |= 1;
n_prev = pos;
}
ret += fun(pos - 1, n_prev, choto | (i < hi), boro | (i > lo), n_suru,
n_status);
ret %= 1000000007;
}
return ret;
}
int main() {
int t;
scanf("%d %d", &t, &k);
memset(dp, -1, sizeof(dp));
while (t--) {
cin >> arr >> brr;
string addd = arr;
string add = "";
int sz = max(arr.size(), brr.size());
int dif = sz - arr.size();
while (dif--) add += '0';
arr = add + arr;
add = "";
dif = sz - brr.size();
while (dif--) add += '0';
brr = add + brr;
reverse(arr.begin(), arr.end());
reverse(brr.begin(), brr.end());
long long ans = fun(sz - 1, 0, 0, 0, 0, 0);
printf("%lld\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print(const vector<T>& a, const string& name = "") {
if (!name.empty()) cout << name << ": ";
for (const auto& item : a) {
cout << item << " ";
}
cout << endl;
}
template <typename T1, typename T2>
void print(const pair<T1, T2>& p, const string& name = "") {
if (!name.empty()) cout << name << ": ";
cout << "(" << p.first << ", " << p.second << ") " << endl;
}
template <typename T1, typename T2>
void print(const vector<pair<T1, T2>>& pairs, const string& name = "") {
if (!name.empty()) cout << name << ": ";
for (const auto& pair : pairs) {
cout << "(" << pair.first << ", " << pair.second << ") ";
}
cout << endl;
}
template <typename T, typename Compare>
void print(const set<T, Compare>& s, const string& name = "") {
if (!name.empty()) cout << name << ": ";
for (const auto& element : s) {
cout << element << " ";
}
cout << endl;
}
template <typename T1, typename T2, typename Compare>
void print(const map<T1, T2, Compare>& m, const string& name = "") {
if (!name.empty()) cout << name << ": ";
for (const auto& p : m) {
cout << "(" << p.first << ", " << p.second << ") ";
}
cout << endl;
}
template <typename T>
void print(const unordered_set<T>& s, const string& name = "") {
if (!name.empty()) cout << name << ": ";
for (const auto& element : s) {
cout << element << " ";
}
cout << endl;
}
template <typename T1, typename T2>
void print(const unordered_map<T1, T2>& m, const string& name = "") {
if (!name.empty()) cout << name << ": ";
for (const auto& p : m) {
cout << "(" << p.first << ", " << p.second << ") ";
}
cout << endl;
}
template <typename T>
void print(const vector<vector<T>>& matrix, const string& name = "") {
if (!name.empty()) cout << name << ": " << endl;
for (const auto& row : matrix) {
for (const auto& element : row) {
cout << element << " ";
}
cout << endl;
}
}
template <class T>
struct RangeMinimumQuery {
vector<T> arr;
vector<vector<T>> table;
RangeMinimumQuery(const vector<T>& a) : arr(a) {
precompute();
};
void precompute() {
int N = arr.size();
int logN = log2(N);
table = vector<vector<T>>(N, vector<T>(logN + 1));
// Bottom up DP. Base cases.
for (int i = 0; i < N; ++i) {
table[i][0] = arr[i];
}
// Recursion. Loop over length (i.e. j) should be first.
for (int j = 1; j < logN + 1; ++j) {
for (int i = 0; i + (1 << j) - 1 < N; ++i) {
table[i][j] = min(table[i][j - 1],
table[i + (1 << (j - 1))][j - 1]);
}
}
}
int query(int left, int right) const {
if (left == right) return table[left][0];
int k = log2(right - left);
T answer = min(table[left][k],
table[right - (1 << k) + 1][k]);
return answer;
}
};
bool isperm(const vector<int>& vals) {
vector<int> vals_copy = vals;
sort(vals_copy.begin(), vals_copy.end());
for (int i = 1; i <= vals_copy.size(); ++i) {
if (vals_copy[i - 1] != i) return false;
}
return true;
}
bool isperm(const vector<int>& vals, int k,
const RangeMinimumQuery<int>& rmq) {
const int N = vals.size();
vector<int> min_vals;
for (int i = 0; i + k - 1 < N; ++i) {
min_vals.push_back(rmq.query(i, i + k - 1));
}
// print(min_vals, "k = " + to_string(k) + ": ");
return isperm(min_vals);
}
void solve() {
int N;
cin >> N;
vector<int> values(N);
bool contains_one = false;
for (int i = 0; i < N; ++i) {
cin >> values[i];
if (values[i] == 1) contains_one = true;
}
if (!contains_one) {
cout << string(N, '0') << endl;
return;
}
RangeMinimumQuery<int> rmq(values);
// k = 2...N
int lo = 2;
int hi = N;
while (lo < hi) {
const int mid = lo + (hi - lo) / 2;
if (isperm(values, mid, rmq)) {
hi = mid;
} else {
lo = mid + 1;
}
}
// k = 1.
if (isperm(values)) {
cout << 1;
} else {
cout << 0;
}
// k = 2...lo
for (int i = 2; i < lo; ++i) {
cout << 0;
}
for (int i = lo; i <= N; ++i) {
cout << 1;
}
cout << endl;
}
int main() {
int num_cases;
cin >> num_cases;
for (int i = 0; i < num_cases; ++i) {
solve();
}
} | 5 |
#include <bits/stdc++.h>
using namespace std;
long long binpow(long long base, long long exp) {
long long mod = 1000000007LL;
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % mod;
exp = exp >> 1;
base = (base * base) % mod;
}
return res;
}
long long mod(long long x) {
return ((x % 1000000007LL + 1000000007LL) % 1000000007LL);
}
long long add(long long a, long long b) { return mod(mod(a) + mod(b)); }
long long mul(long long a, long long b) { return mod(mod(a) * mod(b)); }
bool isPrime(long long n) {
if (n <= 1) return false;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
const long long N = (long long)1e6;
void sieve(long long N) {
bool prime[N + 1];
memset(prime, true, sizeof(prime));
for (long long p = 2; p * p <= N; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= N; i += p) prime[i] = false;
}
}
}
long long fact(long long n) {
long long res = 1;
for (long long i = 1; i <= n; i++) {
res = res * 1ll * i % 1000000007LL;
}
return res;
}
long long C(long long n, long long k) {
return fact(n) * 1ll * binpow(fact(k), 1000000007LL - 2) % 1000000007LL *
1ll * binpow(fact(n - k), 1000000007LL - 2) % 1000000007LL;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
long long n = s.length();
long long flag = 0;
for (auto x : s) {
if (x == 'm' || x == 'w') {
flag = 1;
break;
}
}
if (flag) {
cout << 0;
} else {
vector<long long> dp(n + 1, 0);
dp[0] = 1;
dp[1] = 1;
for (long long i = 1; i < n; i++) {
if (s[i] == s[i - 1] && (s[i] == 'u' || s[i] == 'n')) {
dp[i + 1] = (dp[i] + dp[i - 1]) % 1000000007LL;
} else {
dp[i + 1] = dp[i] % 1000000007LL;
}
}
cout << dp[n];
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void err(istream_iterator<string> it) { cout << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << " ";
err(++it, args...);
}
const int MAX = 1E6 + 10;
int visited[MAX], parent[MAX];
vector<vector<int> > adj(MAX);
int DFS(int u, int p) {
int res = 0;
visited[u] = 1;
for (int v : adj[u]) {
if (v != p) {
res = max(res, DFS(v, u));
}
}
return res + 1;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int p;
cin >> p;
if (p != -1) {
parent[i] = p;
adj[p].push_back(i);
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (!visited[i] && parent[i] == 0) res = max(res, DFS(i, 0));
}
cout << res;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int dsu[N];
int rang[N];
int pred(int a) {
if (a == dsu[a]) return a;
return dsu[a] = pred(dsu[a]);
}
void unite(int a, int b) {
a = pred(a);
b = pred(b);
if (a != b) {
if (rang[a] < rang[b]) {
swap(a, b);
}
dsu[b] = a;
rang[a] += rang[b];
}
}
bool connected(int a, int b) { return pred(a) == pred(b); }
bool used[N];
int color;
int t;
int p[N];
vector<int> colors[N];
void dfs(int v) {
used[v] = 1;
colors[t].push_back(v);
if (!used[p[v]]) {
dfs(p[v]);
}
}
signed main() {
int n, s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
dsu[i] = i;
rang[i] = 1;
}
vector<int> a(n);
vector<pair<int, int> > b;
for (int i = 0; i < n; i++) {
cin >> a[i];
b.push_back({a[i], i});
}
vector<int> ind(n);
sort(b.begin(), b.end());
for (int i = 0; i < n; i++) {
p[b[i].second] = i;
}
for (int i = 0; i < n; i++) {
if (a[i] == b[i].first && p[i] != i) {
p[b[i].second] = p[i];
b[p[i]].second = b[i].second;
p[i] = i;
b[i].second = i;
}
}
for (int i = 0; i < n; i++) {
unite(p[i], i);
}
int it = -1;
for (int i = 0; i < n; i++) {
if (p[b[i].second] == b[i].second) {
continue;
}
if (it >= 0 && a[it] == a[b[i].second]) {
int x = it;
int y = b[i].second;
if (!connected(x, y)) {
unite(x, y);
swap(p[x], p[y]);
}
}
it = b[i].second;
}
t = 0;
for (int i = 0; i < n; i++) {
if (!used[i] && p[i] != i) {
dfs(i);
t++;
}
}
int cnt = 0;
for (int i = 0; i < t; i++) {
cnt += colors[i].size();
}
if (cnt > s) {
cout << -1;
return 0;
}
s -= cnt;
s = min(s, t);
if (s <= 1) {
cout << t << "\n";
for (int i = 0; i < t; i++) {
cout << colors[i].size() << "\n";
for (int j = 0; j < colors[i].size(); j++) {
cout << colors[i][j] + 1 << " ";
}
cout << "\n";
}
return 0;
}
cout << (t - s + 2) << "\n";
for (int i = 0; i < t - s; i++) {
cout << colors[i + s].size() << "\n";
for (int j = 0; j < colors[i + s].size(); j++) {
cout << colors[i + s][j] + 1 << " ";
}
cout << "\n";
cnt -= colors[i + s].size();
}
cout << cnt << "\n";
for (int i = 0; i < s; i++) {
for (int j = 0; j < colors[i].size(); j++) {
cout << colors[i][j] + 1 << " ";
}
}
cout << "\n";
cout << s << "\n";
for (int i = s - 1; i >= 0; i--) {
cout << colors[i][0] + 1 << " ";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 1000;
int n, m, q;
long long tmp;
int vis[maxn];
pair<long long, long long> a[maxn], b[maxn];
int ans[maxn];
int v[maxn * 4];
void build(int l, int r, int x) {
v[x] = 0;
if (r == l) {
return;
}
int mid = (l + r) / 2;
build(l, mid, x << 1);
build(mid + 1, r, x << 1 | 1);
}
void update(int l, int r, int pos, int x) {
if (l == pos && r == pos) {
v[x] = 1;
return;
}
int mid = (l + r) / 2;
if (pos <= mid)
update(l, mid, pos, x << 1);
else
update(mid + 1, r, pos, x << 1 | 1);
v[x] = v[x << 1] + v[x << 1 | 1];
}
int query(int l, int r, int pos, int x) {
if (l == r) {
return l;
}
int mid = (l + r) / 2;
if (v[x << 1] >= pos) {
return query(l, mid, pos, x << 1);
}
return query(mid + 1, r, pos - v[x << 1], x << 1 | 1);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 0; i < n; ++i) {
cin >> tmp;
vis[tmp]++;
}
build(1, m, 1);
for (int i = 1; i <= m; ++i) {
a[i] = {vis[i], i};
}
for (int i = 0; i < q; ++i) {
cin >> tmp;
b[i] = {tmp, i};
}
sort(a + 1, a + m + 1);
sort(b, b + q);
long long tmp = n, ttmp;
int j = 1;
for (int i = 0; i < q; ++i) {
while (b[i].first > tmp && j <= m) {
int tt = a[j].first;
while (j <= m && a[j].first == tt) {
update(1, m, a[j].second, 1);
++j;
}
ttmp = tmp;
if (j > m) {
tmp += (a[m].first - tt) * (j - 1);
} else {
tmp += (a[j].first - tt) * (j - 1);
}
}
int ind = (b[i].first - ttmp) % (j - 1);
if (!ind) {
ind = j - 1;
}
ans[b[i].second] = query(1, m, ind, 1);
}
for (int i = 0; i < q; ++i) {
cout << ans[i] << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int N = 1010;
const long long MOD = 1e9 + 7;
using namespace std;
int n;
long long f[N][N], ans = 0;
int main() {
scanf("%d", &n);
f[0][0] = 1;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= i; j++) {
f[i + 1][j] = (f[i + 1][j] + f[i][j]) % MOD;
if (i > j) f[i][j + 1] = (f[i][j + 1] + f[i][j]) % MOD;
}
}
for (int i = 1; i <= n; i++)
for (int j = 0; j <= i; j++)
if ((i + j) % 2 == 1) ans = (ans + f[i][j]) % MOD;
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string a[100010];
int main() {
int i, t, n, j;
int zer = 0;
string x;
cin >> n;
int flag = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
}
x = "1";
int tmp = 0, flag2 = 0;
for (i = 0; i < n; i++) {
tmp = 0;
flag2 = 0;
if (a[i][0] == '0') {
flag = 1;
break;
}
for (j = 0; j < (int)(a[i].size()); j++) {
if (j == 0) {
if (a[i][j] != '1') {
x = a[i];
flag2 = 1;
break;
}
} else if (a[i][j] != '0') {
x = a[i];
flag2 = 1;
break;
} else
tmp++;
}
if (flag2 == 0) zer += tmp;
}
if (flag)
cout << 0 << endl;
else {
cout << x;
for (i = 0; i < zer; i++) cout << 0;
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(2e5) + 99;
const int INF = int(1e9) + 100;
int t;
int n;
long long s;
pair<int, int> p[N];
bool ok(int mid) {
long long sum = 0;
int cnt = 0;
vector<int> v;
for (int i = 0; i < n; ++i) {
if (p[i].second < mid)
sum += p[i].first;
else if (p[i].first >= mid) {
sum += p[i].first;
++cnt;
} else
v.push_back(p[i].first);
}
assert(is_sorted(v.begin(), v.end()));
int need = max(0, (n + 1) / 2 - cnt);
if (need > v.size()) return false;
for (int i = 0; i < v.size(); ++i) {
if (i < v.size() - need)
sum += v[i];
else
sum += mid;
}
return sum <= s;
}
int main() {
scanf("%d", &t);
for (int tc = 0; tc < t; ++tc) {
scanf("%d %lld", &n, &s);
for (int i = 0; i < n; ++i) scanf("%d %d", &p[i].first, &p[i].second);
sort(p, p + n);
int lf = 1, rg = INF;
while (rg - lf > 1) {
int mid = (lf + rg) / 2;
if (ok(mid))
lf = mid;
else
rg = mid;
}
printf("%d\n", lf);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, K;
long long f[100005][205];
struct node {
long long zhi, nx;
} tt[400005], jl[100005];
bool operator<(node aa, node bb) {
return aa.zhi != bb.zhi ? aa.zhi < bb.zhi : aa.nx < bb.nx;
}
void update(long long rt, long long ll, long long rr, long long L, long long R,
node kk) {
if (ll == L && rr == R) {
if (tt[rt] < kk) tt[rt] = kk;
return;
}
long long mid = (ll + rr) >> 1;
if (R <= mid)
update(rt << 1, ll, mid, L, R, kk);
else if (L > mid)
update(rt << 1 | 1, mid + 1, rr, L, R, kk);
else
update(rt << 1, ll, mid, L, mid, kk),
update(rt << 1 | 1, mid + 1, rr, mid + 1, R, kk);
return;
}
void bt(long long rt, long long ll, long long rr) {
if (ll == rr) {
jl[ll] = tt[rt];
return;
}
long long mid = (ll + rr) >> 1;
if (tt[rt << 1] < tt[rt]) tt[rt << 1] = tt[rt];
if (tt[rt << 1 | 1] < tt[rt]) tt[rt << 1 | 1] = tt[rt];
bt(rt << 1, ll, mid);
bt(rt << 1 | 1, mid + 1, rr);
return;
}
int main() {
scanf("%lld%lld%lld", &n, &m, &K);
for (long long i = 1; i <= K; ++i) {
long long x, y, z, o;
scanf("%lld%lld%lld%lld", &x, &y, &o, &z);
update(1, 1, n, x, y, (node){z, o});
}
bt(1, 1, n);
for (long long i = 0; i <= m; ++i) f[n + 1][i] = 0;
for (long long i = n; i >= 1; --i) {
if (!jl[i].zhi) {
for (long long j = 0; j <= m; ++j) f[i][j] = f[i + 1][j];
} else {
for (long long j = 0; j <= m; ++j) {
f[i][j] = f[jl[i].nx + 1][j] + jl[i].zhi;
if (j) f[i][j] = min(f[i][j], f[i + 1][j - 1]);
}
}
}
printf("%lld", f[1][m]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
template <class T>
std::vector<T> vec(int len, T elem) {
return std::vector<T>(len, elem);
}
template <class T>
std::map<T, int> compress(std::vector<T>& v) {
std::sort(v.begin(), v.end());
v.erase(std::unique(v.begin(), v.end()), v.end());
std::map<T, int> rev;
for (int i = 0; i < (int)v.size(); ++i) rev[v[i]] = i;
return rev;
}
template <int MOD>
struct ModInt {
using lint = long long;
int val;
ModInt(lint v = 0) : val(v % MOD) {
if (val < 0) val += MOD;
};
ModInt operator+() const { return ModInt(val); }
ModInt operator-() const { return ModInt(MOD - val); }
ModInt inv() const { return this->pow(MOD - 2); }
ModInt operator+(const ModInt& x) const { return ModInt(*this) += x; }
ModInt operator-(const ModInt& x) const { return ModInt(*this) -= x; }
ModInt operator*(const ModInt& x) const { return ModInt(*this) *= x; }
ModInt operator/(const ModInt& x) const { return ModInt(*this) /= x; }
ModInt pow(lint n) const {
auto x = ModInt(1);
auto b = *this;
while (n > 0) {
if (n & 1) x *= b;
n >>= 1;
b *= b;
}
return x;
}
ModInt& operator+=(const ModInt& x) {
if ((val += x.val) >= MOD) val -= MOD;
return *this;
}
ModInt& operator-=(const ModInt& x) {
if ((val -= x.val) < 0) val += MOD;
return *this;
}
ModInt& operator*=(const ModInt& x) {
val = lint(val) * x.val % MOD;
return *this;
}
ModInt& operator/=(const ModInt& x) { return *this *= x.inv(); }
bool operator==(const ModInt& b) const { return val == b.val; }
bool operator!=(const ModInt& b) const { return val != b.val; }
bool operator<(const ModInt& b) const { return val < b.val; }
bool operator<=(const ModInt& b) const { return val <= b.val; }
bool operator>(const ModInt& b) const { return val > b.val; }
bool operator>=(const ModInt& b) const { return val >= b.val; }
friend std::istream& operator>>(std::istream& is, ModInt& x) noexcept {
lint v;
is >> v;
x = v;
return is;
}
friend std::ostream& operator<<(std::ostream& os, const ModInt& x) noexcept {
return os << x.val;
}
};
template <class T>
struct Combination {
int max_n;
std::vector<T> f, invf;
explicit Combination(int n) : max_n(n), f(n + 1), invf(n + 1) {
f[0] = 1;
for (int i = 1; i <= n; ++i) {
f[i] = f[i - 1] * i;
}
invf[max_n] = f[max_n].inv();
for (int i = max_n - 1; i >= 0; --i) {
invf[i] = invf[i + 1] * (i + 1);
}
}
T fact(int n) const { return n < 0 ? T(0) : f[n]; }
T invfact(int n) const { return n < 0 ? T(0) : invf[n]; }
T perm(int a, int b) const {
return a < b || b < 0 ? T(0) : f[a] * invf[a - b];
}
T binom(int a, int b) const {
return a < b || b < 0 ? T(0) : f[a] * invf[a - b] * invf[b];
}
};
constexpr int MOD = 998244353;
using mint = ModInt<MOD>;
const Combination<mint> C(500000);
using lint = long long;
void solve() {
int n, m;
std::cin >> n >> m;
std::vector<std::vector<int>> ins(n + 1), outs(n + 1);
for (int i = 0; i < n; ++i) {
int l, r;
std::cin >> l >> r;
ins[l].push_back(i);
outs[r].push_back(i);
}
std::vector<std::pair<int, int>> es(m);
std::vector<int> vs;
for (auto& [u, v] : es) {
std::cin >> u >> v;
vs.push_back(--u);
vs.push_back(--v);
}
auto vrev = compress(vs);
int k = vrev.size();
for (auto& [u, v] : es) u = vrev[u], v = vrev[v];
std::vector<mint> ind(k + 1);
auto calc_ind = [&](lint s) {
std::fill(ind.begin(), ind.end(), 0);
for (int b = 0; b < (1 << m); ++b) {
lint t = 0;
for (int i = 0; i < m; ++i) {
if ((~b >> i) & 1) continue;
auto [u, v] = es[i];
t |= 1LL << u;
t |= 1LL << v;
}
if (~s & t) continue;
int used = __builtin_popcountll(s & t);
int cnt = __builtin_popcountll(s & ~t);
mint sign = mint(-1).pow(__builtin_popcount(b));
for (int z = 0; z <= cnt; ++z) {
ind[z + used] += sign * C.binom(cnt, z);
}
}
};
mint ans = 0;
int num = 0;
lint mask = 0;
calc_ind(mask);
for (int x = 1; x <= n; ++x) {
for (auto v : ins[x]) {
if (vrev.count(v)) {
mask ^= 1LL << vrev[v];
calc_ind(mask);
} else {
++num;
}
}
for (int z = 0; z <= k; ++z) {
ans += C.binom(num, x - z) * ind[z];
}
for (auto v : outs[x]) {
if (vrev.count(v)) {
mask ^= 1LL << vrev[v];
calc_ind(mask);
} else {
--num;
}
}
}
std::cout << ans << "\n";
}
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d %d", &n, &m);
int a[n];
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int ans = 0;
m--;
for (int i = 0; i <= n; i++) {
if (i == 0) {
if (a[m]) ans += a[m];
continue;
}
if ((m - i) >= 0 && (m + i) < n) {
if (a[m - i] && a[m + i]) ans += 2;
} else if ((m - i) >= 0 && a[m - i])
ans++;
else if ((m + i) < n && a[m + i])
ans++;
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
scanf("%d", &T);
while (T--) {
int ans = 0;
string x, y;
cin >> x >> y;
for (int i = y.size() - 1; i >= 0; i--)
if (y[i] == '1') {
ans = y.size() - 1 - i;
break;
}
for (int i = x.size() - 1; i >= 0; i--)
if (x[i] == '1' && x.size() - 1 - i >= ans) {
ans = x.size() - i - 1 - ans;
break;
}
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int nextBlank(int ar[], int i, int n) {
while (ar[i] == -1 && i < n) i++;
return i;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
;
int t;
cin >> t;
while (t--) {
int n, i, temp2;
cin >> n;
int ear[n];
char temp;
for (int i = 0; i < n; i++) {
cin >> temp;
temp2 = temp - '0';
ear[i] = temp2 & 1;
}
bool isRaze = true;
int ans = -1;
for (int i = 0; i < n - 1; i++) {
bool marked = false, sround = false;
comehere:
int j = isRaze ? 0 : 1;
for (j = j; j < n; j += 2) {
if (ear[j] == -1) continue;
if ((ear[j] == isRaze ? 0 : 1) || sround) {
ear[j] = -1;
marked = true;
break;
}
}
if (!marked) {
sround = true;
goto comehere;
}
isRaze = !isRaze;
}
if (ans == -1) {
for (int i = 0; i < n; i++) {
if (ear[i] != -1) {
ans = ear[i];
break;
}
}
}
if (ans == 0) ans = 2;
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int mod = (int)1e9 + 7;
int sum(int a, int b) {
int s = a + b;
if (s >= mod) s -= mod;
return s;
}
int sub(int a, int b) {
int s = a - b;
if (s < 0) s += mod;
return s;
}
int mult(int a, int b) { return (1LL * a * b) % mod; }
int pw(int a, int b) {
if (b == 0) return 1;
if (b & 1) {
return mult(a, pw(a, b - 1));
}
int res = pw(a, b / 2);
return mult(res, res);
}
const int maxN = (int)1e5 + 100;
int n, k;
int a[maxN], b[maxN];
int c[maxN];
vector<pair<int, int> > g[2 * maxN];
void add(int l, int r, int val) {
g[r].emplace_back(l - 2, val);
g[l - 2].emplace_back(r, val);
}
bool used[maxN];
bool ALL_OK = true;
int clr[maxN];
void dfs(int v) {
used[v] = true;
for (auto to : g[v]) {
if (!used[to.first]) {
clr[to.first] = clr[v] ^ to.second;
dfs(to.first);
} else {
if (clr[to.first] != clr[v] ^ to.second) {
ALL_OK = false;
break;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k;
for (int i = 0; i < k; i++) {
cin >> a[i] >> b[i];
char cc;
cin >> cc;
if (cc == 'o')
c[i] = 1;
else
c[i] = 0;
b[i] = n + 1 - b[i];
int s = a[i] + b[i];
int p = a[i] - b[i];
p = abs(p);
if (s > n + 1) {
s = 2 * n + 2 - s;
}
a[i] = (s + p) / 2;
b[i] = (s - p) / 2;
add(p + 2, s, c[i]);
}
int cmp = 0;
for (int i = 0; i <= n + 1; i++) {
if (!used[i]) {
cmp++;
dfs(i);
}
}
if (!ALL_OK) {
cout << 0;
return 0;
}
cout << pw(2, cmp - 2);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = LLONG_MAX;
const long long base = 1e9;
const double PI = acos(-1);
const long long MOD = 1e9 + 7;
const long long N = 1e5 + 10;
void logic() {
long long n, m;
cin >> n >> m;
vector<pair<long long, long long> > v;
long long i, j;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
v.push_back({a, b});
}
long long f = v[0].first, s = v[0].second;
long long f2 = v[0].first, s2 = v[0].second;
long long f1, s1;
for (i = 0; i < m; i++) {
if (v[i].first != f and v[i].first != s) {
if (v[i].second != f and v[i].second != s) {
f1 = v[i].first;
s1 = v[i].second;
break;
}
}
}
if (i == m) {
cout << "YES" << endl;
return;
}
f = f2;
s = f1;
for (i = 0; i < m; i++) {
if (v[i].first != f and v[i].first != s) {
if (v[i].second != f and v[i].second != s) {
break;
}
}
}
if (i == m) {
cout << "YES" << endl;
return;
}
f = f2;
s = s1;
for (i = 0; i < m; i++) {
if (v[i].first != f and v[i].first != s) {
if (v[i].second != f and v[i].second != s) {
break;
}
}
}
if (i == m) {
cout << "YES" << endl;
return;
}
f = s2;
s = f1;
for (i = 0; i < m; i++) {
if (v[i].first != f and v[i].first != s) {
if (v[i].second != f and v[i].second != s) {
break;
}
}
}
if (i == m) {
cout << "YES" << endl;
return;
}
f = s2;
s = s1;
for (i = 0; i < m; i++) {
if (v[i].first != f and v[i].first != s) {
if (v[i].second != f and v[i].second != s) {
f1 = v[i].first;
s1 = v[i].second;
break;
}
}
}
if (i == m) {
cout << "YES" << endl;
return;
}
cout << "NO" << endl;
return;
}
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (long long i = 0; i < t; i++) {
logic();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
scanf("%d%d", &n, &m);
int a = 1, x = m;
while (a < x) {
int b = 1, y = n;
for (int i = 1; i <= n; i++) {
printf("%d %d\n", b, a);
printf("%d %d\n", y, x);
b++;
y--;
}
a++;
x--;
}
if (a == x) {
int b = 1, y = n;
for (int i = 1; i <= n; i++) {
if (i & 1)
printf("%d %d\n", b, a), b++;
else
printf("%d %d\n", y, x), y--;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
long long x = a[0], y = a[n - 1];
cout << a[n - 1] << " ";
for (long long i = 1; i < n - 1; ++i) {
cout << a[i] << " ";
}
cout << a[0] << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
static char ch;
bool sgn = false;
while (ch = getchar(), ch < '0' || ch > '9')
if (ch == '-') sgn = true;
int res = ch - 48;
while (ch = getchar(), ch >= '0' && ch <= '9') res = res * 10 + ch - 48;
return sgn ? -res : res;
}
const int N = 200005;
const int INF = 1 << 30;
int m, n, k, cnt, S, T, cc[N], c[N], pre[N], prd[N], tot;
bool bo[N];
vector<int> Eid[N];
struct Edge {
int c, w, v;
} E[N];
void AddEdge(int x, int y, int c, int w) {
E[++cnt].v = y;
E[cnt].c = c;
E[cnt].w = w;
Eid[x].push_back(cnt);
E[++cnt].v = x;
E[cnt].c = -c;
E[cnt].w = 0;
Eid[y].push_back(cnt);
}
bool spfa() {
static int Q[N * 2];
int ql, qr;
Q[ql = qr = 0] = S;
fill(c, c + T + 1, -1);
cc[T] = 0;
cc[S] = INF;
c[S] = 0;
while (ql <= qr) {
int x = Q[ql++];
bo[x] = 0;
for (int i = 0; i < Eid[x].size(); i++) {
const Edge &e = E[Eid[x][i]];
if (e.w && e.c + c[x] > c[e.v]) {
if (!bo[e.v]) Q[++qr] = e.v;
bo[e.v] = 1;
c[e.v] = e.c + c[x];
cc[e.v] = min(e.w, cc[x]);
pre[e.v] = x;
prd[e.v] = Eid[x][i];
}
}
}
return cc[T] > 0;
}
int MaxFlow() {
int K = k;
int cost = 0;
while (spfa()) {
if (c[T] == 0) break;
cc[T] = min(K, cc[T]);
K -= cc[T];
int k = T;
while (k != S) {
E[prd[k]].w -= cc[T];
E[prd[k] ^ 1].w += cc[T];
k = pre[k];
}
cost += c[T] * cc[T];
if (K == 0) break;
}
return cost;
}
char s[505], t[505];
int main() {
cnt = -1;
n = read();
for (int i = 1; i <= n; i++) AddEdge(i, i + 1, 0, 100);
scanf("%s", s + 1);
m = read();
while (m--) {
scanf("%s", t + 1);
k = read();
for (int i = 1, l = strlen(t + 1); i <= n - l + 1; i++) {
int j = i;
while (t[j - i + 1] == s[j] && j - i + 1 <= l) j++;
if (j - i + 1 > l) AddEdge(i, i + l, k, 1);
}
}
k = read();
S = 1;
T = n + 1;
cout << MaxFlow();
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[1005][1005];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
long long chX[1005], chY[1005];
for (int i = 0; i < n; i++) {
long long sum = 0;
for (int j = 0; j < m; j++) sum += a[i][j];
chX[i] = sum;
}
for (int j = 0; j < m; j++) {
long long sum = 0;
for (int i = 0; i < n; i++) sum += a[i][j];
chY[j] = sum;
}
long long minX = 1e18, minY = 1e18;
int xCoor = 0, yCoor = 0;
for (int i = 0; i <= n; i++) {
long long sum = 0;
for (int j = 0; j < n; j++)
sum += (i * 4 - j * 4 - 2) * (i * 4 - j * 4 - 2) * chX[j];
if (sum < minX) minX = sum, xCoor = i;
}
for (int i = 0; i <= m; i++) {
long long sum = 0;
for (int j = 0; j < m; j++)
sum += (i * 4 - j * 4 - 2) * (i * 4 - j * 4 - 2) * chY[j];
if (sum < minY) minY = sum, yCoor = i;
}
cout << minY + minX << endl << xCoor << " " << yCoor << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 1000 * 100 + 1000;
int n;
pair<int, int> a[MAXN], b[MAXN];
int ans[MAXN];
int p[MAXN];
bool comp(const pair<int, int>& x, const pair<int, int>& y) {
return (x.first >= y.first);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
p[i] = x;
a[i] = make_pair(x, i);
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
b[i] = make_pair(x, i);
}
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
for (int i = 1; i <= n; i++) {
ans[b[i].second] = a[n - i + 1].second;
}
for (int i = 1; i <= n; i++) cout << p[ans[i]] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
struct pt {
int x, y;
inline int operator<(const pt& a) const { return y < a.y; }
} a[N];
int b[2 * N], d[N];
long long ans[N];
vector<int> c[2 * N];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].x, &a[i].y);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) b[2 * i - 1] = a[i].x, b[2 * i] = a[i].x + k;
sort(b + 1, b + 2 * n + 1);
int m = 1;
for (int i = 2; i <= 2 * n; i++)
if (b[i] != b[i - 1]) b[++m] = b[i];
for (int i = 1; i <= n; i++) {
int l = lower_bound(b + 1, b + m + 1, a[i].x) - b,
r = lower_bound(b + 1, b + m + 1, a[i].x + k) - b;
for (int j = l; j < r; j++) c[j].push_back(i);
}
for (int i = 1; i < m; i++) {
int l = 0;
for (vector<int>::iterator p = c[i].begin(); p != c[i].end(); p++)
d[++l] = *p;
int p = 1;
for (int j = 2; j <= l + 1; j++) {
int pre = a[d[j - 1]].y;
while (p < j && (j == l + 1 || a[d[p]].y + k <= a[d[j]].y))
ans[j - p] += 1ll * (b[i + 1] - b[i]) * (a[d[p]].y + k - pre),
pre = a[d[p]].y + k, p++;
ans[j - p] += 1ll * (b[i + 1] - b[i]) * (a[d[j]].y - pre);
}
}
for (int i = 1; i <= n; i++) printf("%I64d ", ans[i]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long v[200000], t[200000];
long long cnt[200000];
signed main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (n); i++) scanf("%lld", &v[i]);
for (int i = 0; i < (n); i++) scanf("%lld", &t[i]);
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
que;
cnt[0] = 0;
for (int i = 0; i < (n); i++) {
que.push(pair<long long, long long>(v[i] + cnt[i], i));
long long ans = 0;
while (!que.empty() && que.top().first <= cnt[i] + t[i]) {
ans += que.top().first - cnt[i];
que.pop();
}
ans += t[i] * (long long)que.size();
cnt[i + 1] = cnt[i] + t[i];
if (i) printf(" ");
printf("%lld", ans);
}
puts("");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
int n, m, a[MAX], mn = 100000003, mni;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int r, s, t;
scanf("%d%d%d", &r, &s, &t);
if (!a[r] && !a[s] && !a[t])
a[r] = 1, a[s] = 2, a[t] = 3;
else if (a[r]) {
(a[r] == 1) ? (a[s] = 2, a[t] = 3)
: ((a[r] == 2) ? (a[s] = 1, a[t] = 3) : (a[s] = 1, a[t] = 2));
} else if (a[s]) {
(a[s] == 1) ? (a[r] = 2, a[t] = 3)
: ((a[s] == 2) ? (a[r] = 1, a[t] = 3) : (a[r] = 1, a[t] = 2));
} else if (a[t]) {
(a[t] == 1) ? (a[s] = 2, a[r] = 3)
: ((a[t] == 2) ? (a[s] = 1, a[r] = 3) : (a[s] = 1, a[r] = 2));
}
}
for (int i = 0; i < n; i++) {
printf("%d ", a[i + 1]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
//#include <ext/pb_ds/detail/standard_policies.hpp>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx2")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
using namespace std;
//using namespace __gnu_pbds;
//template <typename T> using ordered_set = tree <T, null_type, less < T >, rb_tree_tag, tree_order_statistics_node_update>;
mt19937 gen(time(0));
#define ll long long
#define ld long double
#define pb push_back
#define F first
#define S second
#define TIME clock() * 1.0 / CLOCKS_PER_SEC
#define sz(a) int32_t(a.size())
#define endl '\n'
//#define int long long
const int N = 1e5 + 100;
const int M = 20;
const int mod = 1e9 + 7;
const ll inf = 2e18 + 7;
vector < int > pr;
int lp[N], a[N], up[N][M], mp[N];
int32_t main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
#ifdef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#else
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#endif // LOCAL
for(int i = 2; i < N; i++)
{
if (lp[i] == 0)
{
lp[i] = i;
pr.pb(i);
}
for(int j = 0; j < pr.size() && pr[j] <= lp[i] && 1ll * pr[j] * i < N; j++)
{
lp[pr[j] * i] = pr[j];
}
}
for(int i = 0; i < N; i++)
mp[i] = 1e9;
int n, q;
cin >> n >> q;
for(int i = 0; i < n; i++)
{
cin >> a[i];
}
int ls = n;
for(int j = 0; j < M; j++)
up[n][j] = n;
for(int i = n - 1; i >= 0; i--)
{
if (a[i] == 1)
{
up[i][0] = ls;
continue;
}
int gr = up[i + 1][0], ch = a[i];
while (ch > 1)
{
int d = lp[ch];
ch /= d;
gr = min(gr, mp[d]);
}
ch = a[i];
while (ch > 1)
{
int d = lp[ch];
ch /= d;
mp[d] = i;
}
up[i][0] = gr;
ls = gr;
}
for(int i = n - 1; i >= 0; i--)
{
for(int j = 1; j < M; j++)
{
up[i][j] = up[up[i][j - 1]][j - 1];
}
}
while (q--)
{
int l, r;
cin >> l >> r;
l--; r--;
int ans = 1;
for(int j = M - 1; j >= 0; j--)
{
if (up[l][j] <= r)
{
ans += (1 << j);
l = up[l][j];
}
}
cout << ans << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool setmax(T& _a, T _b) {
if (_b > _a) {
_a = _b;
return true;
}
return false;
}
template <class T>
bool setmin(T& _a, T _b) {
if (_b < _a) {
_a = _b;
return true;
}
return false;
}
template <class T>
T gcd(T _a, T _b) {
return _b == 0 ? _a : gcd(_b, _a % _b);
}
template <class T>
T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
struct Point {
int x = 0, y = 0;
Point() {}
Point(int _x, int _y) : x(_x), y(_y) {}
void read() { scanf("%d%d", &x, &y); }
};
struct Ans {
Point p[4];
int travel = numeric_limits<int>::max();
bool operator<(const Ans& a) const { return travel < a.travel; }
Ans rev() const {
Ans r = *this;
for (int i = int(0); i <= int((4) - 1); ++i) swap(r.p[i].x, r.p[i].y);
return r;
}
};
Ans check(map<int, vector<pair<int, int>>> cx,
map<int, vector<pair<int, int>>> cy, int x1, int x2, int y1, int y2) {
if (x2 - x1 != y2 - y1 || x1 == x2) return Ans();
Point target[4] = {Point{x1, y1}, Point{x2, y1}, Point{x1, y2},
Point{x2, y2}};
int g[4][4];
memset(g, 50, sizeof(g));
for (const auto& kv : cx)
for (pair<int, int> p : kv.second) {
for (int i = int(0); i <= int((4) - 1); ++i)
if (kv.first == target[i].x) {
setmin(g[p.second][i], abs(p.first - target[i].y));
}
}
for (const auto& kv : cy)
for (pair<int, int> p : kv.second) {
for (int i = int(0); i <= int((4) - 1); ++i)
if (kv.first == target[i].y) {
setmin(g[p.second][i], abs(p.first - target[i].x));
}
}
Ans ans;
for (int i = int(0); i <= int((4) - 1); ++i)
for (int j = int(0); j <= int((4) - 1); ++j)
if (j != i)
for (int k = int(0); k <= int((4) - 1); ++k)
if (k != i && k != j) {
int l = 0 + 1 + 2 + 3 - i - j - k;
if (setmin(ans.travel, max(g[0][i], g[1][j], g[2][k], g[3][l]))) {
ans.p[0] = target[i];
ans.p[1] = target[j];
ans.p[2] = target[k];
ans.p[3] = target[l];
}
}
return ans;
}
Ans easy(map<int, vector<pair<int, int>>> cx) {
assert(cx.size() == 2);
if (cx.begin()->second.size() != 2) return Ans();
sort(cx.begin()->second.begin(), cx.begin()->second.end());
sort(cx.rbegin()->second.begin(), cx.rbegin()->second.end());
int le = 0, ri = 200000000;
Point p[4];
auto ok = [&p, &cx](int len) {
int d = cx.rbegin()->first - cx.begin()->first;
int l = -1 << 30, r = 1 << 30;
for (const auto& kv : cx) {
setmax(l, kv.second[0].first - len);
setmin(r, kv.second[0].first + len);
setmax(l, kv.second[1].first - d - len);
setmin(r, kv.second[1].first - d + len);
}
if (l > r) return false;
for (const auto& kv : cx) {
p[kv.second[0].second] = Point(kv.first, l);
p[kv.second[1].second] = Point(kv.first, l + d);
}
return true;
};
while (le < ri) {
int mid = (le + ri) / 2;
if (ok(mid))
ri = mid;
else
le = mid + 1;
}
ok(le);
Ans ans;
ans.travel = le;
for (int i = int(0); i <= int((4) - 1); ++i) ans.p[i] = p[i];
return ans;
}
Ans solve(map<int, vector<pair<int, int>>> cx,
map<int, vector<pair<int, int>>> cy) {
assert(cx.size() + cy.size() > 0);
if (cx.size() >= 3 || cy.size() >= 3) return Ans();
if (cx.size() + cy.size() == 1) return Ans();
if (cx.size() == 2 && cy.size() == 0) {
return easy(cx);
}
if (cx.size() == 0 && cy.size() == 2) return solve(cy, cx).rev();
if (cx.size() == 1 && cy.size() == 1) return Ans();
if (cx.size() == 2 && cy.size() == 1) {
int x1 = cx.begin()->first, x2 = cx.rbegin()->first, d = x2 - x1;
int y = cy.begin()->first;
return min(check(cx, cy, x1, x2, y, y + d),
check(cx, cy, x1, x2, y - d, y));
}
if (cx.size() == 1 && cy.size() == 2) return solve(cy, cx).rev();
if (cx.size() == 2 && cy.size() == 2) {
return check(cx, cy, cx.begin()->first, cx.rbegin()->first,
cy.begin()->first, cy.rbegin()->first);
}
assert(false);
}
int main() {
int cs;
scanf("%d", &cs);
while (cs--) {
Point p[4];
for (int i = int(0); i <= int((4) - 1); ++i) p[i].read();
int dir[4];
Ans ans;
for (dir[0] = 0; dir[0] < 2; ++dir[0])
for (dir[1] = 0; dir[1] < 2; ++dir[1])
for (dir[2] = 0; dir[2] < 2; ++dir[2])
for (dir[3] = 0; dir[3] < 2; ++dir[3]) {
map<int, vector<pair<int, int>>> cx, cy;
for (int i = int(0); i <= int((4) - 1); ++i)
if (dir[i] == 0) {
cx[p[i].x].push_back(make_pair(p[i].y, i));
} else {
cy[p[i].y].push_back(make_pair(p[i].x, i));
}
Ans tmp = solve(cx, cy);
setmin(ans, tmp);
}
if (ans.travel < numeric_limits<int>::max()) {
printf("%d\n", ans.travel);
for (int i = int(0); i <= int((4) - 1); ++i)
printf("%d %d\n", ans.p[i].x, ans.p[i].y);
} else {
printf("-1\n");
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, p = 1e9 + 7;
long long f[N][2][2], g[N][2][2];
int main() {
int n, m;
scanf("%d%d", &n, &m);
f[1][1][0] = f[1][0][0] = 1;
for (int i = 2; i <= m; i++) {
f[i][0][0] = (f[i - 1][1][0] + f[i - 1][1][1]) % p;
f[i][0][1] = f[i - 1][0][0];
f[i][1][0] = (f[i - 1][0][0] + f[i - 1][0][1]) % p;
f[i][1][1] = f[i - 1][1][0];
}
long long sum = f[m][0][0] + f[m][1][1] + f[m][1][0] + f[m][0][1];
g[1][1][0] = g[1][0][0] = 1;
for (int i = 2; i <= n; i++) {
g[i][0][0] = (g[i - 1][1][0] + g[i - 1][1][1]) % p;
g[i][0][1] = g[i - 1][0][0];
g[i][1][0] = (g[i - 1][0][0] + g[i - 1][0][1]) % p;
g[i][1][1] = g[i - 1][1][0];
}
long long sum2 = g[n][0][0] + g[n][1][1] + g[n][1][0] + g[n][0][1];
cout << (sum - 2 + sum2 + p) % p << endl;
}
| 4 |
#include <bits/stdc++.h>
const long double PI = acos(-1);
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
long long c[k + 1];
for (long long i = 1; i <= k; i++) cin >> c[i];
vector<vector<long long>> cases;
cases.push_back(vector<long long>());
for (long long a : v) {
if (cases.back().size() == 0) {
cases.back().push_back(a);
continue;
}
long long l = 0, r = cases.size() - 1;
long long ans = -1;
while (l <= r) {
long long m = (l + r) >> 1;
if (c[a] > cases[m].size()) {
ans = m;
r = m - 1;
} else {
l = m + 1;
}
}
if (ans != -1) {
cases[ans].push_back(a);
} else {
cases.push_back(vector<long long>());
cases.back().push_back(a);
}
}
cout << cases.size() << '\n';
for (vector<long long> cs : cases) {
cout << cs.size();
for (long long x : cs) cout << " " << x;
cout << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, a[1000002], b[1000002], suma[1000002], sumb[1000002],
ans[1000002][2];
bool flag;
long long read() {
char c = getchar();
long long w = 0;
while (c < '0' || c > '9') c = getchar();
while (c <= '9' && c >= '0') {
w = w * 10 + c - '0';
c = getchar();
}
return w;
}
void print(bool op, long long la, long long ra, long long lb, long long rb) {
if (op) swap(la, lb), swap(ra, rb);
printf("%lld\n", ra - la + 1);
for (long long i = la; i <= ra; i++) printf("%lld ", i);
printf("\n%lld\n", rb - lb + 1);
for (long long i = lb; i <= rb; i++) printf("%lld ", i);
puts("");
}
signed main() {
n = read();
for (i = 1; i <= n; i++) {
a[i] = read();
suma[i] = suma[i - 1] + a[i];
}
for (i = 1; i <= n; i++) {
b[i] = read();
sumb[i] = sumb[i - 1] + b[i];
}
if (suma[n] > sumb[n]) {
flag = 1;
for (i = 1; i <= n; i++) swap(a[i], b[i]), swap(suma[i], sumb[i]);
}
for (i = j = 1; i <= n; i++) {
while (sumb[j] < suma[i]) j++;
long long tmp = sumb[j] - suma[i];
if (tmp == 0) {
print(flag, 1, i, 1, j);
return 0;
} else if (ans[tmp][0]) {
print(flag, ans[tmp][0] + 1, i, ans[tmp][1] + 1, j);
return 0;
}
ans[tmp][0] = i;
ans[tmp][1] = j;
}
puts("-1");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T sqr(T x) {
return x * x;
}
const double EPS = 1e-9;
const int MAXN = 1e5 + 10;
const int K = 200;
struct Query {
char type;
int x, y;
char c;
Query() { c = 0; }
void read() {
type = getchar();
scanf("%d %d ", &x, &y);
--x;
--y;
if (type == 'C') {
c = getchar();
}
scanf("\n");
}
};
vector<Query> qs;
int n, m, q;
char second[MAXN][11];
pair<int, int> dp[MAXN][11];
bool is_free[MAXN];
bool ready[MAXN][11];
pair<int, int> calc_dp(int i, int j) {
if (!is_free[i]) {
return make_pair(-2, -2);
}
if (ready[i][j]) {
return dp[i][j];
}
ready[i][j] = true;
if (second[i][j] == '<' && !j) {
return dp[i][j] = make_pair(i, -1);
}
if (second[i][j] == '>' && j == m - 1) {
return dp[i][j] = make_pair(i, m);
}
if (second[i][j] == '<' && j > 0 && second[i][j - 1] == '>') {
return dp[i][j] = make_pair(-2, -2);
}
if (second[i][j] == '>' && j < m - 1 && second[i][j + 1] == '<') {
return dp[i][j] = make_pair(-2, -2);
}
if (second[i][j] == '^') {
if (i && is_free[i - 1]) {
return dp[i][j] = calc_dp(i - 1, j);
}
return dp[i][j] = make_pair(i, j);
}
if (second[i][j] == '<') {
return dp[i][j] = calc_dp(i, j - 1);
}
if (second[i][j] == '>') {
return dp[i][j] = calc_dp(i, j + 1);
}
assert(0);
}
pair<int, int> go(int i, int j) {
pair<int, int> ans = make_pair(-1, -1);
while (1) {
if (!is_free[i]) {
if (second[i][j] == '^') {
if (!i) {
ans = make_pair(0, j + 1);
break;
}
--i;
continue;
}
if (second[i][j] == '>') {
if (j == m - 1) {
ans = make_pair(i + 1, m + 1);
break;
}
if (second[i][j + 1] == '<') {
break;
}
++j;
continue;
}
if (second[i][j] == '<') {
if (j == 0) {
ans = make_pair(i + 1, 0);
break;
}
if (second[i][j - 1] == '>') {
break;
}
--j;
continue;
}
assert(0);
} else {
if (make_pair(i, j) == dp[i][j]) {
assert(second[i][j] == '^' && (i == 0 || !is_free[i - 1]));
if (!i) {
ans = make_pair(0, j + 1);
break;
}
--i;
continue;
}
tie(i, j) = dp[i][j];
if (!(0 <= i && i < n && 0 <= j && j < m)) {
ans = make_pair(i + 1, j + 1);
break;
}
}
}
return ans;
}
int main() {
cin >> n >> m >> q;
scanf("\n");
for (int i = 0; i < (int)n; ++i) {
gets(second[i]);
}
scanf("\n");
int cntC = 0;
while (q-- > 0) {
Query cur;
cur.read();
if (cur.type == 'C') {
++cntC;
}
qs.push_back(cur);
if (cntC >= K || !q) {
memset(is_free, true, sizeof is_free);
for (int i = 0; i < (int)((int)(qs).size()); ++i) {
if (qs[i].type == 'C') {
is_free[qs[i].x] = false;
}
}
memset(ready, false, sizeof ready);
for (int i = 0; i < (int)n; ++i) {
for (int j = 0; j < (int)m; ++j) {
calc_dp(i, j);
}
}
for (int k = 0; k < (int)((int)(qs).size()); ++k) {
if (qs[k].type == 'C') {
second[qs[k].x][qs[k].y] = qs[k].c;
} else {
int i = qs[k].x;
int j = qs[k].y;
auto ans = go(i, j);
printf("%d %d\n", ans.first, ans.second);
}
}
qs.clear();
cntC = 0;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int Mod;
const int Nmax = 1005, Kmax = 105;
int Dp[Nmax][Kmax];
int main() {
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K >> Mod;
for (int i = 1; i < 10; ++i) Dp[1][i % K]++;
if (N > 1) Dp[1][K] = 1;
for (int i = 2, pw = 10 % K; i <= N; ++i) {
for (int j = 1; j <= K; ++j) {
for (int k = i == N ? 1 : 0; k < 10; ++k) {
int nj = (1LL * pw * k + j) % K;
Dp[i][nj] = (Dp[i][nj] + Dp[i - 1][j]) % Mod;
}
}
Dp[i][K] = 1;
pw = 10LL * pw % K;
}
int ans = 0, pw = 1;
for (int i = 1; i < N; ++i) {
pw = 10LL * pw % Mod;
}
pw = 9LL * pw % Mod;
for (int i = 1; i < K; ++i) ans = (ans + Dp[N][i]) % Mod;
ans = (pw - ans + Mod) % Mod;
cout << ans << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500005;
vector<int> gr[maxn];
int ansdown[maxn][2];
int ansdownif[maxn][2][3][2][2];
int sz[maxn];
int cntbad[maxn], cntodd[maxn];
int n;
long long answer;
bool isok[maxn];
void calcdown(int cur, int pr) {
sz[cur] = 1;
for (int t : gr[cur])
if (t != pr) {
calcdown(t, cur);
sz[cur] += sz[t];
}
ansdown[cur][0] = 0;
ansdown[cur][1] = 0;
isok[cur] = true;
cntodd[cur] = 0;
cntbad[cur] = 0;
for (int t : gr[cur])
if (t != pr) {
isok[cur] &= isok[t];
cntbad[cur] += !isok[t];
cntodd[cur] += sz[t] % 2;
}
isok[cur] &= cntodd[cur] <= 1;
ansdown[cur][0] += (isok[cur] && cntodd[cur] + (n - sz[cur]) % 2 <= 1);
ansdown[cur][1] +=
(isok[cur] && cntodd[cur] + (n - sz[cur] + 1) % 2 + 1 <= 1);
for (int t : gr[cur])
if (t != pr) {
for (int kbad = 0; kbad <= 1; kbad++) {
for (int kodd = 0; kodd <= 2; kodd++) {
for (int oddabove = 0; oddabove <= 1; oddabove++) {
if ((kbad == 0 || !isok[t]) && kodd + oddabove == 1) {
ansdownif[cur][kbad][kodd][oddabove][0] += ansdown[t][0];
}
if ((kbad == 0 || !isok[t]) &&
kodd - sz[t] % 2 + (sz[t] + 1) % 2 + (oddabove + 1) % 2 == 1) {
ansdownif[cur][kbad][kodd][oddabove][1] += ansdown[t][1];
}
}
}
}
}
if (cntbad[cur] <= 1 && cntodd[cur] <= 2) {
ansdown[cur][0] +=
ansdownif[cur][cntbad[cur]][cntodd[cur]][(n - sz[cur]) % 2][0];
ansdown[cur][1] +=
ansdownif[cur][cntbad[cur]][cntodd[cur]][(n - sz[cur]) % 2][1];
}
}
void calcup(int cur, int pr, int ansup0, int ansup1, bool isupok) {
if (pr != -1) {
if (sz[cur] % 2 == 0) {
answer += (long long)ansup0 * ansdown[cur][0];
} else {
answer += (long long)ansup1 * ansdown[cur][1];
}
}
for (int t : gr[cur])
if (t != pr) {
int nowcntbad = cntbad[cur] + !isupok - !isok[t];
int nowcntodd = cntodd[cur] + (n - sz[cur]) % 2 - sz[t] % 2;
bool isnewok =
isupok && (cntbad[cur] == 0 || (cntbad[cur] == 1 && !isok[t]));
isnewok &= nowcntodd <= 1;
if (nowcntbad > 1 || nowcntodd > 2) continue;
int curansup0 = ansdownif[cur][nowcntbad][nowcntodd][sz[t] % 2][0];
int curansup1 = ansdownif[cur][nowcntbad][nowcntodd][sz[t] % 2][1];
if (isnewok && nowcntodd + sz[t] % 2 <= 1) curansup0++;
if (isnewok && nowcntodd + 1 + (sz[t] + 1) % 2 <= 1) curansup1++;
if ((nowcntbad == 0 || !isupok) && nowcntodd + sz[t] % 2 == 1)
curansup0 += ansup0;
if ((nowcntbad == 0 || !isupok) && nowcntodd - (n - sz[cur]) % 2 +
(n - sz[cur] + 1) % 2 +
(sz[t] + 1) % 2 ==
1)
curansup1 += ansup1;
if ((nowcntbad == 0 || !isok[t]) && nowcntodd + sz[t] % 2 == 1) {
curansup0 -= ansdown[t][0];
}
if ((nowcntbad == 0 || !isok[t]) &&
nowcntodd - sz[t] % 2 + (sz[t] + 1) % 2 + (sz[t] + 1) % 2 == 1) {
curansup1 -= ansdown[t][1];
}
calcup(t, cur, curansup0, curansup1, isnewok);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
gr[a].push_back(b);
gr[b].push_back(a);
}
if (n % 2 == 1) {
cout << 0 << endl;
return 0;
}
calcdown(0, -1);
calcup(0, -1, 0, 0, 1);
cout << answer << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline long long int rand(long long int x, long long int y) {
++y;
return (rng() % (y - x)) + x;
}
string to_string(char c) {
string second(1, c);
return second;
}
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void degug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void degug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
degug_out(T...);
}
inline long long int gcd(long long int a, long long int b) {
if (a > b) swap(a, b);
if (a == 0) return b;
return gcd(b % a, a);
}
int n, m, C[(300006 / 3)];
int A[(300006 / 3)];
int P[(300006 / 3)];
pair<long long int, long long int> micost[(1 << 10)][2];
void offset(int pos, int bm, long long int cost, long long int i) {
if (bm != 0 && micost[bm][0].second != i && micost[bm][1].second != i) {
micost[bm][1] =
min(micost[bm][1], pair<long long int, long long int>(cost, i));
if (micost[bm][1] < micost[bm][0]) swap(micost[bm][0], micost[bm][1]);
}
if (pos == 9) return;
if (bm & (1 << pos)) offset(pos + 1, bm ^ (1 << pos), cost, i);
offset(pos + 1, bm, cost, i);
}
long long int help[(1 << 10)];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (long long int i = 0; i < (long long int)(1 << 10); ++i)
micost[i][0] = micost[i][1] =
pair<long long int, long long int>(((long long)1e18), -1);
for (long long int i = 0; i < (long long int)n; ++i) {
long long int x;
cin >> x;
for (long long int j = 0; j < (long long int)x; ++j) {
long long int b;
cin >> b;
--b;
A[i] += (1 << b);
}
}
for (long long int bm = 0; bm < (long long int)(1 << 9); ++bm) {
for (long long int i = 0; i < (long long int)n; ++i) {
bool no = 0;
for (long long int b = 0; b < (long long int)9; ++b) {
if ((1 << b) & A[i])
if (((1 << b) & bm) == 0) no = 1;
}
if (no) continue;
help[bm]++;
}
}
for (long long int i = 0; i < (long long int)m; ++i) {
cin >> C[i];
long long int x;
cin >> x;
for (long long int j = 0; j < (long long int)x; ++j) {
long long int b;
cin >> b;
--b;
P[i] += (1 << b);
}
}
for (long long int i = 0; i < (long long int)m; ++i) {
offset(0, P[i], C[i], i);
micost[0][1] =
min(micost[0][1], pair<long long int, long long int>(C[i], i));
if (micost[0][1] < micost[0][0]) swap(micost[0][0], micost[0][1]);
}
pair<long long int, long long int> ans =
pair<long long int, long long int>(-1, 0);
pair<long long int, long long int> w =
pair<long long int, long long int>(-2, -2);
for (long long int bm = 0; bm < (long long int)(1 << 9); ++bm) {
for (long long int p = 0; p < (long long int)m; ++p) {
if ((bm | P[p]) > bm) continue;
long long int res = bm;
res ^= P[p];
pair<long long int, long long int> xd =
(micost[res][0].second == p ? micost[res][1] : micost[res][0]);
if (0) cerr << res << ' ' << xd.second << '\n';
if (xd.second == -1) continue;
if (pair<long long int, long long int>(help[bm], -xd.first - C[p]) >
ans) {
ans = pair<long long int, long long int>(help[bm], -xd.first - C[p]);
w = pair<long long int, long long int>(xd.second, p);
}
}
}
if (ans.first == -1) {
assert(micost[0][0].second != -1 && micost[0][1].second != -1);
cout << micost[0][0].second + 1 << ' ' << micost[0][1].second + 1 << '\n';
return 0;
}
cout << w.first + 1 << ' ' << w.second + 1 << '\n';
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
const int maxn = 1e3 + 5;
int n;
int sx[maxn][maxn];
int sy[maxn][maxn];
int vis[maxn][maxn];
char s[maxn][maxn];
int dn[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
set<pair<int, int> > m;
set<pair<int, int> >::iterator it;
queue<pair<int, int> > q;
int f = 1;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
scanf("%d %d", &sx[i][j], &sy[i][j]);
if (sx[i][j] == -1) continue;
m.insert({sx[i][j], sy[i][j]});
}
}
for (it = m.begin(); it != m.end(); ++it) {
while (!q.empty()) q.pop();
int x = it->first, y = it->second;
if (sx[x][y] != x || sy[x][y] != y) {
f = 0;
goto end1;
}
s[x][y] = 'X';
vis[x][y] = 1;
q.push({x, y});
while (!q.empty()) {
int xx = q.front().first, yy = q.front().second;
q.pop();
int tx = xx - 1, ty = yy;
if (tx >= 1 && tx <= n && ty >= 1 && ty <= n && !vis[tx][ty] &&
sx[tx][ty] == x && sy[tx][ty] == y) {
s[tx][ty] = 'D';
vis[tx][ty] = 1;
q.push({tx, ty});
}
tx = xx + 1, ty = yy;
if (tx >= 1 && tx <= n && ty >= 1 && ty <= n && !vis[tx][ty] &&
sx[tx][ty] == x && sy[tx][ty] == y) {
s[tx][ty] = 'U';
vis[tx][ty] = 1;
q.push({tx, ty});
}
tx = xx, ty = yy - 1;
if (tx >= 1 && tx <= n && ty >= 1 && ty <= n && !vis[tx][ty] &&
sx[tx][ty] == x && sy[tx][ty] == y) {
s[tx][ty] = 'R';
vis[tx][ty] = 1;
q.push({tx, ty});
}
tx = xx, ty = yy + 1;
if (tx >= 1 && tx <= n && ty >= 1 && ty <= n && !vis[tx][ty] &&
sx[tx][ty] == x && sy[tx][ty] == y) {
s[tx][ty] = 'L';
vis[tx][ty] = 1;
q.push({tx, ty});
}
}
}
for (int i = 1; i <= n; ++i) {
s[i][n + 1] = '\0';
for (int j = 1; j <= n; ++j) {
if (!vis[i][j]) {
if (sx[i][j] != -1) {
f = 0;
goto end1;
}
int ff = 0;
int tx = i - 1, ty = j;
if (tx >= 1 && tx <= n && ty >= 1 && ty <= n && sx[tx][ty] == -1) {
s[i][j] = 'U';
ff = 1;
continue;
}
tx = i + 1, ty = j;
if (tx >= 1 && tx <= n && ty >= 1 && ty <= n && sx[tx][ty] == -1) {
s[i][j] = 'D';
ff = 1;
continue;
}
tx = i, ty = j + 1;
if (tx >= 1 && tx <= n && ty >= 1 && ty <= n && sx[tx][ty] == -1) {
s[i][j] = 'R';
ff = 1;
continue;
}
tx = i, ty = j - 1;
if (tx >= 1 && tx <= n && ty >= 1 && ty <= n && sx[tx][ty] == -1) {
s[i][j] = 'L';
ff = 1;
continue;
}
if (!ff) {
f = 0;
goto end1;
}
}
}
}
printf("VALID\n");
for (int i = 1; i <= n; ++i) {
printf("%s\n", s[i] + 1);
}
end1:
if (!f) {
printf("INVALID\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e4 + 5;
const long long P1 = 31;
const long long MOD1 = 1e9 + 7;
struct Hashs {
vector<long long> hashs;
vector<long long> pows;
long long P;
long long MOD;
Hashs() {}
Hashs(string &s, long long P, long long MOD) : P(P), MOD(MOD) {
long long n = s.size();
pows.resize(n + 1, 0);
hashs.resize(n + 1, 0);
pows[0] = 1;
for (long long i = n - 1; i >= 0; i--) {
hashs[i] = (1LL * hashs[i + 1] * P + s[i] - 'a' + 1) % MOD;
pows[n - i] = (1LL * pows[n - i - 1] * P) % MOD;
}
pows[n] = (1LL * pows[n - 1] * P) % MOD;
}
long long get_hash(long long l, long long r) {
long long ans =
hashs[l] + MOD - (1LL * hashs[r + 1] * pows[r - l + 1]) % MOD;
ans %= MOD;
return ans;
}
};
long long n, m;
bool cache[N], vis[N];
string s;
string a[N * 10];
set<long long> have;
map<long long, string> store;
vector<long long> lens;
Hashs str;
bool dp(long long idx) {
if (idx == n) return 1;
bool &ans = cache[idx];
if (vis[idx]) return cache[idx];
vis[idx] = 1;
for (auto &it : lens) {
if (idx + it - 1 >= n) continue;
if (have.find(str.get_hash(idx, idx + it - 1)) != have.end())
cache[idx] |= dp(idx + it);
}
return cache[idx];
}
void path(long long idx) {
if (idx == n) return;
for (auto &it : lens) {
if (idx + it - 1 >= n) continue;
if (have.find(str.get_hash(idx, idx + it - 1)) != have.end()) {
if (dp(idx + it)) {
string cur = store[str.get_hash(idx, idx + it - 1)];
reverse(cur.begin(), cur.end());
cout << cur << " ";
return path(idx + it);
}
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
set<long long> lengths;
cin >> n >> s;
str = Hashs(s, P1, MOD1);
cin >> m;
for (long long i = 1; i <= m; i++) {
cin >> a[i];
reverse(a[i].begin(), a[i].end());
string temp = a[i];
for (auto &it : temp) it = tolower(it);
lengths.insert(a[i].size());
long long curhash = (Hashs(temp, P1, MOD1).get_hash(0, temp.size() - 1));
have.insert(curhash);
store[curhash] = a[i];
}
for (auto &it : lengths) lens.push_back(it);
dp(0);
path(0);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename t>
t in(t q) {
cin >> q;
return q;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (int i = 0; i < ((int)(v).size()); ++i) {
os << v[i];
if (i != ((int)(v).size()) - 1) os << ",";
}
os << "]";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const map<T, S>& v) {
for (auto it : v) os << "(" << it.first << ":" << it.second << ")";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
os << "(" << v.first << "," << v.second << ")";
return os;
}
const long double PI = acosl(-1);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng64(chrono::steady_clock::now().time_since_epoch().count());
inline int rand(int l, int r) {
return uniform_int_distribution<int>(l, r)(rng);
}
inline long long rand(long long l, long long r) {
return uniform_int_distribution<long long>(l, r)(rng64);
}
int a[(305)][(305)];
int dp[2 * (305)][(305)][(305)];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(10);
memset(dp, -1, sizeof dp);
int n;
cin >> n;
for (auto i = 0; i < n; i++) {
for (auto j = 0; j < n; j++) {
cin >> a[i][j];
}
}
dp[0][0][0] = a[0][0];
for (auto diag = 0; diag < 2 * n - 1; diag++) {
for (auto r1 = max(0, diag - n); r1 < min(n, diag + 1); r1++) {
for (auto r2 = max(0, diag - n); r2 < min(n, diag + 1); r2++) {
if (diag == 0 && r1 == 0 && r2 == 0) continue;
int an = -(1050000000);
if (r1 > 0 && r2 > 0) {
an = max(dp[diag - 1][r1 - 1][r2 - 1], an);
}
if (diag - r1 > 0 && r2 > 0) {
an = max(dp[diag - 1][r1][r2 - 1], an);
}
if (r1 > 0 && diag - r2 > 0) {
an = max(dp[diag - 1][r1 - 1][r2], an);
}
if (diag - r1 > 0 && diag - r2 > 0) {
an = max(dp[diag - 1][r1][r2], an);
}
an += a[r1][diag - r1] + a[r2][diag - r2];
if (r1 == r2) {
an -= a[r1][diag - r1];
}
dp[diag][r1][r2] = an;
}
}
}
cout << dp[2 * n - 2][n - 1][n - 1];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxint = -1u >> 1;
int n;
long long x[100010];
bool v[100010];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%I64d", &x[i]);
sort(x, x + n);
long long a = -1, b = -1;
long long ret = 0;
for (int i = n - 2; i >= 0; i--) {
if (v[i + 1]) continue;
if (x[i + 1] - x[i] <= 1) {
if (a == -1) {
a = x[i];
v[i] = true;
} else {
b = x[i];
v[i] = true;
ret += a * b;
a = -1;
}
}
}
cout << ret << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int64_t mod = 1e9 + 7;
const int64_t primm = 998244353;
long long q, n;
char a[302];
int main() {
cin >> q;
while (q--) {
cin >> n >> a;
if (n > 2) {
cout << "YES" << endl << 2 << endl << a[0] << endl;
for (long long i = (long long)1; i < (long long)n; i++) cout << a[i];
cout << endl;
} else if (a[0] >= a[1])
cout << "NO" << endl;
else {
cout << "YES" << endl << 2 << endl << a[0] << endl << a[1] << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = (int)5e4 + 5;
char S[M];
int n, m;
int main() {
scanf("%s", S + 1);
n = strlen(S + 1);
for (int l = 1, cnt; l <= n / 2; l++) {
cnt = 0, m = 1;
for (int i = 1; i <= n; i++) {
if (i >= l && S[i] == S[i - l])
cnt++;
else
cnt = 0;
if (cnt >= l) m -= l, cnt = 0;
S[m++] = S[i];
}
n = m - 1, S[m] = 0;
}
puts(S + 1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solution() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
long long x;
cin >> x;
if ((i + j) & 1) {
cout << x + x % 2 << ' ';
} else {
cout << x + !(x % 2) << ' ';
}
}
cout << endl;
}
}
signed main() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
solution();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long vet[200001];
long long modInverse(long long a, long long b) {
return a > 1LL ? b - ((modInverse(b % a, a) * b) / a) : 1LL;
}
long long inv(long long a) {
long long z = modInverse(a, 998244353);
if (z < 0) return z + 998244353;
return z;
}
int main() {
int N;
long long acum = 0, val = 1;
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", &vet[i]);
for (int i = N; i--;) {
val = (val * inv(vet[i])) % 998244353;
val = (val * 100) % 998244353;
acum = (acum + val) % 998244353;
}
printf("%lld\n", acum % 998244353);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
const int MAX2 = 17;
vector<vector<int>> g(MAX);
int n, p;
int pai[MAX2][MAX];
int in[MAX], out[MAX];
int sz[MAX];
void dfs(int k, int pr) {
in[k] = p++;
sz[k] = pr;
for (int i = 0; i < (int)g[k].size(); i++) {
if (in[g[k][i]] == -1) {
pai[0][g[k][i]] = k;
dfs(g[k][i], pr + 1);
}
}
out[k] = p++;
}
void build(int raiz) {
for (int i = 0; i < n; i++) pai[0][i] = i;
p = 0, memset(in, -1, sizeof(in));
dfs(raiz, 0);
for (int k = 1; k < MAX2; k++)
for (int i = 0; i < n; i++) pai[k][i] = pai[k - 1][pai[k - 1][i]];
}
bool anc(int a, int b) { return in[a] <= in[b] and out[a] >= out[b]; }
int lca(int a, int b) {
if (anc(a, b)) return a;
if (anc(b, a)) return b;
for (int k = MAX2 - 1; k >= 0; k--) {
if (!anc(pai[k][a], b)) a = pai[k][a];
}
return pai[0][a];
}
int dist(int a, int b) { return sz[a] + sz[b] - 2 * sz[lca(a, b)]; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
build(0);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--, y--, a--, b--;
int d1 = dist(a, b);
int d2 = dist(a, x) + 1 + dist(y, b);
int d3 = dist(a, y) + 1 + dist(x, b);
if (d1 <= k and (k - d1) % 2 == 0)
cout << "YES" << '\n';
else if (d2 <= k and (k - d2) % 2 == 0)
cout << "YES" << '\n';
else if (d3 <= k and (k - d3) % 2 == 0)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
exit(0);
}
| 6 |
#include <bits/stdc++.h>
template <typename T>
inline void SWAP(T &a, T &b) {
T tmp = a;
a = b;
b = tmp;
}
template <typename T>
inline T ABS(const T &val) {
return val < 0 ? -val : val;
}
template <typename T>
inline T MAX(const T &a, const T &b) {
return a > b ? a : b;
}
template <typename T>
inline T MIN(const T &a, const T &b) {
return a < b ? a : b;
}
const int INTinf = 2147483647;
const int nINTinf = 0 - 2147483648;
using namespace std;
int n, m, a, n2;
int lvl[10];
int rasp[10];
long double MX = 0.0;
long double tmp;
void calc(int pos, long double chance, int sum, int acc) {
if (pos == n) {
if (acc > n2) {
tmp += chance;
} else if (sum == 0) {
tmp += chance;
} else {
tmp += (chance * a) / (a + sum);
}
} else if (rasp[pos] >= 10) {
calc(pos + 1, chance, sum, acc + 1);
} else if (rasp[pos]) {
calc(pos + 1, (chance * rasp[pos]) / 10, sum, acc + 1);
calc(pos + 1, (chance * (10 - rasp[pos])) / 10, sum + lvl[pos], acc);
} else
calc(pos + 1, chance, sum + lvl[pos], acc);
}
void konf(int kol, int pos) {
if (!kol) {
tmp = 0.0;
calc(0, 1, 0, 0);
if (tmp > MX) MX = tmp;
} else if (pos == n - 1) {
rasp[pos] += kol;
tmp = 0.0;
calc(0, 1, 0, 0);
if (tmp > MX) MX = tmp;
rasp[pos] -= kol;
} else {
int mmm = MIN(kol, 10 - rasp[pos]);
for (int i = -1 + 1; i <= mmm; i++) {
konf(kol - i, pos + 1);
rasp[pos]++;
}
rasp[pos] -= mmm + 1;
}
}
int main() {
cin >> n >> m >> a;
n2 = n >> 1;
for (int i = 0; i != n; i++) {
cin >> lvl[i] >> rasp[i];
rasp[i] /= 10;
}
konf(m, 0);
cout.setf(ios_base::fixed);
cout.precision(10);
cout << MX << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char ch = getchar();
int x, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
x = ch - '0';
while (1) {
ch = getchar();
if (ch < '0' || ch > '9') break;
x = x * 10 + ch - '0';
}
return x * f;
}
const int maxn = 100100;
int n, k, sum[maxn], cnt, ret, all, now = 1, ans[maxn], tot, dan;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
sum[i] = read();
if (i == 1)
ret = sum[i];
else
ret = gcd(ret, sum[i]);
if (sum[i] % 2 == 1) cnt = i, dan++;
all += sum[i];
}
if (n == 1) {
printf("%d\n", sum[1]);
for (int i = 1; i <= sum[1]; i++) printf("a");
return 0;
}
if (dan >= 2) {
printf("0\n");
for (int i = 1; i <= n; i++)
for (int j = 1; j <= sum[i]; j++) printf("%c", i + 'a' - 1);
return 0;
}
printf("%d\n", ret);
if (~ret & 1) ret >>= 1;
for (int i = 1; i <= n; i++) sum[i] /= ret;
for (int i = 1; i <= ret; i++) {
for (int j = 1; j <= n; j++)
for (int k = 0; k < sum[j] / 2; k++) printf("%c", j + 'a' - 1);
if (sum[cnt] & 1) printf("%c", cnt + 'a' - 1);
for (int j = 26; j >= 1; j--)
for (int k = 0; k < sum[j] / 2; k++) printf("%c", j + 'a' - 1);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w, h, h1, w1, h2, w2;
cin >> w >> h >> w1 >> h1 >> w2 >> h2;
for (int i = h; i >= 0; i--) {
w += i;
if (i == h1) w -= w1;
if (i == h2) w -= w2;
if (w < 0) w = 0;
}
cout << w << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 200 + 13, MAXM = 200 + 13, MAXR = 200 + 13,
MAXD = 1000 * 1000 * 1000 + 13;
bool diCy(long long hs, long long ts, set<pair<long long, long long> > &dads);
bool mark[MAXR][MAXR], marc[MAXR][MAXR], mard[MAXR][MAXR];
long long dist[MAXR][MAXR], dp[MAXR][MAXR];
queue<pair<long long, long long> > bfsq;
set<pair<long long, long long> > AAA;
vector<pair<long long, long long> > hc, tc, adj[MAXR][MAXR], topo;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long h, t, R;
cin >> h >> t >> R;
mark[R + 1][R + 1] = true;
long long n;
cin >> n;
long long a, b;
hc.push_back(make_pair(0, 0));
for (long long i = 1; i <= n; i++) {
cin >> a >> b;
hc.push_back(make_pair(a, b));
}
long long m;
cin >> m;
tc.push_back(make_pair(0, 0));
for (long long i = 1; i <= m; i++) {
cin >> a >> b;
tc.push_back(make_pair(a, b));
}
long long hp, tp;
for (long long i = 0; i <= R; i++) {
for (long long j = 0; j <= R - i; j++) {
dist[i][j] = MAXD;
dp[i][j] = 0;
if (i == j and i == 0) continue;
for (long long k = 1; k <= min(n, i); k++) {
hp = i - k + hc[k].first, tp = j + hc[k].second;
if (hp + tp <= R)
adj[i][j].push_back(make_pair(hp, tp));
else
adj[i][j].push_back(make_pair(R + 1, R + 1));
}
for (long long k = 1; k <= m and k <= j; k++) {
hp = i + tc[k].first, tp = j - k + tc[k].second;
if (hp + tp <= R)
adj[i][j].push_back(make_pair(hp, tp));
else
adj[i][j].push_back(make_pair(R + 1, R + 1));
}
}
}
bfsq.push(make_pair(h, t));
mark[h][t] = true;
dist[h][t] = 0;
long long fh = h, ft = t;
while (!bfsq.empty()) {
h = bfsq.front().first, t = bfsq.front().second;
mark[h][t] = true;
bfsq.pop();
for (auto i : adj[h][t]) {
hp = i.first, tp = i.second;
if (!mark[hp][tp] and hp + tp <= R) {
dist[hp][tp] = dist[h][t] + 1;
mark[hp][tp] = true;
bfsq.push(make_pair(hp, tp));
}
}
}
if (dist[0][0] < 1000 * 1000 * 1000) {
cout << "Ivan" << endl << dist[0][0] << endl;
return 0;
}
while (!AAA.empty()) AAA.erase(AAA.begin());
if (diCy(fh, ft, AAA)) {
cout << "Draw" << endl;
return 0;
}
reverse(topo.begin(), topo.end());
for (auto i : topo)
for (auto j : adj[i.first][i.second])
dp[j.first][j.second] =
max(dp[j.first][j.second], dp[i.first][i.second] + 1);
cout << "Zmey" << endl;
cout << dp[R + 1][R + 1] << endl;
return 0;
}
bool diCy(long long hs, long long ts, set<pair<long long, long long> > &dads) {
bool children = false;
long long hp, tp;
dads.insert(make_pair(hs, ts));
for (auto i : adj[hs][ts]) {
hp = i.first, tp = i.second;
if (marc[hp][tp] and dads.find(i) != dads.end())
children = true;
else if (!marc[hp][tp]) {
marc[hp][tp] = true;
children = children or diCy(hp, tp, dads);
}
}
dads.erase(make_pair(hs, ts));
topo.push_back(make_pair(hs, ts));
return children;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
string s, w;
cin >> s >> w;
int cnt = 0;
for (int i = 0; i < s.length(); ++i) cnt += s[i] != w[i];
if (cnt % 2)
cout << "impossible";
else {
string ans = "";
int f = 1;
for (int i = 0; i < s.length(); ++i)
if (s[i] == w[i])
ans += w[i];
else if (f)
ans += s[i], f = 1 - f;
else
ans += w[i], f = 1 - f;
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
namespace OPT {
char buf[120];
}
template <typename T>
inline void qw(T x, const char aft, const bool pt) {
if (x < 0) {
x = -x, putchar('-');
}
int top = 0;
do {
OPT::buf[++top] = static_cast<char>(x % 10 + '0');
} while (x /= 10);
while (top) putchar(OPT::buf[top--]);
if (pt) putchar(aft);
}
const int maxn = 600010;
const int MOD = 1000000007;
int n, m;
long long int ans;
long long int Ans[maxn];
char S[maxn], T[maxn];
int len[maxn], L[maxn], R[maxn], sa[maxn], rnk[maxn], tp[maxn], tax[maxn],
height[maxn], ufs[maxn], sz[maxn], sum[maxn][4];
std::vector<int> MU[maxn];
void SA();
void Init();
void Calc();
void Beginning();
void RadixSort();
void CalcHeight();
int find(const int x);
int merge(int u, int v);
void update(const int v, const int p);
int main() {
;
Init();
SA();
CalcHeight();
Beginning();
Calc();
return 0;
}
int find(const int x) { return ufs[x] == x ? x : ufs[x] = find(ufs[x]); }
void update(const int v, const int p) {
long long int _tmp = 1;
for (int i = 0; i < 3; ++i) {
(_tmp *= sum[p][i]) %= MOD;
}
(ans += v * _tmp) %= MOD;
}
int merge(int u, int v) {
if (sz[u] > sz[v]) std::swap(u, v);
for (int i = 0; i < 3; ++i) {
sum[u][i] += sum[v][i];
}
if (sz[u] == sz[v]) {
++sz[u];
}
return ufs[v] = u;
}
void Calc() {
int L = std::min(len[0], std::min(len[1], len[2]));
for (int i = n; i; --i) {
for (auto v : MU[i]) {
int x = find(v), y = find(v - 1);
update(-1, x);
update(-1, y);
update(1, merge(x, y));
}
Ans[i] = ans;
}
for (int i = 1; i <= L; ++i) {
qw((Ans[i] + MOD) % MOD, ' ', true);
}
putchar('\n');
}
void Init() {
for (int i = 2; ~i; --i) {
scanf("%s", T + 1);
memcpy(S + (L[i] = n + 1), T + 1, (len[i] = strlen(T + 1)) * sizeof(char));
R[i] = L[i] + len[i];
S[n += len[i] + 1] = i;
}
}
void SA() {
--n;
for (int i = 1; i <= n; ++i) {
tp[i] = i;
m = std::max(m, rnk[i] = S[i]);
}
RadixSort();
for (int w = 1, p = 0; p != n; w <<= 1) {
p = 0;
for (int i = n - w + 1; i <= n; ++i) tp[++p] = i;
for (int i = 1; i <= n; ++i)
if (sa[i] > w) tp[++p] = sa[i] - w;
RadixSort();
std::swap(tp, rnk);
rnk[sa[1]] = p = 1;
for (int i = 2; i <= n; ++i) {
int ds = sa[i - 1];
rnk[sa[i]] =
((tp[sa[i]] == tp[ds]) && (tp[sa[i] + w] == tp[ds + w])) ? p : ++p;
}
m = p;
}
}
void RadixSort() {
for (int i = 0; i <= m; ++i) tax[i] = 0;
for (int i = 1; i <= n; ++i) ++tax[rnk[i]];
for (int i = 1; i <= m; ++i) tax[i] += tax[i - 1];
for (int i = n; i; --i) sa[tax[rnk[tp[i]]]--] = tp[i];
}
void CalcHeight() {
for (int i = 1, p = 0; i <= n; ++i) {
if (p) --p;
int pre = sa[rnk[i] - 1];
while (S[i + p] == S[pre + p]) ++p;
MU[height[rnk[i]] = p].push_back(rnk[i]);
}
}
void Beginning() {
for (int i = 1; i <= n; ++i) {
sz[ufs[i] = i] = 1;
int k = 3;
for (int j = 0; j < 3; ++j)
if ((sa[i] >= L[j]) && (sa[i] <= R[j])) {
k = j;
break;
}
sum[i][k] = 1;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void umin(T& x, const U& y) {
x = min(x, (T)y);
}
template <class T, class U>
void umax(T& x, const U& y) {
x = max(x, (T)y);
}
template <class T, class U>
void init(vector<T>& v, U x, size_t n) {
v = vector<T>(n, (T)x);
}
template <class T, class U, typename... W>
void init(vector<T>& v, U x, size_t n, W... m) {
v = vector<T>(n);
for (auto& a : v) init(a, x, m...);
}
const long long MOD = 998244353;
template <class T>
T gcdi(T m, T n) {
T x1 = 0;
T y1 = 1;
T x2 = 1;
T y2 = 0;
T r, q, tmp;
T mod = n;
while (n) {
r = m % n;
q = m / n;
m = n;
n = r;
tmp = x1;
x1 = x2 - q * x1;
x2 = tmp;
tmp = y1;
y1 = y2 - q * y1;
y2 = tmp;
}
if (x2 < 0) x2 += mod;
x2 %= mod;
return x2;
}
template <long long M>
class intmod {
public:
long long x;
intmod() { x = 0; }
intmod(long long x) {
this->x = x;
this->x %= M;
}
void operator=(const long long& x) {
this->x = x;
this->x %= M;
}
intmod operator+(const intmod& o) {
long long y = x + o.x;
y -= M * (y >= M);
return y;
}
void operator+=(const intmod& o) {
x += o.x;
x -= M * (x >= M);
}
intmod operator+(const long long& o) {
long long y = x + o;
y -= M * (y >= M);
return y;
}
void operator+=(const long long& o) {
x += o;
x -= M * (x >= M);
}
intmod operator-(const intmod& o) {
long long y = x + M - o.x;
y -= M * (y >= M);
return y;
}
void operator-=(const long long& o) {
x += M - o;
x -= M * (x >= M);
}
intmod operator*(const intmod& o) {
long long y = x * o.x % M;
return y;
}
intmod operator*(const long long& o) {
long long y = x * o % M;
return y;
}
intmod operator/(const intmod& o) {
long long y = x * gcdi(o.x, M) % M;
return y;
}
void operator/=(const intmod& o) { x = x * gcdi(o.x, M) % M; }
friend ostream& operator<<(ostream& out, intmod obj) {
out << obj.x;
return out;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(15);
if (argc == 2 && atoi(argv[1]) == 123456789)
freopen("d:\\code\\cpp\\contests\\stdin", "r", stdin);
int n, m;
cin >> n >> m;
vector<int> d(n);
for (int i = 0; i < n; i++) cin >> d[i];
vector<int> is(n);
iota(is.begin(), is.end(), 0);
sort(d.begin(), d.end());
vector<int> a(m), b(m);
for (int i = 0; i < m; i++) cin >> a[i] >> b[i];
vector<intmod<MOD>> p(n);
p[0] = d[0];
for (int i = 1; i <= n - 1; i++) p[i] = p[i - 1] + d[i];
intmod<MOD> ifac = 1;
for (int i = 2; i <= n; i++) ifac = ifac * i;
ifac = intmod<MOD>(1) / ifac;
for (int i = 0; i < m; i++) {
intmod<MOD> sol = 0;
int l = 0, r = n - 1;
int nrweak = n;
while (l <= r) {
int mm = (l + r) / 2;
if (d[mm] >= b[i]) {
r = mm - 1;
nrweak = mm;
} else {
l = mm + 1;
}
}
int nrstrong = n - nrweak;
if (nrstrong >= a[i]) {
if (nrweak)
sol = sol + (intmod<MOD>(nrstrong) - a[i] + 1) / (nrstrong + 1) *
p[nrweak - 1];
sol = sol + (p[n - 1] - (nrweak ? p[nrweak - 1] : 0)) *
(intmod<MOD>(nrstrong) - a[i]) / nrstrong;
}
cout << sol << endl;
}
if (argc == 2 && atoi(argv[1]) == 123456789)
cout << clock() * 1.0 / CLOCKS_PER_SEC << " sec\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long pwr3[35];
pair<int, int> pre(pair<int, int> node) {
int x = node.first, y = node.second;
if (y == 0 || ((x & (-x)) < (y & (-y)) && x > 0)) {
x--;
} else {
y--;
}
return make_pair(x, y);
}
int depth(pair<int, int> node) { return node.first + node.second; }
pair<int, int> lca_brute_force(pair<int, int> a, pair<int, int> b) {
if (depth(a) < depth(b)) swap(a, b);
int amt = depth(a) - depth(b);
for (int i = 0; i < amt; i++) {
a = pre(a);
}
while (a != b) {
a = pre(a);
b = pre(b);
}
return a;
}
pair<int, int> lca(pair<int, int> a, pair<int, int> b) {
int a_on = a.first | a.second;
int b_on = b.first | b.second;
int ansx = 0, ansy = 0;
for (int i = 30; i >= 0; i--) {
int bit = (1 << i);
if (!((a_on | b_on) & bit)) continue;
if ((a_on & bit) && (b_on & bit)) {
if ((a.first & bit) && (b.second & bit)) return make_pair(ansx, ansy);
if ((a.second & bit) && (b.first & bit)) return make_pair(ansx, ansy);
if (a.first & bit) {
ansx |= bit;
} else {
ansy |= bit;
}
continue;
}
if (b_on & bit) {
swap(a, b);
swap(a_on, b_on);
}
bool postswap = false;
if (a.second & bit) {
swap(a.first, a.second);
swap(b.first, b.second);
swap(ansx, ansy);
postswap = true;
}
int j;
for (j = i - 1; j >= 0; j--) {
if (b.second & (1 << j)) break;
}
ansx |= (~((1 << (j + 1)) - 1)) & ((1 << (i + 1)) - 1) & b.first;
if (postswap) swap(ansx, ansy);
return make_pair(ansx, ansy);
}
return make_pair(ansx, ansy);
}
long long dfs_order(pair<int, int> node, int level) {
if (node.first == 0 && node.second == 0) return 0;
if (node.first > node.second) {
return dfs_order(make_pair(node.second, node.first), level) +
(pwr3[level] - 1LL) / 2LL;
}
if (node.first == 0) return node.second;
if (node.second & (1 << (level - 1)))
return dfs_order(make_pair(node.first, node.second - (1 << (level - 1))),
level - 1) +
(1LL << (level - 1));
return dfs_order(node, level - 1) + pwr3[level - 1];
}
map<pair<int, int>, long long> dfsorder;
bool cmp(pair<int, int> a, pair<int, int> b) {
if (!dfsorder.count(a)) dfsorder[a] = dfs_order(a, 30);
if (!dfsorder.count(b)) dfsorder[b] = dfs_order(b, 30);
return dfsorder[a] < dfsorder[b];
}
int m;
pair<int, int> nodes[200005];
pair<int, int> onodes[200005];
pair<int, int> stk[300005];
int stktop = 0;
map<pair<int, int>, vector<pair<int, int> > > tree;
map<pair<int, int>, int> off;
map<pair<int, int>, int> islca;
set<int> flips;
int ans = 0;
void flip(int val) {
if (val < 0) return;
if (flips.count(val)) {
ans--;
flips.erase(val);
} else {
ans++;
flips.insert(val);
}
}
int dfs(pair<int, int> node) {
int toff = off[node];
for (int i = 0; i < tree[node].size(); i++) {
int offv = dfs(tree[node][i]);
if (offv > 0) {
flip(depth(tree[node][i]));
flip(depth(node));
}
toff += offv;
}
if (islca[node] && !toff) {
flip(depth(node));
flip(depth(node) - 1);
}
return toff;
}
int main() {
pwr3[0] = 1;
for (int i = 1; i <= 30; i++) pwr3[i] = 3LL * pwr3[i - 1];
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &(nodes[2 * i - 1].first), &(nodes[2 * i - 1].second),
&(nodes[2 * i].first), &(nodes[2 * i].second));
}
for (int i = 1; i <= 2 * m; i++) onodes[i] = nodes[i];
sort(nodes + 1, nodes + 2 * m + 1, cmp);
for (int i = 1; i <= 2 * m; i++) {
if (nodes[i] == nodes[i - 1]) continue;
pair<int, int> lcanode = lca(nodes[i], stk[stktop]);
while (depth(stk[stktop]) > depth(lcanode)) {
if (depth(stk[stktop - 1]) < depth(lcanode)) {
tree[lcanode].push_back(stk[stktop]);
} else {
tree[stk[stktop - 1]].push_back(stk[stktop]);
}
stktop--;
}
if (stk[stktop] != lcanode) {
stktop++;
stk[stktop] = lcanode;
}
stktop++;
stk[stktop] = nodes[i];
}
while (stktop) {
tree[stk[stktop - 1]].push_back(stk[stktop]);
stktop--;
}
for (int i = 1; i <= m; i++) {
pair<int, int> lcanode = lca(onodes[i * 2 - 1], onodes[i * 2]);
off[onodes[i * 2 - 1]]++;
off[onodes[i * 2]]++;
off[lcanode] -= 2;
islca[lcanode]++;
}
dfs(make_pair(0, 0));
printf("%d", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
char s[101];
int next[100];
int prior[100];
int a[100];
int x[10];
void solve(int n, int l, int r) {
int c, d, i;
c = l;
d = 1;
for (i = l; i <= r; i++) {
next[i] = i + 1;
prior[i] = i - 1;
if (isdigit(s[i])) {
a[i] = s[i] - '0';
} else {
a[i] = -1;
}
}
memset(x, 0, sizeof(x));
while (1) {
if (s[c] == '>') {
d = 1;
c = next[c];
if (c > r) {
break;
}
if (s[c] == '>' || s[c] == '<') {
if (prior[prior[c]] >= l) {
next[prior[prior[c]]] = c;
}
prior[c] = prior[prior[c]];
}
} else if (s[c] == '<') {
d = 0;
c = prior[c];
if (c < l) {
break;
}
if (s[c] == '>' || s[c] == '<') {
if (next[next[c]] <= r) {
prior[next[next[c]]] = c;
}
next[c] = next[next[c]];
}
} else {
x[a[c]]++;
a[c]--;
if (a[c] == -1) {
if (next[c] <= r) {
prior[next[c]] = prior[c];
} else {
r = prior[c];
}
if (prior[c] >= l) {
next[prior[c]] = next[c];
} else {
l = next[c];
}
}
if (d == 0) {
c = prior[c];
} else {
c = next[c];
}
if (c < l || c > r) {
break;
}
}
}
for (i = 0; i < 9; i++) {
printf("%d ", x[i]);
}
printf("%d\n", x[i]);
}
int main() {
int n, q, i, l, r;
while (scanf("%d%d%s", &n, &q, s) == 3) {
for (i = 0; i < q; i++) {
scanf("%d%d", &l, &r);
solve(n, l - 1, r - 1);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, sum = 0;
string s;
vector<int> v;
int main() {
cin >> n >> s;
for (int i = 0; i < n; i++) {
int a = s[i] - '0';
sum += a;
}
if (sum == 0) {
cout << "YES";
return 0;
}
if (sum > 1) {
v.push_back(1);
}
for (int i = 2; i * i <= sum; i++) {
if (sum % i == 0) {
v.push_back(i);
v.push_back(sum / i);
}
}
for (int i = 0; i < v.size(); i++) {
int temp = 0, chck = 1, tempsum = sum;
for (int j = 0; j < n; j++) {
temp += s[j] - '0';
if (temp > v[i]) {
chck = 0;
break;
}
if (temp == v[i]) {
tempsum -= temp;
temp = 0;
}
}
if (tempsum != 0) chck = 0;
if (chck) {
cout << "YES";
return 0;
}
}
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 20;
int n, i, j, u, v, edge[2], cnt[2], ans[N], mn;
vector<int> adj[2][N];
void dfs1(int nod, int parent = -1) {
for (int j = 0; j < 2; j++)
for (auto i : adj[j][nod])
if (i != parent) edge[j]++, dfs1(i, nod);
}
void dfs2(int node, int parent, int dist) {
ans[node] = edge[1] - cnt[1] + cnt[0];
for (int j = 0; j < 2; j++) {
for (auto i : adj[j][node]) {
if (i != parent) {
cnt[j]++;
dfs2(i, node, dist + 1);
cnt[j]--;
}
}
}
}
int main() {
cin >> n;
for (i = 0; i < n - 1; i++) {
scanf("%d%d", &u, &v);
adj[0][u].push_back(v);
adj[1][v].push_back(u);
}
dfs1(1);
dfs2(1, -1, 0);
mn = *min_element(ans + 1, ans + n + 1);
printf("%d\n", mn);
for (i = 1; i <= n; i++)
if (ans[i] == mn) printf("%d ", i);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 1000;
const int N = maxn;
multiset<int> L, R;
vector<pair<int, int>> v;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
L.insert(l);
R.insert(r);
v.push_back(make_pair(l, r));
}
int ans = 0;
for (auto p : v) {
L.erase(L.find(p.first));
R.erase(R.find(p.second));
ans = max(ans, *R.begin() - *L.rbegin());
L.insert(p.first);
R.insert(p.second);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = ~0ull / 4;
const long long maxn = 110000;
vector<long long> adj[maxn];
long long d[maxn];
long long u[maxn];
long long comp[maxn];
bool seen[maxn];
long long dia[maxn];
long long sz[maxn];
set<pair<pair<long long, long long>, double> > st;
vector<pair<long long, long long> > r[maxn];
vector<long long> par[maxn];
void dfs(long long root) {
sz[comp[root]]++;
for (auto x : adj[root])
if (!comp[x]) {
comp[x] = comp[root];
dfs(x);
d[root] = max(d[root], d[x] + 1);
}
}
void dfs2(long long root) {
dia[comp[root]] = max(dia[comp[root]], max(d[root], u[root]));
seen[root] = 1;
long long m1 = -1;
long long m2 = -1;
for (auto x : adj[root]) {
if (seen[x]) continue;
if (m1 == -1 || d[x] >= d[m1]) {
m2 = m1;
m1 = x;
} else if (m2 == -1 || d[x] > d[m2])
m2 = x;
}
for (auto x : adj[root]) {
if (seen[x]) continue;
u[x] = u[root] + 1;
if (x == m1) {
if (m2 != -1) u[x] = max(u[x], d[m2] + 2);
} else
u[x] = max(u[x], d[m1] + 2);
dfs2(x);
}
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n, m, q;
cin >> n >> m >> q;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (long long i = 0; i < n; i++)
if (!comp[i]) {
comp[i] = i + 1;
dfs(i);
}
for (long long i = 0; i < n; i++)
if (!seen[i]) dfs2(i);
for (long long i = 0; i < n; i++)
r[comp[i]].push_back(make_pair(max(u[i], d[i]), i));
for (long long i = 0; i < n + 1; i++) sort(r[i].begin(), r[i].end());
for (long long i = 0; i < n + 1; i++) {
if (!r[i].size()) continue;
long long sum = 0;
for (auto y : r[i]) sum += y.first;
for (auto y : r[i]) {
long long x = y.first;
par[i].push_back(sum);
sum -= x;
}
}
cout << fixed << setprecision(7);
for (long long i = 0; i < q; i++) {
long long a, b;
cin >> a >> b;
a--, b--;
a = comp[a];
b = comp[b];
if (a == b) {
cout << -1 << "\n";
continue;
}
if (sz[a] > sz[b]) swap(a, b);
auto it = st.lower_bound(make_pair(make_pair(a, b), 0));
if (it->first.first == a and it->first.second == b) {
cout << it->second << "\n";
continue;
}
double e = 0;
long long t = max(dia[a], dia[b]);
for (auto y : r[a]) {
long long x = y.first;
long long st = 0;
long long en = r[b].size();
if (x + r[b][0].first + 1 >= t) {
e += par[b][0] + r[b].size() * (x + 1);
} else {
while (st != en - 1) {
long long mid = (st + en) / 2;
if (r[b][mid].first + x + 1 < t)
st = mid;
else
en = mid;
}
e += en * t;
if (en != r[b].size()) e += par[b][en] + (r[b].size() - en) * (x + 1);
}
}
e = e / double(r[a].size() * r[b].size());
cout << e << "\n";
st.insert(make_pair(make_pair(a, b), e));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a[101];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
if (a[i] - a[i + 1] > 1) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using pii = pair<int, int>;
struct info {
int l[10], r[10], nr;
};
int m, n, cnt;
int a[10][100000];
info st[270000], nullinfo;
info join(info x, info y, int col) {
if (x.nr == -1) return y;
if (y.nr == -1) return x;
info ret;
ret.nr = x.nr + y.nr;
for (int i = 0; i < m; ++i)
if (a[i][col] == a[i][col + 1] && x.r[i] != y.l[i]) {
--ret.nr;
int old = x.r[i];
for (int j = 0; j < m; ++j) {
if (x.l[j] == old) x.l[j] = y.l[i];
if (x.r[j] == old) x.r[j] = y.l[i];
if (y.l[j] == old) y.l[j] = y.l[i];
if (y.r[j] == old) y.r[j] = y.l[i];
}
}
memcpy(ret.l, x.l, sizeof x.l);
memcpy(ret.r, y.r, sizeof y.r);
return ret;
}
void build_aint(int node, int l, int r) {
if (l == r) {
for (int i = 0; i < m; ++i)
if (i > 0 && a[i - 1][l] == a[i][l])
st[node].l[i] = st[node].r[i] = st[node].l[i - 1];
else
st[node].l[i] = st[node].r[i] = cnt++, st[node].nr++;
return;
}
int mid = (l + r) / 2;
build_aint(2 * node, l, mid);
build_aint(2 * node + 1, mid + 1, r);
st[node] = join(st[2 * node], st[2 * node + 1], mid);
}
info query(int node, int l, int r, int a, int b) {
if (r < a) return nullinfo;
if (l > b) return nullinfo;
if (a <= l && r <= b) return st[node];
int mid = (l + r) / 2;
info x = query(2 * node, l, mid, a, b);
info y = query(2 * node + 1, mid + 1, r, a, b);
return join(x, y, mid);
}
int main() {
ios_base::sync_with_stdio(false);
int i, j, q, l, r;
nullinfo.nr = -1;
cin >> m >> n >> q;
for (i = 0; i < m; ++i)
for (j = 0; j < n; ++j) cin >> a[i][j];
build_aint(1, 0, n - 1);
for (; q; --q) {
cin >> l >> r;
auto ret = query(1, 0, n - 1, l - 1, r - 1);
cout << ret.nr << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int sum[N], a[N], b[N], c[N];
const int mod = 998244353;
int main() {
int n;
cin >> n;
long long ans = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
int pos = lower_bound(a + 1, a + i + 1, b[i]) - a;
int g = (1ll * a[i] - b[i] + sum[i - 1] - sum[pos - 1] + mod) % mod;
if (c[i] == 1) ans += g;
sum[i] = sum[i - 1] + g;
sum[i] %= mod;
}
cout << (1ll * ans + a[n] + 1) % mod;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void prime(int n);
int p[100000];
int fact[100000];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, div = 0;
cin >> n >> k;
fill(fact, fact + n, 1);
prime(n);
for (int i = 2, j = 0; i <= n; i++) {
if (p[i] == -1) continue;
while (n % i == 0) {
if (j < k) {
n /= i;
fact[j++] *= i;
div++;
} else
j = 0;
}
}
if (div >= k) {
for (int i = 0; i < k; i++) {
cout << fact[i] << " ";
}
cout << '\n';
} else
cout << -1 << '\n';
return 0;
}
void prime(int n) {
for (long long i = 2; i < n; i++) {
if (p[i]) continue;
for (long long j = i * i; j < n; j += i) {
p[j] = -1;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
const long double PI = 3.14159265358979;
long long binpow(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool parity(long long x, long long y) {
bool f = ((x ^ y) < 0);
return !f;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
long long mat[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> mat[i][j];
}
}
int freq[2];
long long change = 0;
for (int step = 2; step < (n + m + 3) / 2; step++) {
freq[0] = 0;
freq[1] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if ((i + j) == step or (i + j + step) == (n + m + 2)) {
freq[mat[i][j]]++;
}
}
}
change += min(freq[0], freq[1]);
}
cout << change << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, pos, l, r;
cin >> n >> pos >> l >> r;
int ans = 0;
bool out = false;
if (pos < l) {
ans += l - pos;
pos = l;
out = 1;
} else if (pos > r) {
ans += pos - r;
pos = r;
out = 1;
}
if (l == 1 && r == n) {
ans += 0;
} else if (r == n) {
ans += pos - l + 1;
} else if (l == 1) {
ans += r - pos + 1;
} else
ans += min(pos - l + r - l + 2, r - pos + r - l + 2);
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
int ret = n;
while (n > 1) {
int nn = n;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) {
n /= i;
break;
}
if (nn == n) n = 1;
ret += n;
}
printf("%d\n", ret);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > q;
int n, t;
int grid[100][100];
int moves[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int main() {
cin >> n;
grid[0][0] = n;
if (n > 3) q.push_back(make_pair(0, 0));
int minx = 0;
int nit = 0;
while (!q.empty()) {
nit++;
pair<int, int> cur = q[q.size() - 1];
assert(grid[cur.first][cur.second] > 3);
if (cur.first > minx) minx = cur.first;
grid[cur.first][cur.second] -= 4;
if (grid[cur.first][cur.second] < 4) q.pop_back();
for (int i = 0; i < 4; i++) {
int nx = cur.first + moves[i][0];
int ny = cur.second + moves[i][1];
if (nx < 0 || ny < 0) continue;
int inc = (1 + (!nx && cur.first)) * (1 + (!ny && cur.second));
bool ch = grid[nx][ny] < 4;
grid[nx][ny] += inc;
if (grid[nx][ny] >= 4 && ch) q.push_back(make_pair(nx, ny));
}
}
minx++;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
if (a < 0) a *= -1;
if (b < 0) b *= -1;
if (a > minx || b > minx)
cout << 0 << "\n";
else
cout << grid[a][b] << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b[100001], i, j, cnt = 0;
vector<long long int> v;
cin >> a;
for (i = 1; i <= a; i++) cin >> b[i];
sort(b + 1, b + a + 1);
for (i = a - 1; i >= 1; i--) {
if (b[i + 1] - b[i] <= 1) {
v.push_back(b[i]);
i--;
}
}
if (v.size() % 2) v.push_back(0);
for (i = 0; i < v.size(); i += 2) cnt += v[i] * v[i + 1];
cout << cnt;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
const int N = 1e4 + 1;
using bs = bitset<N>;
vector<int> g[N << 2];
int n, q;
bs can;
void add(int& l, int& r, int& x, int u = 1, int b = 1, int e = n) {
if (b > r or e < l) return;
if (l <= b and e <= r) return void(g[u].emplace_back(x));
int m = b + e >> 1;
add(l, r, x, u << 1, b, m);
add(l, r, x, u << 1 | 1, m + 1, e);
}
void solve(int u = 1, int b = 1, int e = n, bs B = can) {
for (int x : g[u]) B = B | (B << x);
if (b == e) return void(can |= B);
int m = b + e >> 1;
solve(u << 1, b, m, B);
solve(u << 1 | 1, m + 1, e, B);
}
int main(int argc, char const* argv[]) {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
scanf("%d %d", &n, &q);
for (int i = 1; i <= q; i++) {
int l, r, x;
scanf("%d %d %d", &l, &r, &x);
add(l, r, x);
}
can[0] = 1;
solve();
vi ans;
for (int i = 1; i <= n; i++) {
if (can[i]) ans.emplace_back(i);
}
printf("%d\n", (int)ans.size());
for (int i = 1; i <= (int)ans.size(); i++) {
printf("%d%c", ans[i - 1], " \n"[i == ans.size()]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> get_number(int x, int y) {
int result1;
cout << "? " << x << ' ' << y << '\n';
cout.flush();
cin >> result1;
int result2;
cout << "? " << y << ' ' << x << '\n';
cout.flush();
cin >> result2;
if (result1 > result2)
return {result1, 1};
else
return {result2, 2};
}
int main() {
int n;
cin >> n;
deque<int> d(n);
for (int i = 0; i < n; i++) d[i] = i;
vector<bool> used(n, false);
vector<int> ans(n);
while (d.size() > 1) {
auto nm = get_number(d[0] + 1, d[1] + 1);
if (nm.second == 1) {
ans[d[0]] = nm.first;
d.pop_front();
}
if (nm.second == 2) {
ans[d[1]] = nm.first;
swap(d[0], d[1]);
d.pop_front();
}
used[nm.first - 1] = true;
}
if (d.size() == 1) {
for (int i = 0; i < n; i++) {
if (!used[i]) {
ans[d[0]] = i + 1;
break;
}
}
}
cout << "! ";
cout.flush();
for (int i = 0; i < n; i++) {
cout << ans[i] << ' ';
cout.flush();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[55];
long long F[55][55];
int main(void) {
int n = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int p = 0;
scanf("%d", &p);
F[0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = n; j > 0; j--) {
for (int k = p; k >= 0; k--) {
if (k + a[i] > p) continue;
F[j][k + a[i]] += F[j - 1][k];
}
}
}
double ans = 0.0;
for (int i = 1; i <= n; i++) {
long long tsum = 0;
for (int j = 0; j <= p; j++) tsum += F[i][j];
double tans = tsum;
for (int j = 0; j < i; j++) tans = tans / (n - j) * (j + 1);
ans += tans;
}
printf("%.12f\n", ans);
while (getchar() != EOF)
;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef long long arr[200010];
arr h, a, h2;
long long n, m, k, p;
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
inline bool check(long long maxh) {
while (!pq.empty()) pq.pop();
for (int i = 1; i <= n; i++) {
h2[i] = maxh;
if (maxh >= m * a[i])
continue;
else
pq.push(make_pair(h2[i] / a[i] - 1, i));
}
long long cur = 0;
for (; cur <= m * k; cur++) {
if (pq.empty()) break;
pair<long long, long long> tp = pq.top();
pq.pop();
if (tp.first < cur / k) return false;
h2[tp.second] += p;
if (h2[tp.second] >= m * a[tp.second]) continue;
pq.push(make_pair(h2[tp.second] / a[tp.second] - 1, tp.second));
}
for (int i = 1; i <= n; i++)
if (h2[i] >= h[i] + m * a[i])
continue;
else {
cur += (h[i] - (h2[i] - m * a[i]) + p - 1) / p;
if (cur > m * k) return false;
}
return true;
}
int main() {
scanf("%I64d%I64d%I64d%I64d", &n, &m, &k, &p);
for (int i = 1; i <= n; i++) scanf("%I64d%I64d", &h[i], &a[i]);
long long l = 0, r = (long long)1e13, ans = 0;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
printf("%I64d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1000000 + 10;
int a[maxn], b[maxn];
int main() {
int n, s, f, sum = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d%d", &s, &f);
for (int i = s; i < f; i++) {
sum += a[i];
}
int temp = sum, t = 1;
for (int i = 2; i <= n; i++) {
if (i - 2 + s > n)
temp -= a[i - 2 + s - n];
else
temp -= a[i - 2 + s];
if (i + f - 2 > n)
temp += a[i + f - 2 - n];
else
temp += a[i + f - 2];
if (temp >= sum) {
sum = temp;
t = n + 2 - i;
}
}
printf("%d\n", t);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD9 = 1e9 + 7;
const int MOD91 = 1e9 + 9;
const long long MOD12 = 1e12 + 39LL;
const long long MOD15 = 1e15 + 37LL;
const long long INF = 1e14;
const int base = 1e9;
const int MAX = 2e5;
const long double EPS = 1e-10;
pair<int, int> a[30];
int k;
int ak[26];
int main() {
string second;
cin >> second;
cin >> k;
for (int i = (0); i < (second.size()); ++i) {
a[second[i] - 'a'].first++;
a[second[i] - 'a'].second = second[i] - 'a';
}
sort(a, a + 26);
for (int i = (0); i < (26); ++i) {
if (k - a[i].first >= 0) {
k -= a[i].first;
a[i].first = 0;
} else {
break;
}
}
int cnt = 0;
for (int i = (0); i < (26); ++i) {
if (a[i].first) {
cnt++;
ak[a[i].second] = 1;
} else {
ak[a[i].second] = 0;
}
}
cout << cnt << endl;
for (int i = (0); i < (second.size()); ++i) {
if (ak[second[i] - 'a']) {
cout << second[i];
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = 1005;
long long int Y[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> Y[i];
int fl = 0;
for (int i = 2; i <= n; i++) {
long long int a = Y[1] - Y[i];
long long int b = i - 1;
set<long long int> tp;
tp.clear();
for (int i = 1; i <= n; i++) {
tp.insert(a * i + b * Y[i]);
}
if ((int)(tp.size()) == 2) {
fl = 1;
break;
}
}
for (int i = 3; i <= 3; i++) {
long long int a = Y[2] - Y[i];
long long int b = i - 2;
set<long long int> tp;
tp.clear();
for (int i = 1; i <= n; i++) {
tp.insert(a * i + b * Y[i]);
}
if ((int)(tp.size()) == 2) {
fl = 1;
break;
}
}
if (fl)
cout << "Yes\n";
else
cout << "No\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s, n;
cin >> s >> n;
vector<pair<int, int>> d;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
d.push_back(make_pair(a, b));
}
sort(d.begin(), d.end());
for (int i = 0; i < d.size(); i++) {
if (s <= d[i].first) {
cout << "NO" << endl;
return 0;
}
s += d[i].second;
}
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int G[1010][1010];
int n, k;
int main() {
scanf("%d", &k);
if (k == 1) {
printf("2\nNY\nYN\n");
return 0;
}
int mx = 0;
for (int i = 0; i < 31; ++i)
if ((k >> i) & 1) mx = i;
vector<int> cur = {1};
n = 2;
int d = 0;
for (int i = mx - 1; i >= 0; --i) {
vector<int> tmp;
n++;
for (int i = 0; i < cur.size(); ++i) G[cur[i]][n] = G[n][cur[i]] = 1;
tmp.push_back(n);
n++;
for (int i = 0; i < cur.size(); ++i) G[cur[i]][n] = G[n][cur[i]] = 1;
tmp.push_back(n);
d++;
int prev = 1;
if ((k >> i) & 1) {
for (int j = 0; j < d; ++j) {
n++;
G[prev][n] = G[n][prev] = 1;
prev = n;
}
tmp.push_back(n);
}
cur = tmp;
}
for (int i = 0; i < cur.size(); ++i) G[cur[i]][2] = G[2][cur[i]] = 1;
printf("%d\n", n);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) printf(G[i][j] ? "Y" : "N");
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
int n;
cin >> n;
map<string, int> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
m[s] += 1;
}
string top;
int top_score = 0;
for (__typeof((m).begin()) it = (m).begin(); it != (m).end(); ++it) {
if (it->second > top_score) {
top = it->first;
top_score = it->second;
}
}
cout << top << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[200006], p[200006];
int main() {
int n, q, pos;
int ls = -1;
a[0] = -1;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (ls == a[i]) {
p[i] = pos;
} else {
pos = p[i] = i - 1;
ls = a[i];
}
}
int l, r, x;
while (q--) {
scanf("%d %d %d", &l, &r, &x);
if (a[r] != x) {
printf("%d\n", r);
} else {
if (p[r] < l)
printf("-1\n");
else
printf("%d\n", p[r]);
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const long double pi = acos(-1);
const int MOD = 1e9 + 7;
set<int> jaentrou;
set<int> dentro;
int main() {
ios::sync_with_stdio(false);
;
int n;
cin >> n;
vector<int> qnt;
int evento = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x > 0) {
evento++;
if (jaentrou.count(x)) {
cout << -1 << endl;
exit(0);
} else {
jaentrou.insert(x);
dentro.insert(x);
}
} else if (x < 0) {
x = -x;
if (!dentro.count(x)) {
cout << -1 << endl;
exit(0);
}
evento++;
dentro.erase(x);
if (dentro.size() == 0) {
jaentrou.clear();
qnt.push_back(evento);
evento = 0;
}
}
}
if (dentro.size() > 0) {
cout << -1 << endl;
exit(0);
}
cout << qnt.size() << endl;
for (int x : qnt) cout << x << endl;
}
| 3 |
#include<bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
//using namespace __gnu_pbds;
//Arr.find_by_order(k-1):kth smallest
//Arr.order_of_key(X):no. of elements less than x
#define int long long
#define ld long double
#define dob double
#define pb push_back
#define tle ios_base::sync_with_stdio(false);cin.tie(NULL);
const int hell=1e9+7;
#define maxheap priority_queue<int>
#define minheap priority_queue<int, vector<int>, greater<int>>
int inf=1e18;
const int N=1e5+9;
//getline(cin,st); To Take Entire Sentence In Input;
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
bool prime(int n)
{
for( int i=2;i*i<=n;i++)
{
if(n%i==0)
return false;
}
return true;
}
int power(int a,int b,int m)
{
int ans=1;
while(b)
{
if(b&1)
ans=(ans*a)%m;
b/=2;
a=(a*a)%m;
}
return ans;
}
int modinv(int k)
{
return power(k, hell-2, hell);
}
int fact[N],invfact[N];
void precompute()
{
fact[0]=1;
fact[1]=1;
for(int i=2;i<N;i++)
{
fact[i]=fact[i-1]*i;
fact[i]=fact[i]%hell;
}
invfact[N-1]=power(fact[N-1],hell-2,hell);
for(int i=N-2;i>=0;i--)
{
invfact[i]=invfact[i+1]*(i+1);
invfact[i]=invfact[i]%hell;
}
}
int nCr(int x,int y)
{
if(x<y)
return 0;
int num=fact[x]%hell;
num=num*invfact[y]%hell;
num=num*invfact[x-y]%hell;
return num;
}
unordered_map<int,int> mp;
bool check(int val)
{
if(mp.count(val))
return 1;
return 0;
}
int32_t main()
{
tle
int t=1;
cin>>t;
//precompute();
for(int i=1;i<=10000;i++)
mp[i*i*i]++;
while(t--)
{
int n;
cin>>n;
int f=0;
for(int i=1;i<=10000;i++)
{
int val=n-(i*i*i);
if(check(val))
f=1;
}
if(f)
cout<<"YES\n";
else
cout<<"NO\n";
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1145141919;
int t[105], d[105], p[105], dp[2005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> idx(n);
for (int i = 0; i < n; i++) {
idx[i] = i;
cin >> t[i] >> d[i] >> p[i];
}
sort(idx.begin(), idx.end(),
[&](const int& i1, const int& i2) { return d[i1] < d[i2]; });
vector<vector<int> > dp(101, vector<int>(2005, -INF));
vector<vector<int> > dp2(101, vector<int>(2005, -1));
dp[0][0] = 0;
for (int ii = 0; ii < idx.size(); ii++) {
int i = idx[ii];
for (int j = 2000 - t[i]; j >= 0; j--) {
dp[ii + 1][j + t[i]] = dp[ii][j + t[i]];
dp2[ii + 1][j + t[i]] = dp2[ii][j + t[i]];
if (j + t[i] >= d[i]) continue;
if (dp[ii][j] == -INF) continue;
if (dp[ii + 1][j + t[i]] < dp[ii][j] + p[i]) {
dp[ii + 1][j + t[i]] = dp[ii][j] + p[i];
dp2[ii + 1][j + t[i]] = ii;
}
}
for (int j = t[i] - 1; j >= 0; j--) {
dp[ii + 1][j] = dp[ii][j];
dp2[ii + 1][j] = dp2[ii][j];
}
}
int ans = -INF, foo = -1;
for (int i = 0; i <= 2000; i++) {
if (ans < dp[n][i]) {
ans = dp[n][i];
foo = i;
}
}
vector<int> af;
for (int i = dp2[n][foo]; foo > 0; i = dp2[i][foo]) {
af.push_back(idx[i] + 1);
foo -= t[idx[i]];
}
reverse(af.begin(), af.end());
cout << ans << endl;
cout << af.size() << endl;
for (int i = 0; i < af.size(); i++) {
cout << af[i];
cout << (i + 1 == af.size() ? "\n" : " ");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353, N = 2e5 + 5;
inline int input() {
char c = getchar();
int o;
while (c > 57 || c < 48) c = getchar();
for (o = 0; c > 47 && c < 58; c = getchar()) o = (o << 1) + (o << 3) + c - 48;
return o;
}
long long A[N], n, k, res = 1, cnt = 0, JC[N], inv[N], Pow2[N], Powk[N];
void init() {
JC[0] = 1;
for (int i = 1; i <= cnt; i++) JC[i] = JC[i - 1] * i % mod;
inv[0] = inv[1] = 1;
for (int i = 2; i <= cnt; i++) inv[i] = inv[mod % i] * (mod - mod / i) % mod;
for (int i = 2; i <= cnt; i++) inv[i] = inv[i] * inv[i - 1] % mod;
Pow2[0] = Powk[0] = 1;
for (int i = 1; i <= cnt; i++) {
Pow2[i] = (Pow2[i - 1] << 1) % mod;
Powk[i] = (Powk[i - 1] * (k - 2)) % mod;
}
}
long long C(long long a, long long b) {
return JC[a] * inv[b] % mod * inv[a - b] % mod;
}
void DP() {
long long ans = 0;
for (int i = 0; i < cnt; i++, ans %= mod)
if ((cnt - i) & 1)
ans = ans + ((C(cnt, i) * Powk[i]) % mod * Pow2[cnt - i - 1] % mod);
else
ans = ans + (((C(cnt, i) * Powk[i]) % mod *
(Pow2[cnt - i] - C(cnt - i, (cnt - i) / 2) + mod)) %
mod * inv[2] % mod);
res = res * (ans + mod) % mod;
}
int main() {
n = input();
k = input();
for (int i = 1; i <= n; i++) {
A[++cnt] = input();
if (A[cnt] == A[cnt - 1]) cnt--, res = res * k % mod;
}
if (A[cnt] == A[1]) cnt--, res = res * k % mod;
init();
if (k == 1) {
puts("0");
return 0;
} else if (k == 2) {
long long ans = 0;
for (int i = 0; i < (cnt + 1) / 2; i++, ans %= mod) ans = ans + C(cnt, i);
res = res * ans % mod;
printf("%lld\n", res);
return 0;
}
DP();
printf("%lld", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 9;
int n, sq, cnt[320];
bool freq[MAX];
long long sum[320][5], temp[5];
vector<pair<int, int> > q;
vector<int> v;
map<int, int> decode;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
if (s[0] == 's') {
q.push_back({2, -1});
} else {
int x;
cin >> x;
int type = (s[0] == 'a' ? 0 : 1);
q.push_back({type, x});
v.push_back(x);
}
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (int i = 0; i < v.size(); ++i) {
decode[i] = v[i];
}
sq = (int)sqrt(n + .0) + 1;
int lst = v.size() / sq;
for (int i = 0; i < n; ++i) {
int type = q[i].first;
if (type == 2) {
long long ans = 0;
for (int j = 0; j <= lst; ++j) {
ans += sum[j][2];
}
cout << ans << "\n";
} else if (type == 0) {
int cntPrv = 0, x = q[i].second,
pos = lower_bound(v.begin(), v.end(), x) - v.begin(),
bucket = pos / sq;
for (int j = 0; j < bucket; ++j) {
cntPrv += cnt[j];
}
for (int j = 0; j < 5; ++j) {
sum[bucket][j] = 0;
}
++cnt[bucket];
freq[pos] = 1;
int index = cntPrv % 5;
for (int j = bucket * sq, en = (bucket + 1) * sq - 1; j <= en; ++j) {
if (freq[j]) {
sum[bucket][index] += decode[j];
++index;
index %= 5;
}
}
for (int j = bucket + 1; j <= lst; ++j) {
for (int k = 0; k < 5; ++k) {
temp[k] = sum[j][k];
}
for (int k = 0; k < 5; ++k) {
sum[j][k] = temp[(k - 1 + 5) % 5];
}
}
} else {
int cntPrv = 0, x = q[i].second,
pos = lower_bound(v.begin(), v.end(), x) - v.begin(),
bucket = pos / sq;
for (int j = 0; j < bucket; ++j) {
cntPrv += cnt[j];
}
for (int j = 0; j < 5; ++j) {
sum[bucket][j] = 0;
}
--cnt[bucket];
freq[pos] = 0;
int index = cntPrv % 5;
for (int j = bucket * sq, en = (bucket + 1) * sq - 1; j <= en; ++j) {
if (freq[j]) {
sum[bucket][index] += decode[j];
++index;
index %= 5;
}
}
for (int j = bucket + 1; j <= lst; ++j) {
for (int k = 0; k < 5; ++k) {
temp[k] = sum[j][k];
}
for (int k = 0; k < 5; ++k) {
sum[j][k] = temp[(k + 1) % 5];
}
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int trafic = 0;
int k = 0;
while (getline(cin, s)) {
if (s[0] == '+')
k++;
else if (s[0] == '-')
k--;
else
for (int i = 0; i < s.size(); i++)
if (s[i] == ':') {
trafic += (s.size() - i - 1) * k;
break;
}
}
cout << trafic;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int max9 = 1000000009, max6 = 1000006, min6 = -1000006,
min9 = -1000000009;
const long long max12 = 1000000000012, max15 = 1000000000000015;
const long long min12 = -1000000000012, min15 = -1000000000000015;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
string x;
cin >> x;
while (m--) {
int l, r;
char g, t;
cin >> l >> r >> g >> t;
for (int i = l - 1; i < r; i++) {
if (x[i] == g) x[i] = t;
}
}
cout << x;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
unsigned int ar[(1000010 >> 6) + 5] = {0};
int len = 0;
int primes[1000010];
int counter[1000010];
int phi_dp[100000][100];
int Is_Prime[1000010 + 2];
void Seive(int n) {
Is_Prime[1] = 1;
for (int i = 4; i <= n; i += 2) Is_Prime[i] = 1;
int sq = sqrt(n + 1);
for (int i = 3; i <= n; i += 2) {
if (Is_Prime[i]) continue;
if (i > sq) continue;
for (int j = i * i; j <= n; j += 2 * i) Is_Prime[j] = 1;
}
for (int i = 1; i <= n; i++) {
if (!Is_Prime[i]) primes[len++] = i;
counter[i] = len;
}
}
void init() {
Seive(1000010 - 1);
int k, n, res;
for (n = 0; n < 100000; n++) phi_dp[n][0] = n;
for (k = 1; k < 100; k++) {
for (n = 0; n < 100000; n++) {
phi_dp[n][k] = phi_dp[n][k - 1] - phi_dp[n / primes[k - 1]][k - 1];
}
}
}
long long phi(long long n, int k) {
if (n < 100000 && k < 100) return phi_dp[n][k];
if (k == 1) return ((++n) >> 1);
if (primes[k - 1] >= n) return 1;
return phi(n, k - 1) - phi(n / primes[k - 1], k - 1);
}
long long Lehmer(long long n) {
if (n < 1000010) return counter[n];
long long w, res = 0;
int i, j, a, b, c, lim;
b = sqrt(n), c = Lehmer(cbrt(n)), a = Lehmer(sqrt(b)), b = Lehmer(b);
res = phi(n, a) + (((b + a - 2) * (b - a + 1)) >> 1);
for (i = a; i < b; i++) {
w = n / primes[i];
lim = Lehmer(sqrt(w)), res -= Lehmer(w);
if (i <= c) {
for (j = i; j < lim; j++) {
res += j;
res -= Lehmer(w / primes[j]);
}
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
init();
long long n, ans = 0, x, y;
cin >> n;
for (int i = 0; i < len; i++) {
x = primes[i];
if (x * x * x > n) break;
ans++;
}
for (int i = 0; i < len; i++) {
x = primes[i];
if (x * x > n) break;
y = n / x;
ans += Lehmer(y) - Lehmer(x);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m, a[100010], b, tmp = 0, ans = 0;
void count_time() {
int res = 0;
a[m + 1] = 10000000;
for (int i = 1; i <= m; ++i)
if (a[i] == a[i + 1] - 1)
++res;
else
break;
ans = n - res;
tmp += m - res - 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
cin >> m;
for (int j = 1; j <= m; ++j) cin >> a[j];
if (a[1] == 1)
count_time();
else
tmp += m - 1;
}
cout << ans - 1 + tmp;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.