solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
char s[113];
int main() {
scanf("%s", s);
int len = strlen(s);
for (int i = 0; i < len; i++) {
if (i == len - i - 1) {
if (s[i] - '0' == 3 || s[i] - '0' == 7)
;
else {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
}
if (s[i] - '0' == 4 && s[len - i - 1] - '0' == 6) continue;
if (s[i] - '0' == 6 && s[len - i - 1] - '0' == 4) continue;
if (s[i] - '0' == 3 && s[len - i - 1] - '0' == 3) continue;
if (s[i] - '0' == 7 && s[len - i - 1] - '0' == 7) continue;
if (s[i] - '0' == 5 && s[len - i - 1] - '0' == 9) continue;
if (s[i] - '0' == 8 && s[len - i - 1] - '0' == 0) continue;
if (s[i] - '0' == 0 && s[len - i - 1] - '0' == 8) continue;
if (s[i] - '0' == 9 && s[len - i - 1] - '0' == 5) continue;
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = 2 * acos(0.0);
const string alphabetU = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string alphabetL = "abcdefghijklmnopqrstuvwxyz";
const long long infinite = 1000000000;
const long long maxn = 100010;
static const int m37pos[] = {32, 0, 1, 26, 2, 23, 27, 0, 3, 16, 24, 30, 28,
11, 0, 13, 4, 7, 17, 0, 25, 22, 31, 15, 29, 10,
12, 6, 0, 21, 14, 9, 5, 20, 8, 19, 18};
inline int nextInt() {
int x = 0;
register int c = getc(stdin);
int sign = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getc(stdin))
;
if (c == '-') {
sign = 1;
c = getc(stdin);
}
for (; c > 47 && c < 58; c = getc(stdin)) x = (x << 1) + (x << 3) + c - 48;
if (sign) x = -x;
return x;
}
inline long long nextLong() {
long long x = 0;
register int c = getc(stdin);
int sign = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getc(stdin))
;
if (c == '-') {
sign = 1;
c = getc(stdin);
}
for (; c > 47 && c < 58; c = getc(stdin)) x = (x << 1) + (x << 3) + c - 48;
if (sign) x = -x;
return x;
}
inline string nextLine() {
string s;
while (!feof(stdin)) {
char c = fgetc(stdin);
if (c == 13) continue;
if (c == 10) return s;
s += c;
}
return s;
}
void scan(int &x) { x = nextInt(); }
void scanl(long long &x) { x = nextLong(); }
void scans(string &s) { s = nextLine(); }
int n, m, ans, ans1 = 0;
vector<vector<int> > lang;
vector<vector<int> > adj;
bool vs[111];
void input() {
memset(vs, false, sizeof(vs));
scan(n);
scan(m);
lang.clear();
lang.resize(m);
int k, v;
for (int i = 0, _b = n; i < _b; i++) {
scan(k);
if (!k) {
ans1++;
vs[i] = true;
}
for (int j = 1, _b = k; j <= _b; j++) {
scan(v);
v--;
lang[v].push_back(i);
}
}
}
void dfs(int u) {
vs[u] = true;
for (typeof(adj[u].begin()) i = adj[u].begin(); i != adj[u].end(); i++)
if (!vs[*i]) dfs(*i);
}
void process() {
adj.clear();
adj.resize(n);
for (int i = 0, _b = m; i < _b; i++)
for (int j = 0, _b = lang[i].size(); j < _b; j++)
for (int k = j + 1, _b = lang[i].size(); k < _b; k++) {
adj[lang[i][j]].push_back(lang[i][k]);
adj[lang[i][k]].push_back(lang[i][j]);
}
ans = -1;
for (int i = 0, _b = n; i < _b; i++) {
if (!vs[i]) {
ans++;
dfs(i);
}
}
if (ans == -1) ans = 0;
cout << ans1 + ans;
}
int main() {
int test = 1;
for (int i = 1, _b = test; i <= _b; i++) {
input();
process();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
bool super(long long x) {
int a = 0, b = 0;
while (x) {
if (x % 10 == 4)
a += 1;
else
b += 1;
x /= 10;
}
return a == b;
}
int main() {
int n;
cin >> n;
queue<long long> q;
q.push(4);
q.push(7);
while (q.front() < 100000000000) {
long long x = q.front();
q.push(x * 10 + 4);
q.push(x * 10 + 7);
if (super(x)) v.push_back(x);
q.pop();
}
for (int i = 0; i < v.size(); ++i) {
if (v[i] >= n) return cout << v[i] << endl, 0;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
long long p = 0;
long long maxk = 0;
cin >> n;
for (int i = 0; i < n; i++) {
long long a, k;
cin >> k >> a;
maxk = max(maxk, k);
int maxp = 0;
int count = 1;
while (a > count) {
count *= 4;
maxp++;
}
p = max(p, k + maxp);
}
if (p == maxk) {
p++;
}
cout << p;
return EXIT_SUCCESS;
}
| 4 |
#include <bits/stdc++.h>
#pragma gcc optimize("O3, unroll-loops")
using namespace std;
template <typename It>
ostream& outIt(ostream& out, It b, It e) {
for (It i = b; i != e; i++) out << (i == b ? "" : " ") << *i;
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T>& v) {
return outIt(out << '[', (v).begin(), (v).end()) << ']';
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
return out << '(' << p.first << ", " << p.second << ')';
}
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& p) {
return in >> p.first >> p.second;
}
vector<int64_t> ans;
int64_t fpow(int64_t a, int64_t b, int64_t mod) {
int64_t ans = 1;
if (b <= 0) return ans;
do
if (b & 1) ans = (int64_t)ans * a % mod;
while (a = (int64_t)a * a % mod, b >>= 1);
return ans;
}
int64_t invmod(int64_t a, int64_t b, int64_t mod, int64_t s0 = 0,
int64_t s1 = 1) {
return b ? invmod(b, a % b, mod,
(s1 - ((int64_t)a / b * s0) % mod + mod) % mod, s0)
: s1;
}
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int64_t n;
cin >> n;
ans.resize(n + 1);
ans[0] = LLONG_MAX;
int64_t xax = invmod(7, n, n);
for (int64_t i = 1; i <= n; i++) {
int64_t x;
cin >> x;
if (n % 7 == 0) {
if (i % 7 == 0)
ans[i] = LLONG_MAX;
else
ans[i] = i + (int64_t)(x - 1) * n;
} else {
int64_t next = ((int64_t)xax * i * 7 - i) % (7 * n) + i;
if (n > 2)
assert(next >= i), assert(next % n == i % n), assert(next % 7 == 0);
if ((next - i) / n >= x)
ans[i] = i + (int64_t)(x - 1) * n;
else
x -= (next - i) / n + 1,
ans[i] = (int64_t)(x / 6 * 7 + x % 6 + 1) * n + next;
}
}
cout << min_element((ans).begin(), (ans).end()) - ans.begin() << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a, b, d, c[109][109];
long long mn = 1000000009, co;
bool e;
int main() {
cin >> a >> b >> d;
for (int i = 1; i <= a; i++)
for (int j = 1; j <= b; j++) cin >> c[i][j];
for (int i = 1; i <= 10000; i++) {
for (int j = 1; j <= a; j++) {
for (int k = 1; k <= b; k++) {
if ((max(c[j][k], i) - min(c[j][k], i)) % d == 0)
co += (max(c[j][k], i) - min(c[j][k], i)) / d;
else {
e = 1;
break;
}
}
}
if (e == 0) mn = min(co, mn);
co = 0, e = 0;
}
if (mn == 1000000009)
cout << -1 << endl;
else
cout << mn << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
struct ban {
int i;
long long x, y;
};
bool operator<(const ban& a, const ban& b) { return a.x - a.y < b.x - b.y; }
int n, m;
ban a[N], ca[N];
vector<int> g[N];
long long p[N], s[N];
long long ans[N];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> a[i].x >> a[i].y;
a[i].i = i;
ca[i] = a[i];
}
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) p[i] = p[i - 1] + a[i].x;
for (int i = n; i >= 1; --i) s[i] = s[i + 1] + a[i].y;
for (int i = 1; i <= n; ++i) {
int x = a[i].i;
ans[x] = p[i - 1] + a[i].y * (i - 1) + s[i + 1] + (n - i) * a[i].x;
for (int j = 0; j < g[x].size(); ++j) {
int h = g[x][j];
ans[x] -= (min(a[i].x + ca[h].y, a[i].y + ca[h].x));
}
}
for (int i = 1; i <= n; ++i) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int x, y, n, d, vx[N], vy[N];
int dp[2][4][N][N];
inline int sqr(int d) { return d * d; }
int dfs(int u, int v, int x, int y) {
if (sqr(x) + sqr(y) > sqr(d)) return dp[u][v][x + 200][y + 200] = 1;
if (dp[u][v][x + 200][y + 200] != -1) return dp[u][v][x + 200][y + 200];
int &r = dp[u][v][x + 200][y + 200];
r = 0;
if (!(v & (1 << u)) && !dfs(1 - u, v + (1 << u), y, x)) r = 1;
for (int i = 0; i < n; i++) {
if (!dfs(1 - u, v, x + vx[i], y + vy[i])) r = 1;
}
return dp[u][v][x + 200][y + 200] = r;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d %d %d %d", &x, &y, &n, &d);
for (int i = 0; i < n; i++) scanf("%d %d", &vx[i], &vy[i]);
puts(dfs(0, 0, x, y) ? "Anton" : "Dasha");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, i, f, t, temp;
long long int val = -99999999999;
cin >> n >> k;
while (n--) {
cin >> f >> t;
if (k >= t) {
if (val < f) val = f;
} else {
temp = f - t + k;
if (val < temp) val = temp;
}
}
cout << val << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, num, opt;
int f[200010], mxlen[200010][20], mnlen[200010][20];
int dep[200010], fa[200010][20], ans[200010];
bool use[200010], vis[200010];
vector<int> v[200010];
vector<int> d[200010];
struct Edge {
int from, to, dis, id;
bool friend operator<(Edge a, Edge b) { return a.dis < b.dis; }
} e[200010 << 1];
int find(int x) { return (f[x] == x) ? x : f[x] = find(f[x]); }
void kruskal(int n, int m) {
int cnt = 0;
memset(use, 0, sizeof(use));
for (int i = 1; i <= n; ++i) f[i] = i;
for (int i = 1; i <= m; ++i) {
int from = e[i].from, to = e[i].to;
int fa = find(from), fb = find(to);
if (fa != fb) {
cnt++;
use[i] = 1;
v[from].push_back(to);
v[to].push_back(from);
d[from].push_back(e[i].dis);
d[to].push_back(e[i].dis);
if (cnt == n - 1) return;
f[fa] = fb;
}
}
}
void dfs(int u, int step) {
vis[u] = 1;
dep[u] = step;
for (int i = 0; i < v[u].size(); ++i) {
int to = v[u][i];
if (!vis[to]) {
fa[to][0] = u;
mxlen[to][0] = d[u][i];
dfs(to, step + 1);
}
}
}
int getmaxlen(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int ans = -0x3f3f3f3f;
for (int i = 18; i >= 0; --i) {
if (dep[fa[x][i]] >= dep[y]) {
ans = max(ans, mxlen[x][i]);
x = fa[x][i];
}
}
if (x == y) return ans;
for (int i = 18; i >= 0; --i) {
if (fa[x][i] != fa[y][i]) {
ans = max(ans, max(mxlen[x][i], mxlen[y][i]));
x = fa[x][i];
y = fa[y][i];
}
}
ans = max(ans, max(mxlen[x][0], mxlen[y][0]));
return ans;
}
void update(int x, int y, int val) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 18; i >= 0; --i) {
if (dep[fa[x][i]] >= dep[y]) {
mnlen[x][i] = min(val, mnlen[x][i]);
x = fa[x][i];
}
}
if (x == y) return;
for (int i = 18; i >= 0; --i) {
if (fa[x][i] != fa[y][i]) {
mnlen[x][i] = min(mnlen[x][i], val);
mnlen[y][i] = min(mnlen[y][i], val);
x = fa[x][i];
y = fa[y][i];
}
}
mnlen[x][0] = min(mnlen[x][0], val);
mnlen[y][0] = min(mnlen[y][0], val);
}
int main() {
num = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &e[i].from, &e[i].to, &e[i].dis);
e[i].id = i;
}
sort(e + 1, e + m + 1);
kruskal(n, m);
memset(vis, 0, sizeof(vis));
fa[1][0] = 0;
dep[0] = -1;
dfs(1, 0);
for (int j = 1; j <= 18; ++j)
for (int i = 1; i <= n; ++i) {
fa[i][j] = fa[fa[i][j - 1]][j - 1];
mxlen[i][j] = max(mxlen[i][j - 1], mxlen[fa[i][j - 1]][j - 1]);
}
memset(ans, 0x3f3f3f3f, sizeof(ans));
memset(mnlen, 0x3f3f3f3f, sizeof(mnlen));
for (int i = 1; i <= m; ++i) {
if (!use[i]) {
ans[e[i].id] = getmaxlen(e[i].from, e[i].to) - 1;
update(e[i].from, e[i].to, e[i].dis - 1);
}
}
for (int j = 17; j >= 0; --j)
for (int i = 1; i <= n; ++i) {
mnlen[i][j] = min(mnlen[i][j], mnlen[i][j + 1]);
mnlen[fa[i][j]][j] = min(mnlen[fa[i][j]][j], mnlen[i][j + 1]);
}
for (int i = 1; i <= m; ++i) {
if (use[i]) {
if (fa[e[i].from][0] == e[i].to)
ans[e[i].id] = mnlen[e[i].from][0];
else
ans[e[i].id] = mnlen[e[i].to][0];
}
}
for (int i = 1; i <= m; ++i) {
printf("%d ", ans[i] == 0x3f3f3f3f ? -1 : ans[i]);
}
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
const int maxm = 2005;
struct detail {
int c[maxm];
int len;
int p;
detail() { len = 0; }
void add(int i) {
c[len] = i;
++len;
}
} details[maxn];
int order[maxn];
int n, m;
bool cmp(const int a, const int b) { return details[a].p > details[b].p; }
int main(int argc, const char* argv[]) {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
order[i] = i;
cin >> details[i].p;
}
for (int i = 0; i < m; ++i) {
int x = 1, y = 1;
cin >> x >> y;
x--;
y--;
details[x].add(y);
details[y].add(x);
}
sort(order, order + n, cmp);
long long a = 0;
for (int i = 0; i < n; ++i) {
int o = order[i];
for (int j = 0; j < details[o].len; ++j) {
a += details[details[o].c[j]].p;
}
details[o].p = 0;
}
cout << a << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100;
unsigned long long binom[maxn][maxn];
vector<int> hsh(long long n) {
vector<int> vec;
for (int i = 2;; i++) {
if (n == 0) break;
vec.push_back(n % i);
n /= i;
}
return vec;
}
int main() {
for (int i = 0; i < maxn; i++) {
binom[i][0] = 1;
for (int j = 1; j <= i; j++) {
binom[i][j] = binom[i - 1][j] + binom[i - 1][j - 1];
}
}
int t;
ios::sync_with_stdio(0);
cin >> t;
for (int i = 1; i <= t; i++) {
long long n;
cin >> n;
vector<int> vec = hsh(n);
sort(vec.begin(), vec.end(), greater<int>());
vector<pair<int, int> > pr;
int lp = 0;
for (int i = 1; i <= vec.size(); i++) {
if (i == vec.size() || vec[i] != vec[i - 1]) {
pr.push_back(make_pair(i - lp, vec[i - 1]));
lp = i;
}
}
unsigned long long ans = 1;
int sm = 0;
for (int i = 0; i < pr.size(); i++) {
int cnt = vec.size() + 1 - pr[i].second - sm;
if (pr[i].second == 0) cnt = vec.size() - sm;
ans *= binom[cnt][pr[i].first];
sm += pr[i].first;
}
if (pr[pr.size() - 1].second == 0) {
unsigned long long oth = 1;
int sm = 1;
for (int i = 0; i < pr.size(); i++) {
int cnt = vec.size() + 1 - pr[i].second - sm;
if (pr[i].second == 0) cnt = vec.size() - sm;
int cn2 = pr[i].first;
if (pr[i].second == 0) cn2--;
oth *= binom[cnt][cn2];
sm += cn2;
}
ans -= oth;
}
cout << (ans - 1) << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
long long powmod(long long a, long long b) {
long long res = 1;
a %= 1000000007;
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n;
vector<int> g[500000];
int s[500000], t[500000], tmps[500000], tmpt[500000];
int fa[500000], dep[500000], cir[500000];
void dfs(int u) {
for (auto v : g[u]) {
if (v == fa[u] || cir[v]) continue;
fa[v] = u;
dep[v] = dep[u] + 1;
dfs(v);
}
}
int vis[500000], tmp[500000], on[500000];
int ansu, ansv;
int main() {
n = read();
int ss, tt;
for (int i = 1; i <= n; i++) {
s[i] = read();
if (s[i] == 0) ss = i;
}
for (int i = 1; i <= n; i++) {
t[i] = read();
if (t[i] == 0) tt = i;
}
for (int i = 1; i < n; i++) {
int u = read(), v = read();
g[u].push_back(v);
g[v].push_back(u);
}
dfs(tt);
int now = ss;
for (int i = 1; i <= n; i++) tmp[i] = s[i];
while (now != tt) {
swap(tmp[now], tmp[fa[now]]);
now = fa[now];
}
int ok = 0;
for (int i = 1; i <= n; i++) ok |= tmp[i] != t[i];
if (!ok) {
printf("0 %d\n", dep[ss]);
return 0;
}
for (int i = 1; i <= n; i++) vis[i] = tmp[i] != t[i];
int a[4], b[4], tot;
for (tot = 0; tot <= 2;) {
int k = 0;
for (int i = 1; i <= n; i++)
if (vis[i]) {
k = i;
break;
}
if (!k) break;
int now = k;
while (true) {
vis[now] = 0;
int mark = 0;
for (auto v : g[now]) {
if (vis[v]) {
now = v;
mark = 1;
break;
}
}
if (!mark) break;
}
a[++tot] = now;
now = k;
while (true) {
vis[now] = 0;
int mark = 0;
for (auto v : g[now]) {
if (vis[v]) {
now = v;
mark = 1;
break;
}
}
if (!mark) break;
}
b[tot] = now;
}
if (tot > 2) {
puts("-1");
return 0;
}
if (tot == 1) {
int &u = a[1], &v = b[1];
if (dep[u] > dep[v]) swap(u, v);
int now = v;
while (now && now != u) now = fa[now];
if (!now) {
puts("-1");
return 0;
}
g[fa[u]].push_back(v), g[v].push_back(fa[u]);
ansu = fa[u], ansv = v;
now = v;
while (now != fa[u]) cir[now] = 1, now = fa[now];
cir[fa[u]] = 1;
} else {
for (int i = 1; i <= 2; i++) {
int &u = a[i], &v = b[i];
if (dep[u] > dep[v]) swap(u, v);
int now = v;
while (now && now != u) now = fa[now];
if (!now) {
puts("-1");
return 0;
}
}
if (fa[a[1]] != fa[a[2]]) {
puts("-1");
return 0;
}
g[b[1]].push_back(b[2]), g[b[2]].push_back(b[1]);
ansu = b[1], ansv = b[2];
for (int i = 1; i <= 2; i++) {
int now = b[i];
while (now != fa[a[i]]) cir[now] = 1, now = fa[now];
cir[fa[a[i]]] = 1;
}
}
for (int i = 1; i <= n; i++)
if (cir[i]) {
fa[i] = 0;
dfs(i);
}
long long ans = 0;
while (!cir[ss]) swap(s[ss], s[fa[ss]]), ss = fa[ss], ans++;
while (!cir[tt]) swap(t[tt], t[fa[tt]]), tt = fa[tt], ans++;
now = ss, tot = 0;
while (true) {
cir[now] = 0;
on[tot++] = now;
int tmp = now;
for (auto v : g[now]) {
if (cir[v]) {
now = v;
break;
}
}
if (now == tmp) break;
}
long long res = INF;
int pos = 0;
for (int i = 0; i < tot; i++)
if (on[i] == tt) pos = i;
for (int _ = -1; _ <= 1; _ += 2) {
memcpy(tmps, s, sizeof s);
memcpy(tmpt, t, sizeof t);
int tmp = 0;
if (pos)
for (int i = pos; i < tot && i; i += _)
swap(tmpt[on[i]], tmpt[on[(i + _) % tot]]), tmp++;
int ii = 1, jj = 0, circle;
for (int i = 1; i < tot; i++)
if (tmpt[on[i]] == tmps[on[1]]) jj = i;
circle = jj;
for (int i = 1; i < tot; i++) {
if (tmpt[on[jj]] != tmps[on[ii]]) {
puts("-1");
return 0;
}
ii += 1;
jj += 1;
if (ii == tot) ii = 1;
if (jj == tot) jj = 1;
}
chkmin(res, 1LL * tot * (min(tot - circle, circle - 1)) + tmp);
}
if (ansu > ansv) swap(ansu, ansv);
printf("%d %d %lld\n", ansu, ansv, ans + res);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long const INF = 2e18 + 100;
int const MAX = 3 * 1e5 + 10;
long long l = (1LL << 62);
unsigned long long m = (1LL << 63);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k, i, j, x = 0;
string s = "";
cin >> n >> k >> s;
if (n == 1 && k > 0) {
cout << "0" << '\n';
return 0;
}
for (i = 0; i < n; i++) {
if (x == k) break;
if (i == 0 && s[i] > '1') {
s[i] = '1';
x++;
} else if (i != 0 && s[i] > '0') {
s[i] = '0';
x++;
}
}
cout << s << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 999;
const long long ll_inf = 1e18 + 1337;
vector<long long> tree;
void build(long long v, long long tl, long long tr) {
if (tl == tr)
tree[v] = 0;
else {
long long tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm + 1, tr);
}
}
void update(long long v, long long tl, long long tr, long long l, long long r) {
if (l > r) return;
if (tl == l && tr == r)
tree[v] += 1;
else {
long long tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(tm, r));
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
}
}
long long get(long long v, long long tl, long long tr, long long pos) {
if (tl == tr)
return tree[v];
else {
long long tm = (tl + tr) / 2;
if (pos <= tm)
return tree[v] + get(v * 2, tl, tm, pos);
else
return tree[v] + get(v * 2 + 1, tm + 1, tr, pos);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m, q;
cin >> n;
tree.resize(4 * n);
build(1, 1, n);
vector<long long> v(n + 1), T(n + 1), pr(n + 1);
v[0] = T[0] = pr[0] = 0;
for (int i = 1; i <= n; ++i) cin >> v[i];
for (int i = 1; i <= n; ++i) {
cin >> T[i];
pr[i] = pr[i - 1] + T[i];
}
vector<long long> ans(n + 1, 0);
for (int i = 1; i <= n; ++i) {
int l = i, r = (int)(upper_bound(pr.begin(), pr.end(), pr[i - 1] + v[i]) -
pr.begin());
if (l != r) update(1, 1, n, l, r - 1);
if (r <= n) ans[r] += v[i] - (pr[r - 1] - pr[i - 1]);
}
for (int i = 1; i <= n; ++i) {
ans[i] += T[i] * get(1, 1, n, i);
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int main() {
int n = read();
int a[n - 1];
int b[n - 1];
int t[n];
for (register int i = (int)(0); i < (int)(n - 1); i++) a[i] = read();
for (register int i = (int)(0); i < (int)(n - 1); i++) b[i] = read();
int flag_out = 0;
for (register int i = (int)(0); i < (int)(4); i++) {
t[0] = i;
for (register int ii = (int)(1); ii < (int)(n); ii++) {
int flag = 0;
for (register int iii = (int)(0); iii < (int)(4); iii++) {
if (((iii | t[ii - 1]) == a[ii - 1]) &&
((iii & t[ii - 1]) == b[ii - 1])) {
t[ii] = iii;
flag = 1;
break;
}
}
if (!flag) goto outer;
}
flag_out = 1;
break;
outer:;
}
if (!flag_out) {
printf("NO");
exit(0);
}
printf("YES\n");
for (register int i = (int)(0); i < (int)(n - 1); i++) {
printf("%d ", t[i]);
}
printf("%d", t[n - 1]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void USACO(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, s, t;
cin >> n >> s >> t;
s--, t--;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i]--;
}
for (int k = 0; k < n; ++k) {
if (s == t) {
cout << k << "\n";
return 0;
}
s = a[s];
}
cout << -1 << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int find_scc(vector<vector<int> > &graph, vector<int> &comp) {
int n = graph.size();
vector<vector<int> > rgraph(n);
for (int u = 0; u < n; u++) {
for (int v : graph[u]) {
rgraph[v].push_back(u);
}
}
vector<int> order;
vector<bool> used(n);
function<void(int)> dfs = [&](int u) {
used[u] = true;
for (int v : graph[u]) {
if (used[v]) continue;
dfs(v);
}
order.push_back(u);
};
for (int u = 0; u < n; u++) {
if (used[u]) continue;
dfs(u);
}
fill(used.begin(), used.end(), false);
int res = 0;
function<void(int)> rdfs = [&](int u) {
used[u] = true;
comp[u] = res;
for (int v : rgraph[u]) {
if (used[v]) continue;
rdfs(v);
}
};
for (int i = n - 1; i >= 0; i--) {
int u = order[i];
if (used[u]) continue;
rdfs(u);
res++;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<string> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
for (auto &c : a[i]) {
c -= '0';
}
}
vector<string> b(n);
for (int i = 0; i < n; i++) {
cin >> b[i];
for (auto &c : b[i]) {
c -= '0';
}
}
string s;
cin >> s;
for (auto &c : s) {
c -= '0';
}
vector<vector<int> > graph(n << 2);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int si = 0; si < 2; si++) {
for (int sj = 0; sj < 2; sj++) {
int x = a[i][j] ^ (si & s[j]) ^ (sj & s[i]);
if (x != b[i][j]) {
graph[i * 2 + si].push_back((n + j) * 2 + (sj ^ 1));
graph[(n + j) * 2 + sj].push_back(i * 2 + (si ^ 1));
}
}
}
}
}
vector<int> comp(n << 2);
find_scc(graph, comp);
vector<int> ans;
for (int i = 0; i < n + n; i++) {
if (comp[i << 1] == comp[i << 1 | 1]) {
cout << "-1\n";
return 0;
}
if (comp[i << 1] < comp[i << 1 | 1]) {
ans.push_back(i);
}
}
cout << (int)ans.size() << '\n';
for (int &x : ans) {
if (x < n) {
cout << "row " << x << '\n';
} else {
cout << "col " << x - n << '\n';
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > gstart;
vector<vector<int> > gupd;
vector<vector<int> > g;
vector<vector<int> > up;
bool used[102400];
int tin[102400];
int tout[102400];
int fup[102400];
int comp[102400];
int len[102400];
int timer;
int n, m, k, l;
int N;
set<pair<int, int> > bridges;
void dfs(int v, int p = -1) {
used[v] = true;
tin[v] = fup[v] = timer++;
for (int i = 0; i < gstart[v].size(); i++) {
int to = gstart[v][i];
if (to == p) continue;
if (used[to])
fup[v] = min(fup[v], tin[to]);
else {
dfs(to, v);
fup[v] = min(fup[v], fup[to]);
if (fup[to] > tin[v]) {
bridges.insert(make_pair(to, v));
bridges.insert(make_pair(v, to));
}
}
}
}
void find_bridges() {
timer = 0;
for (int i = 0; i < n; ++i) used[i] = false;
for (int i = 0; i < n; ++i)
if (!used[i]) dfs(i, -1);
}
void delete_bridges() {
gupd.resize(gstart.size());
for (int i = 0; i < gupd.size(); i++)
for (int j = 0; j < gstart[i].size(); j++)
if (bridges.empty() ||
bridges.find(make_pair(i, gstart[i][j])) == bridges.end())
gupd[i].push_back(gstart[i][j]);
}
void find_comp(int v, int c) {
comp[v] = c;
used[v] = true;
for (int i = 0; i < gupd[v].size(); i++) {
int next = gupd[v][i];
if (!used[next]) find_comp(next, c);
}
}
void find_all_comps() {
int c = 0;
memset(used, 0, sizeof(used));
for (int i = 0; i < n; i++)
if (!used[i]) {
find_comp(i, c);
++c;
}
N = c;
}
void dfs_lca(int v, int p = 0) {
tin[v] = ++timer;
up[v][0] = p;
for (int i = 1; i <= l; ++i) up[v][i] = up[up[v][i - 1]][i - 1];
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to != p) dfs_lca(to, v);
}
tout[v] = ++timer;
}
bool upper(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int lca(int a, int b) {
if (upper(a, b)) return a;
if (upper(b, a)) return b;
for (int i = l; i >= 0; --i)
if (!upper(up[a][i], b)) a = up[a][i];
return up[a][0];
}
void find_len(int v, int c) {
used[v] = true;
len[v] = c;
for (int i = 0; i < g[v].size(); i++) {
int next = g[v][i];
if (!used[next]) find_len(next, c + 1);
}
}
int main() {
cin >> n >> m;
gstart.resize(n);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
gstart[x].push_back(y);
gstart[y].push_back(x);
}
find_bridges();
delete_bridges();
memset(used, 0, sizeof used);
find_all_comps();
g.resize(N);
for (set<pair<int, int> >::iterator it = bridges.begin(); it != bridges.end();
++it) {
g[comp[it->first]].push_back(comp[it->second]);
g[comp[it->second]].push_back(comp[it->first]);
}
for (int i = 0; i < g.size(); i++) {
sort(g[i].begin(), g[i].end());
vector<int>::iterator it = unique(g[i].begin(), g[i].end());
g[i].resize(it - g[i].begin());
}
n = N;
memset(tin, 0, sizeof tin);
memset(tout, 0, sizeof tout);
timer = 0;
up.resize(n);
l = 1;
while ((1 << l) <= n) ++l;
for (int i = 0; i < n; ++i) up[i].resize(l + 1);
dfs_lca(0);
memset(used, 0, sizeof used);
find_len(0, 0);
cin >> k;
for (int i = 0; i < k; i++) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
a = comp[a];
b = comp[b];
int res = len[a] + len[b] - 2 * len[lca(a, b)];
cout << res << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353, N = 3e5 + 5;
int n;
long long f[N][3];
int fir[N], nxt[N << 1], to[N << 1], cntedge, fa[N];
void addedge(int u, int v) {
++cntedge;
to[cntedge] = v;
nxt[cntedge] = fir[u];
fir[u] = cntedge;
}
long long qpow(long long u, int v) {
long long rep = 1;
while (v > 0) {
if (v & 1) {
rep = (rep * u) % MOD;
}
u = (u * u) % MOD;
v >>= 1;
}
return rep;
}
long long inv(long long u) { return qpow(u, MOD - 2); }
void solve(int u) {
f[u][0] = f[u][1] = 1;
for (int v, now = fir[u]; now; now = nxt[now]) {
v = to[now];
if (v == fa[u]) {
continue;
}
fa[v] = u;
solve(v);
}
for (int v, now = fir[u]; now; now = nxt[now]) {
v = to[now];
if (v == fa[u]) {
continue;
}
f[u][0] = (f[u][0] * f[v][0]) % MOD;
f[u][1] = (f[u][1] * ((f[v][0] + f[v][2]) % MOD)) % MOD;
}
for (int v, now = fir[u]; now; now = nxt[now]) {
v = to[now];
if (v == fa[u]) {
continue;
}
f[u][2] = (f[u][2] +
(((inv(f[v][0] + f[v][2]) * f[v][1]) % MOD) * f[u][1]) % MOD) %
MOD;
}
f[u][0] = (f[u][0] + f[u][2]) % MOD;
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
solve(1);
printf("%lld\n", f[1][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1001;
int n;
string input[MAXN];
set<string> words;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> input[i];
for (int i = 0; i < n; i++) {
string tmp = input[i];
int SIZE = tmp.size();
input[i] = "";
sort(tmp.begin(), tmp.end());
int j = 0;
while (j < SIZE) {
if (tmp[j] != tmp[j + 1]) input[i] += tmp[j];
j++;
}
words.insert(input[i]);
}
cout << words.size() << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
vector<long long> a(n);
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort((a).begin(), (a).end());
long long minn = 1e18;
for (int i = 0; i < 1e5 + 5; i++) {
long long tmp = 0;
for (int j = 0; j < n; j++) {
tmp += abs(a[j] - (long long)pow(i, j));
if (tmp >= (6 * 1e17)) break;
}
if (tmp <= minn) {
minn = tmp;
} else {
break;
}
}
cout << minn;
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, b, mod, dp[501][501], a[501];
int main() {
while (~scanf("%d%d%d%d", &n, &m, &b, &mod)) {
int imin = 0, sum = 0;
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
imin = min(a[i], imin);
}
if (imin * m > b) {
puts("0");
continue;
}
dp[0][0] = 1;
for (int i = 1; i <= n; ++i) {
if (a[i] > b) continue;
for (int j = 1; j <= m; ++j)
for (int k = a[i]; k <= b; ++k)
dp[j][k] = (dp[j][k] % mod + dp[j - 1][k - a[i]] % mod) % mod;
}
for (int i = 0; i <= b; ++i) sum = (sum + dp[m][i]) % mod;
printf("%d\n", sum);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-6;
struct POINT {
double x;
double y;
POINT(double a = 0, double b = 0) {
x = a;
y = b;
}
};
struct LINESEG {
POINT s;
POINT e;
LINESEG(POINT a, POINT b) {
s = a;
e = b;
}
LINESEG() {}
};
struct LINE {
double a;
double b;
double c;
LINE(double d1 = 1, double d2 = -1, double d3 = 0) {
a = d1;
b = d2;
c = d3;
}
};
bool lineintersect(LINE l1, LINE l2, POINT &p) {
double d = l1.a * l2.b - l2.a * l1.b;
if (abs(d) < eps) return false;
return true;
}
int equals(double a, double b) { return fabs(a - b) < eps; }
int main() {
POINT pp;
double a, b, c;
double A, B, C;
scanf("%lf%lf%lf", &a, &b, &c);
LINE l1(a, b, c);
scanf("%lf%lf%lf", &A, &B, &C);
LINE l2(A, B, C);
if (a == 0 && b == 0 && c != 0) {
printf("0\n");
return 0;
}
if (A == 0 && B == 0 && C != 0) {
printf("0\n");
return 0;
}
if (a == 0 && b == 0 && c == 0) {
printf("-1\n");
return 0;
}
if (A == 0 && B == 0 && C == 0) {
printf("-1\n");
return 0;
}
if (B == 0 && b == 0) {
if (equals(c / a, C / A)) {
printf("-1\n");
return 0;
}
} else if (A == 0 && a == 0) {
if (equals(c / b, C / B)) {
printf("-1\n");
return 0;
}
} else if (equals(a / a, A / A) && equals(b / a, B / A) &&
equals(c / a, C / A)) {
printf("-1\n");
return 0;
}
bool ret = lineintersect(l1, l2, pp);
if (ret == true)
printf("1\n");
else
printf("0\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool fun(int arr[], int n) {
for (int i = 1; i < n; i++) {
if (arr[i] - arr[i - 1] > 1) return 0;
}
return 1;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
if (fun(arr, n))
cout << "YES\n";
else
cout << "NO\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct segm {
int x;
int y;
int ord;
};
segm v[2000005];
int n, k[2000005], sol[2000005];
int aib[2000005];
int normalizare(int val) {
int sol = 0;
for (int i = 1 << 20; i; i >>= 1)
if (sol + i <= n && k[sol + i] <= val) sol += i;
return sol;
}
int query(int pos) {
int sol = 0;
for (int i = pos; i > 0; i -= i & (-i)) sol += aib[i];
return sol;
}
void update(int pos) {
for (int i = pos; i <= n; i += i & (-i)) aib[i]++;
}
bool segmcomp(const segm &a, const segm &b) {
if (a.x == b.x) return a.y < b.y;
return a.x < b.x;
}
int main() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d %d", &v[i].x, &v[i].y);
v[i].ord = i;
}
sort(v + 1, v + n + 1, segmcomp);
for (i = 1; i <= n; i++) k[i] = v[i].y;
sort(k + 1, k + n + 1);
for (i = n; i >= 1; i--) {
v[i].y = normalizare(v[i].y);
sol[v[i].ord] = query(v[i].y);
update(v[i].y);
}
for (i = 1; i <= n; i++) printf("%d\n", sol[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
char str[100005];
int vis[205];
int main() {
scanf("%s", str);
int len = strlen(str);
for (int i = 0; i < len; i++) vis[str[i] - 'a']++;
int count = 0;
int index = 0;
for (int i = 0; i < 26; i++) {
if (vis[i] > 0) count++;
if (vis[i] >= 2) index++;
}
if (count == 1 || count > 4) {
printf("No\n");
return 0;
}
if ((count == 2 && index < 2) || len < 4) {
printf("No\n");
return 0;
}
printf("Yes\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
string s;
cin >> s;
long long cost[n];
for (long long i = 0; i < n; i++) cin >> cost[i];
string t = "hard";
long long i = 0, j = 0;
while (i < n && j < 4) {
if (s[i] == t[j])
i++, j++;
else
i++;
}
if (j < 4) {
cout << 0 << endl;
return 0;
}
long long dp[n + 1][5];
for (long long i = 0; i <= 4; i++) dp[0][i] = 0;
for (long long i = 1; i <= n; i++) dp[i][0] = dp[i - 1][0] + cost[i - 1];
for (long long i = 1; i <= 4; i++) {
for (long long j = 1; j <= n; j++) {
if (s[j - 1] == t[i - 1]) {
dp[j][i] = min(dp[j - 1][i] + cost[j - 1], dp[j][i - 1]);
} else
dp[j][i] = dp[j - 1][i];
}
}
cout << dp[n][4] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<long long> v(n, 0);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
long long soln = 0;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
if (!(i % 2 == 0 && j % 2 == 1)) {
continue;
}
long long run = 0;
long long minv = 0;
for (int k = i + 1; k < j; ++k) {
if (k % 2 == 0) {
run += v[k];
} else {
run -= v[k];
minv = min(minv, run);
}
}
long long amt_l = max(1LL, -minv);
long long amt_r = run + amt_l;
long long amt = max(0LL, min(1 + v[i] - amt_l, 1 + v[j] - amt_r));
soln += amt;
}
}
cout << soln << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
| 5 |
#include <map>
#include <cmath>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define ite map<int,int>::iterator
#define ll long long
#define ull unsigned long long
#define dd double
using namespace std;
const int maxn=200000,N1=maxn+5; const int inf=0x3f3f3f3f,p=1e9+7;
int T,n,n0,n1;
template <typename _T> void read(_T &ret)
{
ret=0; _T fh=1; char c=getchar();
while(c<'0'||c>'9'){ if(c=='-') fh=-1; c=getchar(); }
while(c>='0'&&c<='9'){ ret=ret*10+c-'0'; c=getchar(); }
ret=ret*fh;
}
struct node{ int a,b; }ab[N1],ba[N1],A[N1];
int cmp1(node s1,node s2)
{
if(s1.a!=s2.a) return s1.a<s2.a;
return s1.b<s2.b;
}
int cmp2(node s1,node s2)
{
if(s1.b!=s2.b) return s1.b<s2.b;
return s1.a<s2.a;
}
int check(int L)
{
int now=0, mr=0;
if(L==2)
n=n;
for(int i=1,j=1;i<=n1;i++)
{
now=ba[i].b;
for(;ab[j].a<=now&&j<=n0;j++) mr=max(mr,ab[j].b);
if(ba[i].a-ba[i].b<L) continue;
if(mr>=now+L) return 1;
}
now=0, mr=0;
for(int i=1,j=1;i<=n0;i++)
{
now=ab[i].a;
for(;ba[j].b<=now&&j<=n1;j++) mr=max(mr,ba[j].a);
if(ab[i].b-ab[i].a<L) continue;
if(mr>=now+L) return 1;
}
return 0;
}
int main()
{
// freopen("a.in","r",stdin);
// freopen("a.out","w",stdout);
scanf("%d",&n); ll ans=0; //int x,y;
for(int i=1;i<=n;i++) read(A[i].a);
for(int i=1;i<=n;i++) read(A[i].b), ans+=abs(A[i].b-A[i].a);
for(int i=1;i<=n;i++)
{
if(A[i].b<A[i].a) ba[++n1]=(node){A[i].a,A[i].b};
else if(A[i].a<A[i].b) ab[++n0]=(node){A[i].a,A[i].b};
}
sort(ab+1,ab+n0+1,cmp1); sort(ba+1,ba+n1+1,cmp2);
int l=0,r=1e9,ma=0,mid,tmp;
while(l<=r)
{
mid=(l+r)>>1;
if(check(mid)) ma=mid, l=mid+1;
else r=mid-1;
}
ans-=2ll* ma;
printf("%lld\n",ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2000100;
bool p[MAX];
void sieve() {
memset(p, -1, sizeof p);
p[0] = p[1] = 0;
int s = (int)sqrt((double)MAX);
for (int i = 2; i <= s; ++i)
if (p[i])
for (int j = i * i; j < MAX; j += i) p[j] = 0;
}
int main() {
sieve();
int n;
cin >> n;
int a[100100];
for (int i = 0; i < n; i++) cin >> a[i];
bool found = 0;
int idx = -1;
for (int i = 0; i < n; i++)
if (a[i] != 1 && p[a[i] + 1]) found = 1, idx = i;
int ones = 0;
for (int i = 0; i < n; i++)
if (a[i] == 1) ones++;
int x = -1, y = -1;
for (int i = 0; i < n - 1; i++)
for (int j = i + 1; j < n; j++)
if (p[a[i] + a[j]]) x = i, y = j;
int ans1 = ones + (idx != -1);
int ans2 = 0;
if (x != -1) ans2 = 2;
if (ans1 > 0 && ans1 > ans2) {
cout << ans1 << endl;
if (idx != -1) cout << a[idx] << " ";
for (int i = 0; i < ones; i++) cout << 1 << " ";
} else if (x != -1)
cout << 2 << endl << a[x] << " " << a[y];
else
cout << 1 << endl << a[0];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct point {
long long x, y;
point() { x = y = (long long)0; }
point(long long _x, long long _y) : x(_x), y(_y) {}
bool operator<(point other) const {
return x * x + y * y < other.x * other.x + other.y * other.y;
}
};
struct vec {
long long x, y, idx;
vec() { x = y = idx = (long long)0; }
vec(long long _x, long long _y, long long _i) : x(_x), y(_y), idx(_i) {}
};
int main() {
long long n, x, y;
cin >> n;
vector<vec> vc(n);
for (long long i = 0; i < n; i++) {
cin >> x >> y;
vc[i] = vec(x, y, i);
}
bool res[n];
while (true) {
point p = point(0, 0);
random_shuffle(vc.begin(), vc.end());
for (long long i = 0; i < n; i++) {
point p1, p2;
p1 = point(p.x + vc[i].x, p.y + vc[i].y);
p2 = point(p.x - vc[i].x, p.y - vc[i].y);
if (p2 < p1) {
p = p2;
res[vc[i].idx] = false;
} else {
p = p1;
res[vc[i].idx] = true;
}
}
if (p.x * p.x + p.y * p.y <= 2.25 * (1e12)) break;
}
for (long long i = 0; i < n; i++) cout << (res[i] ? 1 : -1) << " ";
}
| 7 |
#include <bits/stdc++.h>
const int MAXN = 3e5 + 5;
char s[MAXN];
char s2[MAXN];
int sum[MAXN];
int main() {
int n;
scanf("%d", &n);
scanf("%s", s + 1);
int cnt = 0, mval = 1, mid;
for (int i = 1; i <= n; ++i) {
int tmp = s[i] == '(' ? 1 : -1;
sum[i] = sum[i - 1] + tmp;
cnt += tmp;
if (sum[i] < mval) {
mval = sum[i];
mid = i;
}
}
if (cnt) {
printf("0\n1 1");
return 0;
}
int ans[3] = {0, 1, 1};
int tmp = mid;
for (int i = 1; i <= n; ++i) {
if (tmp == n) tmp = 0;
s2[i] = s[++tmp];
sum[i] = sum[i - 1] + (s2[i] == '(' ? 1 : -1);
if (!sum[i]) ++ans[0];
}
tmp = 1;
int tmp2 = ans[0];
for (int i = 1; i <= n; ++i)
if (sum[i] == 0) {
if (cnt > ans[0]) {
ans[0] = cnt;
ans[1] = tmp;
ans[2] = i;
}
tmp = i + 1;
cnt = 0;
} else if (sum[i] == 1)
++cnt;
for (int i = 1; i <= n; ++i)
if (sum[i] < 2) {
if (cnt + tmp2 > ans[0]) {
ans[0] = cnt + tmp2;
ans[1] = tmp;
ans[2] = i;
}
tmp = i + 1;
cnt = 0;
} else if (sum[i] == 2)
++cnt;
printf("%d\n%d %d", ans[0], (mid + ans[1] - 1) % n + 1,
(mid + ans[2] - 1) % n + 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 2e5 + 5;
int n, k;
long long ans = 0;
bool flag[N_MAX];
vector<int> a[N_MAX];
int dfs(int u, int p) {
int cnt = flag[u];
for (int v : a[u])
if (v != p) {
int cur = dfs(v, u);
cnt += cur;
ans += min(k + k - cur, cur);
}
return cnt;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= k + k; ++i) {
int u;
cin >> u;
flag[u] = true;
}
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
for (int i = 1; i <= n; ++i)
if (flag[i]) {
dfs(i, 0);
break;
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
char a[30], b[30];
int main() {
int t1 = 0, t2 = 0;
scanf("%s%s", a, b);
for (int i = 0; a[i] != '\0'; i += 2) {
if (a[i] == b[i])
continue;
else if (a[i] == '8' && b[i] == '[')
++t1;
else if (a[i] == '[' && b[i] == '8')
++t2;
else if (a[i] == '[' && b[i] == '(')
++t1;
else if (a[i] == '(' && b[i] == '[')
++t2;
else if (a[i] == '(' && b[i] == '8')
++t1;
else
++t2;
}
if (t1 > t2)
printf("TEAM 1 WINS\n");
else if (t1 < t2)
printf("TEAM 2 WINS\n");
else
printf("TIE\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (n != 0 || m == 0) {
printf("%d %d\n", (m > n ? m : n), (m != 0 ? n + m - 1 : n));
} else {
printf("Impossible\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int B = 172, maxn = 44000, maxm = 20;
unordered_map<bitset<B>, int> mp;
bool vis[maxm][maxn];
bitset<B> a[maxn];
int nxt[maxn][10], cnt = 1, bit[20];
long long dp[20][10][maxn];
long long solve(long long x, int k) {
if (x == 0) return 1;
int len = 0;
while (x) {
bit[len++] = x % 10;
x /= 10;
}
int u = 1;
long long ret = 0;
for (int i = len - 1; i >= 0; i--) {
for (int j = 0; j < bit[i] + (i == 0); j++) ret += dp[i][k][nxt[u][j]];
u = nxt[u][bit[i]];
}
return ret;
}
int main() {
bitset<B> Bit;
Bit.set(0);
mp[Bit] = 1;
a[1] = Bit;
vis[0][1] = 1;
for (int i = 1; i < maxm; i++)
for (int u = 1; u <= cnt; u++)
if (vis[i - 1][u]) {
for (int j = 0; j < 10; j++) {
if (!nxt[u][j]) {
if (j == 0)
nxt[u][j] = u;
else {
Bit.reset();
for (int k = j; k < B; k++)
if (a[u][k]) Bit[k - j] = 1;
for (int k = 0; k < B - j; k++)
if (a[u][k]) Bit[k + j] = 1;
for (int k = 1; k < j; k++)
if (a[u][k]) Bit[j - k] = 1;
if (mp.count(Bit))
nxt[u][j] = mp[Bit];
else {
nxt[u][j] = mp[Bit] = ++cnt;
a[cnt] = Bit;
}
}
}
vis[i][nxt[u][j]] = 1;
}
}
for (int i = 1; i <= cnt; i++) {
int j = 0;
for (; j < 10; j++)
if (a[i][j]) break;
for (; j < 10; j++) dp[0][j][i] = 1;
}
for (int j = 1; j < maxm - 1; j++)
for (int k = 1; k <= cnt; k++)
if (vis[maxm - 1 - j][k])
for (int i = 0; i < 10; i++)
for (int l = 0; l < 10; l++) dp[j][l][k] += dp[j - 1][l][nxt[k][i]];
int kase;
scanf("%d", &kase);
while (kase--) {
long long l, r;
int k;
scanf("%I64d%I64d%d", &l, &r, &k);
printf("%I64d\n", solve(r, k) - solve(l - 1, k));
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
set<char> pool[110];
vector<string> vs;
for (int i = 0; i < n; i++) {
string temp;
cin >> temp;
for (int j = 0; j < temp.size(); j++) {
pool[i].insert(temp[j]);
}
vs.push_back(temp);
}
int ans = INT_MIN;
for (int i = 0; i < 26; i++) {
for (int j = 0; j < 26; j++) {
int temp = 0;
for (int k = 0; k < n; k++) {
if (i != j) {
if (pool[k].size() > 2) continue;
} else {
if (pool[k].size() > 1) continue;
}
if ((pool[k].size() == 2 && pool[k].find('a' + i) != pool[k].end() &&
pool[k].find('a' + j) != pool[k].end()) ||
(pool[k].size() == 1 && (pool[k].find('a' + i) != pool[k].end() ||
pool[k].find('a' + j) != pool[k].end()))) {
temp += vs[k].size();
}
}
if (temp > ans) ans = temp;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <iostream>
#include <set>
#include <vector>
#include <algorithm>
#include <cmath>
#include <map>
#include <unordered_map>
#include <string>
#include <algorithm>
#include <cassert>
#include <numeric>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef long double ld;
int n, mod;
int dp[410][410];
int pow2[410];
int C[410][410];
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> mod;
dp[0][0] = 0;
dp[1][0] = 0;
dp[1][1] = 1;
pow2[0] = 1;
for (int i = 1; i <= n; ++i) pow2[i] = pow2[i - 1] * 2 % mod;
C[0][0] = 1;
for (int i = 1; i <= n; ++i)
{
C[i][0] = C[i][i] = 1;
for (int j = 1; j < n; ++j)
{
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
for (int i = 2; i <= n; ++i)
{
for (int j = 1; j <= i; ++j)
{
for (int suff = 1; suff <= j; ++suff)
{
int previous = i - suff - 1;
int mult;
if (previous == -1) mult = 1;
else if (previous == 0) mult = 0;
else mult = dp[previous][j - suff];
dp[i][j] += (ll)mult * pow2[suff - 1] % mod * C[j][suff] % mod;
dp[i][j] %= mod;
}
}
}
int ans = 0;
for (int i = 0; i <= n; ++i)
{
ans = (ans + dp[n][i]) % mod;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200007;
int uni[MAXN];
vector<pair<int, int>> G[MAXN];
bool odw[MAXN];
int n, k;
long long res = 0;
void dfs(int v) {
odw[v] = true;
for (auto ele : G[v]) {
int w, waga;
tie(w, waga) = ele;
if (odw[w] == false) {
dfs(w);
uni[v] += uni[w];
res += waga * min(uni[w], k - uni[w]);
}
}
}
int main() {
cin >> n >> k;
k *= 2;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
uni[x] = 1;
}
for (int i = 2; i <= n; i++) {
int a, b;
cin >> a >> b;
G[a].emplace_back(b, 1);
G[b].emplace_back(a, 1);
}
dfs(1);
cout << res << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int INF = 1e9;
const int MOD = 1e9 + 7;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int a[n];
int b[n];
for (int i = 0; i < n; i++) cin >> a[i];
multiset<int> s;
for (int i = 0; i < n; i++) {
cin >> b[i];
s.insert(b[i]);
}
for (int i = 0; i < n; i++) {
auto it = s.lower_bound(n - a[i]);
if (it == s.end()) it = s.begin();
cout << (a[i] + *it) % n << " ";
s.erase(it);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
node* son[26];
node* fail;
int value;
node() {
memset(son, 0, sizeof(son));
fail = NULL;
value = 0;
}
};
class aho_manager {
public:
int sz;
void reset() {
del_node(Head);
Head = new node();
sz = 0;
}
void add_string(char* s, int n, int val) {
node* act = Head;
sz += n;
for (i = 0; i < n; i++) {
int go = s[i] - 'a';
if (act->son[go] == NULL) act->son[go] = new node();
act = act->son[go];
}
act->value += val;
}
void build_fail() {
while (!Q.empty()) Q.pop();
Q.push(Head);
Head->fail = Head;
while (!Q.empty()) {
node* act = Q.front();
Q.pop();
act->value += act->fail->value;
for (int i = 0; i < 26; i++) {
if (act->son[i] == NULL) continue;
act->son[i]->fail = (act == Head ? Head : next_node(act->fail, i));
Q.push(act->son[i]);
}
}
}
long long evaluate(char* s, int n) {
long long ans = 0;
node* act = Head;
int i;
for (i = 0; i < n; i++) {
int go = s[i] - 'a';
act = next_node(act, go);
ans += 1LL * act->value;
}
return ans;
}
private:
queue<node*> Q;
node* Head;
int i;
void del_node(node* A) {
if (A == NULL) return;
for (int i = 0; i < 26; i++)
if (A->son[i] != NULL) del_node(A->son[i]);
delete A;
}
node* next_node(node* act, int go) {
while (act != Head && act->son[go] == NULL) act = act->fail;
if (act->son[go] != NULL) act = act->son[go];
return act;
}
};
const int limit = 10 * sqrt(300011);
int n, i, last, pos, dim;
int op[300011];
pair<int, int> wh[300011];
char s[300011];
aho_manager Big, Small;
bool need = false;
void reset_big(int step) {
last = step;
Big.reset();
Small.reset();
for (int i = 1; i <= last; i++) {
if (op[i] == 3) continue;
Big.add_string(s + wh[i].first, wh[i].second, (op[i] == 1 ? +1 : -1));
}
Big.build_fail();
}
void reset_small(int step) {
Small.reset();
for (int i = last + 1; i <= step; i++) {
if (op[i] == 3) continue;
Small.add_string(s + wh[i].first, wh[i].second, (op[i] == 1 ? +1 : -1));
}
Small.build_fail();
}
int main() {
last = 0;
pos = 0;
Big.reset();
Small.reset();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %s", &op[i], s + pos);
dim = strlen(s + pos);
wh[i] = make_pair(pos, dim);
pos += dim;
if (op[i] == 3) {
if (need) {
need = false;
Small.sz += dim;
if (Small.sz > limit)
reset_big(i);
else
reset_small(i);
}
long long ans = Big.evaluate(s + wh[i].first, dim);
ans += Small.evaluate(s + wh[i].first, dim);
printf("%lld\n", ans);
fflush(stdout);
} else {
need = true;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, cf, cm, m, psum[100010]{}, msum[100010]{};
pair<long long, int> x[100010];
bool cid(pair<long long, int> a, pair<long long, int> b) {
return a.second < b.second;
}
int main() {
scanf("%I64d%I64d%I64d%I64d%I64d", &n, &a, &cf, &cm, &m);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
x[i] = {a, i};
}
sort(x, x + n);
psum[0] = 0;
for (int i = 1; i < n; i++)
psum[i] = psum[i - 1] + (x[i].first - x[i - 1].first) * i;
for (int i = n - 1; i >= 0; i--) msum[i] = msum[i + 1] + a - x[i].first;
long long cmax = -1, maxv, minv;
for (int i = n, j = n - 1; i >= 0; i--) {
while (j >= 0 && msum[i] + psum[j] > m) j--;
if (j < 0) break;
if (j >= i) {
if (i == 0) {
cmax = n * cf + a * cm;
maxv = i;
minv = cm;
} else {
j = i - 1;
long long val =
cf * (n - i) +
cm * (min(a, x[j].first + (m - msum[i] - psum[j]) / (j + 1)));
if (val > cmax) {
cmax = val;
maxv = i;
minv = min(a, x[j].first + (m - msum[i] - psum[j]) / (j + 1));
}
}
} else {
long long val =
cf * (n - i) +
cm * (min(a, x[j].first + (m - msum[i] - psum[j]) / (j + 1)));
if (val > cmax) {
cmax = val;
maxv = i;
minv = min(a, x[j].first + (m - msum[i] - psum[j]) / (j + 1));
}
}
}
for (int i = n - 1; i >= maxv; i--) x[i].first = a;
for (int i = 0; i < maxv; i++) x[i].first = max(x[i].first, minv);
sort(x, x + n, cid);
printf("%I64d\n", cmax);
for (int i = 0; i < n; i++) printf("%I64d ", x[i].first);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
inline long long rd() {
long long x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * w;
}
struct graph {
int to[N << 1], nt[N << 1], hd[N], tot;
graph() { tot = 1; }
inline void add(int x, int y) {
++tot, to[tot] = y, nt[tot] = hd[x], hd[x] = tot;
++tot, to[tot] = x, nt[tot] = hd[y], hd[y] = tot;
}
} ee, tr;
int n, m, q;
bool p[N << 1];
int be[N], tot, dfn[N], low[N], ti, st[N << 1], tp, co[N];
int e[N], te, dd[N], td;
inline void tj(int x, int ffa) {
dfn[x] = low[x] = ++ti, be[x] = tot;
for (int i = ee.hd[x]; i; i = ee.nt[i]) {
int y = ee.to[i];
if (i == ffa || dfn[y] > dfn[x]) continue;
st[++tp] = i;
if (!dfn[y]) {
dd[++td] = i;
tr.add(ee.to[i], ee.to[i ^ 1]);
co[y] = co[x] ^ 1, tj(y, i ^ 1), low[x] = min(low[x], low[y]);
if (low[y] >= dfn[x]) {
int z = 0;
te = 0;
while (z != i) e[++te] = z = st[tp--];
bool ok = 0;
for (int j = 1; j <= te && !ok; ++j)
ok = co[ee.to[e[j]]] ^ co[ee.to[e[j] ^ 1]] ^ 1;
for (int j = 1; j <= te; ++j) p[e[j]] = p[e[j] ^ 1] = ok;
}
} else
low[x] = min(low[x], dfn[y]);
}
}
int fa[N], sz[N], hson[N], top[N], de[N], a[N];
void dfs1(int x) {
sz[x] = 1;
for (int i = tr.hd[x]; i; i = tr.nt[i]) {
int y = tr.to[i];
if (y == fa[x]) continue;
fa[y] = x, de[y] = de[x] + 1, a[y] = a[x] + p[dd[(i >> 1)]], dfs1(y),
sz[x] += sz[y];
hson[x] = sz[hson[x]] > sz[y] ? hson[x] : y;
}
}
void dfs2(int x, int ntp) {
top[x] = ntp;
if (hson[x]) dfs2(hson[x], ntp);
for (int i = tr.hd[x]; i; i = tr.nt[i]) {
int y = tr.to[i];
if (y == fa[x] || y == hson[x]) continue;
dfs2(y, y);
}
}
inline int glca(int x, int y) {
while (top[x] != top[y]) {
if (de[top[x]] < de[top[y]]) swap(x, y);
x = fa[top[x]];
}
return de[x] < de[y] ? x : y;
}
int main() {
n = rd(), m = rd();
for (int i = 1; i <= m; ++i) ee.add(rd(), rd());
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tp = 0, ++tot, tj(i, 0), de[i] = 1, dfs1(i), dfs2(i, i);
q = rd();
while (q--) {
int x = rd(), y = rd();
if (be[x] ^ be[y])
puts("No");
else {
int lca = glca(x, y);
(((de[x] + de[y] - (de[lca] << 1)) & 1) |
(a[x] + a[y] - (a[lca] << 1) > 0))
? puts("Yes")
: puts("No");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
constexpr int MAXN = 5 + 400000;
int cont[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int q, x;
cin >> q >> x;
set<int> s;
for (int i = 0; i < MAXN; ++i) s.insert(i);
while (q--) {
int p;
cin >> p;
p %= x;
s.erase(cont[p]++ * x + p);
cout << *s.begin() << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const double g = 10.0, eps = 1e-9;
const int N = 1000 + 10, maxn = 16, inf = 9999999;
int n;
bool query(int x, int y) {
if (x < 0 || y > n) return 0;
cout << 1 << " " << x << " " << y << endl;
fflush(stdout);
string s;
cin >> s;
return s == "TAK";
}
int bir(int l, int r) {
if (l > r) return -1;
while (l < r) {
int m = (l + r) / 2;
if (query(m, m + 1))
r = m;
else
l = m + 1;
}
return l;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int x, y, k;
cin >> n >> k;
x = bir(1, n);
y = bir(1, x - 1);
if (!query(y, x)) y = bir(x + 1, n);
cout << 2 << " " << x << " " << y << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, z;
};
node p[300];
int xt[300];
int yt[300];
int xa[300];
int ya[300];
int d;
int n;
int maxi;
bool cmp(node a, node b) { return a.z > b.z; }
void dfs(int l, int cnt) {
int i, j;
if (cnt == n) {
int x = 0;
for (i = 0; i < cnt; i++)
for (j = i + 1; j < cnt; j++)
x += (xt[i] - xt[j]) * (xt[i] - xt[j]) +
(yt[i] - yt[j]) * (yt[i] - yt[j]);
if (x > maxi) {
maxi = x;
for (i = 0; i < cnt; i++) {
xa[i] = xt[i];
ya[i] = yt[i];
}
}
return;
}
for (i = l; i < d; i++) {
xt[cnt] = p[i].x;
yt[cnt] = p[i].y;
dfs(i, cnt + 1);
}
}
int main() {
int r;
while (scanf("%d%d", &n, &r) != EOF) {
int i, j;
memset(p, 0, sizeof(p));
d = 0;
maxi = 0;
int rm = r * r;
int rs = (r - 1) * (r - 1);
for (i = -r; i <= r; i++)
for (j = -r; j <= r; j++) {
int x = i * i + j * j;
if (x <= rm && x > rs) {
p[d].x = i;
p[d].y = j;
p[d++].z = x;
}
}
sort(p, p + d, cmp);
d = 30 - n * 2;
dfs(0, 0);
printf("%d\n", maxi);
for (i = 0; i < n; i++) printf("%d %d\n", xa[i], ya[i]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int arr[305];
int st[305];
int a[100005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(arr, -1, sizeof arr);
int n, k, x;
for (int i = 0; i <= 300; i++) st[i] = i;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (arr[a[i]] == -1) {
x = a[i] - k + 1;
x = max(x, 0);
for (int j = x; j < x + k; j++) {
if (a[i] - st[j] + 1 <= k) {
x = j;
break;
}
}
for (int j = x; j <= a[i]; j++) {
st[j] = x;
arr[j] = x;
}
}
}
for (int i = 0; i < n; i++) {
cout << arr[a[i]] << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
int n;
int a[MAXN];
int h;
int kol[MAXN];
int ans[MAXN];
bool cmp(int aa, int bb) { return a[aa] < a[bb]; }
int main() {
scanf("%d%d", &n, &h);
for (int i = 0; i < (n); ++i) {
scanf("%d", a + i);
kol[i] = i;
}
sort(kol, kol + n, cmp);
int res1 = a[kol[n - 1]] + a[kol[n - 2]] - a[kol[1]] - a[kol[0]];
int mmax = max(a[kol[0]] + a[kol[n - 1]] + h, a[kol[n - 1]] + a[kol[n - 2]]);
int mmin = min(a[kol[0]] + a[kol[1]] + h, a[kol[1]] + a[kol[2]]);
if (res1 < mmax - mmin) {
} else {
ans[kol[0]] = 1;
}
printf("%d\n", min(res1, mmax - mmin));
for (int i = 0; i < (n); ++i) {
printf("%d ", ans[i] + 1);
}
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int R, C, k;
int g[1000][1001];
char cost[40][1001][1001];
vector<pair<int, int> > at[40];
queue<pair<int, int> > q;
int vis[1000][1000], vs;
int dr[4] = {-1, 1, 0, 0};
int dc[4] = {0, 0, -1, 1};
int valid(int r, int c) { return r >= 0 && c >= 0 && r < R && c < C; }
void BFS(int clr) {
memset(cost[clr], -1, sizeof(cost[clr]));
for (auto x : at[clr]) {
cost[clr][x.first][x.second] = 0;
q.push(x);
}
bool vis[40] = {};
vis[clr] = true;
while (!q.empty()) {
int r = q.front().first;
int c = q.front().second;
q.pop();
if (!vis[g[r][c]]) {
vis[g[r][c]] = true;
for (auto x : at[g[r][c]]) {
if (cost[clr][x.first][x.second] == -1) {
cost[clr][x.first][x.second] = cost[clr][r][c] + 1;
q.push(x);
}
}
}
for (int d = 0; d < 4; ++d) {
int nr = r + dr[d];
int nc = c + dc[d];
if (!valid(nr, nc)) continue;
if (cost[clr][nr][nc] != -1) continue;
cost[clr][nr][nc] = cost[clr][r][c] + 1;
q.push({nr, nc});
}
}
}
int main() {
scanf("%d%d%d", &R, &C, &k);
for (int i = 0; i < R; ++i)
for (int j = 0; j < C; ++j) {
scanf("%d", &g[i][j]);
--g[i][j];
at[g[i][j]].push_back({i, j});
}
for (int i = 0; i < k; ++i) BFS(i);
int Q;
scanf("%d", &Q);
while (Q--) {
int r1, c1, r2, c2;
scanf("%d%d%d%d", &r1, &c1, &r2, &c2);
--r1;
--c1;
--r2;
--c2;
++vs;
vis[r1][c1] = vs;
q.push({r1, c1});
int cur = 0;
int best = 1e9;
if (r1 == r2 && c1 == c2) best = 0;
while (!q.empty() && cur < best) {
++cur;
for (int it = q.size(); it > 0; --it) {
auto u = q.front();
q.pop();
int r1 = u.first, c1 = u.second;
if (cost[g[r1][c1]][r2][c2] != -1)
best = min(best, cur + cost[g[r1][c1]][r2][c2]);
for (int d = 0; d < 4; ++d) {
int nr = u.first + dr[d];
int nc = u.second + dc[d];
if (!valid(nr, nc)) continue;
if (vis[nr][nc] == vs) continue;
if (nr == r2 && nc == c2) best = cur;
vis[nr][nc] = vs;
q.push({nr, nc});
}
}
}
while (!q.empty()) q.pop();
printf("%d\n", best);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int a[maxn], cnt[maxn], dp[maxn][3][3];
int n, m;
void init() {
memset(cnt, 0, sizeof(cnt)), memset(dp, -1, sizeof(dp));
dp[0][0][0] = 0;
}
int main() {
while (cin >> n >> m) {
init();
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
cnt[a[i]]++;
}
for (int i = 0; i <= m - 1; i++) {
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 3; y++) {
if (x + y > cnt[i] || dp[i][x][y] == -1) continue;
for (int t = 0; t < 3; t++) {
if (x + y + t > cnt[i + 1]) continue;
int le = cnt[i + 1] - x - y - t;
dp[i + 1][t][x] = max(dp[i + 1][t][x], dp[i][x][y] + y + le / 3);
}
}
}
}
int ans = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
ans = max(ans, dp[m][i][j]);
}
}
printf("%d\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, a;
set<pair<int, int> > s;
int main() {
cin >> n;
cin >> a;
pair<int, int> b(0, 0), c(1000000001, 0), d(a, 1);
s.insert(b);
s.insert(c);
s.insert(d);
for (int i = 2; i <= n; i++) {
cin >> a;
pair<int, int> p(a, i);
int x = s.lower_bound(p)->second, y = (--(s.lower_bound(p)))->second;
int u = s.lower_bound(p)->first, v = (--(s.lower_bound(p)))->first;
cout << (x > y ? u : v) << " ";
s.insert(p);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100;
int n, m, k, a[maxn];
char s[maxn + 1];
bool win_r, win_g;
int main(void) {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
scanf("%s", s);
if (count(s, s + m, 'R') && count(s, s + m, 'G')) {
a[i] = abs(find(s, s + m, 'R') - find(s, s + m, 'G')) - 1;
} else if (count(s, s + m, 'R')) {
if (count(s, s + m, '-')) {
win_r = true;
}
} else if (count(s, s + m, 'G')) {
if (count(s, s + m, '-')) {
win_g = true;
}
}
}
if (win_g && win_r) {
puts("Draw");
return 0;
}
for (int i = 0; i < 10; ++i) {
int cnt = 0;
for (int j = 0; j < n; ++j) {
cnt += (a[j] >> i & 1);
}
if (cnt % (k + 1)) {
if (win_r) {
puts("Second");
} else {
puts("First");
}
return 0;
}
}
if (!win_g) {
puts("Second");
} else {
puts("First");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int mo = 1e9 + 7;
void test() { return; }
const int maxn = 3e5 + 5;
int a[maxn];
int dp[maxn];
vector<int> v[maxn];
int nxtbig[maxn];
int nxtsmall[maxn];
int main() {
test();
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
stack<int> sta;
for (int i = 1; i <= n; i++) {
while (sta.size() && a[i] > a[sta.top()]) {
nxtbig[sta.top()] = i;
sta.pop();
}
sta.push(i);
}
while (sta.size()) {
sta.pop();
}
for (int i = 1; i <= n; i++) {
while (sta.size() && a[i] < a[sta.top()]) {
nxtsmall[sta.top()] = i;
sta.pop();
}
sta.push(i);
}
while (sta.size()) {
sta.pop();
}
memset(dp, 0x3f, sizeof(dp));
dp[1] = 0;
for (int i = 1; i <= n; i++) {
int j = i + 1;
v[j].push_back(i);
if (a[j] > a[i]) {
while (nxtsmall[j]) {
j = nxtsmall[j];
v[j].push_back(i);
if (a[j] <= a[i]) {
break;
}
}
} else if (a[j] < a[i]) {
while (nxtbig[j]) {
j = nxtbig[j];
v[j].push_back(i);
if (a[j] >= a[i]) {
break;
}
}
}
}
for (int i = 2; i <= n; i++) {
for (const auto &x : v[i]) {
dp[i] = min(dp[i], dp[x] + 1);
}
}
printf("%d\n", dp[n]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
constexpr auto INF = 9223372036854775807;
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
inline long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int mod_power(long long int x, long long int y) {
long long int res = 1;
x = x % (long long int)1000000007;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % (long long int)1000000007;
y = y >> 1;
x = (x * x) % (long long int)1000000007;
}
return res;
}
long long modInverse(long long n) {
return mod_power(n, (long long int)1000000007 - 2);
}
long long nCrModPFermat(long long n, long long int r) {
if (r == 0) return 1;
vector<long long int> fac(n + 1, 0);
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = (fac[i - 1] * i) % (long long int)1000000007;
return (fac[n] * modInverse(fac[r]) % (long long int)1000000007 *
modInverse(fac[n - r]) % (long long int)1000000007) %
(long long int)1000000007;
}
bool isprime(long long int n) {
if (n == 2) return true;
if (n % 2 == 0 || n == 1) {
return false;
}
for (long long int j = 3; j <= sqrt(n); j += 2) {
if (n % j == 0) {
return false;
}
}
return true;
}
vector<int> graph[100005];
vector<int> rev_graph[100005];
bool visited[100005];
int arr[100005];
vector<long long int> order;
map<long long int, long long int> mp;
void dfs(long long int u) {
visited[u] = true;
for (auto i : graph[u]) {
if (!visited[i]) dfs(i);
}
order.push_back(u);
}
void dfs2(long long int u) {
visited[u] = true;
if (mp.find(arr[u]) == mp.end())
mp[arr[u]] = 1;
else
mp[arr[u]] += 1;
for (auto i : rev_graph[u]) {
if (!visited[i]) dfs2(i);
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int n;
cin >> n;
for (long long int i = 1; i <= n; i += 1) {
cin >> arr[i];
}
long long int m;
cin >> m;
for (long long int i = 1; i <= n; i += 1) visited[i] = false;
for (long long int i = 0; i < m; i += 1) {
long long int u, v;
cin >> u >> v;
graph[u].push_back(v);
rev_graph[v].push_back(u);
}
for (long long int i = 1; i <= n; i += 1) {
if (!visited[i]) dfs(i);
}
for (long long int i = 1; i <= n; i += 1) visited[i] = false;
long long int mini = 0, cnt = 1;
for (long long int i = order.size() - 1; i >= 0; i -= 1) {
long long int u = order[i];
if (visited[u]) continue;
dfs2(u);
mini += (*mp.begin()).first;
cnt *= (*mp.begin()).second;
cnt %= (long long int)1000000007;
mp.clear();
}
cout << mini << " ";
cout << cnt << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int arr = 2e5 + 10;
const int ar = 2e3 + 10;
const long double pi = acos(-1);
const long double eps = 1e-10;
const long long md = 1e9 + 7;
const int bsize = 500;
vector<int> vh[(int)(2e6 + 10)];
int a[(int)(2e6 + 10)];
int pref[(int)(2e6 + 10)];
long long ans[(int)(2e6 + 10)];
vector<pair<pair<int, int>, int>> q;
int n, m, k;
bool cmp(const pair<pair<int, int>, int>& lhs,
const pair<pair<int, int>, int>& rhs) {
return lhs.first.first / bsize < rhs.first.first / bsize ||
(lhs.first.first / bsize == rhs.first.first / bsize &&
lhs.first.second < rhs.first.second);
}
int get(int val, int l, int r) {
return upper_bound(vh[val].begin(), vh[val].end(), r) -
lower_bound(vh[val].begin(), vh[val].end(), l);
}
void do_sqrt() {
sort(q.begin(), q.end(), cmp);
int l = 1, r = 1;
long long cur_ans = 0;
for (auto i : q) {
while (l > i.first.first) {
l--;
cur_ans += get(pref[l - 1] ^ k, l, r - 1);
}
while (r <= i.first.second) {
cur_ans += get(pref[r] ^ k, l - 1, r - 1);
r++;
}
while (l < i.first.first) {
cur_ans -= get(pref[l - 1] ^ k, l, r - 1);
l++;
}
while (r > i.first.second + 1) {
r--;
cur_ans -= get(pref[r] ^ k, l - 1, r - 1);
}
ans[i.second] = cur_ans;
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m >> k;
vh[0].push_back(0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
pref[i] = pref[i - 1] ^ a[i];
vh[pref[i]].push_back(i);
}
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
q.push_back(make_pair(make_pair(l, r), i));
}
do_sqrt();
for (int i = 1; i <= m; i++) {
cout << ans[i] << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
namespace mem {
namespace stdval {
using i32 = int;
using i64 = long long int;
using u32 = unsigned int;
using u64 = unsigned long long int;
using f32 = float;
using f64 = double;
using f96 = long double;
using i128 = __int128_t;
using u128 = __uint128_t;
} // namespace stdval
namespace utils {
using std::accumulate;
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
using std::function;
using std::get;
using std::lower_bound;
using std::make_pair;
using std::make_tuple;
using std::max_element;
using std::min_element;
using std::reverse;
using std::shuffle;
using std::sort;
using std::swap;
using std::tie;
using std::unique;
using std::upper_bound;
} // namespace utils
namespace random {
const int LuckyNumber = 20040726;
std::mt19937 rng(LuckyNumber ^
std::chrono::steady_clock::now().time_since_epoch().count());
std::mt19937_64 rng64(
LuckyNumber ^ std::chrono::steady_clock::now().time_since_epoch().count());
template <class T>
inline T rand(T l, T r) {
return std::uniform_int_distribution<T>(l, r)(rng);
}
template <class T>
inline T rand64(T l, T r) {
return std::uniform_int_distribution<T>(l, r)(rng);
}
} // namespace random
namespace modint {
template <const int mod>
struct Z {
int x;
inline Z() { x = 0; }
inline Z(int t) { x = t; }
inline void operator-=(Z a) { (x -= a.x) < 0 && (x += mod); }
inline void operator+=(Z a) { (x += a.x) >= mod && (x -= mod); }
inline void operator*=(Z a) { x = (long long)x * a.x % mod; }
friend inline Z operator*(Z a, Z b) { return (long long)a.x * b.x % mod; }
friend inline Z operator-(Z a, Z b) {
return ((a.x -= b.x) < 0 && (a.x += mod)), a;
}
friend inline Z operator+(Z a, Z b) {
return ((a.x += b.x) >= mod && (a.x -= mod)), a;
}
};
template <const int mod>
inline Z<mod> finv(Z<mod> x) {
if (x.x < 2) return x;
return (mod - mod / x.x) * finv(mod % x.x);
}
template <const int mod>
inline Z<mod> fpow(Z<mod> a, int b) {
Z<mod> s = 1;
for (; b; b >>= 1, a = a * a)
if (b & 1) s = s * a;
return s;
}
template <const int mod>
inline void init_inverse(int n, Z<mod> *inv) {
inv[0] = inv[1] = 1;
for (int i = 2; i < n; i++) inv[i] = (mod - mod / i) * inv[mod % i];
}
template <const int mod>
inline void init_factorial(int n, Z<mod> *fac, Z<mod> *ifac) {
fac[0] = 1, init_inverse(n, ifac);
for (int i = 1; i < n; i++)
fac[i] = fac[i - 1] * i, ifac[i] = ifac[i - 1] * ifac[i];
}
} // namespace modint
namespace io {
template <const int mod>
inline void read(modint::Z<mod> &x) {
read(x.x);
}
template <const int mod>
inline void print(modint::Z<mod> x) {
print(x.x);
}
} // namespace io
namespace math {
using std::max;
using std::min;
template <class T>
inline T abs(T x) {
return x < 0 ? -x : x;
}
template <class T>
inline T gcd(T n, T m) {
return m ? gcd(m, n % m) : n;
}
template <class T>
inline T lcm(T n, T m) {
return n / gcd(n, m) * m;
}
template <const stdval::u64 p>
struct FastDiv {
stdval::u64 t, i;
inline FastDiv() : t(stdval::u64(-1) / p), i(mul_inv(p)) {}
inline bool divide(stdval::u64 n) { return n * i <= t; }
inline bool divide(stdval::i64 n) {
return stdval::u64(n < 0 ? -n : n) * i <= t;
}
inline stdval::u64 mul_inv(stdval::u64 n) {
stdval::u64 x = n;
for (int i = 0; i < 5; ++i) x *= 2 - n * x;
return x;
}
};
template <const stdval::u64 b>
struct FastMod {
stdval::u64 m;
inline FastMod() : m(stdval::u64((stdval::u128(1) << 64) / b)) {}
inline stdval::u64 reduce(stdval::u64 a) {
stdval::u64 q = (stdval::u64)((stdval::u128(m) * a) >> 64);
stdval::u64 r = a - q * b;
return r >= b ? r - b : r;
}
};
} // namespace math
namespace container {
using std::get;
using std::make_pair;
using std::make_tuple;
using std::map;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::stack;
using std::tie;
using std::tuple;
using std::unordered_map;
using std::unordered_set;
template <class T>
struct vector : std::vector<T> {
using std::vector<T>::vector;
vector() : std::vector<T>() {}
vector(const std::vector<T> &plain) : std::vector<T>(plain) {}
inline void sort() { std::sort(this->begin(), this->end()); }
inline void concat(const vector &rhs) {
this->insert(this->end(), rhs.begin(), rhs.end());
}
inline bool includes(const T &x) const {
return std::find(this->begin(), this->end(), x) != this->end();
}
template <class Function>
inline void forEach(Function func) {
for (const auto &it : *this) func(it);
}
inline vector slice(int l, int r) const {
if (l > r) return {};
if (r < this->size()) return vector(this->begin() + l, this->begin() + r);
vector<int> rsp = (this->begin() + l, this->end());
return rsp.resize(r - l), rsp;
}
inline void from(const std::set<T> &src) {
this->resize(src.size());
auto it = this->begin();
for (const T e : src) *it++ = e;
}
template <class R, class Function>
inline vector<R> _map(Function func) const {
vector<R> res(this->size());
for (size_t i = 0; i < this->size(); i++)
res[i] = func(this->operator[](i));
return res;
}
template <class R>
inline vector<R> map(R func(T)) const {
return this->_map<R>(func);
}
template <class R>
inline vector<R> map(const std::function<R(T)> &func) const {
return this->_map<R>(func);
}
};
struct string : std::string {
using std::string::string;
string() : std::string("") {}
string(const std::string &plain) : std::string(plain) {}
template <class T>
inline string join(const vector<T> &vet) const;
vector<string> split(const string &dim) const {
if (this->empty()) return {};
char *src = new char[this->length() + 1];
strcpy(src, this->c_str());
char *tar = new char[dim.length() + 1];
strcpy(tar, dim.c_str());
vector<string> rsp;
for (char *pos = strtok(src, tar); pos; pos = strtok(nullptr, tar))
rsp.push_back(string(pos));
delete[] src;
delete[] tar;
return rsp;
}
template <class... Args>
static inline string format(const char *fm, Args... args) {
int len = snprintf(nullptr, 0, fm, args...);
char *buf = new char[len + 1];
snprintf(buf, len + 1, fm, args...);
string str(buf);
delete[] buf;
return str;
}
template <class... Args>
static inline string format(const string &fm, Args... args) {
return format(fm.c_str(), args...);
}
};
inline string to_string(const float &x) { return std::to_string(x); }
inline string to_string(const double &x) { return std::to_string(x); }
inline string to_string(const long double &x) { return std::to_string(x); }
inline string to_string(const int &x) { return std::to_string(x); }
inline string to_string(const unsigned int &x) { return std::to_string(x); }
inline string to_string(const long long int &x) { return std::to_string(x); }
inline string to_string(const unsigned long long int &x) {
return std::to_string(x);
}
inline string to_string(const string &s) { return s; }
inline string to_string(const char *s) { return string(s); }
inline string to_string(const std::string &s) { return string(s); }
template <const int mod>
inline string to_string(const mem::modint::Z<mod> &v) {
return std::to_string(v.x);
}
template <class T>
inline string to_string(const vector<T> &ctn) {
return "[" + string(",").join(ctn) + "]";
}
template <class T>
inline string to_string(const set<T> &ctn) {
string result = "{";
bool flag = false;
for (const auto &it : ctn) {
if (flag) result += ",";
flag = true;
result += to_string(it);
}
return result + "}";
}
template <class T1, class T2>
inline string to_string(const map<T1, T2> &ctn) {
string result = "{";
bool flag = false;
for (const auto &it : ctn) {
if (flag) result += ",";
flag = true;
result += to_string(it.first) + ":" + to_string(it.second);
}
return result + "}";
}
template <class T>
inline string string::join(const vector<T> &vet) const {
if (!vet.size()) return "";
string res = to_string(vet[0]);
for (size_t i = 1; i < vet.size(); i++) {
res += *this;
res += to_string(vet[i]);
}
return res;
}
inline string operator"" _s(const char *s) { return string(s); }
inline string operator"" _s(const char *s, size_t len) {
return string(s, len);
}
inline string operator"" _s(long double x) { return to_string(x); }
inline string operator"" _s(unsigned long long int x) { return to_string(x); }
} // namespace container
namespace io {
namespace fastio {
const int BUFFER = 1 << 18;
char ibuf[BUFFER], *iS, *iT;
inline int getc() {
if (iS == iT) {
iT = (iS = ibuf) + fread(ibuf, 1, BUFFER, stdin);
return iS == iT ? EOF : *iS++;
} else {
return *iS++;
}
}
char obuf[BUFFER], *oS = obuf, *oT = oS + BUFFER - 1;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(int x) {
*oS++ = x;
if (oS == oT) flush();
}
struct Flusher {
~Flusher() { flush(); }
} flusher;
} // namespace fastio
using fastio::getc;
using fastio::putc;
template <class T>
inline void readDigit(T &x) {
x = getc();
while (!isdigit(x)) x = getc();
}
inline int readDigit() {
int x;
readDigit(x);
return x;
}
template <class T>
inline void readAlpha(T &x) {
x = getc();
while (!isalpha(x)) x = getc();
}
inline int readAlpha() {
int x;
readAlpha(x);
return x;
}
inline void read(int &x) {
x = 0;
bool f = 0;
char c = getc();
while (!isdigit(c)) f ^= c == '-', c = getc();
while (isdigit(c)) x = x * 10 + c - '0', c = getc();
if (f) x = -x;
}
inline void read(unsigned int &x) {
x = 0;
bool f = 0;
char c = getc();
while (!isdigit(c)) f ^= c == '-', c = getc();
while (isdigit(c)) x = x * 10 + c - '0', c = getc();
if (f) x = -x;
}
inline void read(long long int &x) {
x = 0;
bool f = 0;
char c = getc();
while (!isdigit(c)) f ^= c == '-', c = getc();
while (isdigit(c)) x = x * 10 + c - '0', c = getc();
if (f) x = -x;
}
inline void read(unsigned long long int &x) {
x = 0;
bool f = 0;
char c = getc();
while (!isdigit(c)) f ^= c == '-', c = getc();
while (isdigit(c)) x = x * 10 + c - '0', c = getc();
if (f) x = -x;
}
inline void read(char &x) { x = getc(); }
inline void read(char *s) {
char c = getc();
while (~c && !isspace(c)) *s++ = c, c = getc();
*s++ = '\0';
}
inline void read(container::string &s) {
char c = getc();
s = "";
while (~c && !isspace(c)) s += c, c = getc();
}
template <class T = int>
inline T read() {
T x;
read(x);
return x;
}
template <class T, class... Args>
inline void read(T &x, Args &...args) {
read(x), read(args...);
}
inline void print(int x) {
if (x < 0) putc('-'), x = -x;
if (x > 9) print(x / 10);
putc('0' + x % 10);
}
inline void print(unsigned int x) {
if (x < 0) putc('-'), x = -x;
if (x > 9) print(x / 10);
putc('0' + x % 10);
}
inline void print(long long int x) {
if (x < 0) putc('-'), x = -x;
if (x > 9) print(x / 10);
putc('0' + x % 10);
}
inline void print(unsigned long long int x) {
if (x < 0) putc('-'), x = -x;
if (x > 9) print(x / 10);
putc('0' + x % 10);
}
inline void print(char x) { putc(x); }
inline void print(const char *s) {
int len = strlen(s);
for (int i = 0; i < len; i++) putc(s[i]);
}
inline void print(const container::string &s) {
for (int i = 0; i < s.length(); i++) putc(s[i]);
}
template <class T, class... Args>
inline void print(const T &x, Args... args) {
print(x), print(args...);
}
template <class... Args>
inline void println(Args... args) {
print(args...), putc('\n');
}
template <class... Args>
inline void printfm(const char *formatter, Args... arguments) {
print(container::string().format(formatter, arguments...));
}
template <class... Args>
inline void printfm(const container::string &formatter, Args... arguments) {
print(container::string().format(formatter, arguments...));
}
} // namespace io
namespace logger {
enum ConsoleColor {
NOPE = -1,
BLACK,
RED,
GREEN,
YELLOW,
BLUE,
PURPLE,
DEEPBLUE
};
template <const ConsoleColor color = NOPE, class... Args>
inline void log(const char *formatter, Args... args) {
if (~color) {
fprintf(stderr, "\033[%dm", 30 + color);
fprintf(stderr, formatter, args...);
fprintf(stderr, "\033[0m");
} else {
fprintf(stderr, formatter, args...);
}
}
template <const ConsoleColor color = NOPE, class... Args>
inline void logln(const char *formatter, Args... args) {
if (~color) {
fprintf(stderr, "\033[%dm", 30 + color);
fprintf(stderr, formatter, args...);
fprintf(stderr, "\033[0m\n");
} else {
fprintf(stderr, formatter, args...);
fprintf(stderr, "\n");
}
}
template <class T>
inline void logs(const T &x) {
fprintf(stderr, container::to_string(x).c_str());
}
template <class T, class... Args>
inline void logs(const T &x, Args... args) {
logs(x), logs(args...);
}
template <class... Args>
inline void logsln(Args... args) {
logs(args...);
fprintf(stderr, "\n");
}
} // namespace logger
using namespace io;
using namespace math;
using namespace utils;
using namespace modint;
using namespace random;
using namespace stdval;
using namespace logger;
using namespace container;
} // namespace mem
using namespace mem;
const int N = 2e5 + 10;
int n, top, stk[N], ans[N], a[N];
set<int> S;
int main() {
memset(ans, -1, sizeof(ans));
read(n);
for (int i = 1; i <= (n << 1); ++i) {
char c = getc();
while (isspace(c)) c = getc();
if (c == '+')
S.insert(i);
else {
read(a[i]);
int tem = a[i];
while (top && a[i] > a[stk[top]]) --top;
stk[++top] = i;
set<int>::iterator it = S.upper_bound(stk[top - 1]);
if (it == S.end()) {
print("NO\n");
return 0;
}
ans[*it] = tem;
S.erase(it);
}
}
print("YES\n");
for (int i = 1; i <= (n << 1); ++i)
if (~ans[i]) print(ans[i], ' ');
print('\n');
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
double x, y, t, t0;
} a[100005];
int vis[100005];
int main() {
int n;
double w, u, v;
while (scanf("%d%lf%lf%lf", &n, &w, &v, &u) != EOF) {
double maxx, maxy, minx, miny;
maxx = maxy = -1000000001;
minx = miny = 1000000001;
int pos_low;
for (int i = 1; i <= n; i++) {
scanf("%lf%lf", &a[i].x, &a[i].y);
if (a[i].x > 0) {
a[i].t = a[i].x / v;
} else {
a[i].t = 0;
}
a[i].t0 = a[i].y / u;
if (a[i].y < miny) {
pos_low = i;
}
maxx = max(maxx, a[i].x);
minx = min(minx, a[i].x);
miny = min(miny, a[i].y);
maxy = min(maxy, a[i].y);
}
double nowt = 0;
double nowy = 0;
int k = pos_low;
double fuckt;
for (int j = 1; j <= n; j++) {
if (a[k].y < nowy) {
k++;
if (k > n) k = 1;
continue;
}
fuckt = (a[k].y - nowy) / u;
if (fuckt + nowt >= a[k].t) {
nowt += fuckt;
nowy = a[k].y;
} else if (fuckt + nowt < a[k].t) {
nowt = a[k].t;
nowy = a[k].y;
}
k++;
if (k > n) k = 1;
}
nowt += (w - nowy) / u;
int flag = 0;
for (int i = 1; i <= n; i++) {
if (a[i].t0 > a[i].t) {
flag = 1;
}
}
if (flag == 0) {
nowt = w / u;
}
printf("%.7lf\n", nowt);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = (long long int)1e9 + 10;
const long long int INFLL = (long long int)1e18 + 10;
const long double EPS = 1e-8;
const long double EPSLD = 1e-18;
const long long int MOD = 1e9 + 7;
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
const int MAX_N = 64;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, -1, 0, 1};
const int ccp[] = {1, -1};
int n, m, pc;
char s[MAX_N][MAX_N];
int pr[MAX_N][MAX_N][4][2];
pair<int, int> memo[MAX_N][MAX_N][4];
pair<int, int> nex(int y, int x, int d) {
if (memo[y][x][d].first != -1) return memo[y][x][d];
int ny = y, nx = x;
while (s[y][x] == s[y + dy[d]][x + dx[d]]) {
y += dy[d];
x += dx[d];
}
return memo[ny][nx][d] = pair<int, int>(y, x);
}
int main() {
for (long long int i = (0); i < (long long int)(MAX_N); i++)
for (long long int j = (0); j < (long long int)(MAX_N); j++)
for (long long int k = (0); k < (long long int)(4); k++)
memo[i][j][k] = pair<int, int>(-1, -1);
for (long long int i = (0); i < (long long int)(MAX_N); i++)
for (long long int j = (0); j < (long long int)(MAX_N); j++)
for (long long int k = (0); k < (long long int)(4); k++)
for (long long int l = (0); l < (long long int)(2); l++)
pr[i][j][k][l] = -1;
scanf("%d %d", &n, &pc);
for (long long int i = (0); i < (long long int)(n); i++)
scanf("%s", s[i + 1] + 1);
m = strlen(s[1] + 1);
for (long long int i = (0); i < (long long int)(n + 2); i++)
s[i][0] = s[i][m + 1] = '0';
for (long long int j = (0); j < (long long int)(m + 2); j++)
s[0][j] = s[n + 1][j] = '0';
int y = 1, x = 1, dp = 0, cp = 0;
while (pc--) {
if (pr[y][x][dp][cp] != -1) m %= pr[y][x][dp][cp] - pc;
pr[y][x][dp][cp] = pc;
auto ne = nex(y, x, dp);
ne = nex(ne.first, ne.second, (dp + ccp[cp] + 4) % 4);
ne = pair<int, int>(ne.first + dy[dp], ne.second + dx[dp]);
if (s[ne.first][ne.second] == '0') {
if (cp == 0)
cp = 1;
else
cp = 0, dp = (dp + 3) % 4;
} else {
y = ne.first;
x = ne.second;
}
}
printf("%c\n", s[y][x]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int a;
int ind;
} arr[100];
int cmp(node x, node y) { return x.a < y.a; }
int main() {
int n, k;
cin >> n;
cin >> k;
int i, j;
for (i = 0; i < n; i++) {
cin >> arr[i].a;
arr[i].ind = i + 1;
}
sort(arr, arr + n, cmp);
for (i = 0; i < n; i++)
if (k >= arr[i].a) {
k -= arr[i].a;
} else
break;
int num = i;
printf("%d\n", num);
if (num == 0) return 0;
for (i = 0; i < num - 1; i++) {
printf("%d ", arr[i].ind);
}
printf("%d\n", arr[i].ind);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
long long dat;
int id;
bool operator<(const pt &a) const { return dat > a.dat; }
};
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long a[100010], h[100010], t[100010], n, m, k, p;
bool check(long long x) {
priority_queue<pt> q;
for (int i = 1; i <= n; ++i) {
t[i] = x;
if (x - a[i] * m < h[i]) q.push({x / a[i], i});
}
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= k; ++j) {
if (q.empty()) return true;
int dat = q.top().dat, id = q.top().id;
q.pop();
if (dat < i) return false;
t[id] += p;
if (t[id] - a[id] * m < h[id]) q.push({t[id] / a[id], id});
}
}
return q.empty();
}
signed main() {
n = read(), m = read(), k = read(), p = read();
for (int i = 1; i <= n; ++i) h[i] = read(), a[i] = read();
long long l = 0, r = 1LL << 60, ans = -1;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid)) {
r = mid - 1;
ans = mid;
} else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, req[260], msk[260];
int pwd[8] = {0};
int con[260], vis[260] = {0};
int getint() {
int a1, a2, a3;
cin >> a1 >> a2 >> a3;
return a1 * 4 + a2 * 2 + a3;
}
vector<int> G[260];
int main() {
cin >> n;
int fin = 1;
for (int i = 1; i <= n; i++) {
req[i] = getint();
if (!req[i]) {
vis[i] = 1;
fin += 1;
}
}
for (int i = 1; i <= n; i++) {
msk[i] = getint();
}
vis[1] = 1;
pwd[7] = 1;
pwd[0] = 1;
while (1) {
int lfin = fin;
for (int i = 1; i <= n; i++) {
if (!vis[i] && pwd[req[i]]) {
int u = pwd[req[i]];
int v = i;
G[u].push_back(v);
vis[i] = 1;
fin += 1;
if (!pwd[msk[i] & req[i]]) {
con[i] = 1;
pwd[msk[i] & req[i]] = i;
}
}
if (!vis[i] && !pwd[req[i]]) {
if (req[i] == 3 && pwd[1] && pwd[2]) {
int u = pwd[1], w = pwd[2];
G[u].push_back(i);
G[w].push_back(i);
pwd[3] = i;
vis[i] = 1;
fin++;
}
if (req[i] == 5 && pwd[1] && pwd[4]) {
int u = pwd[1], w = pwd[4];
G[u].push_back(i);
G[w].push_back(i);
pwd[5] = i;
vis[i] = 1;
fin++;
}
if (req[i] == 6 && pwd[4] && pwd[2]) {
int u = pwd[4], w = pwd[2];
G[u].push_back(i);
G[w].push_back(i);
pwd[6] = i;
vis[i] = 1;
fin++;
}
}
}
if (fin == lfin) break;
}
if (fin == n) {
cout << "Possible\n";
for (int i = 1; i <= n; i++) {
cout << con[i];
if (i != n) cout << ' ';
}
cout << endl;
int m = 0;
for (int i = 1; i <= n; i++) {
for (auto ct : G[i]) m++;
}
cout << m << endl;
for (int i = 1; i <= n; i++) {
for (auto ct : G[i]) cout << i << ' ' << ct << endl;
}
} else {
cout << "Impossible\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b) {
long long int res = 1;
a = a % 1000000007;
while (b > 0) {
if (b & 1) {
res = (res * a) % 1000000007;
b--;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long int gcd(long long int a, long long int b) {
return (b == 0) ? a : gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int T;
cin >> T;
while (T--) {
int n;
cin >> n;
long long int a[n], b[n];
for (long long int i = 0; i <= n - 1; i++) cin >> a[i];
for (long long int i = 0; i <= n - 1; i++) cin >> b[i];
long long int mina = INT_MAX;
long long int minb = INT_MAX;
for (int i = 0; i < n; i++) {
if (a[i] < mina) mina = a[i];
}
for (int i = 0; i < n; i++) {
if (b[i] < minb) minb = b[i];
}
long long int ans = 0;
for (long long int i = 0; i <= n - 1; i++) {
ans += max((a[i] - mina), (b[i] - minb));
}
cout << ans << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
class seg {
public:
long long int c, o, t;
seg() {
c = 0;
o = 0;
t = 0;
}
};
seg stree[4000005];
void build_tree(long long int i, long long int st, long long int en) {
if (st == en) {
if (s[st] == '(')
stree[i].o = 1;
else
stree[i].c = 1;
return;
}
long long int mid = (st + en) / 2;
build_tree(2 * i + 1, st, mid);
build_tree(2 * i + 2, mid + 1, en);
stree[i].t = stree[2 * i + 1].t + stree[2 * i + 2].t;
stree[i].t += min((stree[2 * i + 1].o - stree[2 * i + 1].t),
(stree[2 * i + 2].c - stree[2 * i + 2].t));
stree[i].c = stree[2 * i + 1].c + stree[2 * i + 2].c;
stree[i].o = stree[2 * i + 1].o + stree[2 * i + 2].o;
}
seg query(long long int i, long long int st, long long int en,
long long int qst, long long int qen) {
if (qst == st && qen == en) return (stree[i]);
if (st <= qst && en >= qen) {
long long int mid = (st + en) / 2;
seg a, b;
if (qen > mid && qst <= mid) {
a = query(2 * i + 1, st, mid, qst, mid);
b = query(2 * i + 2, mid + 1, en, mid + 1, qen);
} else {
a = query(2 * i + 1, st, mid, qst, qen);
b = query(2 * i + 2, mid + 1, en, qst, qen);
}
seg ans;
ans.t = a.t + b.t;
ans.t += min((a.o - a.t), (b.c - b.t));
ans.c = a.c + b.c;
ans.o = a.o + b.o;
return ans;
}
seg ans;
return ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> s;
long long int l = s.size();
build_tree(0, 0, l - 1);
long long int m, a, b;
cin >> m;
while (m--) {
cin >> a >> b;
a--;
b--;
seg a1 = query(0, 0, l - 1, a, b);
cout << 2 * a1.t << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int bit[200001];
long long int power(long long int x, long long int y) {
int res = 1;
x = x % 998244353;
while (y > 0) {
if (y & 1) res = (res * x) % 998244353;
y = y >> 1;
x = (x * x) % 998244353;
}
return res;
}
int main() {
long long int n, m, s = 0, i, j;
string a, b;
cin >> n >> m;
cin >> a >> b;
long long int k = -1;
bit[b.length() - 1] = 1;
for (i = 1; i < b.length(); i++) {
if (b[i] == '1')
bit[b.length() - i - 1] = bit[b.length() - i] + 1;
else
bit[b.length() - i - 1] = bit[b.length() - i];
}
for (i = 0; i < a.length(); i++) {
if (a[i] == '1')
s = (s % 998244353 + (power(2, a.length() - i - 1) % 998244353 *
bit[a.length() - i - 1] % 998244353) %
998244353) %
998244353;
}
cout << s % 998244353;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long l, r, u, d;
long long n, x, y, c;
long long sqr(long long x) { return x * x; }
long long tri(long long x) { return (x + 1) * x / 2; }
bool solve(long long t) {
long long sum = t * t + (t + 1) * (t + 1);
if (t > l) sum -= sqr(t - l);
if (t > r) sum -= sqr(t - r);
if (t > u) sum -= sqr(t - u);
if (t > d) sum -= sqr(t - d);
if (t > l + d) sum += tri(t - (l + d) - 1);
if (t > l + u) sum += tri(t - (l + u) - 1);
if (t > r + d) sum += tri(t - (r + d) - 1);
if (t > r + u) sum += tri(t - (r + u) - 1);
if (sum >= c) return true;
return false;
}
int main() {
scanf("%I64d%I64d%I64d%I64d", &n, &x, &y, &c);
l = x - 1;
r = n - x;
u = y - 1;
d = n - y;
long long low = 0, high = 2 * n, mid;
while (low <= high) {
mid = (low + high) / 2;
if (solve(mid))
high = mid - 1;
else
low = mid + 1;
}
printf("%I64d\n", low);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int MAXN = 10010;
const int MAXL = 2010;
int n;
int x[MAXN];
bool f[2][MAXL];
bool Check(int L) {
memset(f[0], 0, sizeof(f[0][0]) * (L + 1));
memset(f[1], 0, sizeof(f[1][0]) * (L + 1));
for (int i = 0; i >= x[0] - L; --i) {
f[0][min(x[0] - i, L - x[0] + i)] = true;
}
int o = 0;
for (int i = 1; i < n; ++i) {
o ^= 1;
memset(f[o], 0, sizeof(f[o][0]) * (L + 1));
for (int j = 0; j <= L; ++j) {
if (f[o ^ 1][j]) {
if (j >= x[i]) {
f[o][j - x[i]] = true;
}
if (L - j >= x[i]) {
f[o][min(L - j - x[i], j + x[i])] = true;
}
}
}
}
for (int i = 0; i <= L; ++i) {
if (f[o][i]) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int times;
cin >> times;
while (times--) {
cin >> n;
int L = 0, R = 0;
for (int i = 0; i < n; ++i) {
cin >> x[i];
L = max(L, x[i]);
}
R = L + L;
L = L - 1;
while (L + 1 < R) {
int mid = (L + R) >> 1;
if (Check(mid))
R = mid;
else
L = mid;
}
cout << R << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 7;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
long long n, m;
long long a[N];
long long b[N];
bool f(long long op) {
long long prev = 0;
for (long long i = 0; i < n; i++) {
if (prev <= a[i]) {
long long k = m - a[i] + prev;
if (k > op) prev = a[i];
} else {
long long k = prev - a[i];
if (k > op) return false;
}
}
return true;
}
void solve() {
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long lo = 0, hi = INF;
while (lo < hi) {
long long m = (lo + hi) / 2;
if (f(m))
hi = m;
else
lo = m + 1;
}
cout << lo << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
clock_t beg = clock();
long long t = 1;
while (t--) {
solve();
}
cerr << "\nExecution time: " << (clock() - beg) / 1000 << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string func(char a, char b) {
if (a != 'S' && b != 'S') return "S";
if (a != 'E' && b != 'E') return "E";
if (a != 'T' && b != 'T') return "T";
}
map<string, long long int> mp;
string s[2005];
long long int ans = 0;
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> s[i];
mp[s[i]] = 1;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string temp = "";
for (int l = 0; l < k; l++) {
if (s[i][l] == s[j][l])
temp += s[i][l];
else
temp += func(s[i][l], s[j][l]);
}
ans += mp[temp];
}
}
cout << ans / 3;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string a;
int f[1000111][2][3];
int main() {
ios_base::sync_with_stdio(0);
cin >> a;
int n = a.size();
a = " " + a;
f[0][0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 3; k++) {
for (int m = 0; m < 2; m++) {
if (m == 1 && (a[i] == '0' || a[i] == '1' || a[i] == '2')) continue;
if (m == 0 && a[i] == '*') continue;
if (k == 1 && m == 1) continue;
if (k == 2 && m == 0) continue;
int kk = 0;
if (a[i] == '0' && j == 1) continue;
if (a[i] == '2' && j == 0) continue;
if (a[i] == '0')
kk = 1;
else if (a[i] == '2')
kk = 2;
if (a[i] == '1') {
if (j == 0)
kk = 2;
else
kk = 1;
}
f[i][m][kk] = (f[i][m][kk] + f[i - 1][j][k]) % 1000000007;
}
}
int ans = 0;
for (int j = 0; j < 2; j++)
for (int k = 0; k < 3; k++) {
if (k == 2) continue;
ans = (ans + f[n][j][k]) % 1000000007;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int a = 0, b = 0, c = 0, ans, last, n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] == '#') {
c++;
last = i;
}
}
for (int i = 0; i < last; i++) {
if (s[i] == '#') s[i] = ')';
}
for (int i = 0; i <= last; i++) {
if (s[i] == '(') a++;
if (s[i] == ')') b++;
}
int sum = 0, flag = 0;
for (int i = last + 1; i < n; i++) {
if (s[i] == ')') {
sum++;
flag = 0;
}
if (s[i] == '(') {
sum--;
flag = 1;
}
}
if (sum < 0 || flag) {
cout << -1;
return 0;
}
ans = a - b;
ans -= sum;
if (ans <= 0) {
cout << "-1";
return 0;
}
s[last] = ')';
s.insert(last, ans - 1, ')');
sum = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '(') sum++;
if (s[i] == ')') sum--;
if (sum < 0) {
cout << -1;
return 0;
}
}
c--;
while (c--) cout << "1" << endl;
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 30 + 10;
long long a[maxn];
inline int read() {
int x = 0;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 3) + (x << 1) + (c ^ 48);
return x;
}
void input() {
int i;
for (i = 0; i < 14; i++) {
a[i] = read();
a[i + 14] = a[i];
}
}
long long check(int x) {
long long ta = a[x], add = a[x] / 14, i, del, ans = 0;
ta %= 14;
for (i = x; i < x + 14; i++) {
del = i - x;
if (((del ? a[i] : 0) + add + (del && del <= ta)) % 2)
;
else
ans += (del ? a[i] : 0) + add + (del && del <= ta);
}
return ans;
}
void solve() {
int i;
long long ans = 0;
for (i = 0; i < 14; i++) ans = max(ans, check(i));
cout << ans;
}
int main() {
input();
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long solve(long long n, long long m) {
long long ans = 0;
for (long long i = 1; i <= m; i++) {
long long p = n / i;
long long j = n / p;
if (j > m) {
j = m;
}
long long a = i + j;
long long b = j - i + 1;
if (a & 1) {
a = (a % mod) * ((b >> 1) % mod);
} else {
a = ((a >> 1) % mod) * (b % mod);
}
long long x = (n % mod) * ((j - i + 1) % mod) - (p % mod) * (a % mod);
ans = (ans + x) % mod;
if (ans < 0) ans += mod;
i = j;
}
return ans;
}
int main() {
long long n, m;
cin >> n >> m;
long long ans = 0;
if (n > m) {
ans = solve(n, m);
} else {
ans = solve(n, n);
ans = (ans + (n % mod) * ((m - n) % mod)) % mod;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, pair<long long, long long> > a[300000];
int main() {
long long k, i, j, p;
cin >> k;
long long cnt = 0, n, sum;
for (i = 0; i < k; i++) {
cin >> n;
sum = 0;
for (j = 0; j < n; j++) {
cin >> p;
a[cnt].first = p;
sum += p;
a[cnt].second.first = i;
a[cnt].second.second = j;
cnt++;
}
for (j = cnt - n; j < cnt; j++) {
a[j].first -= sum;
}
}
sort(a, a + cnt);
for (i = 0; i < cnt - 1; i++) {
if (a[i].first == a[i + 1].first) {
if (a[i].second.first != a[i + 1].second.first) {
cout << "YES\n";
cout << a[i].second.first + 1 << " " << a[i].second.second + 1 << endl;
cout << a[i + 1].second.first + 1 << " " << a[i + 1].second.second + 1
<< endl;
return 0;
}
}
}
cout << "NO\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt, w[400050], a[400050], c[2][400050];
int dp[400050], rk[400050], kth[400050], size[400050];
int tot, last[400050];
struct Edge {
int from, to, s;
} edges[400050 << 1];
template <typename T>
void read(T &x) {
long long k = 0;
char c = getchar();
x = 0;
while (!isdigit(c) && c != EOF) k ^= c == '-', c = getchar();
if (c == EOF) exit(0);
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
x = k ? -x : x;
}
void read_char(char &c) {
while (!isalpha(c = getchar()) && c != EOF)
;
}
void AddEdge(int x, int y) {
edges[++tot] = Edge{x, y, last[x]};
last[x] = tot;
}
void dfs(int x, int pre) {
dp[x] = 1 - dp[pre];
rk[x] = ++cnt;
kth[cnt] = x;
size[x] = 1;
for (int i = last[x]; i; i = edges[i].s) {
Edge &e = edges[i];
if (e.to == pre) continue;
dfs(e.to, x);
size[x] += size[e.to];
}
}
void update(int *c, int x, int tt) {
while (x <= n) {
c[x] += tt;
x += x & -x;
}
}
int get_sum(int *c, int x) {
int ans = 0;
while (x) {
ans += c[x];
x -= x & -x;
}
return ans;
}
int main() {
read(n);
read(m);
for (int i = 1; i <= n; i++) read(w[i]);
for (int i = 1; i <= n - 1; i++) {
int x, y;
read(x);
read(y);
AddEdge(x, y);
AddEdge(y, x);
}
dfs(1, 0);
for (int i = 1; i <= m; i++) {
int id, x, val;
read(id);
if (id == 1) {
read(x);
read(val);
update(c[dp[x]], rk[x], val);
update(c[dp[x]], rk[x] + size[x], -val);
}
if (id == 2) {
read(x);
int ans = get_sum(c[dp[x]], rk[x]) - get_sum(c[1 - dp[x]], rk[x]);
ans += w[x];
printf("%d\n", ans);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long int n;
cin >> n;
vector<long long int> a(n);
for (auto &it : a) cin >> it;
long long int mx = *max_element(a.begin(), a.end());
long long int pos = -1;
for (long long int i = 0; i < n; i++) {
if (a[i] == mx && a[(i - 1 + n) % n] != mx) {
pos = i;
break;
}
}
if (pos == -1) {
if (!mx) {
cout << "YES\n";
for (long long int i = 0; i < n; i++) cout << "1 ";
} else
cout << "NO";
return 0;
}
vector<long long int> b;
b = a;
b[pos] = a[pos];
long long int curr = a[pos] * (1ll << 25);
for (long long int j = 1; j < n; j++) {
long long int idx = (pos - j + n) % n;
b[idx] += curr;
curr = b[idx];
}
cout << "YES\n";
for (auto &it : b) cout << it << " ";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, a, b;
cin >> m >> n;
int sum = 0;
while (cin >> a >> b) sum += a || b;
cout << sum;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
long long n;
cin >> n;
vector<pair<long long, long long>> a(n);
for (long long i = 0; i < n; ++i) {
cin >> a[i].second >> a[i].first;
}
sort(begin(a), end(a));
vector<long long> x(n);
vector<long long> y(n);
for (long long i = 0; i < n; ++i) {
x[i] = a[i].first;
y[i] = a[i].second;
}
vector<pair<long long, long long>> dp(n);
vector<pair<long long, long long>> pref(n + 1, {1e9, 1e9});
for (long long i = n - 1; i >= 0; --i) {
if (lower_bound(begin(x) + i, end(x), y[i]) == end(x)) {
dp[i] = {x[i], 1};
} else {
long long j = lower_bound(begin(x) + i, end(x), y[i]) - begin(x);
dp[i].first = pref[j].first - (y[i] - x[i]);
dp[i].second = pref[j].second % mod;
}
if (dp[i].first < pref[i + 1].first) {
pref[i] = dp[i];
} else if (dp[i].first == pref[i + 1].first) {
pref[i] =
make_pair(dp[i].first, (pref[i + 1].second + dp[i].second) % mod);
} else {
pref[i] = pref[i + 1];
}
}
long long ans = 0, Min = 1e9, m = 1e9;
for (long long i = 0; i < n; ++i) {
Min = min(Min, y[i]);
}
for (int i = 0; i < n; ++i) {
if (x[i] < Min) {
if (dp[i].first < m) {
ans = dp[i].second;
m = dp[i].first;
} else if (dp[i].first == m) {
ans += dp[i].second;
}
}
}
ans %= mod;
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 7 + 1e9;
inline int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
inline int mul(int a, int b) { return a * 1ll * b % mod; }
void wabalabadubdub() {
long long n, k, x;
string s;
cin >> n >> k >> x >> s;
--x;
if (k == 0) {
for (char i : s)
if (i != '*') cout << i;
cout << endl;
return;
}
vector<long long> a;
for (char i : s) {
if (i == '*') {
if (a.empty() || a.back() == 0)
a.push_back(k);
else
a.back() += k;
} else {
a.push_back(0);
}
}
long long per = 1;
string res;
for (int i = a.size() - 1; i >= 0; --i) {
if (a[i] == 0) {
res.push_back('a');
continue;
}
int b = x % (a[i] + 1);
x /= (a[i] + 1);
while (b--) res.push_back('b');
}
reverse(res.begin(), res.end());
cout << res << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) wabalabadubdub();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c = 1, i, j, n, m = 1, l, mod = 0, x, y;
vector<int> d, d1;
d.resize(20);
d1.resize(20);
bool tr = false;
string s, s1;
cin >> a >> b;
n = a;
i = 0;
while (n > 0) d[i] = n % 10, d1[i] = d[i], n /= 10, i++;
l = i;
{
for (i = 0; i < l; i++) {
if (d[i] != 9) {
j = i + 1;
while (d[j] == 0 && j < l) {
d[j] = 9;
j++;
}
if (j == l) {
x = 0;
for (i = l - 1; i >= 0; i--) x = (x * 10) + d[i];
cout << x << endl;
tr = true;
break;
} else {
x = 0;
d[i] = 9;
for (int k = l - 1; k >= 0; k--) {
if (k == j)
x = (x * 10) + (d[k] - 1);
else
x = (x * 10) + d[k];
}
if (a - x <= b)
d[j]--, d1 = d;
else {
x = 0;
for (i = l - 1; i >= 0; i--) x = (x * 10) + d1[i];
cout << x << endl;
tr = true;
break;
}
}
}
}
if (!tr) {
x = 0;
for (i = l - 1; i >= 0; i--) x = (x * 10) + d1[i];
cout << x << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100];
int main() {
int n, ret = 0, n0 = 0, n1 = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) n1 += a[i];
ret = max(n1, n - n1);
for (int i = 0; i < n; i++) {
if (a[i]) {
ret = max(ret, n0 + n1);
n1--;
} else {
n0++;
}
}
printf("%d\n", ret);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
int main() {
cin >> n >> m;
while (n < m) {
if (m % 2 == 1) {
m++;
} else {
m /= 2;
}
ans++;
}
cout << ans + n - m;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[8010], num[5010][5010];
int main() {
int i;
scanf("%d", &n);
getchar();
char ch;
int bo = 0;
for (i = 1; i <= n; i++) {
scanf("%c", &ch);
getchar();
if (ch == 'f') a[i] = 1;
if (ch == 's') a[i] = 2;
}
int j, k;
num[1][0] = 1;
for (i = 1; i <= n - 1; i++) {
if (a[i] == 1) {
for (j = 0; j <= n - 1; j++) num[i + 1][j + 1] = num[i][j];
} else {
int ans = 0;
for (j = n - 1; j >= 0; j--) {
ans += num[i][j];
ans %= 1000000007;
num[i + 1][j] = ans;
}
}
}
int ans = 0;
for (j = 0; j <= n - 1; j++) {
ans += num[n][j];
ans %= 1000000007;
}
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int last[210000], pre[210000], e[210000];
int x, y;
queue<int> q;
int pp[210000];
int d[110000];
int maxx, pos;
void bfs1() {
q.push(1);
pp[1] = 1;
while (!q.empty()) {
int x = q.front();
for (int i = last[x]; i; i = pre[i]) {
if (!pp[e[i]]) {
d[e[i]] = d[x] + 1;
if (d[e[i]] > maxx) {
pos = e[i];
maxx = d[e[i]];
}
q.push(e[i]);
pp[e[i]] = 1;
}
}
q.pop();
}
}
void bfs2() {
maxx = 0;
memset(pp, 0, sizeof(pp));
memset(d, 0, sizeof(d));
q.push(pos);
pp[pos] = 1;
while (!q.empty()) {
int x = q.front();
for (int i = last[x]; i; i = pre[i]) {
if (!pp[e[i]]) {
d[e[i]] = d[x] + 1;
if (d[e[i]] > maxx) {
pos = e[i];
maxx = d[e[i]];
}
q.push(e[i]);
pp[e[i]] = 1;
}
}
q.pop();
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
e[i * 2 - 1] = y;
pre[i * 2 - 1] = last[x];
last[x] = i * 2 - 1;
e[i * 2] = x;
pre[i * 2] = last[y];
last[y] = i * 2;
}
bfs1();
bfs2();
cout << maxx << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, kol, w[250];
char s[250][250];
inline bool fre(const int& ph, const int& i, const int& j) {
if (ph == 1) {
for (int _j = j + 1; _j < m; _j++)
if (s[i + 1][_j] == 'W') return false;
} else {
for (int _j = j - 1; _j >= 0; _j--)
if (s[i + 1][_j] == 'W') return false;
}
return 1;
}
int main() {
scanf("%d%d\n", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf(j + 1 == m ? "%c\n" : "%c", &s[i][j]);
if (s[i][j] == 'W') kol++, w[i]++;
}
int i = 0, j = 0, ng = 0;
int res = 0;
bool rigth = 1;
while (res != kol) {
if (s[i][j] == 'W') ng++, res++;
if (res == kol) break;
if (ng == w[i]) {
ng = 0;
if (i + 1 == n) break;
if (rigth) {
while (!fre(1, i, j)) j++, ans++;
rigth = 0;
} else {
while (!fre(0, i, j)) j--, ans++;
rigth = 1;
}
i++;
ans++;
} else {
if (rigth)
j++, ans++;
else
j--, ans++;
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long int p[2][2];
bool onLine(long long int x, long long int y) {
long long int v1[2], v2[2];
v1[0] = p[0][0] - x;
v1[1] = p[0][1] - y;
v2[0] = p[1][0] - x;
v2[1] = p[1][1] - y;
if (v1[0] * v2[1] != v2[0] * v1[1]) return false;
if (v1[0] * v2[0] > 0) return false;
if (v1[1] * v2[1] > 0) return false;
if (v1[0] == 0) v1[0] = v1[1], v2[0] = v2[1];
if (abs(v1[0]) <= abs(v2[0]) && abs(v1[0]) * 4 >= abs(v2[0])) return true;
if (abs(v1[0]) >= abs(v2[0]) && abs(v2[0]) * 4 >= abs(v1[0])) return true;
return false;
}
};
node l[3];
int main() {
int t;
cin >> t;
while (t--) {
for (int i = 0; i < 3; i++)
cin >> l[i].p[0][0] >> l[i].p[0][1] >> l[i].p[1][0] >> l[i].p[1][1];
bool f = false;
for (int k = 0; k < 3; k++) {
node a = l[k], b = l[(k + 1) % 3];
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
if (a.p[i][0] == b.p[j][0] && a.p[i][1] == b.p[j][1]) {
node c = l[(k + 2) % 3];
long long int v1[2], v2[2];
v1[0] = a.p[(i + 1) % 2][0] - a.p[i][0];
v1[1] = a.p[(i + 1) % 2][1] - a.p[i][1];
v2[0] = b.p[(j + 1) % 2][0] - b.p[j][0];
v2[1] = b.p[(j + 1) % 2][1] - b.p[j][1];
if (v1[0] * v2[0] + v1[1] * v2[1] < 0) continue;
if (v1[0] * v2[1] == v1[1] * v2[0]) continue;
if ((a.onLine(c.p[0][0], c.p[0][1]) &&
b.onLine(c.p[1][0], c.p[1][1])) ||
(a.onLine(c.p[1][0], c.p[1][1]) &&
b.onLine(c.p[0][0], c.p[0][1]))) {
f = true;
break;
}
}
}
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b, d;
scanf("%d%d%d", &n, &b, &d);
int tag = 0, tim = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x > b) continue;
tag += x;
if (tag > d) {
tag = 0;
tim++;
}
}
printf("%d", tim);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, f, k, g, r = 0, ans = 0;
cin >> a >> b >> f >> k;
g = b;
for (int i = 1; i <= k; i++) {
if (g < abs(f - r)) {
cout << "-1";
return 0;
}
g = g - abs(f - r);
if (i != k) {
if (g < (2 * (abs(a - f)))) {
g = b;
ans++;
}
if (g < (2 * (abs(a - f)))) {
cout << "-1";
return 0;
}
g = g - abs(a - f);
swap(r, a);
} else {
if (g < abs(a - f)) {
g = b;
ans++;
}
if (g < abs(a - f)) {
cout << "-1";
return 0;
}
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int r, b, x, y;
cin >> r >> b;
for (int a = 0; a < r + b; a++) cin >> x >> y;
printf(r == b ? "Yes" : "No");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int bj[1000001];
int main() {
int i, n;
char m;
int now = 0, room = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
int u;
scanf(" %c", &m);
scanf("%d", &u);
if (m == '+') {
now++;
bj[u] = 1;
}
if (m == '-') {
if (bj[u] == 1) {
now--;
bj[u] == 0;
} else
room++;
}
if (now > room) room = now;
}
printf("%d\n", room);
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, m, i, l, k;
long long int s = 0;
scanf("%d %d", &n, &m);
int a[m], b[m];
for (i = 0; i < m; i++) {
scanf("%d", &a[i]);
}
b[0] = a[0] - 1;
for (i = 1; i < m; i++) {
k = a[i] - a[i - 1];
if (k >= 0) {
b[i] = k;
} else {
b[i] = (n - a[i - 1]) + 1 + (a[i] - 1);
}
}
for (i = 0; i < m; i++) {
s = s + b[i];
}
printf("%I64d", s);
}
| 1 |
#include <bits/stdc++.h>
int in[301];
int c[301];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", in + i);
for (i = 1; i <= n; i++) scanf("%d", c + i);
for (i = 1; i <= n; i++) {
for (j = 2; j * j <= in[i]; j++) {
if (in[i] % j == 0) {
while (in[i] % j == 0) in[i] /= j;
in[i] *= j;
}
}
}
std::map<int, int> dp, dt;
dp[0] = 0;
for (i = 1; i <= n; i++) {
for (auto t : dp) {
int xx = gcd(t.first, in[i]);
int xy = t.second + c[i];
if (dp.count(xx) == 0 || dp[xx] > xy) {
if (dt.count(xx) == 0 || dt[xx] > xy) dt[xx] = xy;
}
}
for (auto t : dt) {
dp[t.first] = t.second;
}
dt.clear();
}
if (dp.count(1) == 0)
printf("-1");
else
printf("%d", dp[1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, width = 0;
cin >> n >> h;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
if (a[i] <= h)
width++;
else if (a[i] > h) {
width += 2;
}
}
cout << width;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int mods = 998244353;
const int MAXN = 5000005;
const int INF = 0x3f3f3f3f;
inline long long read() {
long long f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
int f[20][1024][2], g[20][1024][2];
int upd(int x, int y) { return x + y >= mods ? x + y - mods : x + y; }
void Upd(int &x, int y) { x = upd(x, y); }
int solve(long long x, long long k) {
if (x < 1) return 0;
memset(f, 0, sizeof f);
memset(g, 0, sizeof g);
int a[20], num = 0;
while (x) a[++num] = x % 10, x /= 10;
for (int i = 1; i <= a[num]; i++)
f[num][1 << i][i == a[num]] = 1, g[num][1 << i][i == a[num]] = i;
for (int i = num; i >= 2; i--) {
for (int j = 0; j <= 9; j++)
for (int t = 0; t < 1024; t++) {
Upd(f[i - 1][t | (1 << j)][0], f[i][t][0]),
Upd(g[i - 1][t | (1 << j)][0],
(10ll * g[i][t][0] + 1ll * f[i][t][0] * j) % mods);
if (j < a[i - 1])
Upd(f[i - 1][t | (1 << j)][0], f[i][t][1]),
Upd(g[i - 1][t | (1 << j)][0],
(10ll * g[i][t][1] + 1ll * f[i][t][1] * j) % mods);
if (j == a[i - 1])
Upd(f[i - 1][t | (1 << j)][1], f[i][t][1]),
Upd(g[i - 1][t | (1 << j)][1],
(10ll * g[i][t][1] + 1ll * f[i][t][1] * j) % mods);
}
for (int j = 1; j <= 9; j++)
Upd(f[i - 1][(1 << j)][0], 1), Upd(g[i - 1][(1 << j)][0], j);
}
int ans = 0;
for (int i = 0; i < 1024; i++)
if (__builtin_popcount(i) <= k) Upd(ans, upd(g[1][i][0], g[1][i][1]));
return ans;
}
signed main() {
long long l = read(), r = read(), k = read();
printf("%d\n", upd(solve(r, k), mods - solve(l - 1, k)));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
bool cmp(pair<ll, ll> a, pair<ll, ll> b) {
if (a.first != b.first)
return a.first < b.first;
else
return a.second > b.second;
}
void er(multiset<pair<ll, ll>>& x) { x.erase(--x.end()); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
map<ll, ll> cnt, no;
for (int i = 0; i < n; ++i) {
ll t, f;
cin >> t >> f;
cnt[t]++;
no[t] += f;
}
multiset<pair<ll, ll>> x;
for (auto i : cnt) {
x.insert({i.second, no[i.first]});
}
ll sum = (*x.rbegin()).first;
ll key = (*x.rbegin()).second;
ll lst = sum;
er(x);
while (x.size() && (*x.rbegin()).first >= lst) {
ll cur = (*x.rbegin()).second;
er(x);
x.insert({lst - 1, cur});
}
while (x.size()) {
auto cur = *x.rbegin();
sum += cur.first;
key += min(cur.first, cur.second);
lst = cur.first;
er(x);
if (lst <= 1) {
break;
}
while (x.size() && (*x.rbegin()).first >= lst) {
ll cur = (*x.rbegin()).second;
er(x);
x.insert({lst - 1, cur});
}
}
cout << sum << " " << key << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int a[1000], i, x, c, n, k, j, m;
x = 1;
c = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) {
if (x == 1) {
if (a[i] != i + 1) {
j = a[i];
x = 0;
c++;
k = i + 1;
m = j - 1;
continue;
}
}
if (x == 0) {
if (a[i] == k) {
x = 1;
continue;
}
if (a[i] == m) {
m--;
continue;
} else
c++;
if (c >= 2) break;
}
if (x == 0) {
if (a[i] == k) {
x == 1;
printf("##%d %d %d\n", x, a[i], j);
}
}
}
if (c == 1)
printf("%d %d", k, j);
else
printf("%d %d", 0, 0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
int num[5050], mx_cnt = 0, cnt = 0, line = 0;
int dp[5050];
int par[5050], flag[5050][5050];
int bef[5050], len[5050];
int main() {
ios::sync_with_stdio(false);
cin >> s;
for (int i = 1; i < s.size() - 1; i++) {
cnt = 0;
while (i < s.size() - 1 && s[i - 1] == s[i + 1]) cnt++, i++;
if (cnt) {
i--, num[cnt]++, mx_cnt = max(mx_cnt, cnt);
bef[++line] = i - cnt + 1;
len[line] = cnt;
}
}
if (!line) {
cout << "Second" << endl;
return 0;
}
cnt = 0;
dp[0] = 0;
for (int i = 1; i <= mx_cnt; i++) {
for (int j = 1; j <= i; j++) {
int comp = (dp[max(0, j - 2)] ^ dp[i - min(j + 1, i)]);
if (!flag[i][comp]) flag[i][comp] = j;
}
for (int j = 0; j <= i; j++)
if (!flag[i][j]) {
dp[i] = j;
break;
}
}
for (int i = 1; i <= mx_cnt; i++)
for (int j = 1; j <= num[i]; j++) cnt ^= dp[i];
if (cnt) {
cout << "First" << endl;
int now = 1;
while (!flag[len[now]][dp[len[now]] ^ cnt]) {
now++;
}
cout << bef[now] + flag[len[now]][dp[len[now]] ^ cnt] << endl;
} else
cout << "Second" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, i;
cin >> n;
for (i = 1; i <= n; i++) cout << 1 << " ";
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long g[65][65], ans[65][65], f[1005][65][65];
int n, m, R;
void doit() {
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
if (i != k)
for (int j = 1; j <= n; j++)
if (i != j && j != k) g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
int main() {
scanf("%d%d%d", &n, &m, &R);
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) ans[j][k] = (1LL << 50);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) scanf("%I64d", &g[j][k]);
doit();
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) ans[j][k] = min(ans[j][k], g[j][k]);
}
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) f[0][j][k] = ans[j][k];
for (int t = 1; t <= 1000; t++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[t][i][j] = f[t - 1][i][j];
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
if (k != i)
for (int j = 1; j <= n; j++)
if (j != i && j != k)
f[t][i][j] = min(f[t][i][j], f[t - 1][i][k] + ans[k][j]);
}
while (R--) {
int x, y, t;
scanf("%d%d%d", &x, &y, &t);
printf("%I64d\n", f[t][x][y]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const long long N = 1001;
void print(long long arr[], long long n) {
for (long long i = 0; i < n; i++) cout << arr[i] << " ";
cout << endl;
}
void print(int arr[], int n) {
for (long long i = 0; i < n; i++) cout << arr[i] << " ";
cout << endl;
}
void print(int arr[], long long n) {
for (long long i = 0; i < n; i++) cout << arr[i] << " ";
cout << endl;
}
void print(vector<long long> arr, long long n) {
for (long long i = 0; i < n; i++) cout << arr[i] << " ";
cout << endl;
}
vector<long long> pr;
bool prime[1000001];
void SieveOfEratosthenes() {
memset(prime, true, sizeof(prime));
for (long long p = 2; p * p <= 1000000; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= 1000000; i += p) prime[i] = false;
}
}
prime[1] = false;
for (long long p = 2; p <= 1000000; p++)
if (prime[p]) pr.push_back(p);
}
long long power(long long a, long long n) {
long long res = 1, mod = M;
while (n) {
if (n % 2) res = (res * a) % mod;
a = (a * a) % mod;
n = n / 2;
}
return res;
}
long long spf[100001];
void sieve() {
spf[1] = 1;
for (long long i = 2; i < 100001; i++) spf[i] = i;
for (long long i = 4; i < 100001; i += 2) spf[i] = 2;
for (long long i = 3; i * i < 100001; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < 100001; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
vector<long long> getFactorization(long long x) {
vector<long long> ret;
while (x != 1) {
ret.push_back(spf[x]);
x = x / spf[x];
}
return ret;
}
vector<long long> fact;
void calculate_factorials(long long n) {
fact.resize(n + 1, 1);
long long ans = 1;
for (long long i = 1; i < n + 1; i++) {
ans = ((ans % M) * (i % M)) % M;
fact[i] = ans;
}
}
void init_code() {}
long long dp[200005][2];
vector<long long> a;
long long ok(long long i, long long turn) {
long long n = a.size();
if (i >= n) return dp[i][turn] = 0;
if (dp[i][turn] != -1) return dp[i][turn];
if (turn) {
long long mini = 1e9;
if (i < n && a[i] == 1) mini = min(mini, ok(i + 1, turn ^ 1) + 1);
if (i < n && a[i] == 0) mini = min(mini, ok(i + 1, turn ^ 1));
if (i + 1 < n && a[i] == 0 && a[i + 1] == 1)
mini = min(mini, ok(i + 2, turn ^ 1) + 1);
if (i + 1 < n && a[i] == 0 && a[i + 1] == 0)
mini = min(mini, ok(i + 2, turn ^ 1));
if (i + 1 < n && a[i] == 1 && a[i + 1] == 0)
mini = min(mini, ok(i + 2, turn ^ 1) + 1);
if (i + 1 < n && a[i] == 1 && a[i + 1] == 1)
mini = min(mini, ok(i + 2, turn ^ 1) + 2);
return dp[i][turn] = mini;
} else {
long long mini = 1e9;
mini = min(ok(i + 1, turn ^ 1), ok(i + 2, turn ^ 1));
return dp[i][turn] = mini;
}
}
void solve() {
long long n;
cin >> n;
for (long long i = 0; i < n + 1; i++) {
for (long long j = 0; j < 2; j++) dp[i][j] = -1;
}
for (long long i = 0; i < n; i++) {
long long ai;
cin >> ai;
a.push_back(ai);
}
ok(0, 1);
cout << dp[0][1] << endl;
a.clear();
}
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
init_code();
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.