solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int V = 3010;
struct Point {
int x, y;
};
struct Rec {
Point a, b;
} a[100100];
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int mx[V][V][4];
bool dr[V][V][4];
Point ls[V];
int ret[100100];
int cl[V][V], s[V][V];
int sum(int lx, int ly, int l) {
int rx = lx + l;
int ry = ly + l;
return s[rx][ry] + s[lx][ly] - s[lx][ry] - s[rx][ly];
}
int va[V];
struct Node {
int l, r, id;
} tr[V * 4];
void init(int id, int l, int r) {
tr[id].l = l;
tr[id].r = r;
if (l == r) {
tr[id].id = l;
return;
}
int mid = (l + r) / 2;
init(id * 2, l, mid);
init(id * 2 + 1, mid + 1, r);
if (va[tr[id * 2].id] < va[tr[id * 2 + 1].id])
tr[id].id = tr[id * 2].id;
else
tr[id].id = tr[id * 2 + 1].id;
}
int Min(int id, int l, int r) {
if (tr[id].l == l && tr[id].r == r) return tr[id].id;
int mid = (tr[id].l + tr[id].r) / 2;
if (r <= mid)
return Min(id * 2, l, r);
else if (l > mid)
return Min(id * 2 + 1, l, r);
else {
int a = Min(id * 2, l, mid);
int b = Min(id * 2 + 1, mid + 1, r);
if (va[a] < va[b])
return a;
else
return b;
}
}
int m, sa[V];
int main() {
while (~scanf("%d", &m)) {
int n = 3001;
memset(dr, 0, sizeof(dr));
memset(cl, 0, sizeof(cl));
memset(s, 0, sizeof(s));
for (int i = 0; i < m; i++) {
scanf("%d%d%d%d", &a[i].a.x, &a[i].a.y, &a[i].b.x, &a[i].b.y);
for (int j = a[i].a.x; j < a[i].b.x; j++)
dr[j][a[i].a.y][1] = 1, dr[j][a[i].b.y][1] = 1;
for (int j = a[i].a.x + 1; j <= a[i].b.x; j++)
dr[j][a[i].a.y][3] = 1, dr[j][a[i].b.y][3] = 1;
for (int j = a[i].a.y; j < a[i].b.y; j++)
dr[a[i].a.x][j][0] = 1, dr[a[i].b.x][j][0] = 1;
for (int j = a[i].a.y + 1; j <= a[i].b.y; j++)
dr[a[i].a.x][j][2] = 1, dr[a[i].b.x][j][2] = 1;
for (int j = a[i].a.x + 1; j <= a[i].b.x; j++)
for (int k = a[i].a.y + 1; k <= a[i].b.y; k++) cl[j][k] = 1;
}
for (int i = 1; i < n; i++)
for (int j = 0; j < n; j++)
s[i][j] = s[i][j - 1] + s[i - 1][j] + cl[i][j] - s[i - 1][j - 1];
for (int x = 0; x < n; x++) {
mx[x][0][2] = 0;
for (int y = 1; y < n; y++)
if (dr[x][y][2])
mx[x][y][2] = mx[x][y - 1][2] + 1;
else
mx[x][y][2] = 0;
mx[x][n - 1][0] = 0;
for (int y = n - 2; y >= 0; y--)
if (dr[x][y][0])
mx[x][y][0] = mx[x][y + 1][0] + 1;
else
mx[x][y][0] = 0;
}
for (int y = 0; y < n; y++) {
mx[0][y][3] = 0;
for (int x = 1; x < n; x++)
if (dr[x][y][3])
mx[x][y][3] = mx[x - 1][y][3] + 1;
else
mx[x][y][3] = 0;
mx[n - 1][y][1] = 0;
for (int x = n - 2; x >= 0; x--)
if (dr[x][y][1])
mx[x][y][1] = mx[x + 1][y][1] + 1;
else
mx[x][y][1] = 0;
}
int lx = -1, ly = -1, rx = -1, ry = -1;
for (int ds = n - 1; ds >= -(n - 1); ds--) {
if (lx != -1) break;
int nx, ny;
if (ds >= 0)
nx = 0, ny = ds;
else
ny = 0, nx = -ds;
int t = 0;
for (int i = 0;; i++) {
if (nx + i >= n || ny + i >= n) break;
ls[t].x = nx + i;
ls[t++].y = ny + i;
}
sa[0] = 0;
while (sum(ls[0].x, ls[0].y, sa[0] + 1) == (sa[0] + 1) * (sa[0] + 1))
sa[0]++;
for (int i = 1; i < t; i++) {
sa[i] = max(0, sa[i - 1] - 1);
while (sum(ls[i].x, ls[i].y, sa[i] + 1) == (sa[i] + 1) * (sa[i] + 1))
sa[i]++;
}
for (int i = 0; i < t; i++) {
va[i] = i - min(mx[ls[i].x][ls[i].y][2], mx[ls[i].x][ls[i].y][3]);
}
init(1, 0, t - 1);
for (int i = 0; i < t; i++) {
int d =
min(sa[i], min(mx[ls[i].x][ls[i].y][0], mx[ls[i].x][ls[i].y][1]));
if (d == 0) continue;
int id = Min(1, i + 1, i + d);
if (va[id] <= i) {
lx = ls[i].x;
ly = ls[i].y;
rx = ls[id].x;
ry = ls[id].y;
break;
}
}
}
if (lx == -1)
puts("NO");
else {
int t = 0;
for (int i = 0; i < m; i++)
if (a[i].a.x >= lx && a[i].a.x <= rx && a[i].a.y >= ly &&
a[i].a.y <= ry && a[i].b.x >= lx && a[i].b.x <= rx &&
a[i].b.y >= ly && a[i].b.y <= ry) {
ret[t++] = i + 1;
}
printf("YES %d\n", t);
for (int i = 0; i < t; i++) printf("%d ", ret[i]);
puts("");
}
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
long long dp[200005][3], res[200005];
pair<long long, long long> a[200005];
void solve() {
long long q;
cin >> q;
for (long long i = 0; i < q; ++i) {
long long n;
string s, t;
cin >> n >> s >> t;
vector<long long> cnts(26), cntt(26);
for (long long j = 0; j < n; ++j) {
++cnts[s[j] - 'a'];
++cntt[t[j] - 'a'];
}
bool ok = true;
bool good = false;
for (long long j = 0; j < 26; ++j) {
ok &= cnts[j] == cntt[j];
good |= cnts[j] > 1;
}
if (!ok) {
cout << "NO" << endl;
continue;
}
if (good) {
cout << "YES" << endl;
continue;
}
long long invs = 0, invt = 0;
for (long long l = 0; l < n; ++l) {
for (long long r = 0; r < l; ++r) {
invs += s[l] > s[r];
invt += t[l] > t[r];
}
}
ok &= (invs & 1) == (invt & 1);
if (ok)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s = "";
long long n;
cin >> n;
while (1) {
s += "47";
sort(s.begin(), s.end());
do {
if (stoll(s) >= n) {
cout << stoll(s) << '\n';
return 0;
}
} while (next_permutation(s.begin(), s.end()));
}
}
| 5
|
#include <bits/stdc++.h>
int main() {
long long int test, t, n, k1, k2, a[100], b[100], i, j;
scanf("%lld", &test);
for (t = 0; t < test; t++) {
scanf("%lld %lld %lld", &n, &k1, &k2);
for (i = 0; i < k1; i++) {
scanf("%lld", &a[i]);
if (a[i] == n) j = 0;
}
for (i = 0; i < k2; i++) {
scanf("%lld", &b[i]);
if (b[i] == n) j = 1;
}
if (j == 0)
printf("YES\n");
else
printf("NO\n");
}
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30005;
int d, m, n, lm, i, j, b[N], gen[25];
long long L, R;
struct atom {
bitset<N> pr, sf, all;
long long ans, l;
void set(int v) {
if (v <= b[n]) pr.set(n);
if (v <= b[1]) sf.set(1);
for (int i = 1; i <= n; ++i)
if (v <= b[i]) all.set(i);
ans = n == 1 && v <= b[1];
l = 1;
}
} a[65][65];
inline atom uni(const atom& a, const atom& b) {
static atom ret;
ret.l = a.l + b.l;
ret.pr = a.pr;
if (a.l < n) ret.pr |= (a.all << a.l & b.pr) >> a.l;
ret.sf = b.sf;
if (b.l < n) ret.sf |= (b.all >> 1 & a.sf) << b.l;
if (a.l + b.l <= n)
ret.all = b.all >> a.l & a.all;
else
ret.all.reset();
ret.ans = a.ans + b.ans + (a.sf << 1 & b.pr).count();
return ret;
}
inline long long calc(long long x) {
long long y = 0, pr = 0;
static atom ans;
bool fl = 0;
ans.ans = 0;
for (i = lm - 1; i >= 0; --i) {
for (j = 0; y + a[i][(pr + gen[j]) % m].l <= x; ++j) {
if (!fl)
ans = a[i][(pr + gen[j]) % m], fl = 1;
else
ans = uni(ans, a[i][(pr + gen[j]) % m]);
y += a[i][(pr + gen[j]) % m].l;
}
pr = (pr + gen[j]) % m;
}
return ans.ans;
}
int main() {
scanf("%d%d", &d, &m);
for (i = 0; i < d; ++i) scanf("%d", gen + i);
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", b + i);
scanf("%lld%lld", &L, &R);
for (i = 0; i < m; ++i) a[0][i].set(i);
for (lm = 1; a[lm - 1][0].l <= R / d; ++lm)
for (i = 0; i < m; ++i) {
a[lm][i] = a[lm - 1][(i + gen[0]) % m];
for (j = 1; j < d; ++j)
a[lm][i] = uni(a[lm][i], a[lm - 1][(i + gen[j]) % m]);
}
printf("%lld\n", calc(R) - calc(L + n - 2));
return 0;
}
| 26
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long m, n;
string str, ptr;
str = "qwertyuiopasdfghjkl;zxcvbnm,./";
char c;
cin >> c;
cin >> ptr;
m = ptr.length();
if (c == 'R') {
for (long long i = 0; i < m; i++) {
for (long long j = 0; j < 30; j++) {
if (ptr[i] == str[j]) {
cout << str[j - 1];
}
}
}
} else {
for (long long i = 0; i < m; i++) {
for (long long j = 0; j < 30; j++) {
if (ptr[i] == str[j]) {
cout << str[j + 1];
}
}
}
}
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
const int mod = 1000000007;
const double pi = (double)22 / 7;
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
if (k > n || (k == 1 && n != 1)) return cout << -1, 0;
string ans = "";
n -= k;
bool flag = 0;
while (n > 0) {
if (n > 1) {
cout << "ab";
n -= 2;
} else {
cout << 'a';
n--;
flag = 1;
}
}
if (flag) {
if (k > 1) {
ans += "ba";
k -= 2;
int c = 2;
for (int i = 0; i < k; i++, c++) ans += char('a' + c);
} else {
ans += 'a';
k--;
}
} else {
for (int i = 0; i < k; i++) ans += char('a' + i);
}
cout << ans;
}
| 5
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
using li = long long;
using ld = long double;
void solve(bool);
void precalc();
clock_t start;
int main() {
start = clock();
int t = 1;
cout.sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
cout << fixed;
precalc();
while (t--) {
solve(true);
}
cout.flush();
return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
if (!w) return 1 % mod;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
template <typename T>
T gcd(T q, T w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
template <typename T>
T lcm(T q, T w) {
return q / gcd(q, w) * w;
}
template <typename T>
void make_unique(vector<T>& vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
template <typename T>
void relax_min(T& cur, T val) {
cur = min(cur, val);
}
template <typename T>
void relax_max(T& cur, T val) {
cur = max(cur, val);
}
mt19937 rng(
(unsigned long long)chrono::steady_clock::now().time_since_epoch().count());
void precalc() {}
const li mod = 998244353;
vector<vector<li>> g;
vector<li> order;
vector<li> parent;
vector<li> cnt;
void dfs(li v, li p) {
parent[v] = p;
cnt[v] = 1;
order.push_back(v);
for (li to : g[v]) {
if (to == p) {
continue;
}
dfs(to, v);
cnt[v] += cnt[to];
}
}
struct Query {
li type, v;
li d;
};
struct SqrtParent {
li far_parent;
li pred_parent;
};
void add(li& cur, li val) { cur = (cur + val) % mod; }
void simple_add(li& cur, li val) {
cur += val;
if (cur >= mod) {
cur -= mod;
}
}
li my_rand() { return (rand() << 16) | rand(); }
void solve(__attribute__((unused)) bool read) {
li n, Q;
g.clear();
order.clear();
if (read) {
cin >> n >> Q;
} else {
n = my_rand() % 1000 + 1;
Q = my_rand() % 1000 + 1;
n = 150000;
Q = 150000;
}
g.resize(n);
for (li i = 1; i < n; ++i) {
li a, b;
if (read) {
cin >> a >> b;
--a;
--b;
} else {
a = i;
b = my_rand() % i;
b = i - 1;
}
g[a].push_back(b);
g[b].push_back(a);
}
parent.assign(n, -1);
cnt.assign(n, 0);
dfs(0, -1);
vector<Query> qs(Q);
for (li i = 0; i < Q; ++i) {
if (read) {
cin >> qs[i].type >> qs[i].v;
--qs[i].v;
} else {
qs[i].type = 1 + my_rand() % 2;
qs[i].v = my_rand() % n;
}
if (qs[i].type == 1) {
if (read) {
cin >> qs[i].d;
} else {
qs[i].d = my_rand() % (li)1e7;
}
}
}
vector<li> pos_in_order(n);
for (li i = 0; i < order.size(); ++i) {
pos_in_order[order[i]] = i;
}
for (li i = 0; i < n; ++i) {
auto it = find(g[i].begin(), g[i].end(), parent[i]);
if (it != g[i].end()) {
g[i].erase(it);
}
}
li block_size = max(1LL, (li)sqrt(max(n, Q)) * 2);
vector<li> vs;
li TIMER = 0;
vector<li> used(n);
vector<SqrtParent> sqrt_parents(n, {-1, -1});
vector<li> sum_inner_queries(n, 0);
vector<li> pushed_queries(n, 0);
li global_add = 0;
vector<li> add_by_vertex(n, 0);
li rev_n = binpow(n, mod - 2, mod);
vector<li> mults(n, 0);
for (li i = 0; i < n; ++i) {
if (parent[i] != -1) {
mults[i] = (n - cnt[parent[i]] - cnt[i]) * rev_n % mod;
if (mults[i] < 0) {
mults[i] += mod;
}
}
}
for (li w = 0; w < Q; w += block_size) {
++TIMER;
li border = min(w + block_size, Q);
vs.clear();
vs.push_back(0);
for (li i = w; i < border; ++i) {
vs.push_back(qs[i].v);
}
sort(vs.begin(), vs.end(),
[&](li q, li w) { return pos_in_order[q] < pos_in_order[w]; });
vs.erase(unique(vs.begin(), vs.end()), vs.end());
for (li v : vs) {
used[v] = TIMER;
}
for (li v : order) {
li far_parent = sqrt_parents[v].far_parent;
li pred_parent = sqrt_parents[v].pred_parent;
if (used[v] == TIMER) {
far_parent = v;
pred_parent = v;
}
for (li to : g[v]) {
sqrt_parents[to] = {far_parent, (far_parent == v) ? to : pred_parent};
}
}
for (li i = w; i < border; ++i) {
li v = qs[i].v;
if (qs[i].type == 1) {
li d = qs[i].d;
add(global_add, cnt[v] * d % mod * rev_n);
add(add_by_vertex[v], (n - cnt[v]) * d % mod * rev_n);
add(sum_inner_queries[v], d);
} else {
li cur_res = (global_add + add_by_vertex[v]) % mod;
li pred = v;
while (pred != 0) {
li par = sqrt_parents[pred].far_parent;
li pred_par = sqrt_parents[pred].pred_parent;
add(cur_res, mults[pred_par] * sum_inner_queries[par]);
pred = par;
}
if (read) {
cur_res %= mod;
if (cur_res < 0) {
cur_res += mod;
}
cout << cur_res << "\n";
}
}
}
for (li v : vs) {
for (li to : g[v]) {
add(pushed_queries[to], mults[to] * sum_inner_queries[v]);
}
sum_inner_queries[v] = 0;
}
for (li v : order) {
simple_add(add_by_vertex[v], pushed_queries[v]);
for (li to : g[v]) {
simple_add(pushed_queries[to], pushed_queries[v]);
}
}
pushed_queries.assign(n, 0);
}
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const int MAXN = 2e5 + 20;
int a[MAXN], w[MAXN], n;
const int P = 1e9 + 7;
inline void MOD(int& p) {
while (p < 0) p += P;
while (p >= P) p -= P;
}
struct BIT1 {
long long bit[MAXN];
inline void modify(int w, long long v) {
while (w <= n) {
bit[w] += v;
w += (w & (-w));
}
}
inline long long sum(int w) {
long long res = 0;
while (w) {
res += bit[w];
w -= (w & (-w));
}
return res;
}
inline long long query(int l, int r) { return sum(r) - sum(l - 1); }
} BitW;
struct BIT2 {
int bit[MAXN];
inline void modify(int w, int v) {
while (w <= n) {
MOD(bit[w] += v);
w += (w & (-w));
}
}
inline int sum(int w) {
MOD(w);
long long res = 0;
while (w) {
res += bit[w];
w -= (w & (-w));
}
return res % P;
}
inline int query(int l, int r) { return (sum(r) - sum(l - 1) + P) % P; }
} BitS;
inline int getAns(int l, int r) {
int L = l, R = r;
while (L <= R) {
int mid = (L + R) >> 1;
if (BitW.query(l, mid) >= BitW.query(mid + 1, r)) {
R = mid - 1;
} else {
L = mid + 1;
}
}
++R;
long long res = 0;
res = -BitS.query(l, R) + BitW.query(l, R) % P * abs(a[R] - R) % P;
res = (res % P + P) % P;
res -= -BitS.query(R, r) + BitW.query(R, r) % P * abs(a[R] - R) % P;
res = (res % P + P) % P;
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int q;
cin >> n >> q;
for (register int i = (1); i <= (n); ++i) {
cin >> a[i];
}
for (register int i = (1); i <= (n); ++i) {
cin >> w[i];
BitW.modify(i, w[i]);
BitS.modify(i, 1ll * w[i] * (a[i] - i) % P);
}
while (q--) {
int l, r;
cin >> l >> r;
if (l < 0) {
l = -l;
BitW.modify(l, -w[l]);
BitS.modify(l, -1ll * w[l] * (a[l] - l) % P);
w[l] = r;
BitW.modify(l, w[l]);
BitS.modify(l, 1ll * w[l] * (a[l] - l) % P);
} else {
cout << getAns(l, r) << '\n';
}
}
return 0;
}
| 17
|
#include <bits/stdc++.h>
const int maxn = 100100;
struct T {
int to, nxt;
} way[maxn << 1];
int h[maxn], num;
inline void adde(int x, int y) {
way[++num] = {y, h[x]}, h[x] = num;
way[++num] = {x, h[y]}, h[y] = num;
}
int fa[maxn], vis[maxn];
double sum[maxn], v[maxn];
inline void dfs(int a) {
vis[a] = 1;
for (int i = h[a]; i; i = way[i].nxt)
if (!vis[way[i].to]) {
dfs(way[i].to);
fa[way[i].to] = a;
sum[a] += v[way[i].to];
}
}
double ans = 0, Sm = 0;
int main() {
int n, q;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lf", v + i), Sm += v[i] = 1 - v[i];
for (int i = 1, x, y; i < n; ++i)
scanf("%d%d", &x, &y), adde(x + 1, y + 1), ans += v[x + 1] * v[y + 1];
dfs(1);
scanf("%d", &q);
while (q--) {
int x;
double p;
scanf("%d%lf", &x, &p), p = 1 - p, ++x;
Sm -= v[x], Sm += p;
ans -= (v[fa[x]] + sum[x]) * v[x];
if (x != 1) sum[fa[x]] -= v[x], sum[fa[x]] += p;
v[x] = p;
ans += (v[fa[x]] + sum[x]) * v[x];
printf("%.6lf\n", Sm - ans);
}
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, k;
cin >> m >> k;
int i;
int score = 0;
int tab[m];
for (i = 0; i < m; i++) {
tab[i] = 5 * (i + 1);
}
i = 0;
while (((k + tab[i]) <= 240) && (i < m)) {
score += 1;
k += tab[i];
i++;
}
cout << score;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b, p;
cin >> n >> b >> p;
int a[n + 10], i, useB = 0, useP = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
if (a[i] == 1) {
useB++;
} else {
if ((p - useP) <= 0)
useB++;
else
useP++;
}
}
b -= useB;
p -= useP;
if (b > p) {
if (p <= 0)
cout << abs(p) << endl;
else
cout << "0" << endl;
} else {
if (b <= 0)
cout << abs(b) << endl;
else
cout << "0" << endl;
}
return 0;
}
| 1
|
#include <bits/stdc++.h>
int a[200005];
std::vector<int> v, p, vt;
int main() {
int n, cnt = 0, cur = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (!a[i]) {
v.push_back(i);
} else if (a[i] < 0) {
++cnt;
p.push_back(i);
} else
vt.push_back(i);
}
if (cnt & 1) {
int pos = 0;
for (int i = 0; i < p.size(); i++)
if (a[p[i]] > a[p[pos]]) pos = i;
v.push_back(p[pos]);
for (int i = 0; i < p.size(); i++)
if (i != pos) vt.push_back(p[i]);
} else
for (int i = 0; i < p.size(); i++) vt.push_back(p[i]);
if (v.size()) {
for (int i = 0; i < v.size() - 1; i++) {
printf("1 %d %d\n", v[i], v[i + 1]);
++cur;
}
if (cur < n - 1) printf("2 %d\n", *(--v.end()));
}
if (vt.size())
for (int i = 0; i < vt.size() - 1; i++)
printf("1 %d %d\n", vt[i], vt[i + 1]);
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
long long hilbertorder(int x, int y, int lg) {
long long ret = 0;
for (int s = lg - 1; s >= 0; --s) {
int rx = x >> s & 1, ry = y >> s & 1;
ret = (ret << 2) | ((rx * 3) ^ ry);
if (!ry) {
if (rx) x = (1 << lg) - 1 - x, y = (1 << lg) - 1 - y;
swap(x, y);
}
}
return ret;
}
int blo;
struct qry {
int l, r, id;
long long ord;
bool operator<(const qry &q) const { return ord < q.ord; }
};
inline int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
int stk[500005], del[500005], cnt[500005], ans[500005], tp = 0;
int main() {
int n = read();
vector<int> a(n);
for (int i = 0; i < n; ++i) a[i] = read();
vector<int> aa = a;
sort(aa.begin(), aa.end());
aa.resize(unique(aa.begin(), aa.end()) - aa.begin());
auto f = [&](int x) {
return lower_bound(aa.begin(), aa.end(), x) - aa.begin();
};
for (int &i : a) i = f(i);
int m = read();
vector<qry> qs(m);
int lg = 0;
while (1 << lg < n) ++lg;
for (int i = 0; i < m; ++i) {
int l = read(), r = read();
--l, --r;
qs[i] = {l, r, i, hilbertorder(l, r, lg)};
}
sort(qs.begin(), qs.end());
int l = 0, r = -1;
int cur = 0;
for (auto q : qs) {
while (r < q.r) {
++r;
if (cnt[a[r]] == 1) del[a[r]]++;
cnt[a[r]]++;
if (cnt[a[r]] == 1) {
if (del[a[r]])
--del[a[r]];
else
stk[++tp] = a[r];
}
}
while (l > q.l) {
--l;
if (cnt[a[l]] == 1) del[a[l]]++;
cnt[a[l]]++;
if (cnt[a[l]] == 1) {
if (del[a[l]])
--del[a[l]];
else
stk[++tp] = a[l];
}
}
while (r > q.r) {
if (cnt[a[r]] == 1) del[a[r]]++;
cnt[a[r]]--;
if (cnt[a[r]] == 1) {
if (del[a[r]])
--del[a[r]];
else
stk[++tp] = a[r];
}
--r;
}
while (l < q.l) {
if (cnt[a[l]] == 1) del[a[l]]++;
cnt[a[l]]--;
if (cnt[a[l]] == 1) {
if (del[a[l]])
--del[a[l]];
else
stk[++tp] = a[l];
}
++l;
}
while (tp) {
while (tp && del[stk[tp]]) {
--del[stk[tp]];
--tp;
}
if (!tp) break;
if (cnt[stk[tp]] == 1) break;
--tp;
}
if (tp)
ans[q.id] = stk[tp];
else
ans[q.id] = -1;
}
for (int i = 0; i < m; ++i) {
if (ans[i] == -1)
puts("0");
else
printf("%d\n", aa[ans[i]]);
}
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000, LL = 20;
int q[N + 3], Fa[LL + 3][N + 3], dep[N + 3], L[N + 3], Ti[N + 3];
int go[N * 2 + 3], t[N * 2 + 3], last[N + 3], NowT[N + 3], n, K, en, Lar, ls,
Dn, ans;
set<int> A;
void add(int u, int v) {
go[++en] = v;
t[en] = last[u];
last[u] = en;
}
void Dfs() {
q[++ls] = 1;
NowT[1] = last[1];
dep[1] = 1;
L[1] = ++Dn;
Ti[1] = 1;
for (; ls;) {
int x = q[ls];
for (; L[go[NowT[x]]]; NowT[x] = t[NowT[x]])
;
if (!NowT[x]) {
ls--;
continue;
}
q[++ls] = go[NowT[x]];
NowT[q[ls]] = last[q[ls]];
L[q[ls]] = ++Dn;
Ti[Dn] = q[ls];
Fa[0][q[ls]] = x;
dep[q[ls]] = dep[x] + 1;
}
}
void Da() {
for (int j = 1; j <= LL; j++)
for (int i = 1; i <= n; i++) Fa[j][i] = Fa[j - 1][Fa[j - 1][i]];
}
int Lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int dd = dep[x] - dep[y];
for (int i = 0; i <= LL; i++)
if ((dd >> i) & 1) x = Fa[i][x];
if (x == y) return x;
for (int i = LL; i >= 0; i--)
if (Fa[i][x] != Fa[i][y]) x = Fa[i][x], y = Fa[i][y];
return Fa[0][x];
}
void find(int w, int &u, int &v) {
set<int>::iterator x = A.lower_bound(L[w]);
if (x == A.end()) {
u = *A.begin(), v = *(--x);
return;
}
if (x == A.begin()) {
u = *x;
set<int>::iterator y = A.end();
v = *(--y);
return;
}
v = *x;
u = *(--x);
}
int Calc(int w) {
if (A.empty()) return 1;
int u, v;
find(w, u, v);
u = Ti[u], v = Ti[v];
return dep[w] - dep[Lca(w, u)] - dep[Lca(w, v)] + dep[Lca(u, v)];
}
void Insert(int w) {
Lar += Calc(w);
A.insert(L[w]);
}
void Del(int w) {
A.erase(L[w]);
Lar -= Calc(w);
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
Dfs();
Da();
int r = 0;
for (int i = 1; i <= n; i++) {
r = max(i - 1, r);
for (; Lar <= K && r < n;) Insert(++r);
if (Lar > K) Del(r--);
ans = max(ans, r - i + 1);
Del(i);
}
printf("%d", ans);
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
long long mp[3005][3005];
long long c[3005][3005];
long long n, m, mod;
long long a, b, x, y;
long long g;
int main() {
cin >> n >> m >> a >> b >> g >> x >> y >> mod;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
mp[i][j] = g;
g = (x * g + y) % mod;
}
}
for (int i = 1; i <= n; i++) {
deque<int> q;
while (!q.empty()) q.pop_front();
for (int j = 1; j <= m; j++) {
while (!q.empty() && mp[i][q.back()] >= mp[i][j]) q.pop_back();
q.push_back(j);
if (j - b >= 0) {
while (q.front() <= j - b) q.pop_front();
c[i][j - b + 1] = mp[i][q.front()];
}
}
}
long long ans = 0;
for (int j = 1; j <= m - b + 1; j++) {
deque<int> p;
while (!p.empty()) p.pop_front();
for (int i = 1; i <= n; i++) {
while (!p.empty() && c[p.back()][j] >= c[i][j]) p.pop_back();
p.push_back(i);
if (i - a >= 0) {
while (p.front() <= i - a) p.pop_front();
ans += c[p.front()][j];
}
}
}
cout << ans;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int n, l[100100], r[100100], ans, a[100100];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int m = n / 2;
for (int i = 1; i <= m; i++) {
if (a[i] >= i) {
l[a[i] - i]++;
}
}
for (int j = 1; j <= m; j++) {
if (a[n - j + 1] >= j) {
r[a[n - j + 1] - j]++;
}
}
if (n % 2) m++;
ans = 1000000;
for (int i = 0; i <= 100010; i++) {
int ch = n - (l[i] + r[i]);
if (n % 2 && a[m] == m + i) {
ch--;
}
ans = min(ch, ans);
}
cout << ans;
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10000;
const int M = 1000000;
const int INF = 0x7f7f7f7f;
struct edge {
int v, cap, cost, next;
edge() {}
edge(int a, int b, int c, int d) : v(a), cap(b), cost(c), next(d) {}
} e[M];
int head[N], sz;
int dis[N], pre[N], cur[N];
bool inq[N];
queue<int> q;
void graphinit() {
memset(head, -1, sizeof(head));
sz = 0;
}
void addedge(int u, int v, int cp, int ct) {
e[sz] = edge(v, cp, ct, head[u]);
head[u] = sz++;
e[sz] = edge(u, 0, -ct, head[v]);
head[v] = sz++;
}
int mcmf(int s, int t) {
int mc = 0, mf = 0;
while (true) {
memset(pre, -1, sizeof(pre));
memset(inq, 0, sizeof(inq));
memset(dis, 0x7f, sizeof(dis));
dis[s] = 0;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
inq[u] = false;
for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].v;
if (e[i].cap > 0 && dis[v] > dis[u] + e[i].cost) {
dis[v] = dis[u] + e[i].cost;
pre[v] = u;
cur[v] = i;
if (!inq[v]) {
inq[v] = true;
q.push(v);
}
}
}
}
if (pre[t] == -1) break;
int aug = INF;
for (int i = t; i != s; i = pre[i]) aug = min(aug, e[cur[i]].cap);
mf += aug;
mc += dis[t] * aug;
for (int i = t; i != s; i = pre[i]) {
e[cur[i]].cap -= aug;
e[cur[i] ^ 1].cap += aug;
}
}
return mc;
}
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
int mz[100][100];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &mz[i][j]);
graphinit();
int s = n * m, t = s + 1;
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++) {
int u = x * m + y;
if ((x + y) % 2 == 0) {
addedge(s, u, 1, 0);
for (int d = 0; d < 4; d++) {
int nx = x + dx[d], ny = y + dy[d];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
int v = nx * m + ny;
int c = mz[x][y] == mz[nx][ny] ? 0 : 1;
addedge(u, v, 1, c);
}
} else {
addedge(u, t, 1, 0);
}
}
int ans = mcmf(s, t);
printf("%d\n", ans);
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200;
const int max_len = 200;
struct widget;
struct Box {
string name;
long long x, y;
vector<Box *> box_inside;
vector<widget *> widget_inside;
long long border, space;
bool type;
vector<Box *> parent;
void init(const string s, const bool t) {
name = s;
x = y = 0;
border = space = 0;
type = t;
}
void update();
void pack(Box *new_parent) {
parent.push_back(new_parent);
new_parent->box_inside.push_back(this);
(*new_parent).update();
}
void set_space(const int new_space) {
space = new_space;
update();
}
void set_border(const int new_border) {
border = new_border;
update();
}
};
struct widget {
string name;
long long x, y;
void pack(Box *new_parent) {
new_parent->widget_inside.push_back(this);
(*new_parent).update();
}
void init(const string s, const int x1, const int y1) {
name = s;
x = x1;
y = y1;
}
};
void Box::update() {
if (type) {
x = 0;
y = 0;
for (size_t i = 0; i < box_inside.size(); ++i) {
x += box_inside[i]->x;
y = max(y, box_inside[i]->y);
}
for (size_t i = 0; i < widget_inside.size(); ++i) {
x += widget_inside[i]->x;
y = max(y, widget_inside[i]->y);
}
if (widget_inside.size() + box_inside.size() != 0) {
x += 2 * border + (box_inside.size() + widget_inside.size() - 1) * space;
y += 2 * border;
}
} else {
x = 0;
y = 0;
for (size_t i = 0; i < box_inside.size(); ++i) {
y += box_inside[i]->y;
x = max(x, box_inside[i]->x);
}
for (size_t i = 0; i < widget_inside.size(); ++i) {
y += widget_inside[i]->y;
x = max(x, widget_inside[i]->x);
}
if (widget_inside.size() + box_inside.size() != 0) {
y += 2 * border + (box_inside.size() + widget_inside.size() - 1) * space;
x += 2 * border;
}
}
for (size_t i = 0; i < parent.size(); ++i) (*parent[i]).update();
}
struct res {
string name;
long long x, y;
};
bool comp(const res a, const res b) {
if (a.name < b.name)
return 1;
else
return 0;
}
Box ar_of_box[maxn];
widget ar_of_widget[maxn];
int n, last_b, last_w;
char buf[max_len];
string s;
res res_ar[maxn];
int main() {
last_b = last_w = 0;
scanf("%d\n", &n);
for (int i = 0; i < n; ++i) {
gets(buf);
s = buf;
if (s.substr(0, 4) == "VBox")
ar_of_box[last_b++].init(s.substr(5, s.size() - 5), false);
if (s.substr(0, 4) == "HBox")
ar_of_box[last_b++].init(s.substr(5, s.size() - 5), true);
if (s.substr(0, 6) == "Widget") {
int x, y;
x = y = 0;
s.erase(0, 7);
string name = "";
int k = 0;
while (s[k] != '(') {
name += s[k];
++k;
}
++k;
while (s[k] >= '0' && s[k] <= '9') {
x = x * 10 + s[k] - '0';
++k;
}
++k;
while (s[k] >= '0' && s[k] <= '9') {
y = y * 10 + s[k] - '0';
++k;
}
ar_of_widget[last_w++].init(name, x, y);
}
if (s.find(".pack") != s.npos) {
string name1, name2;
name1 = name2 = "";
int k = 0;
while (s[k] != '.') {
name1 += s[k];
++k;
}
while (s[k] != '(') ++k;
++k;
while (s[k] != ')') {
name2 += s[k];
++k;
}
Box *parent = NULL;
for (int j = 0; j < last_b; ++j)
if (name1 == ar_of_box[j].name) parent = &ar_of_box[j];
for (int j = 0; j < last_b; ++j)
if (name2 == ar_of_box[j].name) ar_of_box[j].pack(parent);
for (int j = 0; j < last_w; ++j)
if (name2 == ar_of_widget[j].name) ar_of_widget[j].pack(parent);
}
if (s.find(".set_border") != s.npos) {
string name = "";
int k = 0;
int border = 0;
while (s[k] != '.') {
name += s[k];
++k;
}
while (s[k] != '(') ++k;
++k;
while (s[k] >= '0' && s[k] <= '9') {
border = border * 10 + s[k] - '0';
++k;
}
for (int j = 0; j < last_b; ++j)
if (name == ar_of_box[j].name) ar_of_box[j].set_border(border);
}
if (s.find(".set_spacing") != s.npos) {
string name = "";
int k = 0;
int space = 0;
while (s[k] != '.') {
name += s[k];
++k;
}
while (s[k] != '(') ++k;
++k;
while (s[k] >= '0' && s[k] <= '9') {
space = space * 10 + s[k] - '0';
++k;
}
for (int j = 0; j < last_b; ++j)
if (name == ar_of_box[j].name) ar_of_box[j].set_space(space);
}
}
for (int i = 0; i < last_b; ++i) {
res_ar[i].name = ar_of_box[i].name;
res_ar[i].x = ar_of_box[i].x;
res_ar[i].y = ar_of_box[i].y;
}
for (int i = 0; i < last_w; ++i) {
res_ar[i + last_b].name = ar_of_widget[i].name;
res_ar[i + last_b].x = ar_of_widget[i].x;
res_ar[i + last_b].y = ar_of_widget[i].y;
}
sort(&res_ar[0], &res_ar[last_b + last_w], comp);
for (int i = 0; i < last_b + last_w; ++i)
printf("%s %I64d %I64d\n", res_ar[i].name.c_str(), res_ar[i].x,
res_ar[i].y);
fclose(stdin);
fclose(stdout);
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int set_bit(int mask, int c) { return mask |= (1UL << c); }
bool get_bit(int mask, int c) { return (mask >> c) & 1U; }
int fx[] = {1, -1, 0, 0, 1, 1, -1, -1, 0};
int fy[] = {0, 0, 1, -1, 1, -1, 1, -1, 0};
string fn[] = {"D", "U", "R", "L", "DR", "DL", "UR", "UL", "*"};
int kx[] = {2, 2, -2, -2, 1, -1, 1, -1};
int ky[] = {1, -1, 1, -1, 2, 2, -2, -2};
struct TYPE {
int h = 0, m = 0, s = 0;
bool operator<(TYPE t) const {
return make_pair(h, make_pair(m, s)) < make_pair(t.h, make_pair(t.m, t.s));
}
};
double linear_distance(pair<double, double> a, pair<double, double> b) {
return sqrt(pow(a.first - b.first, 2.0) + pow(a.second - b.second, 2.0));
}
const long long MAX = 1e6 + 5, MOD = 1e7 + 7, INF = 1e18;
int KASE;
int n, m;
vector<int> v;
long long dp[(1 << 18) + 5][100 + 5];
long long solve(int mask, int r) {
if (__builtin_popcount(mask) == n) {
return r == 0;
}
if (dp[mask][r] != -1) return dp[mask][r];
long long ret = 0;
bool taken[10];
for (int i = 0; i < 10; i++) taken[i] = false;
for (int i = 0; i < n; i++) {
if (get_bit(mask, i) || (mask == 0 && v[i] == 0) || taken[v[i]]) continue;
ret += solve(set_bit(mask, i), ((r * 10) + v[i]) % m);
taken[v[i]] = true;
}
return dp[mask][r] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int KASE = 1; KASE <= t; KASE++) {
long long number;
cin >> number >> m;
while (number) {
v.emplace_back(number % 10);
number /= 10;
}
n = v.size();
memset(dp, -1, sizeof dp);
cout << solve(0, 0) << "\n";
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
int n;
int t[109][109];
int a[109];
int main() {
scanf("%d", &n);
for (int h = 0; h < n; h++)
for (int j = 0; j < n; j++) scanf("%d", &t[h][j]);
for (int h = 0; h < n; h++)
for (int j = 0; j < n; j++)
if (h != j) a[h] = a[h] | t[h][j];
for (int h = 0; h < n; h++) printf("%d ", a[h]);
}
| 7
|
#include <bits/stdc++.h>
int main() {
int i, n;
char str[1000];
while (scanf("%s", str) != -1) {
n = strlen(str);
if (n < 5) {
printf("Too weak\n");
continue;
}
int a, b, c;
a = b = c = 0;
for (i = 0; i < n; i++) {
if (str[i] >= 'A' && str[i] <= 'Z')
a = 1;
else if (str[i] >= 'a' && str[i] <= 'z')
b = 1;
else if (str[i] >= '0' && str[i] <= '9')
c = 1;
}
if (a + b + c == 3)
printf("Correct\n");
else
printf("Too weak\n");
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
int main() {
int tests;
std::cin >> tests;
for (int i = 0; i < tests; ++i) {
int r;
std::cin >> r;
std::cout << r / 7 + 1 << std::endl;
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
int s[105];
int main() {
scanf("%d%d%d", &n, &a, &b);
s[0] = 1;
int sum = 1, i = 1, ma = 1;
while (b) {
s[i] = sum + 1;
sum += sum + 1;
ma = max(ma, s[i]);
i++;
b--;
}
while (a) {
if (sum <= ma) {
s[i] = s[i - 1];
sum += s[i];
} else {
s[i] = ma + 1;
sum += s[i];
ma = max(ma, s[i]);
a--;
}
i++;
}
if (i > n || s[i - 1] > 50000)
printf("-1\n");
else {
int k;
for (k = i; k < n; k++) s[k] = 1;
for (i = 0; i < n; i++) {
if (i == 0)
printf("%d", s[i]);
else
printf(" %d", s[i]);
}
printf("\n");
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double tiaohe = 0.57721566490153286060651209;
long long oula(long long x) {
long long res = x;
for (register int i = 2; i <= x / i; ++i) {
if (x % i == 0) {
res = res / i * (i - 1);
while (x % i == 0) x /= i;
}
}
if (x > 1) res = res / x * (x - 1);
return res;
}
long long quickmod(long long a, long long n, long long m) {
long long s = 1;
while (n) {
if (n & 1) {
s = s * a % m;
}
a = (a * a) % m;
n = n / 2;
}
return s;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void ex_gcd(long long a, long long b, long long &x, long long &y,
long long &d) {
if (!b) {
d = a, x = 1, y = 0;
} else {
ex_gcd(b, a % b, y, x, d);
y -= x * (a / b);
}
}
long long inv(long long t, long long p) {
long long d, x, y;
ex_gcd(t, p, x, y, d);
return d == 1 ? (x % p + p) % p : -1;
}
bool isPrime(long long x) {
if (x == 2) return true;
if (x % 2 == 0) return false;
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
inline int in() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
double eqa = (1 + sqrt(5.0)) / 2.0;
const int N = 6e5 + 5;
int vis[N][3];
int main() {
string s;
while (cin >> s) {
for (register int i = 0; i <= (int)s.size() - 1; ++i)
if (isalpha(s[i])) {
int cur = s[i] - 'A';
vis[i][cur] = vis[i + 1][cur] = vis[i + 2][cur] = true;
}
int fg = 0;
for (register int i = 1; i <= (int)s.size(); ++i) {
if (vis[i][0] && vis[i][1] && vis[i][2]) {
puts("Yes");
fg = 1;
break;
}
}
if (!fg) puts("No");
}
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long r;
cin >> r;
for (long long x = 1; (x * x + x + 1) < r; ++x) {
long long num = r - (pow(x, 2) + x + 1);
long long deno = 2 * x;
if (num % deno == 0 && num / deno >= 1) {
cout << x << " " << num / deno << "\n";
return 0;
}
}
cout << "NO"
<< "\n";
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int cnt[1000005];
const int mod = 1e9 + 7;
void solve() {
int a, b;
cin >> a >> b;
for (int i = 1;; i += 2) {
if (a >= i) {
a -= i;
} else {
cout << "Vladik" << endl;
return;
}
if (b >= i + 1) {
b -= (i + 1);
} else {
cout << "Valera" << endl;
return;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
t = 1;
while (t--) solve();
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
long long m[1000000], a[1000001], tr[1000001], mx;
long long ans = 0;
void build(int n, int b, int e, long long cost) {
if (b == e) {
m[b] = cost;
return;
}
int l = 2 * n, mid = (b + e) / 2;
build(l, b, mid, cost + a[l]);
build(l + 1, mid + 1, e, cost + a[l + 1]);
}
void build1(int n, int b, int e) {
if (b == e) {
tr[n] = mx - m[b];
return;
}
int l = 2 * n, mid = (b + e) / 2;
build1(l, b, mid);
build1(l + 1, mid + 1, e);
tr[n] = min(tr[l], tr[l + 1]);
}
void build2(int n, int b, int e, long long cost) {
if (b == e) {
ans = ans + (long long)(tr[n] - cost);
return;
}
int l = 2 * n, mid = (b + e) / 2;
ans += ((long long)tr[n] - cost);
build2(l, b, mid, tr[n]);
build2(l + 1, mid + 1, e, tr[n]);
}
int main() {
int i, j, k, l, n, m1;
scanf("%d", &n);
m1 = (1 << (n + 1)) - 2;
for (i = 0; i < m1; i++) scanf("%lld", &a[i]);
for (i = m1 - 1; i >= 0; i--) a[i + 2] = a[i];
build(1, 0, (1 << n) - 1, 0LL);
mx = -1;
for (i = 0; i <= (1 << n) - 1; i++)
if (m[i] > mx) mx = m[i];
build1(1, 0, (1 << n) - 1);
tr[1] = 0;
build2(1, 0, (1 << n) - 1, 0);
printf("%lld\n", ans);
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
template <typename T>
void chmin(T &a, T b) {
if (a > b) a = b;
}
template <typename T>
void chmax(T &a, T b) {
if (a < b) a = b;
}
template <typename T>
void add(T &a, T b) {
a += b;
if (a < 0) a += MOD;
if (a >= MOD) a -= MOD;
}
void FastIn(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int in() {
int x;
scanf("%d", &x);
return x;
}
long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
double din() {
double x;
scanf("%lf", &x);
return x;
}
long long p2[64];
void initP2() {
p2[0] = 1;
for (int i = (1); i <= (63); ++i) {
p2[i] = p2[i - 1] * 2;
}
}
int countBitsBaseB(long long n, long long b) {
if (n == 0) return 1;
int ret = 0;
while (n) {
ret++;
n /= b;
}
return ret;
}
int count1(long long n) {
int ret = 0;
while (n) {
ret += n & 1;
n >>= 1;
}
return ret;
}
long long c[1024][1024] = {0};
void initC() {
for (int i = 0; i < (1024); ++i) {
for (int j = 0; j < (i + 1); ++j) {
if (j == 0 || j == i) {
c[i][j] = 1;
} else {
c[i][j] = c[i - 1][j - 1];
add(c[i][j], c[i - 1][j]);
}
}
}
}
bool IsPrime(int n) {
if (n < 2) return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
void init() {
initP2();
initC();
}
const long long INF = 2e18;
struct City {
int id, num;
bool operator<(const City &a) const {
if (num != a.num) return num < a.num;
return id < a.id;
}
} ct[500010];
int bin(const vector<pair<long long, long long> > &p, long long sum) {
int id = p.size() - 1;
int low = 0, high = p.size() - 1;
while (low <= high) {
int mid = low + high >> 1;
if (p[mid].second >= sum) {
id = mid;
high = mid - 1;
} else
low = mid + 1;
}
return id;
}
struct Tree {
int l, r, sum;
int mid() { return l + r >> 1; }
} node[500010 << 2];
void build(int l, int r, int tag) {
node[tag].l = l;
node[tag].r = r;
node[tag].sum = 0;
if (l + 1 == r) return;
int mid = node[tag].mid();
build(l, mid, ((tag) << 1));
build(mid, r, (((tag) << 1) | 1));
}
void ins(int v, int tag) {
node[tag].sum++;
if (node[tag].l + 1 == node[tag].r) return;
if (v < node[tag].mid())
ins(v, ((tag) << 1));
else
ins(v, (((tag) << 1) | 1));
}
int query(int sum, int tag) {
if (node[tag].l + 1 == node[tag].r) return node[tag].l;
if (sum <= node[((tag) << 1)].sum)
return query(sum, ((tag) << 1));
else
return query(sum - node[((tag) << 1)].sum, (((tag) << 1) | 1));
}
struct Q {
int qid, k, size;
bool operator<(const Q &q) const {
if (size != q.size) return size < q.size;
if (k != q.k) return k < q.k;
return qid < q.qid;
}
} qu[500010];
int ans[500010];
int main() {
init();
int n = in(), m = in(), q = in();
for (int i = 0; i < (m); ++i) {
ct[i].id = i;
ct[i].num = 0;
}
for (int i = 0; i < (n); ++i) {
int a = in() - 1;
ct[a].num++;
}
sort(ct, ct + m);
{}
vector<pair<long long, long long> > p;
long long sum = 0;
for (int i = 0; i < m; i++) {
while (i + 1 < m && ct[i].num == ct[i + 1].num) {
i++;
}
if (i + 1 == m) break;
sum += (long long)(ct[i + 1].num - ct[i].num) * (i + 1);
p.push_back(make_pair(i + 1, sum));
}
p.push_back(make_pair(m, INF));
{}
for (int i = 0; i < (q); ++i) {
long long k = lin() - n;
int id = bin(p, k);
if (id > 0) k -= p[id - 1].second;
k %= p[id].first;
if (k == 0) k = p[id].first;
qu[i].qid = i;
qu[i].k = k;
qu[i].size = p[id].first;
}
build(0, m, 1);
sort(qu, qu + q);
int it = 0;
for (int j = 0; j < (q); ++j) {
while (it + 1 <= qu[j].size) {
ins(ct[it].id, 1);
it++;
}
ans[qu[j].qid] = query(qu[j].k, 1) + 1;
}
for (int i = 0; i < (q); ++i) {
printf("%d\n", ans[i]);
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
long double EPS = 1e-12;
struct pt {
long double x, y;
pt(long double x, long double y) : x(x), y(y) {}
pt operator+(const pt &first) const { return pt(x + first.x, y + first.y); }
pt operator-(const pt &first) const { return pt(x - first.x, y - first.y); }
pt operator*(long double c) const { return pt(x * c, y * c); }
pt operator/(long double c) const { return pt(x / c, y / c); }
bool operator==(const pt &first) const {
return fabs(x - first.x) + fabs(y - first.y) < EPS;
}
};
bool CONVEX;
long double dot(pt first, pt second) {
return first.x * second.x + first.y * second.y;
}
long double cross(pt first, pt second) {
return first.x * second.y - first.y * second.x;
}
long double dist2(pt first, pt second) {
return dot(first - second, first - second);
}
long double dist(pt first, pt second) {
return sqrt(dot(first - second, first - second));
}
bool clockwiseLL(pt a, pt b, pt c, pt d) { return cross(a - b, c - d) > 0; }
bool clockwisePPP(pt a, pt b, pt c) { return cross(a - c, a - b) > 0; }
pt intersectLL(pt a, pt b, pt c, pt d) {
return a + (b - a) * (cross(c - a, c - d)) / (cross(b - a, c - d));
}
pt LINEA = pt(0, 0);
pt LINEB = pt(1, 2);
bool cmp4(pair<pt, pt> l, pair<pt, pt> m) {
pt first = LINEA;
pt second = LINEB;
pt a = LINEA + l.second - l.first;
pt b = LINEA + m.second - m.first;
if (cross(a - first, a - second) * cross(b - first, b - second) >= 0) {
if (cross(a - first, a - second) == 0 && dot(a - first, a - second) > 0)
return true;
if (cross(b - first, b - second) == 0 && dot(b - first, b - second) > 0)
return false;
return cross(b - first, a - first) < 0;
}
return cross(a - first, a - second) > 0;
}
long double areaG(vector<pt> g) {
long double area = 0;
for (int i = 0; i < g.size(); i++) {
area += cross(g[i], g[(i + 1) % g.size()]);
}
return area / 2.0;
}
pt rotateP(pt first, long double t) {
return pt(first.x * cos(t) - first.y * sin(t),
first.x * sin(t) + first.y * cos(t));
}
vector<pt> rotateG(vector<pt> g, long double t) {
vector<pt> h;
for (int i = 0; i < g.size(); i++) {
h.push_back(rotateP(g[i], t));
}
return h;
}
vector<pt> intersectionH(vector<pair<pt, pt> > v) {
sort(v.begin(), v.end(), cmp4);
CONVEX = true;
vector<pair<pt, pt> > ans;
vector<pt> pts;
if (v.size() == 0) return pts;
ans.push_back(v[0]);
int ind = 1;
while (v.size() > ind) {
while (ans.size() > 1) {
pair<pt, pt> a = v[ind];
pair<pt, pt> b = ans[(long long)ans.size() - 2];
pair<pt, pt> c = ans.back();
if (!clockwiseLL(b.first, b.second, a.first, a.second) ||
clockwisePPP(intersectLL(a.first, a.second, b.first, b.second),
c.first, c.second))
break;
ans.pop_back();
}
ans.push_back(v[ind]);
ind++;
}
LINEA = LINEA * -1;
LINEB = LINEB * -1;
v = ans;
ans.clear();
sort(v.begin(), v.end(), cmp4);
ans.push_back(v[0]);
ind = 1;
while (v.size() > ind) {
while (ans.size() > 1) {
pair<pt, pt> a = v[ind];
pair<pt, pt> b = ans[(long long)ans.size() - 2];
pair<pt, pt> c = ans.back();
if (!clockwiseLL(b.first, b.second, a.first, a.second) ||
clockwisePPP(intersectLL(a.first, a.second, b.first, b.second),
c.first, c.second))
break;
ans.pop_back();
}
ans.push_back(v[ind]);
ind++;
}
LINEA = LINEA * -1;
LINEB = LINEB * -1;
for (int i = 0; i < ans.size(); i++) {
pair<pt, pt> a = ans[i];
pair<pt, pt> b = ans[(i + 1) % ans.size()];
if (!clockwiseLL(a.first, a.second, b.first, b.second)) {
CONVEX = false;
cout << "Not convex!";
}
pts.push_back(intersectLL(a.first, a.second, b.first, b.second));
}
return pts;
}
vector<pt> intersectionGG(vector<pt> g, vector<pt> h) {
vector<pair<pt, pt> > v;
for (int i = 0; i < g.size(); i++) {
v.push_back(make_pair(g[i], g[(i + 1) % g.size()]));
}
for (int i = 0; i < h.size(); i++) {
v.push_back(make_pair(h[i], h[(i + 1) % h.size()]));
}
return intersectionH(v);
}
int main() {
long double w, h, a;
cin >> w >> h >> a;
vector<pt> g;
a = (a * atan(1)) / 45;
g.push_back(pt(w / 2, h / 2));
g.push_back(pt(-w / 2, h / 2));
g.push_back(pt(-w / 2, -h / 2));
g.push_back(pt(w / 2, -h / 2));
cout << setprecision(10) << fixed;
cout << areaG(intersectionGG(g, rotateG(g, a))) << endl;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int mn = 2e5 + 10;
int n, a, b, k;
vector<int> v;
int main() {
cin >> n >> a >> b >> k;
int health;
int tk;
int ans = 0;
for (int i = 1; i <= n; ++i) {
cin >> health;
int last = health;
bool f = 1;
int x1 = health / (a + b);
int x2 = x1 * (a + b) + a;
if ((a + b) * x1 == health) x2 = (x1 - 1) * (a + b) + a;
if (x2 >= health) {
ans++;
continue;
}
last = health - x2;
tk = last / a;
if (tk * a != last) tk++;
v.push_back(tk);
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); ++i) {
if (k >= v[i]) {
++ans;
k -= v[i];
}
}
cout << ans << endl;
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int lim = 26;
struct so {
so() : v(0), flip(0), len(0), c(0) {}
so(int _v, int _flip, int _len, int _c) {
v = _v;
flip = _flip;
len = _len;
c = _c;
}
int v, flip, len, c;
};
struct node {
int v, c;
node *next;
} pool[410000], *g[210000];
int top;
int n, m;
int dis[210000][40][3];
pair<int, int> far[210000][3];
int ans;
void add(int u, int v, int c) {
node *tmp = &pool[++top];
tmp->v = v;
tmp->c = c;
tmp->next = g[u];
g[u] = tmp;
}
int get(int flip, int len) {
int i, ret = 0, pw = 1;
for (i = 1; i <= flip; i++) {
ret = (ret + pw) % mod;
pw = (pw * 2) % mod;
}
return (ret + len) % mod;
}
bool operator<(so x1, so x2) {
if (x1.flip <= lim && x2.flip <= lim) {
if (x1.flip == x2.flip) {
return x1.len > x2.len;
} else {
return x1.flip > x2.flip;
}
}
if (x1.flip > lim && x2.flip > lim) {
return x1.flip > x2.flip;
}
if (x1.flip <= lim) return 0;
return 1;
}
void dij() {
int i, j;
priority_queue<so> q;
so k, tmp;
for (i = 1; i <= n; i++) {
for (j = 0; j <= lim; j++) {
dis[i][j][0] = dis[i][j][1] = 0x3f3f3f3f;
}
far[i][0] = far[i][1] = {9999999, 9999999};
}
dis[1][0][0] = 0;
q.push(so(1, 0, 0, 0));
while (q.size()) {
k = q.top();
q.pop();
for (node *j = g[k.v]; j; j = j->next) {
tmp = k;
tmp.v = j->v;
tmp.len++;
tmp.flip += (j->c != k.c);
tmp.c = j->c;
if (k.flip <= lim - 1) {
if (dis[j->v][tmp.flip][tmp.c] > tmp.len) {
dis[j->v][tmp.flip][tmp.c] = tmp.len;
q.push(tmp);
}
} else {
if (far[tmp.v][tmp.c] > make_pair(tmp.flip, tmp.len)) {
far[tmp.v][tmp.c] = {tmp.flip, tmp.len};
q.push(tmp);
}
}
}
}
}
void work() {
int i, j, u, v;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
add(u, v, 0);
add(v, u, 1);
}
dij();
ans = 2147483647;
for (j = 0; j <= lim; j++) {
if (dis[n][j][0] != 0x3f3f3f3f) ans = min(ans, get(j, dis[n][j][0]));
if (dis[n][j][1] != 0x3f3f3f3f) ans = min(ans, get(j, dis[n][j][1]));
}
if (ans != 2147483647) {
printf("%d\n", ans % mod);
} else {
if (far[n][0].first < far[n][1].first) {
printf("%d\n", get(far[n][0].first, far[n][0].second));
} else {
printf("%d\n", get(far[n][1].first, far[n][1].second));
}
}
}
int main() {
work();
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int n;
char a[111][111];
vector<pair<int, int> > v, vv;
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[i][j] == '.') {
v.push_back(make_pair(i, j));
break;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[j][i] == '.') {
vv.push_back(make_pair(j, i));
break;
}
if (v.size() == n)
for (int i = 0; i < n; i++)
cout << v[i].first << " " << v[i].second << endl;
else if (vv.size() == n)
for (int i = 0; i < n; i++)
cout << vv[i].first << " " << vv[i].second << endl;
else
cout << -1;
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 1000000001;
const long long int LLINF = 1000000000000000001LL;
const int ALPH = 2;
struct node {
int s[ALPH];
int flink = -1, dictlink = -1, par;
char parChar;
int word = -1;
node(int par = -1, char parChar = '$') : par(par), parChar(parChar) {
for (int i = (0); i <= (ALPH - 1); ++i) s[i] = -1;
}
int getSon(char c) { return s[c - 'a']; }
void setSon(char c, int k) { s[c - 'a'] = k; }
};
const int MAXNODES = 10000003;
node T[MAXNODES];
struct Aho {
int n = 1;
Aho(vector<string> &V) {
for (int i = (0); i <= ((int)(V).size() - 1); ++i) add(V[i], i);
queue<int> Q;
Q.push(0);
while (!Q.empty()) {
int q = Q.front();
Q.pop();
for (int i = (0); i <= (ALPH - 1); ++i)
if (T[q].s[i] != -1) {
Q.push(T[q].s[i]);
}
if (!q) continue;
int v = T[T[q].par].flink;
char pChar = T[q].parChar;
while (v > -1 && T[v].getSon(pChar) == -1) {
v = T[v].flink;
}
T[q].flink = (v > -1 ? T[v].getSon(pChar) : 0);
v = T[q].flink;
if (T[v].word == -1) {
v = T[v].dictlink;
}
T[q].dictlink = v;
}
}
void add(string &s, int ind) {
int it = 0, v = 0, len = (int)(s).size();
while (it < len && T[v].getSon(s[it]) != -1) {
v = T[v].getSon(s[it++]);
}
while (it < len) {
T[n++] = node(v, s[it]);
T[v].setSon(s[it++], n - 1);
v = n - 1;
}
T[v].word = ind;
}
void createEdges(string &s, int id, vector<vector<int> > &G) {
int v = 0;
for (char c : s) {
while (v && T[v].getSon(c) == -1) {
v = T[v].flink;
}
v = max(T[v].getSon(c), 0);
int it = v;
while (it > 0) {
if (T[it].word != -1) {
int w = T[it].word;
if (G[w][id]) break;
G[w][id] = 1;
}
it = T[it].dictlink;
}
}
}
};
void solve(vector<string> &T, vector<vector<int> > &G) {
Aho aho(T);
for (int i = (0); i <= ((int)(T).size() - 1); ++i)
aho.createEdges(T[i], i, G);
}
int bfs(int s, int t, vector<vector<int> > &G, vector<vector<int> > &Cap,
vector<vector<int> > &F, vector<int> &par) {
queue<int> Q;
Q.push(s);
vector<int> M((int)(G).size(), INF);
par[s] = -2;
while (!Q.empty()) {
int q = Q.front();
Q.pop();
for (int v : G[q]) {
if (Cap[q][v] > F[q][v] && par[v] == -1) {
par[v] = q;
M[v] = min(M[q], Cap[q][v] - F[q][v]);
Q.push(v);
}
}
}
return M[t];
}
void dfs(int v, vector<vector<int> > &G, vector<vector<int> > &Cap,
vector<vector<int> > &F, vector<bool> &vis) {
vis[v] = 1;
for (int u : G[v])
if (!vis[u] && Cap[v][u] > F[v][u]) {
dfs(u, G, Cap, F, vis);
}
}
vector<int> getMinCutVertices(int s, int t, vector<vector<int> > &G,
vector<vector<int> > &Cap) {
int n = (int)(G).size();
vector<vector<int> > F(n);
for (int i = (0); i <= ((int)(F).size() - 1); ++i) F[i].resize(n, 0);
vector<int> par(n, -1);
int f = bfs(s, t, G, Cap, F, par);
int flow = 0;
while (par[t] != -1) {
int v = t;
flow += f;
while (v != s) {
int prev = par[v];
F[prev][v] += f;
F[v][prev] -= f;
v = prev;
}
par = vector<int>(n, -1);
f = bfs(s, t, G, Cap, F, par);
}
vector<int> vert;
vector<bool> vis((int)(G).size(), 0);
dfs(s, G, Cap, F, vis);
for (int u : G[s])
if (!vis[u]) {
vert.push_back(u);
}
for (int u : G[t])
if (vis[u]) {
vert.push_back(u);
}
return vert;
}
void addEdge(int u, int v, int c, vector<vector<int> > &G,
vector<vector<int> > &Cap) {
G[u].push_back(v);
G[v].push_back(u);
Cap[u][v] += c;
}
vector<int> findSolution(int n, vector<vector<int> > &G) {
int m = 2 * n + 2;
vector<vector<int> > network(m);
vector<vector<int> > cap(m, vector<int>(m, 0));
for (int i = (0); i <= (n - 1); ++i)
for (int j = (0); j <= (n - 1); ++j)
if (i != j && G[i][j]) {
addEdge(2 * i, 2 * j + 1, 1, network, cap);
}
for (int i = (0); i <= (n - 1); ++i) {
addEdge(2 * n, 2 * i, 1, network, cap);
addEdge(2 * i + 1, 2 * n + 1, 1, network, cap);
}
vector<int> s = getMinCutVertices(2 * n, 2 * n + 1, network, cap);
vector<bool> touched(n, 0);
for (int v : s) {
touched[v / 2] = 1;
}
vector<int> ans;
for (int i = (0); i <= (n - 1); ++i)
if (!touched[i]) {
ans.push_back(i);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<string> T(n);
for (int i = (0); i <= ((int)(T).size() - 1); ++i) cin >> T[i];
vector<vector<int> > G(n, vector<int>(n, 0));
solve(T, G);
vector<int> sol = findSolution(n, G);
cout << (int)(sol).size() << '\n';
for (int i : sol) {
cout << 1 + i << ' ';
}
return 0;
}
| 24
|
#include <bits/stdc++.h>
using namespace std;
char s[100005];
int n, m;
int g[100005];
using namespace std;
const int maxn = 100001;
int x[maxn], y[maxn], z[maxn];
int main() {
int i, j, k, a, b;
while (cin >> s) {
n = strlen(s);
scanf("%d", &m);
memset(g, 0, sizeof(g));
memset(x, 0, sizeof(x));
memset(y, 0, sizeof(y));
memset(z, 0, sizeof(z));
for (i = 0; i < n; i++) {
x[i + 1] = x[i] + (s[i] == 'x' ? 1 : 0);
y[i + 1] = y[i] + (s[i] == 'y' ? 1 : 0);
z[i + 1] = z[i] + (s[i] == 'z' ? 1 : 0);
}
while (m--) {
k++;
scanf("%d%d", &a, &b);
if (b - a + 1 < 3) {
cout << "YES" << endl;
continue;
}
{
int num1 = x[b] - x[a - 1];
int num2 = y[b] - y[a - 1];
int num3 = z[b] - z[a - 1];
if ((num1 >= (b - a + 1) / 3 && num2 >= (b - a + 1) / 3 &&
num3 >= (b - a + 1) / 3)) {
if ((num1 - (b - a + 1) / 3) <= 1 && (num2 - (b - a + 1) / 3) <= 1 &&
(num3 - (b - a + 1) / 3) <= 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else
cout << "NO" << endl;
}
}
}
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void PV(T x) {
for (__typeof__((x).begin()) i = (x).begin(); i != (x).end(); ++i)
cout << *i << " ";
cout << endl;
}
vector<double> fac;
double logC(int a, int b) { return fac[a] - fac[b] - fac[a - b]; }
int main(int argc, char *argv[]) {
int n, m;
cin >> n >> m;
vector<int> a[m];
for (int n_ = (m), i = 0; i < n_; ++i) {
int ki;
cin >> ki;
while (ki--) {
int aij;
cin >> aij;
a[i].push_back(aij);
}
}
vector<int> all;
for (int n_ = (m), i = 0; i < n_; ++i)
all.insert(all.end(), (a[i]).begin(), (a[i]).end());
sort((all).begin(), (all).end());
reverse((all).begin(), (all).end());
int least = all[n - 1];
for (auto &ai : all)
if (ai > least) n--;
fac.assign(1, 0.0);
for (int n_ = (all.size()), i = 0; i < n_; ++i)
fac.push_back(fac.back() + log(i + 1));
double dp[m + 1][n + 1];
for (int n_ = (m + 1), i = 0; i < n_; ++i)
for (int n_ = (n + 1), j = 0; j < n_; ++j) dp[i][j] = -1.0;
dp[0][0] = 0.0;
int allEqual = 0;
for (int n_ = (m), i = 0; i < n_; ++i) {
int larger = 0, equal = 0;
for (auto &aij : a[i])
if (aij > least)
larger++;
else if (aij == least)
equal++;
allEqual += equal;
for (int n_ = (n + 1), j = 0; j < n_; ++j) {
double &ret = dp[i + 1][j];
ret = 0.0;
for (int n_ = (equal + 1), k = 0; k < n_; ++k) {
if (j - k >= 0 && dp[i][j - k] != -1.0) {
double u = logC(equal, k);
double d = logC(a[i].size(), larger + k);
ret += exp(u - d + dp[i][j - k]);
}
}
if (ret == 0.0)
ret = -1.0;
else
ret = log(ret);
}
}
cout << setiosflags(ios::fixed);
cout << setprecision(18);
cout << exp(dp[m][n] - logC(allEqual, n)) << endl;
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int give[101];
int take[101];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
give[a] += c;
take[b] += c;
}
int sum = 0;
for (int i = 1; i <= n; i++) {
int mn = min(give[i], take[i]);
give[i] -= mn;
take[i] -= mn;
sum += give[i];
}
cout << sum << endl;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5;
int n, T;
double c, pa[N], sa[N];
int a[N];
int main() {
cin >> n >> T >> c;
double revT = 1.0 / T;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
pa[i + 1] = (pa[i] + a[i] * revT) / c;
sa[i + 1] = sa[i] + a[i] * revT;
}
int tt;
scanf("%d", &tt);
while (tt--) {
int x;
scanf("%d", &x);
double u = (sa[x] - sa[x - T]);
double v = pa[x];
double e = fabs(u - v) / u;
printf("%.10lf %.10lf %.10lf\n", u, v, e);
}
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int x, dist[1002][1002], n, m;
vector<int> of[1002];
vector<int> am[1002];
pair<int, int> tmp;
string s;
queue<pair<int, int> > q;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++)
if (s[j] == '#') {
of[i].push_back(j);
am[j].push_back(i);
}
}
while (of[0].size()) {
dist[0][of[0].back()] = 1;
q.push(make_pair(0, of[0].back()));
of[0].pop_back();
}
while (q.size()) {
tmp = q.front();
q.pop();
if (tmp.first == n - 1) {
printf("%d", dist[tmp.first][tmp.second]);
return (0);
}
while (of[tmp.first].size()) {
x = of[tmp.first].back();
of[tmp.first].pop_back();
if (dist[tmp.first][x] == 0) {
dist[tmp.first][x] = dist[tmp.first][tmp.second] + 1;
q.push(make_pair(tmp.first, x));
}
}
while (am[tmp.second].size()) {
x = am[tmp.second].back();
am[tmp.second].pop_back();
if (dist[x][tmp.second] == 0) {
dist[x][tmp.second] = dist[tmp.first][tmp.second] + 1;
q.push(make_pair(x, tmp.second));
}
}
}
printf("-1");
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
long long c[100100], sum, ans;
set<int> st;
int id[100100], pre[100100], suc[100100];
int n, k;
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> c[i];
pre[i] = i - 1;
suc[i] = i + 1;
}
pre[1] = n;
suc[n] = 1;
for (int i = 1; i < n; i++) {
sum += c[i];
ans += c[i] * c[i + 1];
}
sum += c[n];
ans += c[1] * c[n];
long long imp = 0;
while (k--) {
int x;
cin >> x;
long long cur = sum;
cur -= c[x];
if (st.find(pre[x]) != st.end()) {
cur += c[pre[x]];
}
if (st.find(suc[x]) != st.end()) {
cur += c[suc[x]];
}
cur -= imp + c[pre[x]] + c[suc[x]];
ans += cur * c[x];
imp += c[x];
st.insert(x);
}
cout << ans << endl;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
long long resl[1000], resr[1000];
map<pair<int, long long>, long long> cache;
long long query(int f, long long x) {
if (cache.count({f, x})) return cache[{f, x}];
cout << "? " << f << " " << x << "\n" << flush;
long long r;
cin >> r;
cache[{f, x}] = r;
return r;
}
long long findx(int f, long long a, long long b, long long m) {
while (a < b) {
long long c = (a + b) / 2;
long long r = query(f, c);
if (r < m)
a = c + 1;
else
b = c;
}
return a;
}
vector<int> kth(vector<int> f, int k, long long a, long long b, long long &c,
long long m) {
swap(f[0], f[rand() % f.size()]);
vector<int> x, eq, y;
long long p = findx(f[0], a, b, m);
eq.push_back(f[0]);
for (int i = 1; i < f.size(); ++i) {
long long r = query(f[i], p);
if (r > m)
x.push_back(f[i]);
else if (r < m)
y.push_back(f[i]);
else
eq.push_back(f[i]);
}
if (x.size() <= k && k < x.size() + eq.size())
c = p;
else if (k < x.size())
x = kth(x, k, a, p - 1, c, m);
else
y = kth(y, k - x.size() - eq.size(), p + 1, b, c, m);
for (int yy : eq) x.push_back(yy);
for (int yy : y) x.push_back(yy);
return x;
}
void calc(vector<int> f, long long a, long long b, long long l, long long s) {
if (f.size() == 0) return;
if (f.size() == 1) {
resl[f[0] - 1] = a;
resr[f[0] - 1] = b;
return;
}
long long m = l + s * (f.size() / 2);
long long c;
f = kth(f, f.size() / 2, a, b, c, m);
vector<int> x, y;
for (int i = 0; i < f.size() / 2; ++i) x.push_back(f[i]);
for (int i = f.size() / 2; i < f.size(); ++i) y.push_back(f[i]);
calc(x, a, c, l, s);
calc(y, c, b, m, s);
}
int main() {
int n;
long long L;
cin >> n >> L;
vector<int> f;
for (int i = 1; i <= n; ++i) f.push_back(i);
calc(f, 0, 1e18, 0, L / n);
cout << "!\n";
for (int i = 0; i < n; ++i) cout << resl[i] << " " << resr[i] << "\n";
}
| 24
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string x;
getline(cin, x);
int prev = 0;
for (int i = 0; i < x.length(); i++) {
string curStr, prevStr;
curStr = bitset<8>(x.c_str()[i]).to_string();
reverse(curStr.begin(), curStr.end());
unsigned int cur = std::strtol(curStr.c_str(), NULL, 2);
unsigned int res = (prev - cur) % 256;
string ress = bitset<8>(res).to_string();
cout << res << endl;
prev = cur;
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long INF = 1ll << 60;
const double Inf = 1e20;
const double eps = 1e-9;
void gmax(int &a, int b) { a = (a > b ? a : b); }
void gmin(int &a, int b) { a = (a < b ? a : b); }
const int maxn = 200050;
int month[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int n, a[maxn];
bool isleap(int x) { return (x % 4 == 0 && x % 100 != 0) || (x % 400 == 0); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int m1 = 0; m1 <= 11; ++m1) {
bool ok = true;
month[1] = 28;
for (int j = 1; j <= n; ++j) {
if (m1 + j - 1 >= 12) month[1] = 29;
if (m1 + j - 1 >= 24) month[1] = 28;
if (a[j] != month[(m1 + j - 1) % 12]) {
ok = false;
break;
}
}
if (ok) return 0 * printf("Yes");
month[1] = 29;
ok = true;
for (int j = 1; j <= n; ++j) {
if (m1 + j - 1 >= 12) month[1] = 28;
if (m1 + j - 1 >= 24) month[1] = 28;
if (a[j] != month[(m1 + j - 1) % 12]) {
ok = false;
break;
}
}
if (ok) return 0 * printf("Yes");
month[1] = 28;
ok = true;
for (int j = 1; j <= n; ++j) {
if (m1 + j - 1 >= 12) month[1] = 28;
if (m1 + j - 1 >= 24) month[1] = 29;
if (a[j] != month[(m1 + j - 1) % 12]) {
ok = false;
break;
}
}
if (ok) return 0 * printf("Yes");
}
printf("No");
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t) {
int n;
t--;
cin >> n;
if (n % 2 == 0) {
cout << int(n / 2) - 1 << "\n";
} else {
cout << int(n / 2) << "\n";
}
}
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, q, t, k, a, b, c, d;
long long ans[100005];
long long aux[5];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> a >> b >> c >> d;
long long n = a + b + c + d;
aux[0] = a;
aux[1] = b;
aux[2] = c;
aux[3] = d;
deque<long long> d;
for (int i = 0; i < n; ++i) {
int ok = 0;
for (int j = 0; j < 4; ++j) {
if (aux[j]) {
if (d.empty())
d.push_back(j), ok = 1, aux[j]--;
else {
long long back = d.back();
long long front = d.front();
if (abs(back - j) == 1)
d.push_back(j), ok = 1, aux[j]--;
else if (abs(front - j) == 1)
d.push_front(j), ok = 1, aux[j]--;
}
if (ok) break;
}
}
if (!ok) {
cout << "NO";
return 0;
}
}
cout << "YES" << endl;
while (!d.empty()) {
cout << d.front() << ' ';
d.pop_front();
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
long long po[11], tot[11], len[11];
long long calc(long long x, long long lim) {
if (x == 0) return lim;
int num = 0;
long long now = x;
while (now) {
num++;
now /= 10;
}
long long sum = 0;
for (int i = 0; i < num - 1; i++) {
if (sum >= lim - tot[i]) return -1;
sum += tot[i];
}
int det = num - 1;
long long cnt = 0;
cnt = (len[det] + det + 1 + len[det] + (x - po[det] + 1) * (det + 1));
cnt = cnt * (x - po[det] + 1) / 2;
if (sum >= lim - cnt) return -1;
return lim - cnt - sum;
}
long long calx(long long x, long long lim) {
int num = 0;
long long now = x;
while (now) {
num++;
now /= 10;
}
long long sum = 0;
for (int i = 0; i < num - 1; i++) {
long long tp = (po[i + 1] - po[i]) * (i + 1);
if (sum >= lim - tp) return -1;
sum += tp;
}
int det = num - 1;
long long cnt = 0;
cnt = (x - po[det] + 1) * (det + 1);
if (sum >= lim - cnt) return -1;
return lim - cnt - sum;
}
void solve() {
long long k;
scanf("%lld", &k);
long long l = 0, r = 1e9, ans = 0;
while (l <= r) {
long long mid = (l + r) >> 1;
if (calc(mid, k) > 0) {
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
}
}
long long res = calc(ans, k);
l = 0, r = ans + 1, ans = 0;
while (l <= r) {
long long mid = (l + r) >> 1;
if (calx(mid, res) > 0) {
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
}
}
res = calx(ans, res);
long long now = ans + 1;
string num;
while (now) {
num += now % 10 + '0';
now /= 10;
}
reverse(num.begin(), num.end());
cout << num[res - 1] << endl;
}
int main() {
int T;
po[0] = 1;
len[0] = 0;
for (int i = 1; i <= 10; i++) po[i] = 10LL * po[i - 1];
for (int i = 1; i <= 10; i++)
len[i] = len[i - 1] + 1LL * i * (po[i] - po[i - 1]);
for (int i = 0; i <= 9; i++)
tot[i] = (len[i] + (i + 1) + len[i + 1]) * (po[i + 1] - po[i]) / 2;
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, p = 1e9 + 7, v[201], cnt[201], a[201];
bitset<130> f[8];
long long get(long long x) {
long long now = 1, i;
for (i = 1; i < x; i++) now = now * cnt[a[i]] % p;
return now;
}
long long dfs(long long x, long long la) {
long long now = get(x), i;
if (x <= 6) {
for (i = la + 1; i <= m / 2; i++) {
if (!cnt[i]) continue;
if (f[x - 1][i] || f[x - 1][m - i]) continue;
a[x] = i;
if (x <= 5) {
f[x] = f[x - 1];
f[x] |= f[x - 1] << i;
f[x] |= f[x - 1] >> i;
f[x] |= f[x - 1] << (m - i);
f[x] |= f[x - 1] >> (m - i);
}
now = (now + dfs(x + 1, i)) % p;
}
}
return now;
}
int main() {
long long i, k, x;
scanf("%lld%lld%lld", &n, &m, &k);
for (i = 1; i <= k; i++) {
scanf("%lld", &x);
x %= m;
x = min(x, m - x);
v[x] = 1;
cnt[x]++;
}
f[0][0] = 1;
printf("%lld", dfs(1, 0));
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
void bla() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
int main() {
bla();
int n;
cin >> n;
int x[n + 1], y[n + 1];
for (int i = 0; i < n; ++i) cin >> x[i] >> y[i];
int c = 0;
for (int i = 0; i < n; ++i) {
int a = 0, b = 0, d = 0, t = 0;
for (int j = 0; j < n; ++j) {
if (x[j] > x[i] && y[j] == y[i])
a++;
else if (x[j] < x[i] && y[j] == y[i])
b++;
else if (x[j] == x[i] && y[j] < y[i])
d++;
else if (x[j] == x[i] && y[j] > y[i])
t++;
if (a && b && d && t) {
if (a + b + d + t >= 4) {
c++;
break;
}
}
}
}
cout << c;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n++;
cout << ceil(n / 2.0) * (n / 2) << endl;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int w, m, l = 0;
bool f = 1;
int d[30] = {0};
cin >> w >> m;
while (m) {
d[l] = m % w;
m /= w;
l++;
}
for (int i = 0; i < l; i++) {
if (d[i] == 0 || d[i] == 1) continue;
if (d[i] == w - 1 || d[i] == w)
d[i + 1]++;
else {
f = 0;
break;
}
}
if (f)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int now, n, rec;
int a[60];
long long dp[52][52][52];
inline long long DP(int left, int at, int pep) {
if (left < 0 || pep < 0) return 0;
if (at == n) {
if (pep == 0 && left < now) return 1;
return 0;
}
long long a1, a2, ans;
long long &ret = dp[left][at][pep];
if (ret != (-1)) return ret;
a1 = 0;
if (at != rec) a1 = DP(left - a[at], at + 1, pep - 1);
a2 = DP(left, at + 1, pep);
ans = a1 + a2;
ret = ans;
return ret;
}
int main() {
double ans, kk, a1, a2;
int sum, i, p;
scanf("%d", &n);
sum = 0;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
scanf("%d", &p);
if (sum <= p) {
printf("%d.0000000000\n", n);
return 0;
}
ans = 0.0;
for (int l = 0; l < n; l++) {
now = a[l];
rec = l;
memset(dp, -1, sizeof(dp));
for (int pep = 0; pep < n; pep++) {
a2 = DP(p, 0, pep) * 1.0;
a1 = a2;
for (i = 1; i <= pep; i++) {
kk = (i * (1.0)) / (n - i);
a1 = a1 * kk;
}
a1 = a1 / n;
a1 = a1 * pep;
ans = ans + a1;
}
}
printf("%.10lf\n", ans);
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
template <class S, class T>
ostream &operator<<(ostream &os, pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long inf = 1000000001;
const long long INF = (long long)1e18 + 1;
const long double pi = 3.1415926535897932384626433832795028841971L;
vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
vector<int> dx2 = {1, 1, 0, -1, -1, -1, 0, 1},
dy2 = {0, 1, 1, 1, 0, -1, -1, -1};
const long long MOD = 1000000007;
int n;
vector<vector<int> > G;
vector<int> used;
vector<int> d;
void dfs(int now, int par, int depth) {
d[now] = depth;
for (int i = 0; i < (G[now].size()); i++) {
int ch = G[now][i];
if (ch == par) continue;
if (used[ch]) continue;
dfs(ch, now, depth + 1);
}
}
pair<int, int> farest() {
int r;
for (int i = 0; i < (n); i++) {
if (not used[i]) {
r = i;
break;
}
}
fill(d.begin(), d.end(), -inf);
dfs(r, -1, 0);
pair<int, int> ma(-1, inf);
for (int i = 0; i < (n); i++) {
chmax(ma, pair<int, int>(d[i], i));
}
int u = ma.second;
fill(d.begin(), d.end(), -inf);
dfs(u, -1, 0);
ma = pair<int, int>(-1, inf);
for (int i = 0; i < (n); i++) {
chmax(ma, pair<int, int>(d[i], i));
}
int v = ma.second;
return pair<int, int>(u, v);
}
bool dfs2(int now, int par, int tar, vector<int> &path) {
path.push_back(now);
if (now == tar) {
return true;
}
for (int i = 0; i < (G[now].size()); i++) {
int ch = G[now][i];
if (ch == par) continue;
if (used[ch]) continue;
if (dfs2(ch, now, tar, path)) {
return true;
}
}
path.pop_back();
return false;
}
int ask(int u, int v) {
cout << "? " << u + 1 << " " << v + 1 << endl << flush;
int res;
cin >> res;
res--;
return res;
}
void ans(int u) { cout << "! " << u + 1 << endl << flush; }
void dfs3(int now, int par) {
used[now] = true;
for (int i = 0; i < (G[now].size()); i++) {
int ch = G[now][i];
if (ch == par) continue;
if (used[ch]) continue;
dfs3(ch, now);
}
}
void mid(int u, int v) {
vector<int> path;
dfs2(u, -1, v, path);
if (path.size() == 1) {
ans(path[0]);
exit(0);
}
if (path.size() <= 3) {
int w = ask(path[0], path.back());
if (w == path[0] or w == path.back()) {
ans(w);
exit(0);
} else {
used[path[0]] = true;
used[path.back()] = true;
}
} else {
int m = path.size();
int u = path[m / 2 - 1], v = path[m / 2];
int w = ask(u, v);
int make;
if (w == u)
make = v;
else
make = u;
dfs3(make, w);
}
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
;
cin >> n;
G.resize(n);
d.resize(n);
used.resize(n);
for (int i = 0; i < (n - 1); i++) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].push_back(v);
G[v].push_back(u);
}
for (int _ = 0; _ < (n / 2); _++) {
pair<int, int> uv = farest();
mid(uv.first, uv.second);
}
for (int i = 0; i < (n); i++) {
if (not used[i]) {
ans(i);
return 0;
}
}
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(long long first) {
return first ? 8 * sizeof(long long) - __builtin_clzll(first) : 0;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
class DPowerTree {
public:
int N;
vector<vector<int>> E;
vector<int> C;
vector<pair<long long, long long>> Ans;
pair<long long, long long> solve(int u, int p) {
if (E[u].size() == 1 && u != 0) {
return Ans[u] = {C[u], C[u]};
};
long long a = 0, b = 0;
for (int v : E[u]) {
if (v != p) {
auto s = solve(v, u);
a = max(a, s.first);
b += s.second;
}
}
if (C[u] < a) {
return Ans[u] = {C[u], b - a + C[u]};
} else {
return Ans[u] = {a, b};
}
}
void collect(int u, int p, bool allPaths, vector<int>& Ret) {
if (allPaths && C[u] == Ans[u].first) Ret.push_back(u + 1);
int worst = -1;
int cnt = 0;
for (int v : E[u]) {
if (v != p) {
int myDiff = Ans[v].first;
if (myDiff > worst) {
worst = myDiff;
cnt = 0;
}
cnt += myDiff == worst;
}
}
for (int v : E[u]) {
if (v != p) {
collect(v, u,
Ans[v].first < worst || cnt > 1 || (worst <= C[u] && allPaths),
Ret);
}
}
}
void solve(istream& cin, ostream& cout) {
cin >> N;
C.resize(N);
cin >> C;
E.resize(N);
Ans.resize(N);
for (int i = 0; i < N - 1; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
E[u].push_back(v);
E[v].push_back(u);
}
auto s = solve(0, -1);
vector<int> X;
collect(0, -1, true, X);
sort(X.begin(), X.end());
cout << s.second << ' ' << X.size() << endl;
cout << X;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
DPowerTree solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
long long da[15], a[15][15], n;
int main() {
scanf("%lld", &n);
for (int i = 1; i < n; i++)
for (int j = 1; j < n; j++) {
a[i][j] = i * j;
memset(da, 0, sizeof da);
long long now = a[i][j], ans = 0, num = 0;
while (now >= 1) {
da[++num] = now % n;
now = now / n;
}
for (int j = i; j >= 1; j--) ans = ans * 10 + da[j];
a[i][j] = ans;
}
for (int i = 1; i < n; i++) {
for (int j = 1; j < n; j++) printf("%lld ", a[i][j]);
printf("\n");
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int l(int x1, int y1, int x2, int y2) {
if (x1 == x2 || y1 == y2)
return 1;
else
return 2;
}
int s(int x1, int y1, int x2, int y2) {
if (((x1 % 2) == 0 && (y1 % 2) == 0) || ((x1 % 2) != 0 && (y1 % 2) != 0)) {
if (((x2 % 2) == 0 && (y2 % 2) == 0) || ((x2 % 2) != 0 && (y2 % 2) != 0)) {
if (abs(x1 - x2) == abs(y1 - y2))
return 1;
else
return 2;
} else
return 0;
} else if (((x1 % 2) == 0 && (y1 % 2) != 0) ||
((x1 % 2) != 0 && (y1 % 2) == 0))
if (((x2 % 2) == 0 && (y2 % 2) != 0) || ((x2 % 2) != 0 && (y2 % 2) == 0)) {
if (abs(x1 - x2) == abs(y1 - y2))
return 1;
else
return 2;
} else
return 0;
}
int k(int x1, int y1, int x2, int y2) {
return max(abs(x1 - x2), abs(y1 - y2));
}
int main() {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
int a1 = l(x1, y1, x2, y2);
int a2 = s(x1, y1, x2, y2);
int a3 = k(x1, y1, x2, y2);
printf("%d %d %d\n", a1, a2, a3);
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n % 4 == 0) {
cout << n / 4;
} else if (n % 2 == 0 && n >= 6) {
n -= 6;
cout << n / 4 + 1;
} else if (n % 2 != 0 && n >= 9) {
if (n == 9)
cout << 1;
else if (n == 11)
cout << -1;
else {
n -= 9;
if (n % 2 == 0) {
if (n % 4 != 0)
cout << (n - 6) / 4 + 2;
else
cout << n / 4 + 1;
}
}
} else
cout << -1;
cout << endl;
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
#define ll long long
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define deb(x) cout<<#x<<"="<<x<<endl;
#define endl '\n'
#define M 1000000007
#define int long long
#define INF 1e18
#define N 1000005
using namespace std;
void solve()
{
ll n, m;
cin >> n >> m;
ll a[n];
ll sum = 0;
set<pair<ll, ll>> s;
ll pre[n];
for (int i = 0; i < n; ++i)
{
cin >> a[i];
sum += a[i];
}
ll mx = 0;
for (int i = 0; i < n; ++i)
{
if (i == 0)pre[i] = a[i];
else pre[i] = pre[i - 1] + a[i];
if (pre[i] > mx)
s.insert({pre[i], i});
mx = max(mx, pre[i]);
}
while (m--)
{
ll x;
cin >> x;
if (x <= mx)
{
ll pos = s.lower_bound({x, -1})->second;
cout << pos << " ";
}
else if (sum <= 0)
{
cout << -1 << " ";
}
else
{
ll round = (x - mx) / sum;
if (x - round * sum > mx)
round++;
x -= round * sum;
ll pos = s.lower_bound({x, -1})->second;
cout << pos + round*n << " ";
}
} cout << endl;
}
int32_t main()
{
IOS
ll T = 1;
cin >> T;
for (ll i = 1; i <= T; ++i)
{
// cout<<"Case #"<<i<<": ";
solve();
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int cards[222222];
pair<int, int> cards2[222222];
int big = 1000000002;
map<int, int> mp;
char mark[222222];
int m;
int allocard1() {
static int last = -1;
last += 2;
while (true) {
if (mp.find(last) == mp.end()) {
break;
}
last += 2;
}
if (last > m) {
printf("-1");
exit(0);
}
return last;
}
int allocard2() {
static int last = 0;
last += 2;
while (true) {
if (mp.find(last) == mp.end()) {
break;
}
last += 2;
}
if (last > m) {
printf("-1");
exit(0);
}
return last;
}
int main() {
int n;
scanf("%i%i", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%i", &cards[i]);
}
int mc = m / 2;
int mn = m - mc;
int bc = 0;
int bn = 0;
int oc = 0;
int on = 0;
for (int i = 0; i < n; i++) {
if (cards[i] & 1) {
on++;
} else {
oc++;
}
if (mp[cards[i]] == 1) {
if (cards[i] & 1) {
bn++;
} else {
bc++;
}
mark[i] = 1;
} else {
mp[cards[i]] = 1;
mark[i] = 0;
}
cards2[i] = make_pair(cards[i], i);
}
sort(cards2, cards2 + n);
int killc = 0;
int killn = 0;
if (n / 2 < oc - bc) {
killc = oc - bc - n / 2;
}
if (n / 2 < on - bn) {
killn = on - bn - n / 2;
}
int lb = 2;
int kill = 0;
if (killc > 0) {
lb = 0;
kill = killc;
} else if (killn > 0) {
lb = 1;
kill = killn;
}
int add = 0;
for (int i = 0, j = 0; i < n && j < kill; i++) {
if ((cards2[i].first & 1) == lb && !mark[cards2[i].second]) {
mark[cards2[i].second] = 1;
add++;
j++;
}
}
if (killc > 0) {
bc += add;
} else if (killn > 0) {
bn += add;
}
int ans = bc + bn;
mp.clear();
int gc = 0;
int gn = 0;
for (int i = 0; i < n; i++) {
if (!mark[i]) {
mp[cards[i]] = 1;
if (cards[i] & 1) {
gn++;
} else {
gc++;
}
}
}
for (int i = 0; i < n; i++) {
if (mark[i]) {
if (gn < n / 2) {
cards[i] = allocard1();
gn++;
} else {
cards[i] = allocard2();
}
}
}
printf("%i\n", ans);
for (int i = 0; i < n; i++) {
printf("%i ", cards[i]);
}
}
| 11
|
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
const int N = 100010;
const int inf = 0x3f3f3f3f;
using namespace std;
int a[100005];
int main() {
int n, i, dis, cot, ans;
while (~scanf("%d", &n)) {
ans = 0;
cot = 10000000;
while (n--) {
scanf("%d", &dis);
cot = cot < dis ? cot : dis;
}
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (i = n; i >= 1; i--)
if ((n - i + 1) % (cot + 2) && (n - i + 1) % (cot + 2) != (cot + 1))
ans += a[i];
printf("%d\n", ans);
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = -1, MOD = 1e9 + 7;
int n;
long long ans;
bool roto;
set<int> P, S, U;
void mete(int t) {
if (((int)P.size()) && *P.rbegin() > t) {
P.insert(t);
return;
}
if (((int)S.size()) && *S.begin() < t) {
S.insert(t);
return;
}
U.insert(t);
}
void corre(int t) {
if (((int)P.size()) && *P.rbegin() > t) {
assert(P.find(t) != P.end());
roto = true;
return;
}
if (((int)S.size()) && *S.begin() < t) {
assert(S.find(t) != S.end());
roto = true;
return;
}
if (((int)P.size()) && *P.rbegin() == t) {
for (int nt : U) S.insert(nt);
U.clear();
P.erase(t);
return;
}
if (((int)S.size()) && *S.begin() == t) {
for (int nt : U) P.insert(nt);
U.clear();
S.erase(t);
return;
}
assert(U.find(t) != U.end());
for (int nt : U) {
if (nt < t) P.insert(nt);
if (nt > t) S.insert(nt);
}
U.clear();
ans = ans * 2 % MOD;
}
int main() {
ios::sync_with_stdio(false);
while (cin >> n) {
ans = 1;
roto = false;
P.clear();
S.clear();
U.clear();
for (int i = (0); i < (int)(n); i++) {
int t;
string K;
cin >> K >> t;
if (K == "ADD")
mete(t);
else {
corre(t);
if (roto) break;
}
}
ans = ans * (((int)U.size()) + 1) % MOD;
cout << (roto ? 0 : ans) << endl;
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
int count = 0;
while (1) {
if ((*min_element(arr, arr + n) == k)) {
break;
}
sort(arr, arr + n);
int prev = -1;
for (int i = 0; i < n; i++) {
if (arr[i] != prev) {
prev = arr[i];
arr[i]++;
}
}
count++;
}
cout << count;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > s, t;
void read(int n, int m, vector<vector<int> >& b, vector<int>& elem) {
b.assign(n, vector<int>(m, 0));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &b[i][j]), elem.push_back(b[i][j]);
;
sort(elem.begin(), elem.end());
}
void solve1r(vector<pair<int, int> >& ans) {
int m = s[0].size();
for (int i = 0; i < m; ++i) {
for (int j = 0; j < m; ++j) {
vector<vector<int> > tmp = s;
int dir = (j > i) - (j < i);
for (int k = i; k != j; k += dir) {
swap(tmp[0][k], tmp[0][k + dir]);
}
if (tmp == t) {
ans.push_back(pair<int, int>(0, i));
for (int k = i; k != j; k += dir) {
ans.push_back(pair<int, int>(0, k + dir));
}
return;
}
}
}
}
void rot(int& pr, int& pc, int n, int m) {
int tmp = pr;
pr = pc;
pc = n - 1 - tmp;
}
void inv_rot(int& pr, int& pc, int n, int m) {
int tmp = pr;
pr = m - 1 - pc;
pc = tmp;
}
void inv_rot(vector<pair<int, int> >& ans, int n, int m) {
for (pair<int, int>& p : ans) {
p = pair<int, int>(m - 1 - p.second, p.first);
}
}
vector<vector<int> > rot(vector<vector<int> >& vec) {
int n = vec.size(), m = vec[0].size();
vector<vector<int> > ans(m, vector<int>(n, 0));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
ans[j][n - 1 - i] = vec[i][j];
}
return ans;
}
vector<vector<int> > inv_rot(vector<vector<int> >& vec) {
int n = vec.size(), m = vec[0].size();
vector<vector<int> > ans(m, vector<int>(n, 0));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
ans[m - 1 - j][i] = vec[i][j];
}
return ans;
}
void find(int& sr, int& sc, int tr, int tc) {
int n = s.size(), m = s[0].size();
for (sr = 0; sr < n; ++sr)
for (sc = 0; sc < m; ++sc)
if (s[sr][sc] == t[tr][tc]) return;
}
void move(vector<pair<int, int> >& ans, int& pr, int& pc, int rd, int cd) {
int rv = (rd > pr) - (rd < pr);
int cv = (cd > pc) - (cd < pc);
while (pr != rd || pc != cd) {
swap(s[pr][pc], s[pr + rv][pc + cv]);
ans.push_back(pair<int, int>(pr += rv, pc += cv));
}
}
int solve3r(int& pr, int& pc, vector<pair<int, int> >& ans) {
int n = s.size(), m = s[0].size();
move(ans, pr, pc, pr, m - 1);
move(ans, pr, pc, n - 1, pc);
for (int i = n - 1; i > 1; --i) {
for (int j = m - 1; j >= 0; --j) {
int ro, co;
find(ro, co, i, j);
assert(ro != i || co != j);
if (co <= j && j > 0) {
ro = min(ro, i - 1);
co = min(co, j - 1);
while (move(ans, pr, pc, pr, pc - 1), s[i][j] != t[i][j]) {
move(ans, pr, pc, pr, co);
move(ans, pr, pc, ro, pc);
move(ans, pr, pc, pr, j);
move(ans, pr, pc, i, pc);
assert(pr == i && pc == j);
}
} else {
ro = min(ro, i - 2);
while (swap(s[pr][pc], s[pr - 1][pc + 1]),
ans.push_back(pair<int, int>(--pr, ++pc)), s[i][j] != t[i][j]) {
move(ans, pr, pc, pr, m - 1);
move(ans, pr, pc, ro, pc);
move(ans, pr, pc, pr, j);
move(ans, pr, pc, i, pc);
assert(pr == i && pc == j);
}
if (j == 0) {
move(ans, pr, pc, pr, m - 1);
} else {
move(ans, pr, pc, pr, pc - 2);
move(ans, pr, pc, pr + 1, pc);
}
}
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> es, et;
read(n, m, s, es);
read(n, m, t, et);
if (es != et) {
printf("-1\n");
return 0;
}
vector<pair<int, int> > ans;
if (n == 1) {
solve1r(ans);
} else if (m == 1) {
s = rot(s);
t = rot(t);
solve1r(ans);
inv_rot(ans, s.size(), s[0].size());
} else {
int pr, pc;
find(pr, pc, 0, 0);
ans.push_back(pair<int, int>(pr, pc));
solve3r(pr, pc, ans);
s.resize(2);
t.resize(2);
if (m > 2) {
rot(pr, pc, s.size(), s[0].size());
s = rot(s);
t = rot(t);
vector<pair<int, int> > ans2;
solve3r(pr, pc, ans2);
inv_rot(ans2, s.size(), s[0].size());
ans.insert(ans.end(), ans2.begin(), ans2.end());
inv_rot(pr, pc, s.size(), s[0].size());
s.resize(2);
t.resize(2);
s = inv_rot(s);
t = inv_rot(t);
assert(pr == 0 && pc == 1);
move(ans, pr, pc, 1, 1);
}
assert(pr == 1 && pc == 1);
int ro, co;
find(ro, co, 1, 1);
move(ans, pr, pc, ro, co);
move(ans, pr, pc, 0, 0);
while (s != t) {
move(ans, pr, pc, 0, 1);
move(ans, pr, pc, 1, 0);
move(ans, pr, pc, 0, 0);
}
}
if (ans.empty()) {
printf("-1\n");
} else {
printf("%d\n", (int)ans.size() - 1);
for (int i = 0; i < ans.size(); ++i) {
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
}
}
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
struct ed {
int x, y, w, id;
} e[maxn * maxn];
bool cmp(ed a, ed b) { return a.w > b.w; }
int fa[maxn], en[maxn];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void Merge(int x, int y) {
int f = find(y);
fa[f] = find(x);
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].x, &e[i].y, &e[i].w);
e[i].id = i;
}
sort(e + 1, e + m + 1, cmp);
while (q--) {
memset(en, -1, sizeof(en));
for (int i = 1; i <= n; i++) fa[i] = i;
int l, r, ans = -1;
scanf("%d%d", &l, &r);
for (int i = 1; i <= m; i++)
if (e[i].id >= l && e[i].id <= r) {
if (find(e[i].x) == find(e[i].y)) {
ans = e[i].w;
break;
}
if (en[e[i].x] != -1)
Merge(en[e[i].x], e[i].y);
else
en[e[i].x] = e[i].y;
if (en[e[i].y] != -1)
Merge(en[e[i].y], e[i].x);
else
en[e[i].y] = e[i].x;
}
printf("%d\n", ans);
}
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
vector<int> a;
cin >> n;
for (int i = 0; i < n; i++) {
int tmp;
cin >> tmp;
if (tmp) a.push_back(tmp);
}
int count = 0;
if (a.size()) {
count = 1;
sort(a.begin(), a.end());
int book = a[0];
for (int i = 1; i <= a.size() - 1; i++) {
if (a[i] != book) {
count++;
book = a[i];
}
}
}
cout << count;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, a, b;
cin >> q;
for (int t = 0; t < q; t++) {
cin >> a >> b;
int c = b / a;
int d = b % a;
cout << d * (c + 1) * (c + 1) + (a - d) * c * c << endl;
}
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1E9 + 7);
const double EPS = 1e-6;
int main() {
int n, p[4][4];
bool found;
int f, s;
while (cin >> n) {
found = false;
for (int i = (0); (i) < int(4); ++i)
for (int j = (0); (j) < int(4); ++j) cin >> p[i][j];
for (int i = (0); (i) < int(4); ++i) {
for (int j = (0); (j) < int(2); ++j)
for (int h = (2); (h) < int(4); ++h) {
if (p[i][j] + p[i][h] <= n) {
f = p[i][j];
s = p[i][h];
if (f + s <= n) f += n - (f + s);
found = true;
printf("%d %d %d\n", i + 1, f, s);
goto done;
}
}
}
done:
if (!found) puts("-1");
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int dp[5009][5009], a[5009], b[5009], c[5009], from[5009], n;
vector<int> retval[5009];
int solve(int i, int m) {
if (i == (n + 1)) return 0;
if (m < a[i]) return dp[i][m] = -1e9;
if (dp[i][m] != -1) return dp[i][m];
int ansmax = solve(i + 1, m + b[i]);
int ans, j, cnt = 0, sz = retval[i].size();
for (j = 0; j < sz; j++) {
if (j >= (m + b[i])) break;
cnt += retval[i][j];
ans = solve(i + 1, m + b[i] - j - 1) + cnt;
ansmax = max(ansmax, ans);
}
return dp[i][m] = ansmax;
}
int main() {
int i, j, k, l, m, ans, men;
cin >> n >> m >> men;
for (i = 0; i <= 5000; i++) {
for (j = 0; j <= 5000; j++) {
dp[i][j] = -1;
}
from[i] = i;
}
for (i = 1; i <= n; i++) cin >> a[i] >> b[i] >> c[i];
for (i = 0; i < m; i++) {
cin >> j >> k;
if (from[k] < j) from[k] = j;
}
for (i = 1; i <= n; i++) {
retval[from[i]].push_back(c[i]);
}
for (i = 1; i <= n; i++)
sort(retval[i].begin(), retval[i].end(), greater<int>());
ans = solve(1, men);
if (ans < 0)
cout << -1 << endl;
else
cout << ans << endl;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1 << 10;
const int mod = (int)1e9 + 7;
int dp[2][maxN][maxN];
string a[maxN];
void add(int &x, int a) {
x += a;
if (x >= mod) {
x -= mod;
}
}
int abs_(int x) { return max(x, -x); }
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m + 2; i++) {
a[0].push_back('#');
a[n + 1].push_back('#');
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] = "#" + a[i] + "#";
}
dp[1][1][n] = (a[1][1] == a[n][m]);
int ans = 0;
for (int l = 1; l * 2 <= n + m; l++) {
for (int i = 1; i <= n; i++) {
for (int ii = 1; ii <= n; ii++) {
dp[(l + 1) & 1][i][ii] = 0;
}
}
for (int i = 1; i <= n; i++) {
for (int ii = 1; ii <= n; ii++) {
int j = 1 + l - i;
int jj = m + n - ii - l + 1;
if ((j < 1 || j > m) || (jj > m || jj < 1)) continue;
if (abs_(i - ii) + abs_(j - jj) <= 1) {
add(ans, dp[l & 1][i][ii]);
} else {
for (int m1 = 1; m1 <= 2; m1++) {
for (int m2 = 1; m2 <= 2; m2++) {
int i2 = i + (m1 & 1);
int j2 = j + (m1 >> 1);
int ii2 = ii - (m2 & 1);
int jj2 = jj - (m2 >> 1);
if (a[i2][j2] == a[ii2][jj2]) {
add(dp[(l + 1) & 1][i2][ii2], dp[l & 1][i][ii]);
}
}
}
}
}
}
}
cout << ans << endl;
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = 100100;
const int inf = 1e9;
const int mod = 1000000007;
char s[MXN];
int add(int a, int b, int m) { return (a + b) % m; }
int mul(int a, int b, int m) { return (1LL * a * b) % m; }
int powmod(int a, int n, int m) {
int res = 1;
while (n) {
if (n & 1) res = mul(res, a, m);
a = mul(a, a, m);
n >>= 1;
}
return res;
}
int main() {
int p, k;
scanf("%d%d", &p, &k);
if (k == 0) {
printf("%d", powmod(p, p - 1, mod));
return 0;
}
int x = 1;
int pw = k;
for (;;) {
if (pw == 1) break;
pw = mul(pw, k, p);
x++;
}
int muller = 1;
if (k == 1) muller = p;
printf("%d", mul(muller, powmod(p, (p - 1) / x, mod), mod));
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
long long q;
cin >> q;
map<long long, long long> m1, m2;
long long problem = 0;
while (q--) {
long long r, c;
cin >> r >> c;
if (r == 1) {
if (m1[c] == 1) {
m1[c] = 0;
if (m2[c - 1] == 1) {
problem--;
}
if (m2[c + 1] == 1) {
problem--;
}
if (m2[c] == 1) problem--;
} else {
m1[c] = 1;
if (m2[c - 1] == 1) problem++;
if (m2[c + 1] == 1) problem++;
if (m2[c] == 1) problem++;
}
} else {
if (m2[c] == 1) {
m2[c] = 0;
if (m1[c - 1] == 1) {
problem--;
}
if (m1[c + 1] == 1) {
problem--;
}
if (m1[c] == 1) problem--;
} else {
m2[c] = 1;
if (m1[c - 1] == 1) problem++;
if (m1[c + 1] == 1) problem++;
if (m1[c] == 1) problem++;
}
}
if (problem > 0)
cout << "NO\n";
else
cout << "YES\n";
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
const int off = 1e5 - 100;
const int B = 1e4 - 100 + off;
int n, k, a[N], b[N];
int dp[N][B];
int f(int n, int r) {
if (n == 0) return a[0] * (a[0] - k * b[0] == r - off);
if (dp[n][r] != -1) return dp[n][r];
int ans = f(n - 1, r);
if (f(n - 1, r - a[n] + k * b[n]))
ans = max(ans, a[n] + f(n - 1, r - a[n] + k * b[n]));
else if (a[n] - k * b[n] == r - off)
ans = max(ans, a[n] + f(n - 1, r - a[n] + k * b[n]));
return dp[n][r] = ans;
}
int main() {
ios::sync_with_stdio(0);
while (cin >> n >> k) {
for (int i = 0; i < N; i++)
for (int j = 0; j < B; j++) dp[i][j] = -1;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
int ans = f(n - 1, off);
cout << (ans ? ans : -1) << "\n\n";
}
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int min(int x, int y) { return (x < y) ? x : y; }
int max(int x, int y) { return (x > y) ? x : y; }
int find(int disjoint[], int x) {
if (disjoint[x] == x)
return x;
else
disjoint[x] = find(disjoint, disjoint[x]);
return disjoint[x];
}
void unio(int disjoint[], int rank[], int x, int y) {
int val1 = find(disjoint, x);
int val2 = find(disjoint, y);
if (val1 == val2) return;
if (rank[val1] > rank[val2]) {
disjoint[val2] = val1;
rank[val1]++;
} else {
disjoint[val1] = val2;
rank[val2]++;
}
}
int dp[1003][1003] = {0};
int main(int argc, char const *argv[]) {
int n, m, w, x, y;
scanf("%d %d %d", &n, &m, &w);
int weight[1003], beauty[1003];
int disjoint[1003] = {0}, rank[1003] = {0};
for (int i = 1; i <= n; i++) disjoint[i] = i;
for (int i = 1; i <= n; ++i) scanf("%d", &weight[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &beauty[i]);
for (int i = 0; i < m; ++i) {
scanf("%d %d", &x, &y);
unio(disjoint, rank, x, y);
}
std::map<int, std::vector<int> > map;
for (int i = 1; i <= n; ++i) {
map[find(disjoint, i)].push_back(i);
}
int max_weight[1003] = {0}, max_beauty[1003] = {0};
for (std::map<int, std::vector<int> >::iterator it = map.begin();
it != map.end(); it++) {
int we = 0;
int sum = 0;
std::vector<int> v = it->second;
int length = v.size();
for (int i = 0; i < length; ++i) {
sum += beauty[v[i]];
we += weight[v[i]];
}
max_weight[it->first] = we;
max_beauty[it->first] = sum;
}
int map_count = 1;
for (std::map<int, std::vector<int> >::iterator it = map.begin();
it != map.end(); it++) {
std::vector<int> v = it->second;
int length = v.size();
for (int i = 0; i < length; ++i) {
for (int j = 1; j <= w; ++j) {
if (weight[v[i]] <= j)
dp[map_count][j] =
max(dp[map_count][j],
max(dp[map_count - 1][j],
(beauty[v[i]] + dp[map_count - 1][j - weight[v[i]]])));
else
dp[map_count][j] = max(dp[map_count][j], dp[map_count - 1][j]);
}
}
for (int i = 1; i <= w; ++i) {
if (max_weight[it->first] <= i)
dp[map_count][i] =
max(dp[map_count][i],
max(dp[map_count - 1][i],
(max_beauty[it->first] +
dp[map_count - 1][i - max_weight[it->first]])));
}
map_count++;
}
printf("%d\n", dp[map_count - 1][w]);
return 0;
}
| 8
|
#include <bits/stdc++.h>
long long ans = 1e9, a, b, i, j, o, sum, siz, D[3333], data[3333][3333],
sz[3333], x, y, h;
int main() {
ans = ans * ans;
scanf("%lld%lld", &a, &b);
for (i = 0; i < a; i++) {
scanf("%lld%lld", &x, &y);
data[x][sz[x]++] = y;
}
for (i = 1; i <= b; i++) std::sort(data[i], data[i] + sz[i]);
for (h = 1; h <= a; h++) {
o = h;
sum = 0;
siz = 0;
for (i = 2; i <= b; i++) {
if (sz[i] >= h) {
for (j = 0; j <= sz[i] - h; j++) {
sum += data[i][j];
o--;
}
for (j = sz[i] - h + 1; j < sz[i]; j++) {
D[siz++] = data[i][j];
}
} else {
for (j = 0; j < sz[i]; j++) {
D[siz++] = data[i][j];
}
}
}
o -= sz[1];
if (o < 0) continue;
if (o > 0) {
std::sort(D, D + siz);
for (j = 0; j < siz; j++) {
if (o > 0) {
o--;
sum += D[j];
} else
break;
}
}
if (ans > sum) ans = sum;
}
printf("%lld", ans);
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a;
scanf("%lld%lld", &n, &a);
long long ang = 2;
double pang = 180. / n;
for (int i = 2; i < n; ++i) {
if (fabs(pang * (i - 1) - a) < fabs(pang * (ang - 1) - a)) ang = i;
}
printf("%lld %lld %lld\n", 2ll, 1ll, ang + 1);
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
long long fr() {
long long t = 0;
long long flag = 0;
char ch = getchar();
while (ch < 33) ch = getchar();
if (ch == '-') {
flag = 1;
ch = getchar();
}
while (ch > 32) {
t = t * 10 + ch - '0';
ch = getchar();
}
if (flag == 1)
return ((-1) * t);
else
return t;
}
int main(void) {
long long i, j, k, t, n, h, x, index, sum, y, cur, m, ma, ans;
long long b[200] = {0};
n = fr();
m = fr();
for (i = 0; i < m; i++) {
for (j = 0, ma = 0, index = 0; j < n; j++) {
x = fr();
if (x > ma) {
ma = x;
index = j;
}
}
b[index]++;
}
for (j = 0, ma = 0, index = 1; j < n; j++) {
if (b[j] > ma) {
ma = b[j];
index = j + 1;
}
}
printf("%I64d\n", index);
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int x, y, w;
int mp[22][22];
int d[22];
int minn;
int stk[22], top;
bool vis[22];
void DFS(int cnt, int val) {
if (cnt == top) minn = min(minn, val);
for (int i = 0; i < top; i++) {
int now = stk[i];
if (!vis[now]) {
for (int j = i + 1; j < top; j++) {
int next = stk[j];
if (!vis[next]) {
vis[now] = vis[next] = true;
DFS(cnt + 2, val + mp[now][next]);
vis[now] = vis[next] = false;
}
}
break;
}
}
}
int main() {
while (~scanf("%d%d", &n, &m)) {
memset(mp, 0x3f3f3f3f, sizeof(mp));
memset(d, 0, sizeof(d));
int sum = 0;
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &x, &y, &w);
mp[x][y] = min(mp[x][y], w);
mp[y][x] = mp[x][y];
sum += w;
d[x]++;
d[y]++;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
mp[i][j] = min(mp[i][j], mp[i][k] + mp[k][j]);
bool flag = true;
for (int i = 1; i <= n; i++) {
if (mp[i][1] == 0x3f3f3f3f)
for (int j = 1; j <= n; j++) {
if (mp[i][j] != 0x3f3f3f3f) flag = false;
}
}
if (flag) {
memset(vis, 0, sizeof(vis));
top = 0;
for (int i = 1; i <= n; i++)
if (d[i] & 1) stk[top++] = i;
minn = 0x3f3f3f3f;
DFS(0, 0);
printf("%d\n", sum + minn);
} else
printf("-1\n");
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(const pair<long long int, long long int>& a,
const pair<long long int, long long int>& b) {
if (a.first > b.first) return true;
if (a.first < b.first) return false;
if (a.first == b.first) return a.second < b.second;
}
int main() {
long long int t = 1;
while (t--) {
long long int n, i, j, x;
cin >> n;
long long int a[n];
long long int c2 = 0;
long long int c4 = 0;
long long int c6 = 0;
long long int c8 = 0;
map<long long int, long long int> m;
for (i = 0; i < n; i++) {
cin >> a[i];
x = a[i];
m[x]++;
if (m[x] == 2) {
c2++;
} else if (m[x] == 4) {
c4++;
c2--;
} else if (m[x] == 6) {
c6++;
c4--;
} else if (m[x] == 8) {
c8++;
c6--;
}
}
long long int q;
cin >> q;
char c;
for (i = 0; i < q; i++) {
cin >> c;
cin >> x;
if (c == '+') {
m[x]++;
if (m[x] == 2) {
c2++;
} else if (m[x] == 4) {
c4++;
c2--;
} else if (m[x] == 6) {
c6++;
c4--;
} else if (m[x] == 8) {
c8++;
c6--;
}
} else {
m[x]--;
if (m[x] == 1) {
c2--;
} else if (m[x] == 3) {
c2++;
c4--;
} else if (m[x] == 5) {
c4++;
c6--;
} else if (m[x] == 7) {
c6++;
c8--;
}
}
if ((c8 >= 1) || (c6 == 1 && (c2 >= 1 || c4 >= 1)) || (c6 > 1) ||
(c4 == 1 && c2 >= 2) || (c4 >= 2)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i == 1 && j == 1)
cout << "W";
else
cout << "B";
}
cout << endl;
}
}
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100, maxk = 13, maxm = 4;
const int mod = 1000000007;
int mul(long long a, long long b) { return a * b % mod; }
int f[maxn][1 << maxm][maxk];
int main() {
int n, k, m;
cin >> n >> k >> m;
f[n + 1][0][0] = 1;
for (int i = n + 1; i >= 2; i--) {
for (int j = 0; j < 1 << m; j++) {
for (int rk = 0; rk < k; rk++) {
if (f[i][j][rk]) {
int nj = ((j << 1) + 1) & ((1 << m) - 1);
f[i - 1][nj][rk + 1] += mul(__builtin_popcount(j) + 1, f[i][j][rk]);
if (f[i - 1][nj][rk + 1] >= mod) f[i - 1][nj][rk + 1] -= mod;
nj &= ~1;
f[i - 1][nj][rk] += f[i][j][rk];
if (f[i - 1][nj][rk] >= mod) f[i - 1][nj][rk] -= mod;
}
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j < 1 << m; j++) {
ans += f[i][j][k];
if (ans >= mod) ans -= mod;
}
cout << ans << endl;
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
bool flag = false;
for (int i = 1; i <= k; i++) {
int x, y;
scanf("%d%d", &x, &y);
int dx1 = x - 1;
int dx2 = n - x;
int dy1 = y - 1;
int dy2 = m - y;
if (dx1 <= 4 || dx2 <= 4) flag = true;
if (dy1 <= 4 || dy2 <= 4) flag = true;
}
if (flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
void fw_update(map<int, int> &f, int pos, int diff, int max_pos) {
for (int i = pos; i <= max_pos; i += i & (-i)) {
f[i] += diff;
}
}
int fw_sum(map<int, int> &f, int pos) {
int res = 0;
for (int i = pos; i >= 1; i -= i & (-i)) {
res += f[i];
}
return res;
}
int main(int argc, char **argv) {
int n;
scanf("%d", &n);
map<int, map<int, int> > q;
const int max_pos = 1000000000;
for (int i = 0; i < n; i++) {
int ai, ti, xi;
scanf("%d%d%d", &ai, &ti, &xi);
switch (ai) {
case 1:
fw_update(q[xi], ti, +1, max_pos);
break;
case 2:
fw_update(q[xi], ti, -1, max_pos);
break;
default:
printf("%d\n", fw_sum(q[xi], ti));
break;
}
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
string a;
int n;
int k;
int used[50];
int used1[50];
void input();
void solve();
int main() {
input();
solve();
return 0;
}
void input() {
cin >> a;
n = a.size();
cin >> k;
}
void solve() {
int i, j;
int br1 = 0;
for (i = 0; i < n; i++) {
if (used[a[i] - 'a'] == 0) br1++;
used[a[i] - 'a']++;
}
for (i = 0; i < 26; i++) {
used1[i] = used[i];
}
sort(used, used + 26);
int sm = 0;
int br = 0;
for (i = 0; i < 26; i++) {
sm += used[i];
if (sm > k) {
sm -= used[i];
break;
}
if (used[i] != 0) br++;
}
printf("%d\n", br1 - br);
int h = 0;
for (i = 0; i < 26; i++) {
if (used[i] != 0) {
if (h == br) break;
h++;
for (j = 0; j < 26; j++) {
if (used[i] == used1[j]) {
used1[j] = -1;
break;
}
}
}
}
for (i = 0; i < n; i++) {
}
for (i = 0; i < n; i++) {
if (used1[a[i] - 'a'] != -1) cout << a[i];
}
cout << "\n";
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int n, m, k;
ll need;
vector<vector<int>> row, col;
vector<int> dx = {0, 1, 0, -1};
vector<int> dy = {1, 0, -1, 0};
int mn_x, mx_x, mn_y, mx_y;
inline void GG(bool chk = false) {
cout << (chk ? "Yes\n" : "No\n");
exit(0);
}
ll go(int x, int y, int d = 0) {
if (d == 4) d = 0;
if (d == 0) {
int pos = lower_bound(row[x].begin(), row[x].end(), y) - row[x].begin();
int to_y;
if (pos == row[x].size())
to_y = mx_y - 1;
else
to_y = min(row[x][pos], mx_y) - 1;
ll cur = to_y - y;
mx_y = to_y;
if (to_y == y && !(make_pair(x, y) == make_pair(0, 0))) return 0;
return cur + go(x, to_y, d + 1);
} else if (d == 1) {
int pos = lower_bound(col[y].begin(), col[y].end(), x) - col[y].begin();
int to_x;
if (pos == col[y].size())
to_x = mx_x - 1;
else
to_x = min(mx_x, col[y][pos]) - 1;
ll cur = to_x - x;
mx_x = to_x;
if (to_x == x) return 0;
return cur + go(to_x, y, d + 1);
} else if (d == 2) {
int pos = lower_bound(row[x].begin(), row[x].end(), y) - row[x].begin() - 1;
int to_y;
if (pos == -1)
to_y = mn_y + 1;
else
to_y = max(mn_y, row[x][pos]) + 1;
ll cur = y - to_y;
mn_y = to_y;
if (to_y == y) return 0;
return cur + go(x, to_y, d + 1);
} else {
int pos = lower_bound(col[y].begin(), col[y].end(), x) - col[y].begin() - 1;
int to_x;
if (pos == -1)
to_x = mn_x + 1;
else
to_x = max(col[y][pos], mn_x) + 1;
ll cur = x - to_x;
mn_x = to_x;
if (to_x == x) return 0;
return cur + go(to_x, y, d + 1);
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m >> k;
need = 1ll * n * m - k;
row.resize(n);
col.resize(m);
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
x--, y--;
row[x].push_back(y);
col[y].push_back(x);
}
for (auto &el : row) sort(el.begin(), el.end());
for (auto &el : col) sort(el.begin(), el.end());
mn_x = 0, mx_x = n, mn_y = -1, mx_y = m;
GG(go(0, 0) + 1 == need);
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
template <class T>
inline T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long n, x, res[1000006], top;
bool ok[1000006];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> x;
ok[0] = ok[x] = true;
for (long long i = 1, _b = 1 << n; i < _b; i++) {
if (ok[i]) continue;
res[++top] = i;
ok[x ^ i] = true;
}
cout << top << "\n";
for (long long i = 1, _b = top; i <= _b; i++)
cout << (res[i] ^ res[i - 1]) << " ";
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAX = 1e5 + 55;
const int INF = 1e9 + 77;
const long long INFINF = 1e18 + 1e17;
const double PI = acos(-1.0);
long long Power(long long x, long long y) {
if (!y) return 1;
long long s = Power(x, y >> 1);
s *= s;
if (y & 1) s *= x;
return s;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, d, m;
cin >> n >> d >> m;
vector<long long> small;
vector<long long> big;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
if (a > m) {
big.push_back(a);
} else {
small.push_back(a);
}
}
sort(small.begin(), small.end(), greater<long long>());
sort(big.begin(), big.end(), greater<long long>());
vector<long long> preSmall((int)small.size());
vector<long long> preBig((int)big.size());
if ((int)small.size()) {
preSmall[0] = small[0];
for (int i = 1; i < (int)small.size(); i++) {
preSmall[i] = preSmall[i - 1] + small[i];
}
}
if ((int)big.size()) {
preBig[0] = big[0];
for (int i = 1; i < (int)big.size(); i++) {
preBig[i] = preBig[i - 1] + big[i];
}
}
long long ans = 0;
for (int how = 0; how <= (int)small.size(); how++) {
long long rest = n - how;
rest = (rest / (d + 1)) + ((bool)(rest % (d + 1)));
long long curAns = 0;
if (how) {
curAns = preSmall[how - 1];
}
if (rest <= (int)big.size()) {
if (rest) {
curAns += preBig[rest - 1];
}
ans = max(ans, curAns);
}
}
cout << ans;
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, a[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
map<int, int> f;
long long x = 0, y;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++f[a[i]];
}
sort(a, a + n);
for (auto x : f)
if (x.second > 2) return cout << "cslnb\n", 0;
int c = 0;
for (auto x : f)
if (x.second == 2) ++c;
for (auto x : f) {
if (x.second == 2 && f[x.first - 1]) return cout << "cslnb\n", 0;
}
if (c > 1) return cout << "cslnb\n", 0;
if (f[0] >= 2) return cout << "cslnb\n", 0;
for (int i = 0; i < n; ++i) x += a[i] - i;
if (x & 1)
cout << "sjfnb\n";
else
cout << "cslnb\n";
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
int dp[(1 << 20) + 100];
int a[50][50];
int main() {
int n, k, i, j, mask, m, _m;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
}
}
m = n / 2;
dp[0] = 0;
for (mask = 1; mask < (1 << m); mask++) {
int lim = 32 - __builtin_clz(mask);
for (i = 0; i < lim; i++) {
if (!(mask & (1 << i))) continue;
for (j = 0; j < lim; j++) {
if (i == j) continue;
if (!(mask & (1 << j))) continue;
if (!a[i][j]) break;
}
dp[mask] = max(dp[mask], dp[mask ^ (1 << i)] + (j == lim));
}
}
int ans = dp[mask - 1];
_m = n - m;
for (mask = 1; mask < (1 << _m); mask++) {
int lim = 32 - __builtin_clz(mask);
for (i = 0; i < lim; i++) {
if (!(mask & (1 << i))) continue;
for (j = i + 1; j < lim; j++) {
if (!(mask & (1 << j))) continue;
if (!a[m + i][m + j]) break;
}
if (j < lim) break;
}
if (i == lim) {
int _mask = 0;
for (i = 0; i < m; i++) {
for (j = 0; j < _m; j++) {
if (!(mask & (1 << j))) continue;
if (!a[i][m + j]) break;
}
if (j == _m) {
_mask |= (1 << i);
}
};
ans = max(ans, __builtin_popcount(mask) + dp[_mask]);
}
}
printf("%.10lf\n", ((double)k * k) * (ans - 1) / (2.0 * ans));
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int high[105];
vector<string> v;
bool stu[105];
int main() {
int n, m;
cin >> n >> m;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
v.push_back(s);
for (int i = 0; i < s.size(); i++) {
int x = s[i] - '0';
high[i] = max(high[i], x);
}
}
for (int i = 0; i < v.size(); i++) {
for (int j = 0; j < v[i].size(); j++) {
int x = v[i][j] - '0';
if (x == high[j]) {
stu[i] = 1;
}
}
}
int c = 0;
for (int i = 0; i < n; i++) {
if (stu[i]) c++;
}
cout << c << endl;
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int n, m, sum;
int main() {
cin >> n >> m;
int pos = 1;
while (1) {
if (m >= pos)
m -= pos;
else
break;
pos++;
if (pos == n + 1) pos = 1;
}
cout << m;
time_t start = clock();
cerr << "\n"
<< "Execution Time = " << double(clock() - start) / CLOCKS_PER_SEC
<< "\t";
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
string s1, s2;
int ans[maxn];
int main() {
int n, m, q;
cin >> n >> m >> q;
cin >> s1 >> s2;
memset(ans, 0, sizeof(ans));
for (int i = 0; i + m <= n; i++) {
if (s1.substr(i, m) == s2) {
ans[i + 1]++;
}
}
for (int i = 1; i <= n; i++) {
ans[i] += ans[i - 1];
}
while (q--) {
int a, b;
cin >> a >> b;
b -= m - 1;
if (b < 0) b = 0;
cout << max(0, ans[b] - ans[a - 1]) << endl;
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
int a[maxn];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int i, j;
int t;
cin >> t;
long long n, a, b;
while (t--) {
cin >> n >> a >> b;
if (2 * a <= b) {
cout << n * a << endl;
} else {
long long num = n / 2;
long long yushu = n % 2;
cout << num * b + yushu * a << endl;
}
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const long long mod = 1e9 + 7;
const int maxn = 1e6 + 5;
int n, m;
vector<pair<int, int>> g[maxn];
int a[maxn];
vector<int> ans;
bool viz[maxn];
int dfs(int at, int id = -1) {
viz[at] = true;
int cur = a[at];
for (auto ed : g[at]) {
int to = ed.second;
if (!viz[to] && dfs(to, ed.first)) {
cur = 1 ^ cur;
}
}
if (cur) {
assert(id != -1);
ans.push_back(id);
}
return cur;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
int neg1 = 0;
int d = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == -1) {
neg1++;
} else {
d += a[i];
}
}
if (d % 2 && neg1 == 0) out(-1);
for (int i = 1; i <= n; i++) {
if (a[i] == -1) {
if (d % 2) {
a[i] = 1;
d++;
} else {
a[i] = 0;
}
}
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back({i, v});
g[v].push_back({i, u});
}
dfs(1);
cout << ans.size() << endl;
for (auto x : ans) {
cout << x + 1 << "\n";
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int N = 52, mod = 1e9 + 7;
int c[N], dp[N][N][N], power[N];
inline long long mul(int a, int b) { return 1LL * a * b % mod; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, p;
cin >> n >> p;
for (int i = 0; i < n; i++) cin >> c[i];
dp[0][0][0] = 1;
power[0] = 1;
for (int i = 1; i < N; i++) power[i] = 2LL * power[i - 1] % mod;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= i; j++)
for (int k = 0; k + j <= i; k++) {
if (c[i - 1] != 1) {
long long ways = 0;
if (j) {
if (k == 0)
ways = power[i - 1];
else
ways = power[i - 2];
dp[i][j][k] += mul(ways, dp[i - 1][j - 1][k]), dp[i][j][k] %= mod;
}
if (k == 0)
ways = 0;
else
ways = power[i - 2];
dp[i][j][k] += mul(ways, dp[i - 1][j][k]), dp[i][j][k] %= mod;
}
if (c[i - 1] != 0) {
long long ways = 0;
if (k) {
if (j == 0)
ways = power[i - 1];
else
ways = power[i - 2];
dp[i][j][k] += mul(ways, dp[i - 1][j][k - 1]) % mod,
dp[i][j][k] %= mod;
}
if (j == 0)
ways = 0;
else
ways = power[i - 2];
dp[i][j][k] += mul(ways, dp[i - 1][j][k]) % mod, dp[i][j][k] %= mod;
}
}
int ans = 0;
for (int j = 0; j <= n; j++)
for (int k = 0; k + j <= n; k++)
if ((k + j) % 2 == p) ans += dp[n][j][k], ans %= mod;
cout << ans << endl;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const int N = 102, mod = 1000000007;
vector<int> compute_prefix(string s) {
vector<int> pi(s.size(), -1);
int k = -1;
for (int i = 1; i < s.size(); i++) {
while (k >= 0 && s[k + 1] != s[i]) k = pi[k];
if (s[k + 1] == s[i]) k++;
pi[i] = k;
}
return pi;
}
char s1[N], s2[N], s3[N];
vector<int> pi;
int n, m, k;
int mem[N][N][N];
int sol[N][N][N];
int dp(int i, int j, int mm) {
if (mm == (int)pi.size() - 1) return -inf;
if (i >= n || j >= m) return 0;
int &ret = mem[i][j][mm + 1];
if (ret != -1) return ret;
int c1 = dp(i + 1, j, mm);
int c2 = dp(i, j + 1, mm);
ret = max(c1, c2);
if (c1 > c2)
sol[i][j][mm + 1] = -10;
else
sol[i][j][mm + 1] = -20;
if (s1[i] == s2[j]) {
int ma = mm;
while (ma > -1 && s3[ma + 1] != s1[i]) ma = pi[ma];
if (s3[ma + 1] == s1[i]) ma++;
int c3 = dp(i + 1, j + 1, ma) + 1;
if (c3 >= ret) {
ret = c3;
sol[i][j][mm + 1] = ma;
}
}
return ret;
}
void build_sol(int i, int j, int mm) {
if (mm == (int)pi.size() - 1) return;
if (i >= n || j >= m) return;
if (sol[i][j][mm + 1] == -10) {
return build_sol(i + 1, j, mm);
}
if (sol[i][j][mm + 1] == -20) {
return build_sol(i, j + 1, mm);
}
printf("%c", s1[i]);
return build_sol(i + 1, j + 1, sol[i][j][mm + 1]);
}
int main() {
scanf("%s", s1);
scanf("%s", s2);
scanf("%s", s3);
n = strlen(s1);
m = strlen(s2);
k = strlen(s3);
pi = compute_prefix(s3);
memset(mem, -1, sizeof mem);
int ANS = dp(0, 0, -1);
if (ANS <= 0) {
printf("0\n");
return 0;
}
build_sol(0, 0, -1);
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
int m;
cin >> n >> m;
vector<int> w(n);
for (int _n(n), i(0); i < _n; i++) cin >> w[i];
vector<int> b(m);
for (int _n(m), i(0); i < _n; i++) {
cin >> b[i];
b[i]--;
}
long long ans = 0;
vector<int> top(n);
int ntop = 0;
for (int x : b) {
int pos = 0;
while (pos < ntop && top[pos] != x) {
ans += w[top[pos]];
++pos;
}
if (pos == ntop) ++ntop;
for (int i = pos; i > 0; --i) {
top[i] = top[i - 1];
}
top[0] = x;
}
cout << ans << endl;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int a[100000];
int main() {
int n, k;
scanf("%i%i", &n, &k);
k--;
for (int i = 0; i < n; i++) scanf("%i", &a[i]);
for (int i = k + 1; i < n; i++)
if (a[i] != a[k]) {
printf("-1\n");
return 0;
}
int cnt = n;
for (int i = n - 1; i >= 0; i--)
if (a[i] != a[k])
break;
else
cnt--;
printf("%i\n", cnt);
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 2;
const int logn = 20 + 2;
const int mod = 998244353;
char str[maxn];
int x, y, len, ans;
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int change(char ch) { return ch - '0'; }
int dp[maxn][logn][logn][logn][2];
int DP(int pos, int pre, int state1, int state2, bool limit) {
if (pos > len) return !pre && (state1 & state2);
int &ret = dp[pos][pre + x][state1][state2][limit];
if (~ret) return ret;
ret = 0;
int up = !limit ? change(str[pos]) : 9;
for (int i = 0; i <= 9; i++)
for (int j = 0; j <= up; j++) {
int now = pre * 10 - i * y + j * x, st1 = 0, st2 = 0;
if (now <= -x || now >= y) continue;
if (i && !(i % x) && i <= 9 / y * x) st1 = 1 << (i / x - 1);
if (j && !(j % y)) st2 = 1 << (j / y - 1);
ret = (ret + DP(pos + 1, now, state1 | st1, state2 | st2,
limit | (j < change(str[pos])))) %
mod;
}
return ret;
}
int main() {
scanf("%s", str + 1);
len = strlen(str + 1);
for (int i = 1; i <= len; i++) ans = (ans * 10LL + change(str[i])) % mod;
for (x = 1; x <= 8; x++)
for (y = x + 1; y <= 9; y++)
if (gcd(x, y) == 1) {
memset(dp, -1, sizeof(dp));
ans = (ans + 2LL * DP(1, 0, 0, 0, false)) % mod;
}
printf("%d", ans);
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int n;
double mx[100010], mn[100010];
double a[100010], b[100010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lf", mx + i);
mx[i] += mx[i - 1];
}
for (int i = 1; i <= n; i++) {
scanf("%lf", mn + i);
mn[i] += mn[i - 1];
}
for (int i = 1; i <= n; i++) {
a[i] = (mx[i] + mn[i] -
pow(max(0.0, pow(mx[i] + mn[i], 2.0) - 4.0 * mx[i]), 0.5)) /
2.0;
b[i] = (mx[i] + mn[i] +
pow(max(0.0, pow(mx[i] + mn[i], 2.0) - 4.0 * mx[i]), 0.5)) /
2.0;
}
for (int i = 1; i <= n; i++) printf("%lf ", a[i] - a[i - 1]);
puts("");
for (int i = 1; i <= n; i++) printf("%lf ", b[i] - b[i - 1]);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
vector<int> g[maxn];
int n, a[maxn], nxt[maxn], gcd;
long long ans;
void work(int l, int r) {
for (int i = l; i <= min(r, n); i++)
if (nxt[i] < r) {
ans += (long long)gcd * (r - nxt[i]);
nxt[i] = r;
} else
break;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
int li = sqrt(a[i]);
nxt[i] = i;
for (int j = 1; j <= li; j++)
if (a[i] % j == 0) {
g[a[i] / j].push_back(i);
if (j * j != a[i]) g[j].push_back(i);
}
}
for (gcd = 200000; gcd; gcd--) {
if (g[gcd].size() < 2) continue;
work(g[gcd][1] + 1, n + 1);
work(g[gcd][0] + 1, g[gcd][g[gcd].size() - 1]);
work(1, g[gcd][g[gcd].size() - 2]);
}
cout << ans << endl;
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
double p = 1;
int n, m, h;
int A[1005], sum;
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= m; i++) {
scanf("%d", &A[i]);
sum += A[i];
}
if (sum < n) {
puts("-1");
return 0;
}
if (sum - A[h] < n - 1) {
puts("1");
return 0;
}
for (int i = n - 1; i >= 1; i--) {
p *= 1.0 * (sum - A[h] - i + 1) / (sum - 1 - i + 1);
}
printf("%.7lf\n", 1.0 - p);
return 0;
}
| 8
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.