solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n;
const double ep = 1e-10;
inline char nc() {
static char buf[100000], *l = buf, *r = buf;
return l == r && (r = (l = buf) + fread(buf, 1, 100000, stdin), l == r)
? EOF
: *l++;
}
template <class T>
void read(T &x) {
x = 0;
int f = 1, ch = nc();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = nc();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 - '0' + ch;
ch = nc();
}
x *= f;
}
struct pnt {
double x, y;
pnt(double x = 0, double y = 0) : x(x), y(y) {}
pnt operator+(const pnt &b) const { return pnt(x + b.x, y + b.y); }
pnt operator-(const pnt &b) const { return pnt(x - b.x, y - b.y); }
pnt operator*(const double &b) { return pnt(x * b, y * b); }
pnt operator/(const double &b) { return pnt(x / b, y / b); }
double operator&(const pnt &b) { return x * b.x + y * b.y; }
pnt rot() { return pnt(-y, x); }
double dist() { return sqrt(x * x + y * y); }
void input() { read(x), read(y); }
} p[100005], A, B, M, dir;
double r[100005], R, R2;
void answer(double R) {
cout << fixed << setprecision(10) << R << endl;
exit(0);
}
bool far(pnt C, double cr, pnt D, double dr) {
double d = (C - D).dist();
if (d > cr + dr - ep) return 1;
return 0;
}
bool con(pnt C, double cr, pnt D, double dr) {
double d = (C - D).dist();
if (cr > d + dr - ep) return 1;
return 0;
}
using pdd = pair<double, double>;
double far_yes_max(pnt p, double r) {
double st = R, en = 1e11;
if (!far(M, R, p, r)) return R;
int step = 100;
while (step--) {
double mid = (en + st) * .5;
pnt O = M + dir * sqrt(mid * mid - R2);
if (far(O, mid, p, r))
st = mid;
else
en = mid;
}
return st;
}
double con_yes_min(pnt p, double r) {
double st = R, en = 1e11;
int step = 100;
while (step--) {
double mid = (en + st) * .5;
pnt O = M + dir * sqrt(mid * mid - R2);
if (con(O, mid, p, r))
en = mid;
else
st = mid;
}
return en;
}
double con_yes_max(pnt p, double r) {
double st = R, en = 1e11;
int step = 100;
while (step--) {
double mid = (en + st) * .5;
pnt O = M + dir * sqrt(mid * mid - R2);
if (con(O, mid, p, r))
st = mid;
else
en = mid;
}
return st;
}
double far_yes_min(pnt p, double r) {
double st = R, en = 1e11;
int step = 100;
while (step--) {
double mid = (en + st) * .5;
pnt O = M + dir * sqrt(mid * mid - R2);
if (far(O, mid, p, r))
en = mid;
else
st = mid;
}
return en;
}
vector<pdd> vec;
int main() {
A.input(), B.input();
read(n);
for (int i = 1; i <= n; i++) {
p[i].input();
read(r[i]);
}
M = (A + B) * 0.5;
R = (A - B).dist() * 0.5;
R2 = R * R;
bool flag = 0;
for (int i = 1; i <= n; i++) {
bool f = far(M, R, p[i], r[i]) || con(M, R, p[i], r[i]);
if (!f) {
flag = 1;
break;
}
}
if (!flag) answer(R);
double ans = 1e12;
dir = (B - A).rot();
dir = dir / dir.dist();
for (int t = 0; t < 2; t++) {
vec.clear();
for (int i = 1; i <= n; i++) {
double f, s;
if ((dir & p[i] - B) > -ep) {
if (con(M, R, p[i], r[i])) continue;
if (far(M, R, p[i], r[i]))
f = far_yes_max(p[i], r[i]);
else
f = R;
s = con_yes_min(p[i], r[i]);
} else {
if (far(M, R, p[i], r[i])) continue;
if (con(M, R, p[i], r[i]))
f = con_yes_max(p[i], r[i]);
else
f = R;
s = far_yes_min(p[i], r[i]);
}
if (abs(s - f) > ep) vec.push_back(pdd(f, s));
}
sort(vec.begin(), vec.end());
double res = R + 2 * ep;
for (auto x : vec) {
if (x.first < res - ep) {
res = max(res, x.second);
} else
break;
}
ans = min(ans, res);
dir = pnt(-dir.x, -dir.y);
}
answer(ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int f(long long int a) {
long long int i, r = 0;
for (i = 1; i <= a; i++) {
r += i * (9 * (pow(10, i - 1)));
}
return r;
}
int main() {
long long int i, n, a;
cin >> n;
for (i = 1; n % (long long int)(pow(10, i)) != n; i++)
;
a = f(i - 1);
n = n - (pow(10, i - 1));
a = a + ((n + 1) * (i));
cout << a;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
for (auto v : V) os << v << " ";
return cout << "";
}
template <class T>
ostream& operator<<(ostream& os, set<T> S) {
for (auto s : S) os << s << " ";
return cout << "";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << P.first << " " << P.second;
}
const long long mod = 1;
long long inv(long long i) {
if (i == 1) return 1;
return (mod - ((mod / i) * inv(mod % i)) % mod) % mod;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b, b % a);
}
int main() {
int r, h;
cin >> r >> h;
int ans = 2 * (h / r);
if ((double)(h - (ans / 2) * r) / (double)r >= sqrt(3) / 2) {
ans += 3;
} else if (2 * (h - (ans / 2) * r) >= r) {
ans += 2;
} else
ans++;
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t, i, m, n, j, k, ans = 0, count = 0, tot = 0, flag = 0;
cin >> t;
while (t--) {
cin >> n >> k;
if (n % 2 == 0 && k % 2 == 0) {
if (k <= n) {
cout << "YES\n";
for (i = 0; i < k - 1; i++) {
cout << "1 ";
}
cout << n - (k - 1) << "\n";
} else {
cout << "NO\n";
}
} else if (n % 2 == 0 && k % 2 == 1) {
if (2 * k > n) {
cout << "NO\n";
} else {
cout << "YES\n";
for (i = 0; i < k - 1; i++) {
cout << "2 ";
}
cout << n - 2 * (k - 1) << "\n";
}
} else if (n % 2 == 1 && (k % 2 == 0) || k > n) {
cout << "NO\n";
} else {
cout << "YES\n";
for (i = 0; i < k - 1; i++) {
cout << "1 ";
}
cout << n - (k - 1) << "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, s[100005], w, h;
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i];
cin >> m;
for (int i = 0; i < m; i++) {
cin >> w >> h;
if (s[1] > s[w]) {
cout << s[1] << endl;
s[1] += h;
} else {
cout << s[w] << endl;
s[1] = s[w] + h;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
int n = s.size();
int i;
for (i = 0; i < n; ++i) {
if (s[i] == 'A' || s[i] == 'a' || s[i] == 'E' || s[i] == 'e' ||
s[i] == 'I' || s[i] == 'i' || s[i] == 'O' || s[i] == 'o' ||
s[i] == 'U' || s[i] == 'u' || s[i] == 'Y' || s[i] == 'y')
continue;
else if (s[i] >= 65 && s[i] <= 90) {
s[i] += 32;
cout << "." << s[i];
} else
cout << "." << s[i];
}
}
| 1 |
#include <bits/stdc++.h>
inline long long sbt(long long x) { return __builtin_popcount(x); }
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
string s;
long long adj[200003][27];
long long lft[200003], rgt[200003];
long long p[200003];
long long slink[200003];
long long tv;
long long tp;
long long nd_idx;
long long la;
void add_leaf_r1(long long c) {
adj[tv][c] = nd_idx;
lft[nd_idx] = la;
p[nd_idx++] = tv;
tv = slink[tv];
tp = rgt[tv] + 1;
}
void split_the_edge() {
lft[nd_idx] = lft[tv];
rgt[nd_idx] = tp - 1;
p[nd_idx] = p[tv];
adj[nd_idx][s[tp] - 'a'] = tv;
}
void add_c_transition_leaf(long long c) {
adj[nd_idx][c] = nd_idx + 1;
lft[nd_idx + 1] = la;
p[nd_idx + 1] = nd_idx;
}
void go_down() {
while (tp <= rgt[nd_idx - 2]) {
tv = adj[tv][s[tp] - 'a'];
tp += rgt[tv] - lft[tv] + 1;
}
}
void st_iteration(long long c) {
slable:;
if (rgt[tv] < tp) {
if (adj[tv][c] == -1) {
add_leaf_r1(c);
goto slable;
}
tv = adj[tv][c];
tp = lft[tv];
}
if (tp == -1 || c == s[tp] - 'a') {
tp++;
} else {
split_the_edge();
add_c_transition_leaf(c);
lft[tv] = tp;
p[tv] = nd_idx;
adj[p[nd_idx]][s[lft[nd_idx]] - 'a'] = nd_idx;
nd_idx += 2;
tv = slink[p[nd_idx - 2]];
tp = lft[nd_idx - 2];
go_down();
if (tp == rgt[nd_idx - 2] + 1)
slink[nd_idx - 2] = tv;
else
slink[nd_idx - 2] = nd_idx;
tp = rgt[tv] - (tp - rgt[nd_idx - 2]) + 2;
goto slable;
}
}
void init_st(long long start_idx) {
tv = 0;
tp = 0;
nd_idx = start_idx;
fill(rgt, rgt + 200003, s.size() - 1);
memset(adj, -1, sizeof adj);
slink[0] = 1;
for (long long i = 0; i < start_idx; i++) {
lft[i] = -1;
rgt[i] = -1;
if (i) memset(adj[i], 0, sizeof adj[i]);
}
long long m = s.size();
for (la = 0; la < m; la++) st_iteration(s[la] - 'a');
}
long long l[200003], substring_starting[200003];
void dfs(long long i) {
bool isleaf = 1;
long long neeche = 0;
long long endings = 0;
for (long long ch = 0; ch <= 26; ch++) {
if (adj[i][ch] != -1) {
dfs(adj[i][ch]);
endings += l[adj[i][ch]];
neeche += substring_starting[adj[i][ch]];
isleaf = 0;
}
}
if (isleaf) {
l[i] = 1;
} else {
l[i] = endings;
}
long long no_of_substr_on_edge =
(rgt[i] - lft[i] + (rgt[i] != (s.size() - 1)));
substring_starting[i] = (no_of_substr_on_edge * l[i] * l[i]);
}
long long n;
long long k, curr;
string res;
int32_t main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
long long t;
cin >> t;
while (t--) {
memset(substring_starting, 0, sizeof substring_starting);
memset(l, 0, sizeof l);
cin >> s;
n = s.size();
s = s + '{';
n++;
init_st(2);
dfs(0);
long long res = 0;
for (long long i = 1; i <= 2 * n + 1; i++) {
res += (substring_starting[i]);
}
cout << res << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long pla, num, a, b, cnt = 0;
cin >> a;
for (long long i = 1; i < n; i++) {
cin >> b;
if (a > b)
cnt++;
else
cnt = 1, a = b;
if (a == n or cnt == k) {
cout << a << endl;
break;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, j, k;
cin >> n;
m = log2(n);
cout << m + 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 500005;
std::stack<int> stack;
struct edge {
int x, y, next;
};
int bel[N], col[N];
bool vis[N];
int read() {
int x = 0, v = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; v = (ch == '-') ? (-1) : v, ch = getchar())
;
for (; ch <= '9' && ch >= '0'; x = x * 10 + ch - '0', ch = getchar())
;
return x * v;
}
struct Graph {
edge e[N * 2];
int ls[N], up[N], dw[N], edCnt;
int fa[N][21], dep[N], n;
void add_edge(int x, int y) {
e[++edCnt] = (edge){x, y, ls[x]};
ls[x] = edCnt;
e[++edCnt] = (edge){y, x, ls[y]};
ls[y] = edCnt;
}
void dfs1(int x) {
for (int i = 1; i <= 20; ++i) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = ls[x]; i; i = e[i].next) {
if (e[i].y == fa[x][0]) continue;
fa[e[i].y][0] = x, dep[e[i].y] = dep[x] + 1;
dfs1(e[i].y);
}
}
void dfs2(int x) {
vis[x] = 1;
for (int i = ls[x]; i; i = e[i].next) {
if (vis[e[i].y]) continue;
dfs2(e[i].y);
up[x] += up[e[i].y];
dw[x] += dw[e[i].y];
}
}
int get_lca(int x, int y) {
if (dep[x] < dep[y]) std::swap(x, y);
for (int i = 20; i >= 0; --i)
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
if (x == y) return x;
for (int i = 20; i >= 0; --i)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
void solve(int q) {
for (int i = 1; i <= n; ++i)
if (!dep[i]) {
dep[i] = 1;
dfs1(i);
}
for (int i = 1; i <= q; ++i) {
int x = read(), y = read();
if (col[x] != col[y]) {
puts("No");
return;
}
x = bel[x], y = bel[y];
int lca = get_lca(x, y);
up[x]++, up[lca]--;
dw[y]++, dw[lca]--;
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) dfs2(i);
for (int i = 1; i <= n; ++i)
if (up[i] && dw[i]) {
puts("No");
return;
}
puts("Yes");
}
} G;
edge e[N * 2];
int dfn[N], low[N];
int ls[N], edCnt, tot;
void add_edge(int x, int y) {
e[++edCnt] = (edge){x, y, ls[x]};
ls[x] = edCnt;
e[++edCnt] = (edge){y, x, ls[y]};
ls[y] = edCnt;
}
void dfs(int x, int from) {
dfn[x] = low[x] = ++dfn[0];
col[x] = col[0];
stack.push(x), vis[x] = 1;
for (int i = ls[x]; i; i = e[i].next) {
if ((i ^ 1) == from) continue;
if (!dfn[e[i].y]) {
dfs(e[i].y, i);
low[x] = std::min(low[x], low[e[i].y]);
} else if (vis[e[i].y])
low[x] = std::min(low[x], dfn[e[i].y]);
}
if (dfn[x] <= low[x]) {
int y = 0;
tot++;
while (y != x) {
y = stack.top(), stack.pop();
bel[y] = tot;
vis[y] = 0;
}
}
}
int main(void) {
int n = read(), m = read(), q = read();
edCnt = 1;
for (int i = 1; i <= m; ++i) add_edge(read(), read());
for (int i = 1; i <= n; ++i)
if (!dfn[i]) {
col[0]++;
dfs(i, 0);
}
for (int i = 2; i <= edCnt; i += 2) {
if (bel[e[i].x] != bel[e[i].y]) {
G.add_edge(bel[e[i].x], bel[e[i].y]);
}
}
G.n = tot;
G.solve(q);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans(1);
int i, k, c;
char s[100000];
int m[10000];
void r(int x) {
int o, i;
for (i = 0; i < ans.size(); i++) {
ans[i] *= x;
}
o = 0;
for (i = 0; i < ans.size(); i++) {
ans[i] += o;
if (ans[i] > 9) {
o = ans[i] / 10;
ans[i] = ans[i] % 10;
}
}
while (o) {
ans.push_back(o % 10);
o = o / 10;
}
}
int main() {
gets(s);
ans[0] = 1;
for (i = 0; i < strlen(s); i++) {
if (isalpha(s[i]) && m[s[i]] == 0) {
k++;
m[s[i]] = 1;
}
}
if (s[0] == *"?") {
s[0] = *"9";
ans[0] = 9;
}
c = 10;
if (isalpha(s[0])) {
ans[0] = 9;
k--;
c = 9;
}
for (i = 0; i < k; i++) {
r(c);
c--;
}
for (i = ans.size() - 1; i >= 0; i--) {
printf("%d", ans[i]);
}
for (i = 0; i < strlen(s); i++) {
if (s[i] == *"?") printf("%d", 0);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string text;
int last, value, answer;
int convertValue(int value) {
int temp, size, queue[50];
size = 0;
while (value) {
queue[size++] = value % 2;
value /= 2;
}
temp = 0;
while (size < 8) queue[size++] = 0;
for (int i = size - 1; i >= 0; i--) temp += queue[i] * (1 << (size - i - 1));
return temp;
}
int main() {
char temp;
text = "";
temp = getchar();
while (temp != '\n') {
text += temp;
temp = getchar();
}
last = 0;
for (int i = 0; i < text.length(); i++) {
value = text[i];
value = convertValue(value);
answer = last - value;
last = value;
while (answer < 0) answer += 256;
while (answer >= 256) answer -= 256;
cout << answer << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXVAL = (int)(1e5 + 2);
int num[MAXVAL], cur[MAXVAL];
int main() {
int n;
vector<int> a;
cin >> n;
a.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) ++num[a[i]];
int mx = -MAXVAL, ans = 0;
for (int i = 0; i < n; ++i) {
mx = max(mx, a[i]);
ans = max(ans, num[i]);
}
if (n == 1 && mx == 1) {
cout << "1\n1";
return 0;
}
for (int i = mx - 1; i >= 1; --i) {
if (num[i] < num[i + 1]) {
cout << -1 << endl;
return 0;
}
}
cout << ans << endl;
for (int i = 0; i < n; ++i) {
cout << ++cur[a[i]] << ' ';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long MAXN = 1e5;
long long n, m, t;
long long ans[MAXN | 1];
signed main() {
scanf("%lld", &n);
long long cnt = 0;
for (long long i = 1; i <= std::sqrt(n); ++i) {
if (n % i == 0) {
ans[++cnt] = (1 + n - i + 1) * (n / i) / 2;
if (i * i != n) ans[++cnt] = (1 + n - n / i + 1) * i / 2;
}
}
std::sort(ans + 1, ans + cnt + 1);
for (long long i = 1; i <= cnt; ++i) printf("%lld ", ans[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long getint() {
long long _x = 0, _tmp = 1;
char _tc = getchar();
while ((_tc < '0' || _tc > '9') && _tc != '-') _tc = getchar();
if (_tc == '-') _tc = getchar(), _tmp = -1;
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x * _tmp;
}
long long mypow(long long _a, long long _x, long long _mod) {
if (_x == 0) return 1ll;
long long _tmp = mypow(_a, _x / 2, _mod);
_tmp = (_tmp * _tmp) % _mod;
if (_x & 1) _tmp = (_tmp * _a) % _mod;
return _tmp;
}
bool equal(double _x, double _y) { return _x > _y - 1e-9 && _x < _y + 1e-9; }
int __ = 1, cs;
void build() {}
int n, m;
void init() {
n = getint();
m = getint();
}
void solve() {
if (n == 1 && m == 1)
puts("1.000000000000");
else {
double ans = 1.0 / (double)n + (double)(n - 1) * (double)(m - 1) /
((double)n * (double)(n * m - 1));
printf("%.12f\n", ans);
}
}
int main() {
build();
while (__--) {
init();
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
int n, x;
int dis[N][N];
double A[N][N];
void Pivot(int n, int m, double A[N][N], int a, int b) {
for (int i = 0; i <= m; i++) {
if (i == a) continue;
for (int j = 0; j <= n; j++)
if (j != b) A[i][j] -= A[a][j] * A[i][b] / A[a][b];
}
for (int i = 0; i <= n; i++)
if (i != b) A[a][i] /= -A[a][b];
for (int i = 0; i <= m; i++)
if (i != a) A[i][b] /= A[a][b];
A[a][b] = 1.0 / A[a][b];
}
double Simplex(int n, int m, double A[N][N]) {
while (1) {
int a = 1, b = 1;
for (int i = 1; i <= m; i++)
if (A[i][0] < A[a][0]) a = i;
if (A[a][0] >= 0) break;
for (int i = 1; i <= n; i++)
if (A[a][i] > A[a][b]) b = i;
if (A[a][b] <= 0) return 1e100;
Pivot(n, m, A, a, b);
}
while (1) {
int a = 1, b = 1;
for (int i = 1; i <= n; i++)
if (A[0][i] < A[0][b]) b = i;
if (A[0][b] >= 0) break;
for (int i = 1; i <= m; i++)
if (A[i][b] < -eps &&
(A[a][b] >= 0 || A[i][0] / A[i][b] > A[a][0] / A[a][b]))
a = i;
if (A[a][b] >= 0) return -1e100;
Pivot(n, m, A, a, b);
}
return A[0][0];
}
int main() {
scanf("%d%d", &n, &x);
int s = 0;
for (int i = 1; i <= n; i++) {
scanf("%lf", &A[0][i]);
A[0][i] = 1 - A[0][i];
s += A[0][i] == 0;
}
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i < n; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
dis[x][y] = dis[y][x] = z;
}
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
for (int i = 1; i <= n; i++) {
A[i][0] = -1;
for (int j = 1; j <= n; j++) A[i][j] = (dis[i][j] <= x);
}
A[n + 1][0] = s;
for (int i = 1; i <= n; i++) A[n + 1][i] = -1;
double ans = Simplex(n, n + 1, A);
if (ans > 1000)
puts("-1");
else
printf("%d\n", int(ans + 0.5));
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : (-x);
}
template <class T>
T sqr(T x) {
return x * x;
}
vector<pair<int, int> > v;
const int maxn = 1010;
bool open[maxn];
int n, m, k;
vector<int> keys[2][maxn];
int a1[maxn], a2[maxn];
int get1(int x) {
if (a1[x] == x) return x;
return a1[x] = get1(a1[x]);
}
int get2(int x) {
if (a2[x] == x) return x;
return a2[x] = get2(a2[x]);
}
int uni1(int x, int y) {
x = get1(x), y = get1(y);
if (rand() % 2) swap(x, y);
return a1[x] = y;
}
int uni2(int x, int y) {
x = get2(x), y = get2(y);
if (rand() % 2) swap(x, y);
return a2[x] = y;
}
map<int, int> keySet;
int main() {
cin >> n >> m >> k;
map<string, vector<int> > M;
map<int, vector<int> > kM;
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
--x, --y;
v.push_back(pair<int, int>(x, y));
}
for (int it = 0; it < 2; ++it) {
for (int i = 0; i < k; ++i) {
string s;
int room;
cin >> s >> room;
--room;
M[s].push_back(room);
int knum;
cin >> knum;
for (int j = 0; j < knum; ++j) {
int x;
cin >> x;
--x;
keys[it][room].push_back(x);
kM[x].push_back(room);
}
}
}
bool ok = true;
for (int it = 0; it < 2; ++it) {
for (int i = 0; i < maxn; ++i) a1[i] = a2[i] = i;
keySet.clear();
for (int i = 0; i < n; ++i) {
int ind = -1;
for (int j = 0; j < ((int)(keys[it][i]).size()); ++j) {
if (ind != -1) uni2(ind, keys[it][i][j]);
ind = get2(keys[it][i][j]);
}
keySet[get1(i)] = ind;
}
memset(open, 0, sizeof(open));
while (1) {
bool ch = false;
for (int i = 0; i < m; ++i) {
if (open[i]) continue;
if (get1(v[i].first) == get1(v[i].second)) continue;
int s1 = keySet[get1(v[i].first)];
int s2 = keySet[get1(v[i].second)];
if (get2(i) == s1 || get2(i) == s2) {
ch = true;
open[i] = true;
int root = uni1(v[i].first, v[i].second);
int kr;
if (s1 == -1)
kr = s2;
else if (s2 == -1)
kr = s1;
else
kr = uni2(s1, s2);
keySet[root] = kr;
}
}
if (!ch) break;
}
for (int i = 0; i < m; ++i)
if (get1(kM[i][0]) != get1(kM[i][1])) {
ok = false;
break;
}
for (map<string, vector<int> >::iterator it = M.begin(); it != M.end();
++it) {
if (get1(it->second[0]) != get1(it->second[1])) {
ok = false;
break;
}
}
}
printf("%s\n", ok ? "YES" : "NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int n;
long long m;
int a[maxn];
struct node {
int num;
int cnt;
} sum[maxn];
int main(void) {
scanf("%d%lld", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
sum[0].cnt = 1;
sum[0].num = a[0];
int j = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1]) {
sum[j].cnt++;
} else {
j++;
sum[j].num = a[i + 1];
sum[j].cnt = 1;
}
}
int l = 0, r = j;
while (m > 0) {
if (l == r) {
break;
}
long long kl, kr;
kl = (long long)(sum[l + 1].num - sum[l].num) * (long long)sum[l].cnt;
kr = (long long)(sum[r].num - sum[r - 1].num) * (long long)sum[r].cnt;
if (sum[l].cnt > sum[r].cnt) {
if (m >= kr) {
sum[r - 1].cnt += sum[r].cnt;
r--;
m -= kr;
} else {
sum[r].num -= (m / sum[r].cnt);
break;
}
} else if (sum[l].cnt < sum[r].cnt) {
if (m >= kl) {
sum[l + 1].cnt += sum[l].cnt;
l++;
m -= kl;
} else {
sum[l].num += (m / sum[l].cnt);
break;
}
} else {
if (m >= kl + kr) {
sum[l + 1].cnt += sum[l].cnt;
l++;
m -= kl;
sum[r - 1].cnt += sum[r].cnt;
if (l != r) r--;
m -= kr;
} else {
sum[l].num += (m / sum[l].cnt);
break;
}
}
}
printf("%d\n", sum[r].num - sum[l].num);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const ll inf = 1;
const ll mod = 1E9;
int main() {
int n, m;
scanf("%d %d", &n, &m);
int colors = 1;
vector<vector<int> > mset(n, vector<int>());
vector<vector<int> > G(n, vector<int>());
for (int i = 0; i < n; i++) {
int lim;
scanf("%d", &lim);
for (int j = 0; j < lim; j++) {
int x;
scanf("%d", &x);
mset[i].push_back(x - 1);
}
colors = max(colors, lim);
}
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
G[u - 1].push_back(v - 1);
G[v - 1].push_back(u - 1);
}
set<int> ms;
vector<int> col(m, 0);
vector<bool> vis(n, false);
queue<int> Q;
Q.push(0);
vis[0] = true;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (auto j : mset[u]) {
if (col[j] != 0) ms.insert(col[j]);
}
int now = 1;
for (auto j : mset[u]) {
if (col[j] == 0) {
while (ms.find(now) != ms.end()) now++;
col[j] = now;
now++;
}
}
for (auto v : G[u]) {
if (!vis[v]) {
vis[v] = true;
Q.push(v);
}
}
ms.clear();
}
printf("%d\n", colors);
for (int i = 0; i < m; i++) {
if (col[i] == 0) col[i] = 1;
printf("%d ", col[i]);
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double p[3010][310], f[3010][310], q[3010], c[3010], ans;
int n, m, w;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) f[0][i] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
scanf("%d", &w), p[i][j] = w / 1000.,
f[i + 1][j] = f[i][j] * (1 - p[i][j]);
for (int i = 0; i < m; i++) q[i] = 1 - f[n][i];
for (int i = 0; i < n; i++) {
int k = max_element(q, q + m) - q;
ans += q[k];
for (int i = 0; i < n; i++)
c[i + 1] = c[i] * (1 - p[i][k]) + f[i][k] * p[i][k];
for (int i = 0; i < n + 1; i++) f[i][k] = c[i];
q[k] -= c[n];
}
printf("%.10f\n", ans);
}
| 9 |
#include <bits/stdc++.h>
int main() {
int n, m, k, s = 0;
scanf("%d", &n);
for (m = 0; m < n; m++) {
scanf("%d", &k);
s += k;
}
if (s / 5 == n)
printf("-1");
else {
if (s / 5 >= 9) {
for (m = 0; m < s / 45 * 9; m++) printf("5");
for (m = 0; m < n - s / 5; m++) printf("0");
} else {
printf("0");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
bool liking[7][7];
vector<int> arr[3];
vector<pair<int, int> > sorted;
void rec(int n) {
if (n == 7) {
if (!arr[0].empty() && !arr[1].empty() && !arr[2].empty()) {
int xp0, xp1, xp2, max, min, likes = 0;
xp0 = a / arr[0].size();
xp1 = b / arr[1].size();
xp2 = c / arr[2].size();
xp0 > xp1 ? (xp0 > xp2 ? max = xp0 : max = xp2)
: (xp1 > xp2 ? max = xp1 : max = xp2);
xp0 < xp1 ? (xp0 < xp2 ? min = xp0 : min = xp2)
: (xp1 < xp2 ? min = xp1 : min = xp2);
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 7; j++) {
if (liking[i][j]) {
if ((find(arr[0].begin(), arr[0].end(), j) != arr[0].end() &&
find(arr[0].begin(), arr[0].end(), i) != arr[0].end()) ||
((find(arr[1].begin(), arr[1].end(), j) != arr[1].end()) &&
(find(arr[1].begin(), arr[1].end(), i) != arr[1].end())) ||
((find(arr[2].begin(), arr[2].end(), j) != arr[2].end()) &&
(find(arr[2].begin(), arr[2].end(), i) != arr[2].end())))
likes++;
}
}
}
sorted.push_back(make_pair(max - min, -likes));
}
return;
}
arr[0].push_back(n);
rec(n + 1);
arr[0].pop_back();
arr[1].push_back(n);
rec(n + 1);
arr[1].pop_back();
arr[2].push_back(n);
rec(n + 1);
arr[2].pop_back();
}
int main() {
memset(liking, 0, sizeof liking);
int n, x, y;
string p, likes, q;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p >> likes >> q;
if (p == "Anka")
x = 0;
else if (p == "Chapay")
x = 1;
else if (p == "Cleo")
x = 2;
else if (p == "Troll")
x = 3;
else if (p == "Dracul")
x = 4;
else if (p == "Snowy")
x = 5;
else
x = 6;
if (q == "Anka")
y = 0;
else if (q == "Chapay")
y = 1;
else if (q == "Cleo")
y = 2;
else if (q == "Troll")
y = 3;
else if (q == "Dracul")
y = 4;
else if (q == "Snowy")
y = 5;
else
y = 6;
liking[x][y] = true;
}
cin >> a >> b >> c;
rec(0);
sort(sorted.begin(), sorted.end());
cout << sorted.front().first << " " << -sorted.front().second;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, f = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ '0');
ch = getchar();
}
return f ? x : -x;
}
const int N = 1e5 + 5;
int n, m, head[N], num, vis[N], col[N], id;
vector<int> E[N];
int dep[N], fa[N], top[N], son[N], siz[N];
inline void dfs1(int u, int pa) {
vis[u] = 1;
col[u] = id;
dep[u] = dep[fa[u] = pa] + 1;
siz[u] = 1;
for (int v : E[u]) {
if (vis[v]) continue;
dfs1(v, u);
siz[u] += siz[v];
if (siz[son[u]] < siz[v]) son[u] = v;
}
}
inline void dfs2(int u) {
vis[u] = 1;
if (!top[u]) top[u] = u;
if (son[u]) {
top[son[u]] = top[u];
dfs2(son[u]);
}
for (int v : E[u]) {
if (vis[v] || v == son[u]) continue;
dfs2(v);
}
}
inline int lca(int x, int y) {
while (top[x] ^ top[y])
if (dep[top[x]] < dep[top[y]])
y = fa[top[y]];
else
x = fa[top[x]];
return dep[x] < dep[y] ? x : y;
}
int dfn[N], low[N], dfc, stk[N], tp, cnt[N], tot, c[N], flg;
vector<int> V[N];
inline void Tarjan(int u, int pa) {
dfn[u] = low[u] = ++dfc;
stk[++tp] = u;
for (int v : E[u]) {
if (v == pa) continue;
if (!dfn[v]) {
Tarjan(v, u);
low[u] = min(low[u], low[v]);
if (dfn[u] <= low[v]) {
V[++tot].push_back((u));
for (int x = 0; x ^ v; --tp) x = stk[tp], V[tot].push_back((x));
}
} else
low[u] = min(low[u], dfn[v]);
}
}
inline void Dfs(int u, int ccc) {
if (flg) return;
c[u] = ccc;
for (int v : E[u]) {
if (vis[v] ^ vis[u]) continue;
if (!c[v])
Dfs(v, 3 - ccc);
else if (c[u] == c[v]) {
flg = 1;
return;
}
}
}
inline void Cal(int u, int pa) {
vis[u] = 1;
cnt[u] += cnt[pa];
for (int v : E[u]) {
if (vis[v]) continue;
Cal(v, u);
}
}
inline bool check(int x, int y) {
if (col[x] != col[y]) return 0;
if ((dep[x] & 1) ^ (dep[y] & 1)) return 1;
return cnt[x] + cnt[y] - 2 * cnt[lca(x, y)] > 0;
}
int main() {
n = read(), m = read();
for (int i = (1), _ed = (m); i <= _ed; ++i) {
int u = read(), v = read();
E[u].push_back(v), E[v].push_back(u);
}
for (int i = (1), _ed = (n); i <= _ed; ++i)
if (!vis[i]) ++id, dfs1(i, 0);
memset(vis, 0, sizeof vis);
for (int i = (1), _ed = (n); i <= _ed; ++i)
if (!vis[i]) dfs2(i);
for (int i = (1), _ed = (n); i <= _ed; ++i)
if (!dfn[i]) tp = 0, Tarjan(i, 0);
memset(vis, 0, sizeof vis);
for (int i = (1), _ed = (tot); i <= _ed; ++i) {
for (int j = (0), _ed = (V[i].size() - 1); j <= _ed; ++j)
vis[V[i][j]] = i, c[V[i][j]] = 0;
flg = 0;
Dfs(V[i][0], 1);
if (flg)
for (int j = (1), _ed = (V[i].size() - 1); j <= _ed; ++j)
cnt[V[i][j]] = 1;
}
memset(vis, 0, sizeof vis);
for (int i = (1), _ed = (n); i <= _ed; ++i)
if (!vis[i]) Cal(i, 0);
for (int q = (1), _ed = (read()); q <= _ed; ++q) {
int x = read(), y = read();
puts(check(x, y) ? "Yes" : "No");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int SG[4 * 131079], N;
void build(int pt, int s, int e, int ar[], int flag) {
if (s == e) {
SG[pt] = ar[s];
return;
}
int m = (s + e) >> 1;
build(2 * pt + 1, s, m, ar, flag + 1);
build(2 * pt + 2, m + 1, e, ar, flag + 1);
if ((N - flag) & 1)
SG[pt] = SG[2 * pt + 1] | SG[2 * pt + 2];
else
SG[pt] = SG[2 * pt + 1] ^ SG[2 * pt + 2];
}
void update(int pt, int s, int e, int pos, int val, int flag) {
if (s == e) {
SG[pt] = val;
return;
}
SG[pt] ^= val;
int m = (s + e) >> 1;
if (pos <= m)
update(2 * pt + 1, s, m, pos, val, flag + 1);
else
update(2 * pt + 2, m + 1, e, pos, val, flag + 1);
if ((N - flag) & 1)
SG[pt] = SG[2 * pt + 1] | SG[2 * pt + 2];
else
SG[pt] = SG[2 * pt + 1] ^ SG[2 * pt + 2];
}
int main() {
int n;
scanf("%d", &n);
int m;
scanf("%d", &m);
N = n;
n = 1 << n;
int ar[n];
for (int i = 0; i < n; i++) cin >> ar[i];
build(0, 0, n - 1, ar, 0);
for (int i = 0; i < m; i++) {
int p;
scanf("%d", &p);
int b;
scanf("%d", &b);
update(0, 0, n - 1, p - 1, b, 0);
printf("%d\n", SG[0]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using LL = long long;
const int N = 210;
using namespace std;
int n, mod;
int dp[N][N][40], f[N], inv[N];
int vis[N][N][40];
int a1;
int binpow(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = (1LL * a * a) % mod)
if (b & 1) {
res = (1LL * res * a) % mod;
}
return res;
}
int solve(int cur, int sum, int k) {
if (cur == n) return f[n];
if (k == 0) return 1LL * f[n] * inv[n - cur] % mod;
if (vis[cur][sum][k] == a1) return dp[cur][sum][k];
vis[cur][sum][k] = a1;
int &res = dp[cur][sum][k];
res = 0;
int lim = (a1 - sum) / k;
for (int cnt = lim; cnt >= 0; cnt--) {
if (k > 1 && cur + cnt < n - a1 + 2 - k) continue;
res =
(res + 1LL * solve(cur + cnt, sum + cnt * k, k - 1) * inv[cnt] % mod) %
mod;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> mod;
f[0] = inv[0] = 1;
for (int i = 1; i < N; i++) {
f[i] = 1LL * f[i - 1] * i % mod;
inv[i] = binpow(f[i], mod - 2);
}
int ans = 0;
int lim = (2 * sqrt(n) + 1);
for (a1 = max(1, n - lim); a1 <= n; a1++) {
ans += solve(0, 0, n + 1 - a1);
ans %= mod;
}
cout << ans;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
pair<long double, long double> operator+(
const pair<long double, long double> &p1,
const pair<long double, long double> &p2) {
return {p1.first + p2.first, p1.second + p2.second};
}
pair<long double, long double> operator-(
const pair<long double, long double> &p1,
const pair<long double, long double> &p2) {
return {p1.first - p2.first, p1.second - p2.second};
}
pair<long double, long double> operator*(
const long double &d, const pair<long double, long double> &p) {
return {d * p.first, d * p.second};
}
long double operator*(const pair<long double, long double> &p1,
const pair<long double, long double> &p2) {
return p1.first * p2.first + p1.second * p2.second;
}
long double operator^(const pair<long double, long double> &p1,
const pair<long double, long double> &p2) {
return p1.first * p2.second - p1.second * p2.first;
}
const long double eps = 1e-8;
bool is_0(long double x) { return fabs(x) <= eps; }
int sgn(long double x) { return (x > eps) - (x < -eps); }
const int N = 100006;
pair<long double, long double> intersect(pair<long double, long double> p1,
pair<long double, long double> p2,
pair<long double, long double> q1,
pair<long double, long double> q2) {
return p1 + ((q1 - p1) ^ (q2 - q1)) / ((p2 - p1) ^ (q2 - q1)) * (p2 - p1);
}
bool on_seg(pair<long double, long double> p1,
pair<long double, long double> p2,
pair<long double, long double> q) {
if (sgn((p1 - p2) ^ (p1 - q)) != 0) return false;
return sgn((p1 - q) * (p2 - q)) == -1;
}
bool banana(pair<long double, long double> p1,
pair<long double, long double> p2,
pair<long double, long double> q1,
pair<long double, long double> q2) {
if (sgn((p1 - p2) ^ (q1 - q2)) == 0) {
return false;
}
return sgn((p1 - q1) ^ (p2 - q1)) * sgn((p1 - q2) ^ (p2 - q2)) == -1 &&
sgn((q1 - p1) ^ (q2 - p1)) * sgn((q1 - p2) ^ (q2 - p2)) == -1;
}
long double dis(pair<long double, long double> p) { return sqrt(p * p); }
vector<pair<long double, long double> > pts[N];
pair<pair<long double, long double>, pair<long double, long double> > line[N];
int n;
bool in_polygon(pair<long double, long double> p) {
for (int i = 0; i < n; ++i) {
pair<long double, long double> a = line[3 * i].first;
pair<long double, long double> b = line[3 * i + 1].first;
pair<long double, long double> c = line[3 * i + 2].first;
pair<long double, long double> d = {889301, 890501};
if (on_seg(a, b, p)) continue;
if (on_seg(b, c, p)) continue;
if (on_seg(a, c, p)) continue;
int cnt = 0;
if (banana(p, d, a, b)) ++cnt;
if (banana(p, d, b, c)) ++cnt;
if (banana(p, d, a, c)) ++cnt;
if (cnt & 1) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
int id = 0;
for (int i = 1; i <= n; ++i) {
pair<long double, long double> a, b, c;
cin >> a.first >> a.second >> b.first >> b.second >> c.first >> c.second;
pts[id].push_back(a);
pts[id].push_back(b);
line[id] = {a, b};
++id;
pts[id].push_back(b);
pts[id].push_back(c);
line[id] = {b, c};
++id;
pts[id].push_back(a);
pts[id].push_back(c);
line[id] = {c, a};
++id;
}
for (int i = 0; i < id; ++i) {
for (int j = i + 1; j < id; ++j) {
pair<long double, long double> a = line[i].first, b = line[i].second,
c = line[j].first, d = line[j].second;
if (a == c || a == d || b == c || b == d) continue;
if (banana(a, b, c, d)) {
pair<long double, long double> ret = intersect(a, b, c, d);
pts[i].push_back(ret);
pts[j].push_back(ret);
}
}
}
long double ans = 0;
for (int i = 0; i < id; ++i) {
sort(pts[i].begin(), pts[i].end());
pts[i].resize(unique(pts[i].begin(), pts[i].end()) - pts[i].begin());
for (int j = 0; j < (int)pts[i].size() - 1; ++j) {
if (!in_polygon(0.5 * (pts[i][j] + pts[i][j + 1]))) {
ans += dis(pts[i][j + 1] - pts[i][j]);
}
}
}
cout << fixed << setprecision(12) << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
int n = a * c - b * c;
if (n % b > 0)
printf("%d\n", n / b + 1);
else
printf("%d\n", n / b);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200009;
struct node {
int x, y;
bool operator<(const node &other) const { return y < other.y; }
} a[N];
int n;
const int oo = (int)(2e9) + 10;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d %d", &x, &y);
a[i].x = x - y;
a[i].y = x + y;
}
sort(a + 1, a + n + 1);
int result = 0;
int value = -oo;
for (int i = 1; i <= n; i++) {
if (a[i].x >= value) {
result++;
value = a[i].y;
}
}
printf("%d\n", result);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 2;
vector<int> v;
int main() {
long long n;
long long ans = 0;
scanf("%I64d", &n);
if (n == 1) {
puts("1 0");
return 0;
}
long long mn = 1;
for (int i = 2; i <= n; i++) {
if (n % i == 0) {
int cnt = 0;
mn *= i;
while (n % i == 0) {
n /= i;
cnt++;
}
v.emplace_back(cnt);
}
}
printf("%I64d ", mn);
mn = 1;
for (int i : v)
if (i > mn) mn = i;
long long nee = 1;
while (nee < mn) nee *= 2, ans++;
int add = 0;
for (int i : v)
if (i != nee) add = 1;
printf("%I64d", ans + add);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
int m[26];
for (auto i = 0; i < 26; i++) m[i] = 0;
int k;
cin >> k;
for (auto i = 0; i < n; i++) m[s[i] - 'a']++;
int ones = 0, twos = 0;
for (auto i = 0; i < 26; i++) {
if (m[i] == 1)
ones++;
else if (m[i] > 1) {
twos += (m[i] - 1);
ones++;
}
}
if (ones >= k) {
cout << "0\n";
return 0;
}
if (min(twos, 26 - ones) + ones < k) {
cout << "impossible\n";
return 0;
}
cout << (k - ones) << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
string a, b;
cin >> a >> b;
vector<long long> v;
for (long long i = 0; i < n; i++) {
if (a[0] == b[n - i - 1]) {
v.push_back(1);
if (a[0] == '0')
a[0] = '1';
else
a[0] = '0';
}
v.push_back(n - i);
string s = "";
for (long long j = 0; j < n - i; j++) {
if (a[j] == '0')
s += '1';
else
s += '0';
}
reverse(s.begin(), s.end());
for (long long j = 0; j < s.length(); j++) a[j] = s[j];
}
cout << v.size() << " ";
for (auto x : v) cout << x << " ";
cout << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool cur1;
int n, m, K;
int L[100005 * 120], R[100005 * 120], res[100005 * 120], tt, rt[100005 * 3];
int update(int p, int l, int r, int x, int v) {
int c = ++tt;
L[c] = L[p], R[c] = R[p];
if (l == r) {
res[c] = min((p ? res[p] : 0x3f3f3f3f), v);
return c;
}
int mid = (l + r) >> 1;
if (x <= mid)
L[c] = update(L[p], l, mid, x, v);
else
R[c] = update(R[p], mid + 1, r, x, v);
res[c] = max(res[L[c]], res[R[c]]);
return c;
}
int query(int p, int u, int v, int l, int r) {
if (u <= l && r <= v) {
return res[p];
}
int mid = (l + r) >> 1;
int ans = 0;
if (u <= mid) ans = max(ans, query(L[p], u, v, l, mid));
if (v > mid) ans = max(ans, query(R[p], u, v, mid + 1, r));
return ans;
}
struct seg {
int a, b, c;
bool operator<(const seg &_) const {
if (a != _.a) return a < _.a;
if (c != _.c) return c < _.c;
if (b != _.b) return b > _.b;
}
} Sg[100005 * 3];
int B[100005 * 3];
void solve() {
tt = 0;
int tot = 0;
scanf("%d %d %d", &n, &m, &K);
for (int a, b, c, i = 1; i <= K; i++) {
scanf("%d %d %d", &a, &b, &c);
B[i] = a;
Sg[i] = (seg){a, b, c};
}
sort(B + 1, B + K + 1);
sort(Sg + 1, Sg + K + 1);
tot = unique(B + 1, B + 1 + K) - B - 1;
for (int i = 1; i <= n; i++)
rt[tot + 1] = update(rt[tot + 1], 1, n, i, 0x3f3f3f3f);
Sg[K + 1].a = 0x3f3f3f3f;
for (int i = K; i >= 1; i--) {
int t = lower_bound(B + 1, B + 1 + tot, Sg[i].a) - B;
if (Sg[i].a != Sg[i + 1].a) {
rt[t] = update(rt[t + 1], 1, n, Sg[i].c, Sg[i].b);
} else
rt[t] = update(rt[t], 1, n, Sg[i].c, Sg[i].b);
}
while (m--) {
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
if (c > B[tot]) {
puts("no");
fflush(stdout);
continue;
} else {
int t = lower_bound(B + 1, B + 1 + tot, c) - B;
if (query(rt[t], a, b, 1, n) <= d)
puts("yes");
else
puts("no");
}
fflush(stdout);
}
}
bool cur2;
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T countBit(T n) {
T ans = 0;
while (n) {
n = n & (n - 1);
ans++;
}
return ans;
}
long long dp[50];
int main() {
int n;
cin >> n;
int a;
for (int i = 0; i < n; i++) {
cin >> a;
dp[countBit(a)]++;
}
long long ans = 0;
for (int i = 0; i < sizeof(dp) / sizeof(long long); i++) {
if (dp[i]) ans += dp[i] * (dp[i] - 1) / 2;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int dp[80][80][80][2];
char c[80];
vector<int> V, K, a;
int cal(int id, vector<int> vv, int pos) {
int cnt = 0;
for (int i = id; i < ((int)vv.size()); i++)
if (vv[i] < pos) cnt++;
return cnt;
}
int cc(int i, int j, int k, int pos) {
return cal(i, V, pos) + cal(j, K, pos) + cal(k, a, pos);
}
void mi(int &a, int b) {
if (a > b) a = b;
}
int main() {
int n;
scanf("%d", &n);
scanf("%s", c);
for (int i = 0; i < n; i++) {
if (c[i] == 'V')
V.push_back(i);
else if (c[i] == 'K')
K.push_back(i);
else
a.push_back(i);
}
for (int i = 0; i <= ((int)V.size()); i++)
for (int j = 0; j <= ((int)K.size()); j++)
for (int k = 0; k <= ((int)a.size()); k++)
for (int l = 0; l < 2; l++) dp[i][j][k][l] = INF;
dp[0][0][0][0] = 0;
for (int i = 0; i <= ((int)V.size()); i++)
for (int j = 0; j <= ((int)K.size()); j++)
for (int k = 0; k <= ((int)a.size()); k++)
for (int l = 0; l < 2; l++) {
if (i + 1 <= ((int)V.size()))
mi(dp[i + 1][j][k][1], dp[i][j][k][l] + cc(i, j, k, V[i]));
if (j + 1 <= ((int)K.size()) && l == 0)
mi(dp[i][j + 1][k][0], dp[i][j][k][l] + cc(i, j, k, K[j]));
if (k + 1 <= ((int)a.size()))
mi(dp[i][j][k + 1][0], dp[i][j][k][l] + cc(i, j, k, a[k]));
}
printf("%d\n", min(dp[((int)V.size())][((int)K.size())][((int)a.size())][0],
dp[((int)V.size())][((int)K.size())][((int)a.size())][1]));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
bool win, lose, isLeaf;
Node* child[27];
};
Node* newNode() {
Node* ret = new Node;
ret->win = false;
ret->lose = false;
ret->isLeaf = true;
for (int i = 0; i <= 26; ++i) ret->child[i] = NULL;
return ret;
}
Node* root = newNode();
Node* insert(string st) {
Node* p = root;
for (char c : st) {
int i = c - 'a';
p->isLeaf = false;
if (p->child[i] == NULL) p->child[i] = newNode();
p = p->child[i];
}
return p;
}
void DFS(Node* u) {
if (u->isLeaf) {
u->lose = 1;
u->win = 0;
}
for (int i = 0; i <= ('z' - 'a'); ++i)
if (u->child[i] != NULL) {
DFS(u->child[i]);
u->lose = u->lose || (!u->child[i]->lose);
u->win = u->win || (!u->child[i]->win);
}
}
int n, k;
void FileInit() {
{
freopen(
""
".inp",
"r", stdin);
freopen(
""
".out",
"w", stdout);
}
}
void FileDebug() {
{
freopen(
""
".inp",
"r", stdin);
freopen(
""
".out",
"w", stdout);
freopen(
""
".err",
"w", stderr);
}
}
void FileClose() {
fclose(stdin);
fclose(stdout);
}
void Enter() {
char str[131072];
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%s", &str);
insert(string(str));
}
}
void Solve() {
DFS(root);
if (root->win && root->lose) {
puts("First");
} else if (!root->win) {
puts("Second");
} else if (root->win && (!root->lose)) {
puts((k & 1) ? "First" : "Second");
}
}
int main() {
Enter();
Solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
int x = 0, n = a.length();
for (int i = 1; i < n; i++) {
if (isupper(a[i])) x++;
}
if (x == n - 1) {
transform(a.begin() + 1, a.end(), a.begin() + 1, ::tolower);
if (isupper(a[0])) {
a[0] = tolower(a[0]);
} else
a[0] = toupper(a[0]);
cout << a;
return 0;
}
cout << a;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int iNF = 0x3f3f3f3f;
const int MAXN = 4000006;
const int MAXC = 22;
int n, a[MAXN], dp[1 << MAXC];
inline int rev(int val) { return ((1 << MAXC) - 1) ^ val; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
memset(dp, (-1), sizeof(dp));
for (int i = 0; i < n; i += 1) {
cin >> a[i];
dp[a[i]] = a[i];
}
for (int i = 0; i < MAXC; i += 1) {
for (int j = 0; j < (1 << MAXC); j += 1) {
if (j & (1 << i)) {
dp[j] = max(dp[j], dp[j ^ (1 << i)]);
}
}
}
for (int i = 0; i < n; i += 1) {
cout << dp[rev(a[i])] << " \n"[i == n - 1];
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
long long a[1000][200];
long long n, m;
int cmp(const void* a, const void* b) {
return *(long long*)b - *(long long*)a;
}
long long as(long long x) {
for (long long i = 1; i <= x; i++) {
for (long long j = 1; j <= m; j++) {
if (a[i][j] != a[x * 2 - i + 1][j]) {
return x * 2;
}
}
}
if (x == 1) {
return 1;
}
if (x % 2 == 1) {
return x;
}
return as(x / 2);
}
int main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
scanf("%lld", &a[i][j]);
}
}
if (n % 2 == 1) {
printf("%lld", n);
} else {
printf("%lld", as(n / 2));
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<unsigned long long> v1, v2;
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string input;
cin >> input;
int n = input.length();
for (int i = 0; i < n - 1; i++) {
if (input[i] + input[i + 1] - 2 * '0' == 9) v1.push_back(i);
}
if (v1.empty()) {
cout << "1";
return 0;
}
for (int i = 0; i < v1.size() - 1; i++) {
if (v1[i + 1] - v1[i] == 1) {
int ct = 1;
while (v1[i + 1] - v1[i] == 1 && i < v1.size() - 1) {
ct++;
i++;
}
if (ct % 2 == 0) v2.push_back(ct / 2);
}
}
unsigned long long res = 1;
if (!v2.empty())
for (int i = 0; i < v2.size(); i++) {
res = res * ((v2[i] + 1));
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (a != 0 && b != 0) {
if (a >= b)
a %= b;
else
b %= a;
}
return a > b ? a : b;
}
int main() {
long long n, m, q;
cin >> n >> m >> q;
long long g = gcd(n, m);
long long nd = n / g;
long long md = m / g;
for (int i = 0; i < q; i++) {
long long a, b, c, d, e, f;
cin >> a >> b >> c >> d;
b--;
d--;
if (a == 1)
e = b / nd;
else
e = b / md;
if (c == 1)
f = d / nd;
else
f = d / md;
if (e == f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int f[55], s[55];
long double p[55];
long double dp[55][5005];
bool vis[55][5005];
int main() {
int n, r;
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) {
scanf("%d%d%Lf", &f[i], &s[i], &p[i]);
p[i] /= 100;
}
long double lo = 0, hi = 1e18, ans = 0;
for (int i = 0; i < 200; i++) {
long double mid = (lo + hi) / 2;
memset(vis, 0, sizeof(vis));
memset(dp, 0, sizeof(dp));
vis[n + 1][0] = 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= r; j++) {
long double res = 0;
if (j >= s[i]) {
res += (f[i] + dp[i + 1][j - f[i]]) * p[i];
res += (s[i] + dp[i + 1][j - s[i]]) * (1 - p[i]);
res = min(res, mid);
dp[i][j] = res;
vis[i][j] = 1;
} else if (j >= f[i]) {
res += (f[i] + dp[i + 1][j - f[i]]) * p[i];
res += (s[i] + mid) * (1 - p[i]);
res = min(res, mid);
dp[i][j] = res;
vis[i][j] = 1;
} else {
res += (f[i] + mid) * p[i];
res += (s[i] + mid) * (1 - p[i]);
res = min(res, mid);
dp[i][j] = mid;
vis[i][j] = mid;
}
}
}
bool ok = 0;
if (dp[1][r] < mid) ok = 1;
if (ok)
ans = mid, hi = mid;
else
lo = mid;
}
printf("%.20Lf\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long dp0[1111111], dp1[1111111], dp2[1111111], xxx[8], p[1111111];
void add(long long &a, long long b) {
a += b;
if (a >= mod) a -= mod;
}
void sub(long long &a, long long b) {
a -= b;
if (a < 0) a += mod;
}
int main() {
xxx[0] = 1;
for (int i = 1; i < 8; i++) xxx[i] = xxx[i - 1] * 10;
int n, a;
scanf("%d", &n);
p[0] = 1;
for (int i = 1; i < n + 1; i++) p[i] = p[i - 1] * 2 % mod;
for (int i = 1; i < n + 1; i++) {
scanf("%d", &a);
dp2[a] = dp2[a] * 2 % mod;
add(dp2[a], a * 1LL * a % mod * p[dp0[a]] % mod);
if (dp0[a]) add(dp2[a], 2 * dp1[a] * a % mod * p[1 + dp0[a] - 2] % mod);
dp0[a]++, add(dp1[a], a);
}
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 1e6; j++) {
int k = (j % xxx[i + 1]) / xxx[i];
for (int kk = k + 1; kk < 10; kk++) {
int xx = j - k * xxx[i] + kk * xxx[i];
dp2[j] = dp2[j] * p[dp0[xx]] % mod,
add(dp2[j], dp2[xx] * p[dp0[j]] % mod);
if (dp0[j] && dp0[xx])
add(dp2[j],
2 * dp1[j] * dp1[xx] % mod * p[dp0[j] + dp0[xx] - 2] % mod);
add(dp0[j], dp0[xx]);
add(dp1[j], dp1[xx]);
}
}
}
for (int i = 0; i < 6; i++) {
for (int j = xxx[6] - 1; j >= 0; j--) {
int k = (j % xxx[i + 1]) / xxx[i];
for (int kk = k + 1; kk < 10; kk++)
sub(dp2[j], dp2[j - k * xxx[i] + kk * xxx[i]]);
}
}
long long res = 0;
for (int i = 0; i < 1e6; i++) res ^= i * dp2[i];
printf("%I64d\n", res);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long INF = 1e18;
const int MX = 100001;
std::string zodis;
const int lg = 26;
void print(vector<int> a) {
for (auto u : a) printf("%d ", u);
printf("\n");
}
void print(int a[]) {
for (int i = 0; i < lg; ++i) {
printf("%d ", a[i]);
}
printf("\n");
}
struct node {
int l, r;
bool asc, desc;
node *left, *right;
int val[lg];
void surink(int a, int b, int (&curr)[lg]) {
if (l != r) {
if (asc) make_asc();
if (desc) make_desc();
}
int mid = (l + r) / 2;
if (a <= l and b >= r) {
for (int i = 0; i < lg; ++i) {
curr[i] += val[i];
val[i] = 0;
}
return;
} else if (b <= mid) {
left->surink(a, b, curr);
} else if (a > mid) {
right->surink(a, b, curr);
} else {
left->surink(a, b, curr);
right->surink(a, b, curr);
}
if (l != r)
for (int i = 0; i < lg; ++i) val[i] = left->val[i] + right->val[i];
}
void make_asc() {
int ls = left->r - left->l + 1;
int rs = right->r - right->l + 1;
memset(left->val, 0, sizeof(left->val));
memset(right->val, 0, sizeof(right->val));
for (int i = 0; i < lg; ++i) {
int diff = min(val[i], ls);
left->val[i] += diff;
ls -= diff;
right->val[i] += min(val[i] - diff, rs);
rs -= min(val[i] - diff, rs);
}
asc = false;
desc = false;
left->asc = true;
left->desc = false;
if (left->l == left->r) left->asc = false;
right->asc = true;
right->desc = false;
if (right->l == right->r) right->asc = false;
}
void make_desc() {
int ls = left->r - left->l + 1;
int rs = right->r - right->l + 1;
memset(left->val, 0, sizeof(left->val));
memset(right->val, 0, sizeof(right->val));
for (int i = lg - 1; i >= 0; --i) {
int diff = min(val[i], ls);
left->val[i] += diff;
ls -= diff;
right->val[i] += min(val[i] - diff, rs);
rs -= min(val[i] - diff, rs);
}
asc = false;
desc = false;
left->asc = false;
left->desc = true;
if (left->l == left->r) left->desc = false;
right->asc = false;
right->desc = true;
if (right->l == right->r) right->desc = false;
}
void change(int a, int b, int first, int curr[lg]) {
int mid = (l + r) / 2;
if (a <= l && b >= r) {
for (int i = 0; i < lg; ++i) {
val[i] = curr[i];
}
if (l == r) return;
if (first) {
asc = true;
desc = false;
} else {
asc = false;
desc = true;
}
return;
} else if (b <= mid) {
left->change(a, b, first, curr);
} else if (a > mid) {
right->change(a, b, first, curr);
} else {
int ls = mid - max(l, a) + 1;
int rs = min(b, r) - mid;
int kair[lg];
int des[lg];
memset(kair, 0, sizeof(kair));
memset(des, 0, sizeof(des));
if (first) {
for (int i = 0; i < lg; ++i) {
int diff = min(curr[i], ls);
kair[i] += diff;
ls -= diff;
des[i] += min(curr[i] - diff, rs);
rs -= min(curr[i] - diff, rs);
}
} else {
for (int i = lg - 1; i >= 0; --i) {
int diff = min(curr[i], ls);
kair[i] += diff;
ls -= diff;
des[i] += min(curr[i] - diff, rs);
rs -= min(curr[i] - diff, rs);
}
}
left->change(a, b, first, kair);
right->change(a, b, first, des);
}
for (int i = 0; i < lg; ++i) {
val[i] = left->val[i] + right->val[i];
}
}
void finish() {
if (l == r) {
for (int i = 0; i < lg; ++i) {
if (val[i]) {
zodis[l - 1] = char(i + 'a');
return;
}
}
}
if (desc) make_desc();
if (asc) make_asc();
left->finish();
right->finish();
}
node(int a, int b) {
l = a;
r = b;
asc = false;
desc = false;
memset(val, 0, sizeof(val));
if (a != b) {
left = new node(a, (a + b) / 2);
right = new node((a + b) / 2 + 1, b);
for (int i = 0; i < lg; ++i) val[i] = left->val[i] + right->val[i];
} else {
val[zodis[a - 1] - 'a']++;
}
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N, Q;
cin >> N >> Q >> zodis;
int a, b, first;
node medis(1, N);
int pivot[lg];
for (int i = 0; i < Q; ++i) {
cin >> a >> b >> first;
if (a == b) continue;
memset(pivot, 0, sizeof(pivot));
medis.surink(a, b, pivot);
medis.change(a, b, (int)first, pivot);
}
medis.finish();
cout << zodis << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
string a, b;
cin >> n;
cin >> a >> b;
long long a1 = 0, a0 = 0, c0 = 0, c1 = 0;
for (int i = 0; i < n; i++) {
if (a[i] == '1')
a1++;
else
a0++;
}
for (int i = 0; i < n; i++) {
if (a[i] == '0' && b[i] == '0') {
c0++;
} else if (a[i] == '1' && b[i] == '0') {
c1++;
}
}
long long d = (a1 * c0);
cout << d + (c1 * (a0 - c0)) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, a, c = 0;
cin >> n;
map<int, int> x;
x.clear();
for (int i = 0; i < n; i++) {
cin >> a;
x[a]++;
if (a && x[a] > 2)
c = -2000;
else if (a && x[a] == 2)
c++;
}
cout << max(c, -1) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 312345;
const int INF = 0x3f3f3f3f;
const long long MOD = 1000000007;
int n, q;
queue<pair<int, int> > f;
map<int, int> r;
map<int, int> d;
map<int, int> k;
int main() {
scanf("%d%d", &n, &q);
int u = 0, temp = 0;
for (int i = 0; i < q; i++) {
int a, b;
scanf("%d%d", &a, &b);
if (a == 1) {
u++;
r[b]++;
f.push(make_pair(++temp, b));
d[b] = temp;
}
if (a == 2) {
u -= r[b];
r[b] = 0;
k[b] = d[b];
}
if (a == 3) {
while (!f.empty()) {
int vi = (f.front()).first, id = (f.front()).second;
if (vi > b) break;
f.pop();
if (vi > k[id]) {
u--;
r[id]--;
}
}
}
printf("%d\n", u);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n % 2)
cout << "Ehab";
else
cout << "Mahmoud";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string ans[256][3];
string ans2[256][3];
inline string bests(string p1, string p2) {
if (p1 == "") return p2;
if (p2 == "") return p1;
if (p1.length() < p2.length()) return p1;
if (p2.length() < p1.length()) return p2;
if (p1 < p2) return p1;
return p2;
}
bool dd[256][6];
int main() {
ans[240][2] = "x";
ans[204][2] = "y";
ans[170][2] = "z";
while (1) {
bool done = 1;
for (int i = 0; i <= 255; ++i) {
if (ans[i][0] == "" || ans[i][1] == "" || ans[i][2] == "") {
done = 0;
break;
}
}
if (done) break;
for (int i = 0; i <= 255; ++i)
for (int j = 0; j <= 2; ++j) {
if (ans[i][j] == "") continue;
if (j < 2) {
ans2[i ^ 255][2] = bests(ans2[i ^ 255][2], "!(" + ans[i][j] + ")");
} else {
ans2[i ^ 255][2] = bests(ans2[i ^ 255][2], "!" + ans[i][j]);
}
if (j < 2 && ans[i][2] == "") {
ans2[i][2] = bests(ans2[i][2], "(" + ans[i][j] + ")");
}
for (int k = 0; k <= 255; ++k)
for (int l = 0; l <= 2; ++l)
if (ans[k][l] != "") {
if (1) {
ans2[i | k][0] =
bests(ans2[i | k][0], ans[i][j] + "|" + ans[k][l]);
}
if (j > 0 && l > 0) {
ans2[i & k][1] =
bests(ans2[i & k][1], ans[i][j] + "&" + ans[k][l]);
}
}
}
for (int i = 0; i <= 255; ++i)
for (int j = 0; j <= 2; ++j) ans[i][j] = bests(ans[i][j], ans2[i][j]);
}
int q;
cin >> q;
while (q--) {
string s;
cin >> s;
int mask = 0;
for (int i = 0; i <= 7; ++i)
if (s[i] == '1') mask += (1 << i);
cout << bests(ans[mask][0], bests(ans[mask][1], ans[mask][2])) << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
while (~scanf("%d", &n)) {
int pos, mintimes = 0x3f3f3f3f;
int minpos;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
pos = x % n;
int now = x;
if (i >= pos)
now += (i - pos);
else
now += (n - pos + i);
if (now < mintimes) {
mintimes = now;
minpos = i;
}
}
printf("%d\n", minpos + 1);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, l[5], r[5];
double result;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> l[i] >> r[i];
for (int winner = 0; winner < n; winner++) {
double probmore = 0;
for (int i = l[winner]; i <= r[winner]; i++)
probmore += 1.0 / (r[winner] - l[winner] + 1);
double sumprob = 0;
for (int i = 0; i <= 10000; i++) {
if (i >= l[winner] && i <= r[winner])
probmore -= 1.0 / (r[winner] - l[winner] + 1);
double cprob = 1;
for (int j = 0; j < n; j++)
if (j != winner) {
if (l[j] <= i)
cprob *= 1.0 * (min(i, r[j]) - l[j] + 1) / (r[j] - l[j] + 1);
else
cprob = 0;
}
result += (cprob - sumprob) * probmore * i;
sumprob = cprob;
}
}
for (int comb = 1; comb < (1 << n); comb++) {
int nwinners = 0;
bool wins[5] = {false, false, false, false, false};
for (int i = 0; i < n; i++)
if ((comb & (1 << i)) != 0) nwinners++, wins[i] = true;
if (nwinners <= 1) continue;
for (int i = 0; i <= 10000; i++) {
double cadd = 1;
for (int j = 0; j < n; j++) {
if (wins[j]) {
if (i >= l[j] && i <= r[j])
cadd *= 1.0 / (r[j] - l[j] + 1);
else
cadd = 0;
} else if (!wins[j]) {
if (i <= l[j])
cadd = 0;
else
cadd *= 1.0 * (min(i, r[j] + 1) - l[j]) / (r[j] - l[j] + 1);
}
}
result += cadd * i;
}
}
cout << fixed << setprecision(11) << result << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool f(int k, string& s) {
int n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] == '*')
if (i + 4 * k < n && s[i + k] == '*' && s[i + 2 * k] == '*' &&
s[i + 3 * k] == '*' && s[i + 4 * k] == '*')
return true;
}
return false;
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 1; i < n; i++) {
if (f(i, s)) {
cout << "yes" << endl;
return 0;
}
}
cout << "no" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long const llINF = numeric_limits<long long>::max();
int const INF = numeric_limits<int>::max();
vector<int> search(vector<vector<int>> &net, vector<vector<int>> &target) {
int N = target.size();
vector<int> order;
vector<int> nvalues(N + 1, 0);
int val = 0;
for (int i = 0; i < N; i++) {
vector<int> curr = target.back();
target.pop_back();
if (curr.empty()) continue;
unordered_map<int, bool> blocked;
bool pass = true;
for (auto node : curr) {
if (nvalues[node] == val && !blocked[node]) {
order.push_back(node);
for (auto n : net[node]) {
blocked[n] = true;
}
} else {
pass = false;
break;
}
}
if (!pass) break;
if (!blocked.empty()) {
for (auto el : blocked) {
nvalues[el.first]++;
}
}
val++;
}
return order;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int N, M;
cin >> N >> M;
vector<vector<int>> net(N + 1);
for (int repetitions = 0; repetitions < M; repetitions++) {
int a;
int b;
cin >> a >> b;
net[a].emplace_back(b);
net[b].emplace_back(a);
}
vector<vector<int>> target(N);
for (int i = 0; i < N; i++) {
int topic;
cin >> topic;
target[N - topic].push_back(i + 1);
}
vector<int> order = search(net, target);
if (order.size() == N) {
if (order.size())
for (auto elem : order) {
cout << elem << " ";
}
cout << '\n';
;
} else
cout << -1 << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Rect {
char label;
int length, width;
Rect() {}
Rect(int l, int w, char com) : length(l), width(w), label(com) {}
bool operator<(const Rect& rhs) const { return length > rhs.length; }
};
int main() {
int x1, y1, x2, y2, x3, y3;
scanf("%d%d%d%d%d%d", &x1, &y1, &x2, &y2, &x3, &y3);
if (x1 < y1) swap(x1, y1);
if (x2 < y2) swap(x2, y2);
if (x3 < y3) swap(x3, y3);
int total = x1 * y1 + x2 * y2 + x3 * y3;
int side;
for (side = 0; side * side < total; side++) {
}
if (side * side != total) {
printf("-1\n");
} else {
Rect rects[3];
rects[0] = Rect(x1, y1, 'A');
rects[1] = Rect(x2, y2, 'B');
rects[2] = Rect(x3, y3, 'C');
sort(rects, rects + 3);
char output[side][side];
if (rects[0].length != side) {
printf("-1\n");
} else {
for (int i = 0; i < rects[0].width; i++) {
for (int j = 0; j < side; j++) {
output[i][j] = rects[0].label;
}
}
if (rects[1].length == side && rects[2].length == side) {
printf("%d\n", side);
for (int i = rects[0].width; i < rects[0].width + rects[1].width; i++) {
for (int j = 0; j < side; j++) {
output[i][j] = rects[1].label;
}
}
for (int i = rects[0].width + rects[1].width; i < side; i++) {
for (int j = 0; j < side; j++) {
output[i][j] = rects[2].label;
}
}
for (int i = 0; i < side; i++) {
for (int j = 0; j < side; j++) {
printf("%c", output[i][j]);
}
printf("\n");
}
} else if (rects[1].length == rects[2].length &&
rects[1].width + rects[2].width == side) {
printf("%d\n", side);
for (int i = rects[0].width; i < side; i++) {
for (int j = 0; j < rects[1].width; j++) {
output[i][j] = rects[1].label;
}
}
for (int i = rects[0].width; i < side; i++) {
for (int j = rects[1].width; j < side; j++) {
output[i][j] = rects[2].label;
}
}
for (int i = 0; i < side; i++) {
for (int j = 0; j < side; j++) {
printf("%c", output[i][j]);
}
printf("\n");
}
} else if (rects[1].width == rects[2].length &&
rects[1].length + rects[2].width == side) {
printf("%d\n", side);
for (int i = rects[0].width; i < side; i++) {
for (int j = 0; j < rects[1].length; j++) {
output[i][j] = rects[1].label;
}
}
for (int i = rects[0].width; i < side; i++) {
for (int j = rects[1].length; j < side; j++) {
output[i][j] = rects[2].label;
}
}
for (int i = 0; i < side; i++) {
for (int j = 0; j < side; j++) {
printf("%c", output[i][j]);
}
printf("\n");
}
} else if (rects[1].width == rects[2].width &&
rects[1].length + rects[2].length == side) {
printf("%d\n", side);
for (int i = rects[0].width; i < side; i++) {
for (int j = 0; j < rects[1].length; j++) {
output[i][j] = rects[1].label;
}
}
for (int i = rects[0].width; i < side; i++) {
for (int j = rects[1].length; j < side; j++) {
output[i][j] = rects[2].label;
}
}
for (int i = 0; i < side; i++) {
for (int j = 0; j < side; j++) {
printf("%c", output[i][j]);
}
printf("\n");
}
} else {
printf("-1\n");
}
}
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int t,n,a[200020],dp[200020],keep[200020],check[200020],ans,res;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
//freopen("VD1.INP","r",stdin);
//freopen("VD1.OUT","w",stdout);
cin>>t;
while (t--)
{
cin>>n;
for (int i=n;i>=1;i--)
{
cin>>a[n-i+1];
keep[i]=0;
dp[i]=-1;
dp[i]++;
}
res=0;
for (int i=1;i<=n;i++)
{
if (keep[a[i]]==0) dp[a[i]]=(i!=1);
else
if (i-1-keep[a[i]]>0) dp[a[i]]++;
keep[a[i]]=i;
}
res=dp[a[n]];
for (int i=1;i<=n;i++) check[i]=0;
check[a[n]]=1;
for (int i=1;i<=n;i++)
if (check[a[n-i+1]]==0)
{
dp[a[n-i+1]]++;
check[a[n-i+1]]=1;
}
ans=res;
res=10;
ans=1e9;
for (int i=1;i<=n;i++) ans=min(ans,dp[a[i]]);
cout<<ans<<"\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 << 17;
const int inf = 1000000007;
int n, m, l, r, ansa, ansb;
int a[maxn], b[maxn], c[maxn];
long double ans = 1e15;
long double sqr(long double x) { return x * x; }
long double f(int i, int j) {
long double res = 0;
res += c[i];
res += sqrt(sqr(l) + sqr(a[j]));
res += sqrt(sqr(r - l) + sqr(b[i] - a[j]));
return res;
}
int main() {
cin >> n >> m >> l >> r;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
for (int i = 0; i < m; i++) cin >> c[i];
int j = 0;
for (int i = 0; i < m; i++) {
while (j < n - 1 && f(i, j + 1) < f(i, j)) j++;
if (f(i, j) < ans) ansb = i + 1, ansa = j + 1, ans = f(i, j);
}
cout << ansa << " " << ansb << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
int index1, index2;
map<int, int> m;
for (int i = 0; i < n; i++) {
cin >> arr[i];
m[arr[i]] = i;
if (arr[i] == 1) index1 = i;
if (arr[i] == 2) index2 = i;
}
bool ans = true;
if (index1 < n - 1 && index2 != index1 + 1) {
ans = false;
cout << "No" << endl;
continue;
}
int temp1 = 1;
int lastele = 1;
int index = index1;
int lastindex = n;
while (temp1 <= n && ans) {
int i;
for (i = index; i < lastindex; i++) {
if (arr[i] != temp1) {
cout << "No" << endl;
ans = false;
break;
}
temp1++;
}
lastele = arr[lastindex - 1];
lastindex = index;
index = m[lastele + 1];
}
if (ans) cout << "Yes" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, x, i, p, q;
cin >> a >> b >> x;
p = a;
q = b;
for (i = 1; i <= x; i++) cout << ((i & 1) == (a < b));
if (a >= b)
b -= x >> 1, a -= x - (x >> 1);
else
a -= x >> 1, b -= x - (x >> 1);
if ((x & 1) == (p >= q))
while (a--) putchar('0');
else
while (b--) putchar('1');
while (a > 0) putchar('0'), a--;
while (b > 0) putchar('1'), b--;
return 0;
}
| 2 |
/*
___ ___ ___ ___ ___ ___ ___ _____ ___ ___ ___
/ /\ /__/\ / /\ /__/\ / /\ /__/\ / /\ / /::\ / /\ / /\ / /\
/ /::\ | |::\ / /::\ \ \:\ / /::\ | |::\ / /::\ / /:/\:\ / /::\ / /::\ / /::\
/ /:/\:\ | |:|:\ / /:/\:\ \__\:\ / /:/\:\ | |:|:\ / /:/\:\ / /:/ \:\ / /:/\:\ / /:/\:\ / /:/\:\
/ /:/ \:\ __|__|:|\:\ / /:/ \:\ ___ / /::\ / /:/~/::\ __|__|:|\:\ / /:/~/::\ /__/:/ \__\:| / /:/ \:\ / /:/ \:\ / /:/ \:\
/__/:/ \__\:\ /__/::::| \:\ /__/:/ \__\:\ /__/\ /:/\:\ /__/:/ /:/\:\ /__/::::| \:\ /__/:/ /:/\:\ \ \:\ / /:/ /__/:/ \__\:\ /__/:/ \__\:\ /__/:/ \__\:\
\ \:\ / /:/ \ \:\~~\__\/ \ \:\ / /:/ \ \:\/:/__\/ \ \:\/:/__\/ \ \:\~~\__\/ \ \:\/:/__\/ \ \:\ /:/ \ \:\ / /:/ \ \:\ / /:/ \ \:\ / /:/
\ \:\ /:/ \ \:\ \ \:\ /:/ \ \::/ \ \::/ \ \:\ \ \::/ \ \:\/:/ \ \:\ /:/ \ \:\ /:/ \ \:\ /:/
\ \:\/:/ \ \:\ \ \:\/:/ \ \:\ \ \:\ \ \:\ \ \:\ \ \::/ \ \:\/:/ \ \:\/:/ \ \:\/:/
\ \::/ \ \:\ \ \::/ \ \:\ \ \:\ \ \:\ \ \:\ \__\/ \ \::/ \ \::/ \ \::/
\__\/ \__\/ \__\/ \__\/ \__\/ \__\/ \__\/ \__\/ \__\/ \__\/
*/
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define endl '\n'
using namespace std;
const int MOD=1000000007;
const int N=1000100;
long long po(ll x,ll y)
{
if(y==0)return 1;
ll ret=po(x,y/2);//%MOD;
ret*=ret;
//ret%=MOD;
if(y%2)ret*=x;//,ret%=MOD;
return ret;
}
ll n;
ll a[N];
vector<ll>mak(ll sum)
{
vector<ll>ans;
for(ll i=1;i<=sum;i++){
if(sum%i==0){
ans.pb(i);
}
}
return ans;
}
ll shit(ll div,ll sum)
{
ll ans=0;
ll sum2=0;
for(ll i=0;i<n;i++){
sum2+=a[i];
if(sum2-a[i])
ans++;
if(sum2==sum/div){
sum2=0;
}
if(sum2>sum/div)
return 1e14;
}
return ans;
}
void solve()
{
ll sum=0;
cin>>n;
for(ll i=0;i<n;i++){
cin>>a[i];
sum+=a[i];
}
vector<ll>v=mak(sum);
ll ans=1e14;
for(ll i=0;i<v.size();i++){
ans=min(ans,shit(v[i],sum));
}
cout<<ans<<endl;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
//freopen("perimeter.in","r",stdin);freopen("perimeter.out","w",stdout);
ll t;
cin>>t;
while(t--){
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int dir[4][2] = {1, 0, 0, -1, 0, 1, -1, 0};
const char c[5] = "DLRU";
int n, m, K, d[N][N];
char g[N][N];
queue<pair<int, int> > Q;
vector<char> ans;
int main() {
scanf("%d%d%d", &n, &m, &K);
for (int i = 0; i < n; i++) scanf("%s", g[i]);
if (K % 2)
printf("IMPOSSIBLE\n");
else {
int sx, sy;
memset(d, -1, sizeof(d));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (g[i][j] == 'X')
Q.push(make_pair(i, j)), d[i][j] = 0, sx = i, sy = j;
while (!Q.empty()) {
pair<int, int> u = Q.front();
Q.pop();
for (int i = 0; i < 4; i++) {
int x = u.first + dir[i][0];
int y = u.second + dir[i][1];
if (x < 0 || x >= n || y < 0 || y >= m || g[x][y] == '*' ||
d[x][y] != -1)
continue;
d[x][y] = d[u.first][u.second] + 1;
Q.push(make_pair(x, y));
}
}
for (int i = 0; i < K; i++) {
int f = 0;
for (int j = 0; j < 4; j++) {
int x = sx + dir[j][0];
int y = sy + dir[j][1];
if (x < 0 || x >= n || y < 0 || y >= m || g[x][y] == '*' ||
d[x][y] > K - i)
continue;
ans.push_back(c[j]);
f = 1;
sx = x;
sy = y;
break;
}
if (!f) {
printf("IMPOSSIBLE\n");
return 0;
}
}
for (int i = 0; i < (int)ans.size(); i++) printf("%c", ans[i]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
vector<int> g[maxn];
int dep[maxn], book[maxn];
int ans;
void dfs(int x) {
for (int i = 0; i < g[x].size(); i++) {
int to = g[x][i];
dep[to] = dep[x] + 1;
dfs(to);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
g[x].push_back(i);
}
dep[1] = 1;
dfs(1);
for (int i = 1; i <= n; i++) book[dep[i]]++;
ans = 0;
for (int i = 1; i <= n; i++) {
if (book[i] % 2 == 1) ans++;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &val) {
val = 0LL;
int f = 1LL;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1LL;
c = getchar();
}
while (isdigit(c)) {
val = (val << 3LL) + (val << 1LL) + (c ^ 48);
c = getchar();
}
val *= f;
}
long long n, k, a, b;
vector<long long> rst;
long long gcd(long long x, long long y) {
if (y == 0LL) return x;
return gcd(y, x % y);
}
long long lcm(long long x, long long y) { return y / gcd(x, y); }
int main() {
read(n);
read(k);
read(a);
read(b);
long long tot = n * k;
for (long long i = 1; i <= tot; i += k) {
rst.push_back(i);
}
long long minn = LLONG_MAX, maxx = 0LL;
long long beg = (1LL + a + tot) % tot;
for (int i = 0; i < rst.size(); i++) {
long long l;
l = ((rst[i] - b + tot) % tot - beg + tot) % tot;
if (!l) l = tot;
minn = min(minn, lcm(l, tot));
maxx = max(maxx, lcm(l, tot));
l = ((rst[i] + b + tot) % tot - beg + tot) % tot;
if (!l) l = tot;
minn = min(minn, lcm(l, tot));
maxx = max(maxx, lcm(l, tot));
}
beg = (1LL - a + tot) % tot;
for (int i = 0; i < rst.size(); i++) {
long long l;
l = ((rst[i] - b + tot) % tot - beg + tot) % tot;
if (!l) l = tot;
minn = min(minn, lcm(l, tot));
maxx = max(maxx, lcm(l, tot));
l = ((rst[i] + b + tot) % tot - beg + tot) % tot;
if (!l) l = tot;
minn = min(minn, lcm(l, tot));
maxx = max(maxx, lcm(l, tot));
}
cout << minn << ' ' << maxx << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
long long x, y, z, a;
struct matrix {
long long arr[5][5];
matrix(long long x) {
memset(arr, 0, sizeof(arr));
for (int i = 0; i < 2; i++) {
arr[i][i] = x;
}
}
friend matrix operator*(matrix s, matrix ss) {
matrix dp(0);
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
(dp.arr[i][j] += s.arr[i][k] * ss.arr[k][j]) %= (1000000007);
}
}
}
return dp;
}
};
matrix rip(0), res(1);
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> x;
rip.arr[0][0] = rip.arr[1][1] = 3;
rip.arr[1][0] = rip.arr[0][1] = 1;
res.arr[0][0] = res.arr[1][1] = 1;
for (int i = 0; i < 63; i++) {
if (x & (1LL << i)) {
res = res * rip;
}
rip = rip * rip;
}
cout << res.arr[0][0] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void input(vector<T>& v) {
for (T& x : v) cin >> x;
}
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
input(v);
long long total_sum = 0;
for (auto& x : v) total_sum += x;
if (total_sum % n != 0) {
cout << -1 << '\n';
return;
}
long long final_value = total_sum / n;
vector<array<long long, 3> > ops;
for (long long i = 1; i < n; i++) {
long long j = i + 1;
long long x = v[i];
if (x % j == 0) {
ops.push_back({j, 1, x / j});
} else {
ops.push_back({1, j, j - (x % j)});
ops.push_back({j, 1, (x + j - 1) / j});
}
}
for (long long i = 1; i < n; i++) {
long long j = i + 1;
long long x = v[i];
ops.push_back({1, j, final_value});
}
cout << ops.size() << '\n';
for (auto& op : ops) {
cout << op[0] << " " << op[1] << " " << op[2] << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 9];
for (int i = 0; i < n; i++) cin >> a[i];
int j = 0;
while (a[j] == 0) j++;
int k = n - 1;
while (a[k] == 0) k--;
int count = 0, cnt = 0;
for (int i = j; i <= k; i++) {
if (a[i] == 1)
count++;
else {
cnt++;
while (a[i] == 0) i++;
i--;
}
}
cout << (count + cnt) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pi = pair<ll, ll>;
const int mod = 7 * 17 * (1 << 23) + 1;
const ll inf = 1e18;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int w = 390359979, iw = 304321983;
const int maxn = (1 << 20), inv2 = 499122177;
void norm(int &x) {
if (x >= mod) x -= mod;
if (x < 0) x += mod;
}
int pw[maxn + 1], ipw[maxn + 1];
void init() {
pw[maxn] = w, ipw[maxn] = iw;
for (int i = maxn; i >>= 1;) {
pw[i] = (pw[i << 1] * 1ll * pw[i << 1]) % mod;
ipw[i] = (ipw[i << 1] * 1ll * ipw[i << 1]) % mod;
}
}
vi a, res1, res2;
void ntt(vector<int> &a, vector<int> &ans, int l, int cl, int step, int n,
bool inv) {
if (n == 1) {
ans[l] = a[cl];
return;
}
ntt(a, ans, l, cl, step * 2, n / 2, inv);
ntt(a, ans, l + n / 2, cl + step, step * 2, n / 2, inv);
int cw = 1, gw = (inv ? ipw[n] : pw[n]);
for (int i = l; i < l + n / 2; i++) {
int u = ans[i], v = (cw * 1ll * ans[i + n / 2]) % mod;
ans[i] = (u + v) % mod;
ans[i + n / 2] = (u - v) % mod;
if (ans[i + n / 2] < 0) ans[i + n / 2] += mod;
if (inv) {
ans[i] = (ans[i] * 1ll * inv2) % mod;
ans[i + n / 2] = (ans[i + n / 2] * 1ll * inv2) % mod;
}
cw = (cw * 1ll * gw) % mod;
}
}
int n;
vi mul(vi x, vi y, vi &res2) {
int sz = x.size() + y.size(), m = 1;
while (m < sz) m <<= 1;
while (x.size() < m) x.push_back(0);
while (y.size() < m) y.push_back(0);
res1.resize(m);
res2.resize(m);
ntt(x, res1, 0, 0, 1, m, 0);
ntt(y, res2, 0, 0, 1, m, 0);
for (int i = 0; i < res1.size(); i++)
res1[i] = (res2[i] * 1ll * res1[i]) % mod;
ntt(res1, res2, 0, 0, 1, m, 1);
while (res2.size() > n) res2.pop_back();
while (!res2.empty() && !res2.back()) res2.pop_back();
return res2;
}
void multiply(int l, int r, vi &res) {
if (l + 1 == r) {
res = vi(a[l] + 1, 1);
return;
};
vi a, b;
multiply(l, (l + r) >> 1, a);
multiply((l + r) >> 1, r, b);
mul(a, b, res);
}
vi t;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
init();
map<int, int> cnt;
cin >> n;
for (int t, i = 0; i < n; i++) cin >> t, cnt[t]++;
for (auto i : cnt) a.push_back(i.second);
multiply(0, a.size(), t);
cout << t[n / 2];
}
| 9 |
//Bismillahir Rahmanir Raheem
#include<bits/stdc++.h>
typedef long long ll;
#define ff first
#define ss second
using namespace std;
void fast()
{
ios::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
}
ll gcd(ll a,ll b){if(b==0) return a; else return gcd(b,a%b);}
ll lcm(ll a,ll b){ return (a*b)/gcd(a,b);}
ll ncr(ll n,ll r){ ll ans=1;for(ll i=1;i<=r;i++) ans=(ans*(n-i+1))/i;return ans;}
#define PI 3.14159265
int main()
{
int t;
cin>>t;
while(t--)
{
ll n;
cin>>n;
map<pair<ll,ll>,ll> ar;
for(int i=0;i<n;i++)
{
ll x,y,a,b,temp;
cin>>x>>y>>a>>b;
x=x-a,y=y-b;
temp=abs(gcd(x,y));
ar[make_pair(x/temp,y/temp)]++;
}
ll ans=0;
for(auto it : ar)
{
ll x,y,temp;
x=it.first.first,y=it.first.second;
if(x>=0&&y>=0)
{
if(x==0&&y==0)
temp=0;
else if(x==0)
temp=ar[make_pair(x,-y)];
else if(y==0)
temp=ar[make_pair(-x,y)];
else
temp=ar[make_pair(-x,-y)];
}
else if(x>=0)
temp=ar[make_pair(-x,-y)];
else if(y>=0)
temp=ar[make_pair(-x,-y)];
else
temp=ar[make_pair(-x,-y)];
ans=ans+temp*it.second;
ar[make_pair(x,y)]=0;
}
cout<<ans<<endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T>
bool mmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T>
bool mmin(T &m, const T q) {
if (q < m) {
m = q;
return true;
} else
return false;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec) os << v << ",";
os << "]";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &vec) {
os << "{";
for (auto v : vec) os << v << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << "(" << pa.first << "," << pa.second << ")";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
os << "{";
for (auto v : mp) os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
constexpr int INF = 1.1e9;
int main() {
int N, M, K;
cin >> N >> M >> K;
vector<pint> lr(N);
for (auto &p : lr) cin >> p.first >> p.second;
sort(lr.begin(), lr.end());
set<int> z;
for (auto p : lr) z.insert(p.first), z.insert(p.second + 1);
map<int, vector<int>> l2r;
for (auto p : lr) l2r[p.first].push_back(p.second + 1);
vector<int> dp(1 << K, -INF);
dp[0] = 0;
vector<int> R(K, 0);
int exist = 0;
int xp = 0;
for (auto x : z) {
for (int S = 0; S < (1 << K); ++S)
if (!((~exist) & S) and (__builtin_popcount(S) & 1)) dp[S] += x - xp;
for (int d = 0; d < K; ++d)
if (R[d] == x) {
R[d] = 0;
exist -= 1 << d;
for (int S = 0; S < (1 << K); ++S)
if ((S >> d) & 1) {
mmax(dp[S - (1 << d)], dp[S]);
dp[S] = -INF;
}
}
for (auto nxtr : l2r[x]) {
int d = 0;
while (R[d]) d++;
R[d] = nxtr;
exist += 1 << d;
for (int S = 0; S < (1 << K); ++S)
if ((S >> d) & 1) mmax(dp[S], dp[S - (1 << d)]);
}
xp = x;
}
cout << *max_element(dp.begin(), dp.end()) << endl;
}
| 8 |
#include <bits/stdc++.h>
int main() {
long long int n, i, j;
scanf("%lld", &n);
long long int a[n + 1][n + 1], v = (n * 2) - 1, k = 1, l = 1;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (j == 1)
a[i][j] = l++;
else {
if (j % 2 == 0) {
a[i][j] = a[i][j - 1] + v;
} else {
a[i][j] = a[i][j - 1] + k;
}
}
}
k = k + 2;
v = v - 2;
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
printf("%lld ", a[i][j]);
}
printf("\n");
}
}
| 2 |
#include <bits/stdc++.h>
const int MAX_N = 2 * 1e5;
int arr[MAX_N + 10];
std::string ans;
int main() {
std::cin.tie(NULL);
std::cout.tie(NULL);
std::ios_base::sync_with_stdio(false);
int n;
std::cin >> n;
for (int i = 0; i < n; ++i) {
std::cin >> arr[i];
}
int curr = 0, l = 0, r = n - 1, num = 0;
while (l <= r) {
if (curr > arr[l] && curr > arr[r]) {
break;
}
if (curr < arr[l] && curr > arr[r]) {
ans.push_back('L');
++num;
curr = arr[l];
++l;
} else if (curr > arr[l] && curr < arr[r]) {
ans.push_back('R');
++num;
curr = arr[r];
--r;
} else {
if (arr[l] < arr[r]) {
ans.push_back('L');
++num;
curr = arr[l];
++l;
} else {
ans.push_back('R');
++num;
curr = arr[r];
--r;
}
}
}
std::cout << num << '\n' << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
map<int, int> p;
int dp[1000000 + 10];
int rec(int dist) {
if (dist < 0) return 0;
int val = p[dist];
int sec = dist - val - 1;
if (sec < 0) return 1;
int &st = dp[dist];
if (st != -1) return st;
int low = 0, high = v.size() - 1, mid;
while (low < high) {
mid = low + (high - low) / 2;
if (v[mid].first > sec)
high = mid;
else if (v[mid].first < sec)
low = mid + 1;
else {
high = mid;
break;
}
}
if (v[high].first > sec) {
if (high == 0) return 1;
if (v[high - 1].first > sec) return 1;
high--;
}
int e = 1 + rec(v[high].first);
return st = e;
}
int main() {
int n, m, k, d, t, tem1, tem2, tem3, tem4, y = 1, sum = 0, ans = 0,
mini = 1e9;
string s, c;
memset(dp, -1, sizeof dp);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &tem1, &tem2);
v.push_back({tem1, tem2});
p[tem1] = tem2;
}
sort(v.begin(), v.end());
for (int i = v.size() - 1; i >= 0; i--) {
int e = v[i].first;
mini = min(n - rec(e), mini);
}
printf("%d", mini);
return 0;
}
| 4 |
#include <iostream>
using namespace std;
string toBinary(int n)
{
string r;
while (n != 0){
r += ( n % 2 == 0 ? "0" : "1" );
n /= 2;
}
return r;
}
int main(int argc, const char * argv[]) {
int t=0;
cin>>t;
while(t--){
int n=0,ans=0,dot=1;
cin>>n;
for(int i=(int)toBinary(n).size();i>1;i--){
ans+=dot;
dot*=2;
}
cout<<ans<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 32;
char s[MAX];
int len, ans;
const int limit = 1e6 + 0.5;
int trans(const string &a) {
if ((a[0] == '0' && a.size() > 1) || a.size() > 7)
return INT_MIN;
else {
int ret = 0;
for (int i = 0; i < a.size(); i++) {
ret = ret * 10 + a[i] - '0';
}
if (ret > limit)
return INT_MIN;
else
return ret;
}
}
int track[5];
void sol(int pos) {
if (pos == 3) {
int v1 = trans(string(s, s + track[1]));
int v2 = trans(string(s + track[1], s + track[1] + track[2]));
int v3 = trans(string(s + track[1] + track[2], s + len));
if (v1 == INT_MIN || v2 == INT_MIN || v3 == INT_MIN)
return;
else {
ans = max(ans, v1 + v2 + v3);
}
} else {
if (pos == 1) {
for (int sel = 1; sel <= len - 2; sel++) {
track[pos] = sel;
sol(pos + 1);
}
} else if (pos == 2) {
for (int sel = 1; sel <= len - track[pos - 1] - 1; sel++) {
track[pos] = sel;
sol(pos + 1);
}
}
}
}
int main() {
scanf("%s", s);
len = strlen(s);
if (len < 3 || len > 21)
printf("%d\n", -1);
else {
ans = INT_MIN;
sol(1);
if (ans == INT_MIN)
printf("%d\n", -1);
else
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long sum[2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long a, b;
cin >> a >> b;
long long x = (a + b), l = 0, i = 1;
while ((l + i) <= x) {
l += i++;
}
vector<long long> o;
long long mv = i - 1;
set<long long> rem;
for (int j = 0; j < i - 1; j++) rem.insert(j + 1);
while (a > 0 && mv > 0) {
if (a > mv)
a -= mv, o.push_back(mv), rem.erase(mv--);
else
o.push_back(a), rem.erase(a), a = 0;
}
cout << o.size() << '\n';
for (long long j : o) cout << j << ' ';
cout << '\n';
cout << rem.size() << '\n';
for (long long j : rem) cout << j << ' ';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3005;
vector<int> col[MAX];
int cnt = 0;
void solve() {
int n;
cin >> n;
vector<int> v(n + 1);
vector<vector<int>> dp(n + 1, vector<int>(n + 1));
for (int i = 1; i <= n; i++) col[i].clear();
for (int i = 1; i <= n; i++) {
cin >> v[i];
col[v[i]].push_back(i);
}
for (int lt = n; lt >= 1; lt--) {
for (int rt = lt; rt <= n; rt++) {
if (lt == rt) continue;
int a = dp[lt][rt - 1];
int b = dp[lt + 1][rt];
if (v[lt] != v[rt] && v[rt - 1] != v[rt]) a++;
if (v[lt] != v[lt + 1] && v[lt] != v[rt]) b++;
dp[lt][rt] = min(a, b);
int c = v[lt];
for (int i = 0; i < col[c].size(); i++) {
int x = col[c][i];
if (x <= lt) continue;
if (x >= rt) break;
dp[lt][rt] = min(dp[lt][rt], dp[lt][x] + dp[x + 1][rt] + 1);
}
c = v[rt];
for (int i = 0; i < col[c].size(); i++) {
int x = col[c][i];
if (x <= lt) continue;
if (x >= rt) break;
dp[lt][rt] = min(dp[lt][rt], dp[lt][x - 1] + dp[x][rt] + 1);
}
}
}
cout << dp[1][n] << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tt;
cin >> tt;
while (tt--) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 << 22;
const int oo = 1000000000;
int n, m, limit;
int a[maxn];
bool vis[maxn];
inline int read() {
int x = 0;
bool flag = false;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') flag = true;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return flag ? -x : x;
}
void dfs(int x) {
if (vis[x] == true) return;
vis[x] = true;
for (int i = 0; i < n; i++) {
if ((x & (1 << i)) == 0) continue;
dfs(x ^ (1 << i));
}
if (a[x] == true) dfs((1 << n) - 1 - x);
}
int main() {
n = read(), m = read(), limit = 1 << n;
for (int i = 1; i <= m; i++) a[read()] = true;
int ans = 0;
for (int i = 0; i < limit; i++) {
if (vis[i] == true || a[i] == false) continue;
dfs(limit - 1 - i);
ans++;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
class NTT {
long long mod;
int rootOrder;
long long root;
vector<long long> pw;
vector<vector<long long> > ca;
vector<int> rv;
long long qpowmod(long long a, long long b, long long mod) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
int rev(int num, int blen) {
int res = 0;
for (int i = 0; i < blen; i++) {
if (num & 1) res |= 1 << (blen - i - 1);
num >>= 1;
}
return res;
}
long long get_generator() {
vector<long long> fact;
long long phi = mod - 1;
long long t = mod - 1;
for (long long i = 2; i * i <= t; i++)
if (t % i == 0) {
fact.push_back(i);
while (t % i == 0) t /= i;
}
if (t) fact.push_back(t);
for (int i = 2;; i++) {
bool ok = true;
for (long long j : fact)
if (qpowmod(i, phi / j, mod) == 1) {
ok = false;
break;
}
if (ok) return i;
}
throw;
}
void init_rv(int n) {
int blen = 0;
while ((1 << blen) < n) blen++;
int len = 1 << blen;
if (rv.size() != len) {
rv.resize(len);
for (int i = 0; i < len; i++) rv[i] = rev(i, blen);
}
}
public:
NTT(long long mod, int maxlen) : mod(mod) {
rootOrder = 0;
while ((1 << rootOrder) < maxlen) rootOrder++;
long long k = 1LL << rootOrder;
assert((mod - 1) % k == 0);
long long g = get_generator();
root = qpowmod(g, (mod - 1) / k, mod);
pw.resize(rootOrder + 1);
pw[rootOrder] = root;
for (int i = rootOrder - 1; i >= 0; i--)
pw[i] = pw[i + 1] * pw[i + 1] % mod;
ca.resize(rootOrder);
for (int i = 1; i <= rootOrder; i++) {
int cur2 = 1 << (i - 1);
int cur = 1 << (i);
long long cn = pw[i];
long long c = 1;
ca[i - 1].resize(cur2);
for (int k = 0; k < cur2; k++) {
ca[i - 1][k] = c;
c = c * cn % MOD;
}
}
}
void transformInPlace(bool inverse, long long* p, int len) {
assert((len & (len - 1)) == 0);
init_rv(len);
int blen = 0;
while ((1 << blen) < len) blen++;
for (int i = 0; i < len; i++) {
int id = rv[i];
if (id < i) swap(p[i], p[id]);
}
for (int i = 1; i <= blen; i++) {
int cur2 = 1 << (i - 1);
int cur = 1 << (i);
for (int j = 0; j < len; j += cur) {
long long* chunk = &p[j];
for (int k = 0; k < cur2; k++) {
long long t = chunk[k + cur2] * ca[i - 1][k] % MOD;
chunk[k + cur2] = (chunk[k] + (MOD - t));
if (chunk[k + cur2] > MOD) chunk[k + cur2] -= MOD;
chunk[k] = (chunk[k] + t);
if (chunk[k] > MOD) chunk[k] -= MOD;
}
}
}
if (inverse) {
reverse(p + 1, p + len);
long long mul = qpowmod(len, mod - 2, mod);
for (int i = 0; i < len; i++) p[i] = p[i] * mul % mod;
}
}
vector<long long> transform(bool inverse, vector<long long> v) {
assert((v.size() & (v.size() - 1)) == 0);
transformInPlace(inverse, &v[0], v.size());
return v;
}
};
const int MAXN = 100000;
char buf[MAXN][5];
int cnt[2][3][2];
long long dp2[MAXN + 1][2][2];
bool fits(char* s, char* t) {
for (int i = 0; i < 2; i++)
if (s[i] != '?' && s[i] != t[i]) return false;
return true;
}
vector<long long>& operator*=(vector<long long>& a,
const vector<long long>& b) {
assert(a.size() == b.size());
for (int i = 0; i < a.size(); i++) a[i] = (a[i] * b[i]) % MOD;
return a;
}
vector<long long> ONE;
vector<long long> qpolypow(vector<long long> a, long long pw, NTT& ntt) {
vector<long long> res = ONE;
while (pw) {
if (pw & 1) res *= a;
a *= a;
pw /= 2;
}
return res;
}
vector<long long> poly[3];
int main() {
int n;
scanf("%d", &n);
int sz = 1;
while (sz < 2 * n + 1 || sz < 4) sz *= 2;
NTT ntt(MOD, sz);
for (int i = 0; i < n; i++) {
scanf("%s", buf[i]);
int coeff[3] = {};
if (fits(buf[i], "BB")) coeff[0]++;
if (fits(buf[i], "BW")) coeff[1]++;
if (fits(buf[i], "WB")) coeff[1]++;
if (fits(buf[i], "WW")) coeff[2]++;
cnt[coeff[0]][coeff[1]][coeff[2]]++;
}
vector<long long> res(sz);
res[0] = 1;
ntt.transformInPlace(false, &res[0], sz);
ONE = res;
for (int i = 0; i < 3; i++) {
poly[i].resize(sz);
poly[i][i] = 1;
ntt.transformInPlace(false, &poly[i][0], sz);
}
vector<long long> mul(sz);
for (int i = 0; i < 2; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 2; k++) {
int iarr[] = {i, j, k};
for (int i1 = 0; i1 < sz; i1++) {
mul[i1] = 0;
for (int j1 = 0; j1 < 3; j1++) mul[i1] += poly[j1][i1] * iarr[j1];
mul[i1] %= MOD;
}
res *= qpolypow(mul, cnt[i][j][k], ntt);
}
ntt.transformInPlace(true, &res[0], sz);
long long rescnt = 0L;
for (int i = 0; i <= 0; i++) {
int pos = n + i;
if (0 <= pos && pos < res.size()) rescnt += res[pos];
}
rescnt %= MOD;
dp2[0][0][0] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++) {
if (fits(buf[i], "BW"))
dp2[i + 1][1][k] = (dp2[i + 1][1][k] + dp2[i][j][k]) % MOD;
if (fits(buf[i], "WB"))
dp2[i + 1][j][1] = (dp2[i + 1][j][1] + dp2[i][j][k]) % MOD;
}
rescnt = (rescnt + MOD - dp2[n][1][1]) % MOD;
printf("%lld\n", rescnt);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char arr[105][105];
void fill_arr(int sx, int ex, int sy, int ey, char a) {
for (int i = sx; i < ex; i++)
for (int j = sy; j < ey; j++) arr[i][j] = a;
}
void print_arr(int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << arr[i][j];
cout << endl;
}
}
int main() {
int x1, y1, x2, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
map<int, int> m;
m[x1]++;
m[y1]++;
m[x2]++;
m[y2]++;
m[x3]++;
m[y3]++;
int area = x1 * y1 + x2 * y2 + x3 * y3;
int s = sqrt(area);
if (s * s == area && m[s] >= 1) {
cout << s << endl;
if ((x1 == s || y1 == s) && (x2 == s || y2 == s) && (x3 == s || y3 == s)) {
fill_arr(0, x1 + y1 - s, 0, s, 'A');
fill_arr(x1 + y1 - s, x2 + y2 - s + x1 + y1 - s, 0, s, 'B');
fill_arr(x2 + y2 - s + x1 + y1 - s, s, 0, s, 'C');
print_arr(s);
return 0;
} else {
if (x1 == s || y1 == s) {
fill_arr(0, x1 + y1 - s, 0, s, 'A');
fill_arr(x1 + y1 - s, s, 0, x2 + y2 - s + x1 + y1 - s, 'B');
fill_arr(x1 + y1 - s, s, x2 + y2 - s + x1 + y1 - s, s, 'C');
print_arr(s);
return 0;
}
if (x2 == s || y2 == s) {
fill_arr(0, x2 + y2 - s, 0, s, 'B');
fill_arr(x2 + y2 - s, s, 0, x1 + y1 - s + x2 + y2 - s, 'A');
fill_arr(x2 + y2 - s, s, x1 + y1 - s + x2 + y2 - s, s, 'C');
print_arr(s);
return 0;
}
if (x3 == s || y3 == s) {
fill_arr(0, x3 + y3 - s, 0, s, 'C');
fill_arr(x3 + y3 - s, s, 0, x2 + y2 - s + x3 + y3 - s, 'B');
fill_arr(x3 + y3 - s, s, x2 + y2 - s + x3 + y3 - s, s, 'A');
print_arr(s);
return 0;
}
}
} else {
cout << "-1";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double lower = 10.;
double upper = 100000000000.;
int N;
int a[1010];
int main() {
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> a[i];
double nupper = (10.0 * a[i] + 10) / i;
upper = min(upper, nupper);
if (a[i - 1] != (a[i] - 1)) {
double nlower = (10.0 * (a[i] - 1) + 10) / i;
lower = max(lower, nlower);
}
}
double lleft = lower * (N + 1) - a[N] * 10.0 + 1e-6;
double rleft = upper * (N + 1) - a[N] * 10.0 - 1e-6;
int lt = (int)(lleft / 10.0);
int rt = (int)(rleft / 10.0);
if (lt != rt) {
cout << "not unique";
} else {
cout << "unique" << endl;
cout << a[N] + lt;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, d[200001], p[200001];
vector<int> v[200001];
int find(int x) {
if (x != p[x]) p[x] = find(p[x]);
return p[x];
}
void un(int x, int y) {
x = find(x), y = find(y);
if (x < y)
p[x] = y;
else
p[y] = x;
}
int main() {
int x, y, i, j, f, ans = 0;
cin >> n >> m;
for (i = 1; i <= n; i++) p[i] = i;
for (i = 1; i <= m; i++) {
cin >> x >> y;
d[x]++;
d[y]++;
if (find(x) != find(y)) un(x, y);
}
for (i = 1; i <= n; i++) v[find(i)].push_back(i);
for (i = 1; i <= n; i++) {
if (v[i].size() < 3) continue;
f = 1;
for (j = 0; j < v[i].size(); j++)
if (d[v[i][j]] != 2) {
f = 0;
break;
}
if (f) ans++;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void checkMin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
inline void checkMax(T& a, T b) {
if (a < b) a = b;
}
const int MAX_N = 3010;
const int MOD = int(1e9 + 7);
int n, m;
char mp[MAX_N][MAX_N];
int w1[MAX_N][MAX_N], w2[MAX_N][MAX_N];
inline void add(int& a, int b) {
if ((a += b) >= MOD) {
a -= MOD;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> &mp[i][1];
}
w1[1][2] = mp[1][2] == '.', w2[2][1] = mp[2][1] == '.';
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (mp[i][j] == '.') {
add(w1[i][j], w1[i - 1][j]);
add(w1[i][j], w1[i][j - 1]);
add(w2[i][j], w2[i - 1][j]);
add(w2[i][j], w2[i][j - 1]);
}
}
}
long long ac = w1[n - 1][m], ad = w1[n][m - 1];
long long bc = w2[n - 1][m], bd = w2[n][m - 1];
long long ans = ac * bd % MOD + (MOD - ad * bc % MOD);
cout << ans % MOD << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void checkpoint1() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
bool comp(pair<long long, long long> &a, pair<long long, long long> &b) {
if (a.first != b.first)
return a.first < b.first;
else {
if (a.second > b.second)
return b.second < a.second;
else if (a.second < b.second)
return a.second < b.second;
}
return a.first > b.first;
}
int main() {
checkpoint1();
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
bool vis[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long ans = 0, temp = 0;
for (long long i = 0; i < n; i++) {
long long tot = a[i];
vis[i] = 1;
temp = 0;
for (long long j = i + 1; j < n; j++) {
temp = 0;
memset(vis, 0, sizeof(vis));
tot = a[i];
vis[i] = vis[j] = 1;
tot += a[j];
temp++;
ans = max(ans, temp);
long long ii = 0, jj = n - 1;
while (ii < jj) {
if (vis[ii]) {
ii++;
continue;
}
if (vis[jj]) {
jj--;
continue;
}
if (a[ii] + a[jj] == tot && vis[ii] == 0 && vis[jj] == 0) {
temp++;
vis[ii] = vis[jj] = 1;
ans = max(ans, temp);
}
if (tot < a[ii] + a[jj])
jj--;
else if (tot > a[ii] + a[jj])
ii++;
else {
if (vis[ii])
ii++;
else
jj--;
}
}
}
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
char str1[100040], str2[40];
int i, j, l1, l2, ind, total;
ind = 0;
total = 0;
scanf("%s", &str1);
scanf("%s", &str2);
l1 = strlen(str1);
l2 = strlen(str2);
for (i = 0; i < l1; i++) {
if (str1[i] != str2[ind]) {
if (ind != 0) {
i = i - ind;
ind = 0;
}
} else {
ind++;
if (ind == l2) {
total++;
ind = 0;
}
}
}
printf("%d\n", total);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct rec {
int x, t;
} a[100001];
int c[100001], b, n, m, v, j;
bool operator<(rec a, rec b) {
return (a.t * v - a.x < b.t * v - b.x ||
a.t * v - a.x == b.t * v - b.x && a.t * v + a.x < b.t * v + b.x);
}
signed main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].x >> a[i].t;
a[++n] = (rec){0, 0};
cin >> v;
sort(a + 1, a + n + 1);
for (int i = n; i > 0; i--) {
b = (-a[i].t * v - a[i].x);
j = upper_bound(c + 1, c + m + 1, b) - c;
if (!a[i].t && !a[i].x)
cout << j - 1 << " ";
else
c[j] = b, m = max(m, j);
}
cout << m;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e4 + 10;
struct Bottle {
int v, n;
} a[110];
int DP[110][MAX];
int main() {
int n, sum_n = 0, sum_v = 0, maxx = 0, num = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].n);
sum_n += a[i].n;
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].v);
sum_v += a[i].v;
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j; j--)
for (int k = sum_v; k >= a[i].v; k--)
if (DP[j - 1][k - a[i].v] || k == a[i].v)
DP[j][k] = max(DP[j][k], DP[j - 1][k - a[i].v] + a[i].n);
for (int i = 1; i <= n; i++) {
for (int j = sum_n; j <= sum_v; j++)
if (DP[i][j] > maxx) {
maxx = DP[i][j];
num = i;
}
if (maxx != 0) break;
}
printf("%d %d\n", num, sum_n - maxx);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adj;
int H[100050], parent[100050], sz[100050], L[100050 << 1], E[100050 << 1],
M[100050][20], SEG[(100050 << 3) + 15];
int n, timer;
int dfs(int node, int depth, int perr) {
sz[node] = 1;
H[node] = timer;
E[timer] = node;
L[timer++] = depth;
parent[node] = perr;
for (int i = 0; i < adj[node].size(); ++i) {
if (adj[node][i] != perr) {
sz[node] += dfs(adj[node][i], depth + 1, node);
E[timer] = node;
L[timer++] = depth;
}
}
return sz[node];
}
void buildKthParent() {
memset(M, -1, sizeof(M));
for (int i = 0; i < n; ++i) M[i][0] = parent[i];
for (int j = 1; (1 << j) < n; ++j)
for (int i = 1; i < n; ++i)
if (M[i][j - 1] != -1) M[i][j] = M[M[i][j - 1]][j - 1];
return;
}
void construct(int index, int st, int en) {
if (st == en) {
SEG[index] = st;
return;
}
if ((index << 1) + 2 < (100050 << 3)) {
int mid = st + ((en - st) >> 1);
construct((index << 1) + 1, st, mid);
construct((index << 1) + 2, mid + 1, en);
if (L[SEG[(index << 1) + 1]] < L[SEG[(index << 1) + 2]])
SEG[index] = SEG[(index << 1) + 1];
else
SEG[index] = SEG[(index << 1) + 2];
}
return;
}
int Query(int index, int Rs, int Re, int first, int last) {
if (Rs >= first and Re <= last) return SEG[index];
if (Re < first || Rs > last) return timer;
if ((index << 1) + 2 < (100050 << 3)) {
int mid = Rs + ((Re - Rs) >> 1);
int x = Query((index << 1) + 1, Rs, mid, first, last);
int y = Query((index << 1) + 2, mid + 1, Re, first, last);
if (L[x] < L[y]) return x;
return y;
}
return timer;
}
int LCA(int u, int v) {
int idx = Query(0, 0, timer - 1, H[u], H[v]);
return E[idx];
}
int getKthParent(int node, int kth) {
int lg = log2(L[H[node]]);
for (int i = lg; i > -1; --i)
while (L[H[node]] - (1 << i) >= kth) node = M[node][i];
return node;
}
int main() {
scanf("%d", &n);
adj.resize(n + 5);
for (int i = 1; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
adj[a - 1].push_back(b - 1);
adj[b - 1].push_back(a - 1);
}
dfs(0, 0, -1);
L[timer] = (1 << 30);
buildKthParent();
construct(0, 0, timer - 1);
int m;
scanf("%d", &m);
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
if (H[a] > H[b]) swap(a, b);
if (a == b) {
printf("%d\n", n);
continue;
}
int node = LCA(a, b);
int len = L[H[a]] + L[H[b]] - (L[H[node]] << 1);
if (len & 1)
printf("0\n");
else {
int ans;
if (L[H[a]] < L[H[b]]) swap(a, b);
len >>= 1;
--len;
int node1 = getKthParent(a, L[H[a]] - len);
int node2 = parent[node1];
if (node2 == node and L[H[node]] < L[H[a]] and L[H[node]] < L[H[b]]) {
int node3 = getKthParent(b, L[H[b]] - len);
ans = n - sz[node3] - sz[node1];
} else
ans = sz[node2] - sz[node1];
printf("%d\n", ans);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int t, n, a, b, k, c, G;
cin >> t;
vector<int> D[1000], T;
int A[1000], B[1000], g[1000], K[1000];
for (int i = 0; i < t; i++) {
cin >> n;
for (int y = 0; y < n; y++) {
A[y] = 0;
B[y] = 0;
g[y] = 1;
}
for (int y = 0; y < n - 1; y++) {
cin >> a >> b;
a--;
b--;
D[a].push_back(b);
D[b].push_back(a);
}
cin >> k;
for (int y = 0; y < k; y++) {
cin >> a;
a--;
A[a] = 1;
}
cin >> k;
for (int y = 0; y < k; y++) {
cin >> K[y];
K[y]--;
}
cout << "B " << K[0] + 1 << endl;
cin >> c;
c--;
T.push_back(c);
for (int y = 0; y < T.size(); y++) {
if (A[T[y]] == 1) {
cout << "A " << T[y] + 1 << endl;
cin >> c;
c--;
G = 0;
for (int u = 0; u < k; u++) {
if (K[u] == c) {
G = 1;
cout << "C " << T[y] + 1 << endl;
}
}
if (G == 0) {
cout << "C " << -1 << endl;
}
y = T.size() + 1;
} else {
for (int u = 0; u < D[T[y]].size(); u++) {
if (g[D[T[y]][u]] == 1) {
g[D[T[y]][u]] = 0;
T.push_back(D[T[y]][u]);
}
}
}
}
for (int y = 0; y < 1000; y++) {
D[y].clear();
}
T.clear();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int max(long long int a, long long int b) {
if (a >= b) return a;
return b;
}
int main() {
long long int end, temp = 0, start = -1, n, t, M = 1000000000, mx = 0;
cin >> n;
long long int arr[n], brr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
brr[i] = 0;
if (M >= arr[i]) {
end = i;
M = arr[i];
}
}
for (int i = 0; i < n; i++) {
if (arr[i] == M) {
if (start == -1) start = i;
brr[i] = 1;
}
}
mx = max((start + n - end - 1), mx);
temp = start;
for (int i = start; i <= end; i++) {
if (arr[i] == M) {
mx = max(mx, i - temp - 1);
temp = i;
}
}
cout << (mx + M * n);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << ' ' << H;
debug_out(T...);
}
const unsigned long long INF = 1e9;
const unsigned long long MOD = 1e9 + 7;
const int N = 4e2 + 2;
int DP[N][N];
int MAIN() {
string s, t;
cin >> s >> t;
int n = (int)(s.size()), m = (int)(t.size());
for (int k = 0; k <= m; k++) {
string a = t.substr(0, k), b = t.substr(k);
memset(DP, -1, sizeof DP);
DP[0][0] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j <= k; j++) {
DP[i + 1][j] =
max(DP[i + 1][j], DP[i][j] + (DP[i][j] >= 0 && DP[i][j] < m - k &&
s[i] == b[DP[i][j]]));
if (j < k && s[i] == a[j])
DP[i + 1][j + 1] = max(DP[i + 1][j + 1], DP[i][j]);
}
if (DP[n][k] == m - k) return cout << "YES" << '\n', 0;
}
return cout << "NO" << '\n', 0;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) MAIN();
return 0;
}
| 7 |
#include <bits/stdc++.h>
namespace FastRead {
char __buff[5000];
int __lg = 0, __p = 0;
char nc() {
if (__lg == __p) {
__lg = fread(__buff, 1, 5000, stdin);
__p = 0;
if (!__lg) return EOF;
}
return __buff[__p++];
}
template <class T>
void read(T &__x) {
T __sgn = 1;
char __c;
while (!isdigit(__c = nc()))
if (__c == '-') __sgn = -1;
__x = __c - '0';
while (isdigit(__c = nc())) __x = __x * 10 + __c - '0';
__x *= __sgn;
}
} // namespace FastRead
using namespace FastRead;
using namespace std;
const int N = 3e5 + 10;
const int M = 1e9 + 7;
const long double PI = acos(-1);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n;
int A[N], P[N];
struct Trie {
Trie *child[2];
int cnt;
Trie() {
child[0] = child[1] = NULL;
cnt = 0;
}
void insert(int x, int bit, Trie *T) {
if (bit == -1) return T->cnt++, void();
int b = x >> bit & 1;
if (T->child[b] == NULL) T->child[b] = new Trie;
insert(x, bit - 1, T->child[b]);
}
int query(int x, int bit, Trie *T) {
if (bit == -1) return 0;
int b = x >> bit & 1;
if (T->child[b] == NULL)
return (1 << bit) * (!b) + query(x, bit - 1, T->child[!b]);
else
return (1 << bit) * b + query(x, bit - 1, T->child[b]);
}
bool erase(int x, int bit, Trie *T) {
if (bit == -1) {
--T->cnt;
if (!T->cnt) {
delete T;
return 1;
}
return 0;
} else {
int b = x >> bit & 1;
int v = erase(x, bit - 1, T->child[b]);
if (v) T->child[b] = NULL;
if (v && T->child[!b] == NULL) {
delete T;
return 1;
}
return 0;
}
}
} *T = new Trie;
signed main() {
int i;
cin >> n;
for (i = 1; i <= n; i++) cin >> A[i];
for (i = 1; i <= n; i++) cin >> P[i], T->insert(P[i], 29, T);
for (i = 1; i <= n; i++) {
int x = T->query(A[i], 29, T);
T->erase(x, 29, T);
int v = 0;
for (int bit = 29; bit >= 0; bit--)
if (A[i] >> bit & 1) {
if (x >> bit & 1)
;
else
v += (1 << bit);
} else {
if (x >> bit & 1) v += (1 << bit);
}
cout << v << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int frpqs[26];
int main() {
string s;
cin >> s;
if (s == "AABCDEFGHIJKLMNOPQRSTUVWXYZ") return 0;
for (auto &c : s) frpqs[c - 'A']++;
char the_hollychar;
for (int i = 0; i < 26; i++)
if (frpqs[i] > 1) {
the_hollychar = i + 'A';
}
while (s[0] != the_hollychar) {
s = s.substr(1) + s[0];
}
int thedisrabce = 1;
while (s[thedisrabce] != the_hollychar) thedisrabce++;
if (thedisrabce == 1) {
cout << "Impossible\n";
return 0;
}
thedisrabce--;
char ans[2][15] = {0};
int theposition = thedisrabce / 2;
int r = 0;
ans[r][theposition] = the_hollychar;
s = s.substr(1);
while (s[0] != the_hollychar) {
if (r == 1) {
theposition++;
} else {
if (theposition == 0)
r = 1;
else
theposition--;
}
ans[r][theposition] = s[0];
s = s.substr(1);
}
s = s.substr(1);
theposition = thedisrabce / 2;
r = 0;
while (!s.empty()) {
if (r == 1) {
theposition--;
} else {
if (theposition == 12)
r = 1;
else
theposition++;
}
ans[r][theposition] = s[0];
if (s.size() == 1) break;
s = s.substr(1);
}
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 13; j++) {
cout << ans[i][j];
}
cout << endl;
}
}
| 4 |
#include<bits/stdc++.h>
#include<time.h>
#include<string>
#include<math.h>
#include<cmath>
#include<algorithm>
using namespace std;
#define ll long long int
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--){
ll n;
cin>>n;
ll sum = 0;
int a[n];
for(int i = 0; i<n; i++){
cin>>a[i];
sum += a[i];
}
ll r = sum%n;
cout<<(n-r)*r<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 2000000000;
const long long BIG = 1446803456761533460LL;
const int maxn = 100010;
const int second = 1300;
int n, q, m, bn, A[maxn], qs[maxn][3], comp[maxn * 2];
struct Block {
int fen[maxn], cnt[maxn * 2];
void update(int i, int v) {
for (++i; i < maxn; i += i & -i) fen[i] += v;
}
int get(int i) {
int v = 0;
for (++i; i; i ^= i & -i) v += fen[i];
return v;
}
void change(int x, int d) {
update(cnt[x], -1);
cnt[x] += d;
update(cnt[x], 1);
}
int atleast(int x) { return m - get(x - 1); }
} block[maxn / second + 5];
int getid(int x) { return lower_bound(comp, comp + m, x) - comp; }
void change(int p, int x, int d) {
for (int i = p / second + 1; i < bn; ++i) {
block[i].change(x, d);
}
}
int getA2(int p) {
++p;
int ii = p / second;
for (int i = ii * second; i < p; ++i) block[ii].cnt[A[i]]++;
int res = block[ii].cnt[A[p - 1]];
for (int i = ii * second; i < p; ++i) block[ii].cnt[A[i]]--;
return res;
}
int getA3(int p) {
int c = getA2(p);
++p;
int ii = p / second;
int res = block[ii].atleast(c);
for (int i = ii * second; i < p; ++i)
if (++block[ii].cnt[A[i]] == c) ++res;
for (int i = ii * second; i < p; ++i) block[ii].cnt[A[i]]--;
return res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> A[i];
comp[i] = A[i];
}
m = n;
cin >> q;
for (int i = 0; i < q; ++i) {
cin >> qs[i][0] >> qs[i][1] >> qs[i][2];
if (qs[i][0] == 1) comp[m++] = qs[i][1];
}
sort(comp, comp + m);
m = unique(comp, comp + m) - comp;
bn = n / second + 1;
for (int i = 0; i < bn; ++i) block[i].update(0, m);
for (int i = 0; i < n; ++i) {
A[i] = getid(A[i]);
change(i, A[i], 1);
}
for (int i = 0; i < q; ++i) {
if (qs[i][0] == 1) {
int p = qs[i][2] - 1;
int v = getid(qs[i][1]);
change(p, A[p], -1);
A[p] = v;
change(p, A[p], 1);
} else if (qs[i][1] == 1) {
cout << comp[A[qs[i][2] - 1]] << '\n';
} else if (qs[i][1] % 2 == 0) {
cout << getA2(qs[i][2] - 1) << '\n';
} else {
cout << getA3(qs[i][2] - 1) << '\n';
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<long long, string> Map;
unordered_map<long long, string>::iterator it;
string Get(long long x) {
string ans = "";
int s[13], cnt = 0;
while (x) {
s[++cnt] = x % 10;
x /= 10;
}
for (int i = cnt; i >= 1; i--) ans += char(s[i] + '0');
return ans;
}
int main() {
long long n;
scanf("%lld", &n);
long long len = sqrt(n);
for (long long i = 2; i <= len; i++) {
for (long long j = i * i, k = 2; j <= n; j *= i, k++) {
string gg = Get(i) + "^" + Get(k);
if (gg.size() >= Get(j).size()) continue;
if (Map[j].size() == 0) {
Map[j] = gg;
} else if (Map[j].size() > gg.size())
Map[j] = gg;
}
}
string ans = Get(n);
for (it = Map.begin(); it != Map.end(); it++) {
long long k = (*it).first;
string gg = (*it).second;
if (n / k >= 2) {
gg += "*";
gg += (Map.count(n / k)) ? Map[n / k] : Get(n / k);
}
if (n % k) {
gg += "+";
gg += (Map.count(n % k)) ? Map[n % k] : Get(n % k);
}
if (ans.size() > gg.size()) ans = gg;
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline void Rd(int &res) {
char c;
res = 0;
while (c = getchar(), c < '0')
;
do {
res = (res << 1) + (res << 3) + (c ^ 48);
} while (c = getchar(), c >= '0');
}
const int M = 2005;
int n, A[M], sum[3][M], suf[M];
int main() {
Rd(n);
for (int i = 1; i <= n; i++) Rd(A[i]);
for (int i = 1; i <= n; i++) {
sum[1][i] = sum[1][i - 1];
sum[2][i] = sum[2][i - 1];
sum[A[i]][i]++;
}
int ans = 0;
for (int i = 0; i <= n; i++)
ans = max(ans, sum[1][i] + sum[2][n] - sum[2][i]);
for (int i = 1; i <= n; i++)
for (int j = i - 1; j <= n; j++)
suf[i] = max(suf[i], sum[1][j] - sum[1][i - 1] + sum[2][n] - sum[2][j]);
for (int i = 1; i <= n; i++) {
int pre12 = 0;
for (int j = 0; j < i; j++)
pre12 = max(pre12, sum[1][j] + sum[2][i - 1] - sum[2][j]);
int tmp = sum[2][i - 1] - sum[1][i - 1];
for (int j = i; j <= n; j++) {
int l1 = sum[1][j] - sum[1][i - 1];
int l2 = sum[2][j] - sum[2][i - 1];
tmp = max(tmp, sum[2][j] - sum[1][j]);
int l21 = sum[1][j] - sum[2][i - 1] + tmp;
ans = max(ans, pre12 + l2 + sum[2][n] - sum[2][j]);
ans = max(ans, sum[1][i - 1] + l21 + sum[2][n] - sum[2][j]);
ans = max(ans, sum[1][i - 1] + l1 + suf[j + 1]);
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int main() {
long long n, c1, c2, c3, sum;
cin >> n;
cout << "? " << 1 << ' ' << 2 << "\n";
fflush(stdout);
cin >> sum;
c1 = sum;
cout << "? " << 3 << ' ' << 2 << "\n";
fflush(stdout);
cin >> sum;
c2 = sum;
cout << "? " << 1 << ' ' << 3 << "\n";
fflush(stdout);
cin >> sum;
c3 = sum;
vector<long long> v;
v.push_back((-c2 + c1 + c3) / 2);
v.push_back((c2 + c1 - c3) / 2);
v.push_back((c2 - c1 + c3) / 2);
long long st = v[0], r = 4;
while ((long long)v.size() < n) {
cout << "? " << 1 << ' ' << r++ << "\n";
fflush(stdout);
cin >> sum;
v.push_back(sum - st);
}
cout << "! ";
for (long long i = 0; i < (long long)v.size(); i++) {
cout << v[i] << ' ';
}
cout << "\n";
fflush(stdout);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 3e5 + 100;
int a[N], ans[N];
vector<pair<int, int>> q[N];
struct Node {
int l, r, len;
long long sum, lazy;
} tree[N << 2];
void pushup(int k) { tree[k].sum = tree[k << 1].sum + tree[k << 1 | 1].sum; }
void pushdown(int k) {
if (tree[k].lazy) {
long long lz = tree[k].lazy;
tree[k].lazy = 0;
tree[k << 1].sum += tree[k << 1].len * lz;
tree[k << 1 | 1].sum += tree[k << 1 | 1].len * lz;
tree[k << 1].lazy += lz;
tree[k << 1 | 1].lazy += lz;
}
}
void build(int k, int l, int r) {
tree[k].l = l;
tree[k].r = r;
tree[k].len = r - l + 1;
tree[k].sum = tree[k].lazy = 0;
if (l == r) return;
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
pushup(k);
}
void update(int k, int l, int r) {
if (l > r) return;
if (tree[k].l > r || tree[k].r < l) return;
if (tree[k].l >= l && tree[k].r <= r) {
tree[k].sum += tree[k].len;
tree[k].lazy++;
return;
}
pushdown(k);
update(k << 1, l, r);
update(k << 1 | 1, l, r);
pushup(k);
}
long long query(int k, int pos) {
if (tree[k].l == tree[k].r) return tree[k].sum;
pushdown(k);
int mid = tree[k].l + tree[k].r >> 1;
if (pos <= mid)
return query(k << 1, pos);
else
return query(k << 1 | 1, pos);
}
int get_pos(int i) {
int l = 1, r = i, ans = -1;
while (l <= r) {
int mid = l + r >> 1;
if (query(1, mid) >= a[i]) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
return ans;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
a[i] = i - a[i];
if (a[i] < 0) a[i] = inf;
}
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
l++;
r = n - r;
q[r].emplace_back(l, i);
}
build(1, 1, n);
for (int i = 1; i <= n; i++) {
int pos = get_pos(i);
update(1, 1, pos);
for (int j = 0; j < q[i].size(); j++)
ans[q[i][j].second] = query(1, q[i][j].first);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, t;
cin >> n >> t;
long long int a[n];
long long int maxx = 0;
long long int minn = 1000000000000;
long long int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > maxx) maxx = a[i];
if (a[i] < minn) minn = a[i];
sum += a[i];
}
long long int temp = t - maxx;
long long int q = temp / sum;
long long int rem = (temp % sum) + maxx;
long long int tc = q * n;
while (rem > sum) {
temp = rem;
q = temp / sum;
rem = (temp % sum);
tc += q * n;
}
long long int tot = 0;
long long int i = 0;
while (rem >= minn) {
sum = 0;
int coun = 0;
for (int i = 0; i < n; i++) {
if (rem >= a[i]) {
rem -= a[i];
tc++;
coun++;
sum += a[i];
}
}
while (rem > sum) {
q = rem / sum;
temp = rem;
rem = temp % sum;
tc += (q * coun);
}
}
cout << tc << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, show = 1, t = 0;
cin >> d >> n;
vector<int> M(n + 1);
for (int i = 1; i <= (n); ++i) cin >> M[i];
for (int i = 1; i <= (n - 1); ++i) {
show += M[i];
t += d - show + 1;
show = 1;
}
cout << (t) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int INF = 1000000007;
string FILENAME = "input";
string FILEINPUT = FILENAME;
void writeln(int a) { printf("%d\n", a); }
void writeln(int a, int b) { printf("%d %d\n", a, b); }
void writeln(int a, int b, int c) { printf("%d %d %d\n", a, b, c); }
void writeln(int a, int b, int c, int d) {
printf("%d %d %d %d\n", a, b, c, d);
}
void write(int a) { printf("%d", a); }
void write(int a, int b) { printf("%d %d", a, b); }
void write(int a, int b, int c) { printf("%d %d %d", a, b, c); }
void write(int a, int b, int c, int d) { printf("%d %d %d %d", a, b, c, d); }
void read(int &a) { scanf("%d", &a); }
void read(int &a, int &b) { scanf("%d %d", &a, &b); }
void read(int &a, int &b, int &c) { scanf("%d %d %d", &a, &b, &c); }
void read(int &a, int &b, int &c, int &d) {
scanf("%d %d %d %d", &a, &b, &c, &d);
}
void readln(int &a) { scanf("%d\n", &a); }
void readln(int &a, int &b) { scanf("%d %d\n", &a, &b); }
void readln(int &a, int &b, int &c) { scanf("%d %d %d\n", &a, &b, &c); }
void readln(int &a, int &b, int &c, int &d) {
scanf("%d %d %d %d\n", &a, &b, &c, &d);
}
void readln(vector<int> &f, int n) {
int x;
for (int i = 1; i <= n; i++) {
read(x);
f.push_back(x);
}
}
void writeln(vector<int> &f) {
for (int i = 0; i < f.size(); i++)
printf("%d%c", f[i], i == f.size() - 1 ? '\n' : ' ');
}
void run() {
int n;
vector<int> a;
read(n);
readln(a, n);
sort(a.begin(), a.end());
int i = -1, j = 0, t, mx = 0;
read(t);
while (j != n) {
i++;
while (j < n && a[j] - a[i] <= t) j++;
mx = max(mx, j - i);
}
writeln(mx);
}
int main() {
run();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, t, k, m, a[4000] = {0}, ans = 0;
int main() {
scanf("%d %d", &n, &t);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
if (a[i - 1] >= a[i]) {
k = a[i - 1] - a[i] + 1;
m = k / t;
if (k % t == 0) {
a[i] += m * t;
ans += m;
} else {
a[i] += m * t + t;
ans += m + 1;
}
}
}
printf("%d", ans);
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.