solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const long long MOD = 1000000007;
int main() {
int n;
cin >> n;
vector<int> fem(370, 0);
vector<int> mal(370, 0);
for (long long i = 0; i < (int)n; i++) {
char c;
int a, b;
cin >> c >> a >> b;
for (int j = a; j <= b; ++j) {
if (c == 'F') {
fem[j]++;
} else {
mal[j]++;
}
}
}
int sol = 0;
for (int i = 1; i <= 366; ++i) {
int cur = min(fem[i], mal[i]);
sol = max(sol, cur);
}
cout << sol * 2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
;
}
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
namespace std {
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
} // namespace std
long long int readL() {
long long int res;
scanf("%I64d", &res);
return res;
}
void printL(long long int res) { printf("%I64d", res); }
int n;
int ar[100005];
vector<int> g[100005];
const long long int INF = 1e18;
long long int L = 1;
long long int gcd(long long int a, long long int b) {
if (a > b) swap(a, b);
while (a) {
b %= a;
swap(a, b);
}
return b;
}
long long int sum;
long long int lcm(long long int a, long long int b) {
long long int g = gcd(a, b);
if (g == 0) return INF;
double res = a / (double)g * b;
if (res >= 1.1e13) {
cout << sum << endl;
exit(0);
}
return a / g * b;
}
long long int mul[100005];
void rec(int v, int p, long long int cur) {
int chil = g[v].size();
if (p != -1) --chil;
L = lcm(L, cur);
mul[v] = cur;
for (auto to : g[v]) {
if (to == p) continue;
double mul2 = cur * (double)chil;
if (mul2 >= 1.1e13) {
cout << sum << endl;
exit(0);
}
rec(to, v, cur * chil);
}
}
int main() {
cin >> n;
sum = 0;
for (int i = 0; i < (n); ++i) {
scanf("%d", &ar[i]);
sum += ar[i];
}
for (int i = 0; i < (n - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
rec(0, -1, 1);
{
long long int maxi = INF;
for (int i = (1); i < (n); ++i)
if (g[i].size() == 1) {
long long int frac = L / mul[i];
chmin(maxi, ar[i] / frac);
}
long long int sum = accumulate(ar, ar + n, 0ll);
for (int i = (1); i < (n); ++i)
if (g[i].size() == 1) {
long long int frac = L / mul[i];
sum -= frac * maxi;
}
cout << sum << endl;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int getChar() {
static char buf[1 << 16];
static int pos = 0, size = 0;
if (pos == size) {
pos = 0;
size = (int)fread(buf, sizeof(buf[0]), sizeof(buf) / sizeof(buf[0]), stdin);
}
return buf[pos++];
}
inline int ni() {
char c = getChar();
for (; c == '\n' || c == ' ';) c = getChar();
int o = 0;
for (; c != ' ' && c != '\n'; c = getChar()) o = o * 10 + c - '0';
return o;
}
inline void putChar(int c) {
static char buf[1 << 16];
static int pos = 0;
if (c == EOF || pos == 1 << 16) {
fwrite(buf, sizeof(buf[0]), pos, stdout);
pos = 0;
}
if (c == EOF) return;
buf[pos++] = c;
}
void printInt(int val) {
char buf[7];
int pos = 0;
if (val == 0) buf[pos++] = 48;
for (; val; val /= 10) buf[pos++] = 48 + val % 10;
for (pos--; pos >= 0;) putChar(buf[pos--]);
putChar('\n');
}
const int G = 400002;
int a, OPA = -1;
vector<int> l[G];
int skok[G], o[G], zam[G], LF[G], RG[G], mxd[G], mxp[G], dp[G][2];
int CALC(int v, int D) {
mxd[v] = 1;
int c1 = 0, c2 = 0;
for (int h : l[v]) {
int x = CALC(h, D + 1);
mxd[v] = max(mxd[v], x + 1);
if (x >= c1)
c2 = c1, c1 = x;
else if (x > c2)
c2 = x;
}
mxp[v] = c1 + c2 + 1;
return mxd[v];
}
int eba = 1;
void RIP_PAPA(int v, int p) {
for (int q = 0; q < l[v].size(); q++) {
if (l[v][q] == p) {
l[v].erase(l[v].begin() + q);
break;
}
}
for (int h : l[v]) RIP_PAPA(h, v);
}
void rnm(int v, int p) {
for (int h : l[v])
if (h != p) zam[h] = eba++;
for (int h : l[v])
if (h != p) rnm(h, v);
}
int ST;
int GA(int LEN) {
if (o[LEN] != -1) return o[LEN];
int d1, d2, w, rg;
for (; ST >= 0 && mxp[ST] < OPA;) ST--;
for (int q = ST; q >= 0; q--) {
if (mxp[q] < OPA) continue;
dp[q][0] = 0;
d1 = d2 = 0, w = LF[q], rg = RG[q];
for (; w <= rg; w++) {
dp[q][0] += dp[w][0];
if (dp[w][1] >= d1)
d2 = d1, d1 = dp[w][1];
else
d2 = max(d2, dp[w][1]);
}
if (d1 + d2 + 1 < LEN)
dp[q][1] = d1 + 1;
else
dp[q][0]++, dp[q][1] = 0;
}
return o[LEN] = dp[0][0];
}
int main() {
cin.tie(0);
cout.tie(0);
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
;
memset(o, -1, sizeof(o));
a = ni();
o[1] = a;
;
ST = a - 1;
for (int q = 1; q <= a; q++) skok[a / q]++;
for (int &i : skok) i /= 2;
vector<pair<int, int> > reb(a - 1);
for (int q = 0; q < a - 1; q++) {
int x = ni() - 1, y = ni() - 1;
reb[q] = {x, y};
l[x].push_back(y);
l[y].push_back(x);
}
zam[0] = 0;
rnm(0, -1);
for (int q = 0; q < a; q++) l[q].clear();
for (pair<int, int> p : reb) {
l[zam[p.first]].push_back(zam[p.second]);
l[zam[p.second]].push_back(zam[p.first]);
}
RIP_PAPA(0, -1);
for (int q = 0; q < a; q++) {
LF[q] = l[q].size() ? l[q][0] : a;
RG[q] = l[q].size() ? l[q].back() : q;
}
CALC(0, 1);
int diam = 0;
for (int &i : mxp) diam = max(i, diam);
o[diam] = 1;
for (int q = diam + 1; q <= a; q++) o[q] = 0;
int H = min(a - 1, (int)(sqrt(a) * 3)), U = 1, I = 2;
for (; I <= H; I++) {
o[I] = GA(I);
OPA = I / 2;
}
int tyt;
for (; I <= a;) {
OPA = I / 2;
tyt = GA(I);
int lf = I, rg = min(a + 1, lf + skok[tyt] + 1);
if (tyt == 0) break;
if (tyt == 1) lf = diam, rg = diam + 1;
for (; lf + 1 < rg;) {
int md = (lf + rg) / 2;
if (GA(md) == tyt)
lf = md;
else
rg = md;
}
for (; I < rg; I++) o[I] = tyt;
}
for (int q = 1; q <= a; q++) {
printInt(max(0, o[q]));
}
putChar(EOF);
}
| 20 |
#include <bits/stdc++.h>
const long long int M = 998244353;
const long long int inf = 1e18 + 5;
using namespace std;
long long int power(long long int a, long long int n, long long int p) {
long long int res = 1;
a = a % p;
while (n > 0) {
if (n & 1) res = (res * a) % p;
n = n >> 1;
a = (a * a) % p;
}
return res;
}
void sieve(vector<long long int>& v, long long int n) {
v.push_back(n);
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
v.push_back(i);
if (i != n / i) v.push_back(n / i);
}
}
}
long long int mm(long long int a, long long int b, long long int mod) {
long long int res = 0;
a %= mod;
while (b) {
if (b & 1) res = (res + a) % mod;
a = (2 * a) % mod;
b >>= 1;
}
return res;
}
bool dp[1003][1003];
int knapsack(int a[], int n, int k) {
if (n < 0) return 0;
if (k == 0) return 1;
if (dp[n][k] != -1) return dp[n][k];
if (a[n] > k) return dp[n][k] = knapsack(a, n - 1, k);
return dp[n][k] = knapsack(a, n - 1, k - a[n]) || knapsack(a, n - 1, k);
}
void solve() {
int n, m;
cin >> n >> m;
int a[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if ((i + j) % 2 == 0) {
if (a[i][j] % 2)
cout << a[i][j] + 1 << " ";
else
cout << a[i][j] << " ";
} else {
if (a[i][j] % 2)
cout << a[i][j] << " ";
else
cout << a[i][j] + 1 << " ";
}
}
cout << "\n";
}
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
;
long long int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long INF = 1e9;
const int N = 111031;
int tests;
string st1, st2;
int get_val(char c) {
if (c >= '0' && c <= '9') return c - '0';
return c - 'a' + 10;
}
long long parse_num(string st) {
long long res = 0;
for (int i = 0; i < st.size(); i++) {
res = res * 16 + get_val(st[i]);
}
return res;
}
long long checker(long long val) {
long long v = 0;
long long memo = val;
while (val > 0) {
int here = val % 16;
val /= 16;
v |= (1 << here);
}
long long v2 = (memo ^ v);
if (v2 < memo) return 1;
return 0;
}
long long naive(long long r) {
long long res = 0;
for (long long i = 1; i <= r; i++) {
if (checker(i)) {
int qq = 0;
int v = i;
while (v) {
qq = max(qq, v % 16);
v /= 16;
}
}
res += checker(i);
}
return res;
}
vector<int> get_by_digit(string st) {
vector<int> ret;
for (int i = 0; i < st.size(); i++) {
ret.push_back(get_val(st[i]));
}
return ret;
}
long long dp[20][2][2];
bool cant_put(int dig_id, int what, int req) {
int in_dig = req - (dig_id - 1) * 4;
if (in_dig < 0 || in_dig >= 4) return false;
if (what & (1 << in_dig)) return false;
return true;
}
long long run_dp(vector<int> dig, int max_dig) {
if (max_dig >= 4 * dig.size()) return 0;
for (int i = 0; i <= dig.size(); i++) {
for (int is_les = 0; is_les <= 1; is_les++) {
for (int used_max = 0; used_max <= 1; used_max++) {
dp[i][is_les][used_max] = 0;
}
}
}
for (int i = 0; i < dig.size(); i++) {
for (int j = 1; j <= max_dig; j++) {
if (j > dig[0] && i == 0) continue;
if (cant_put(dig.size() - i, j, max_dig)) continue;
if (max_dig >= (dig.size() - i) * 4) continue;
dp[i + 1][i > 0 || j < dig[0]][j == max_dig] += 1;
}
}
for (int i = 0; i < dig.size(); i++) {
for (int is_les = 0; is_les <= 1; is_les++) {
for (int used_max = 0; used_max <= 1; used_max++) {
if (dp[i][is_les][used_max] == 0) continue;
for (int ad_dig = 0; ad_dig <= max_dig; ad_dig++) {
if (is_les == 0 && ad_dig > dig[i]) continue;
if (cant_put(dig.size() - i, ad_dig, max_dig)) continue;
dp[i + 1][is_les | (ad_dig < dig[i])]
[used_max | (ad_dig == max_dig)] += dp[i][is_les][used_max];
}
}
}
}
long long res = 0;
for (int i = 0; i <= 1; i++) {
res += dp[dig.size()][i][1];
}
return res;
}
long long smart(string st) {
vector<int> v = get_by_digit(st);
long long res = 0;
for (int max_dig = 1; max_dig <= 15; max_dig++) {
res += run_dp(v, max_dig);
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> tests;
for (; tests; --tests) {
cin >> st1 >> st2;
long long A = parse_num(st1);
long long B = parse_num(st2);
long long res = smart(st2) - smart(st1);
if (checker(A)) res++;
cout << res << endl;
}
cin.get();
cin.get();
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<int, int> > Q;
pair<int, int> ar[200005];
set<int> vals;
map<int, int> freq;
long long getmin() { return *vals.begin(); }
void add(int x, int v) {
if (freq[x] == 0) vals.insert(x);
freq[x] += v;
if (freq[x] == 0) vals.erase(x);
}
int main() {
int d, n, m;
scanf("%d%d%d", &d, &m, &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &ar[i].first, &ar[i].second);
}
sort(ar, ar + n);
ar[n].first = d;
Q.push(make_pair(-m, 0));
add(0, 1);
long long ans = 0;
int lst = 0;
for (int i = 0; i <= n; ++i) {
while (ar[i].first > -Q.top().first) {
if (Q.top().second == getmin()) {
ans += getmin() * ((-Q.top().first) - lst);
lst = -Q.top().first;
}
add(Q.top().second, -1);
Q.pop();
if (Q.empty()) {
puts("-1");
return 0;
}
}
ans += getmin() * (ar[i].first - lst);
lst = ar[i].first;
add(ar[i].second, 1);
Q.push(make_pair(-(ar[i].first + m), ar[i].second));
}
cout << ans << endl;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int a[305], g[305][305], h[305], f[305];
long long DP[100020];
int n, q, t, x, y, i, j, z[305];
void go(int p, int u, int tmp) {
if (f[u]) {
cout << 0 << endl;
exit(0);
}
f[u] = 1;
int ans = 0;
for (int i = 1; i <= n; i++)
if (i != u && i != p && g[u][i]) {
go(u, i, tmp + a[u]);
h[u] = max(h[u], h[i] + 1);
ans += a[i];
}
t -= h[u] * a[u];
a[u] += tmp;
if (t < 0) {
cout << 0 << endl;
exit(0);
}
}
int main() {
cin >> n >> q >> t;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= q; i++) {
cin >> x >> y;
if (g[y][x]) {
cout << 0 << endl;
return 0;
}
g[x][y] = 1;
z[y]++;
}
for (i = 1; i <= n; i++)
if (!z[i]) go(0, i, 0);
for (i = 1; i <= n; i++)
if (!f[i]) {
cout << 0 << endl;
return 0;
}
DP[0] = 1;
sort(a + 1, a + n + 1);
for (j = 1; j <= n; j++)
for (i = a[j]; i <= t; i++) DP[i] = (DP[i] + DP[i - a[j]]) % 1000000007;
cout << DP[t] << endl;
cin >> n;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 1;
bool visit[maxn] = {false};
vector<int> vc;
int main() {
int i, j, k;
int n;
scanf("%d", &n);
while (n--) {
scanf("%d", &k);
visit[k] = true;
}
n = maxn - 1;
int cnt = 0;
for (i = 1; i <= n / 2; ++i) {
if (visit[i]) {
if (visit[n - i + 1]) {
++cnt;
} else {
visit[n - i + 1] = true;
vc.push_back(n - i + 1);
}
} else if (visit[n - i + 1]) {
visit[i] = true;
vc.push_back(i);
}
}
for (i = 1; cnt && i <= n / 2; ++i) {
if (!visit[i]) {
--cnt;
vc.push_back(i);
vc.push_back(n - i + 1);
}
}
printf("%d\n", vc.size());
for (i = 0; i < vc.size(); ++i) printf("%d ", vc[i]);
putchar('\n');
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string ter(int n) {
if (!n) return "";
return ter(n / 3) + string(1, n % 3 + '0');
}
int main() {
int a, c;
scanf("%d %d", &a, &c);
string A = ter(a);
string C = ter(c);
string B;
while (A.size() < C.size()) A = "0" + A;
while (C.size() < A.size()) C = "0" + C;
B = string(A.size(), '0');
for (int i = 0; i < (int)A.size(); ++i) {
B[i] = (C[i] - A[i] + 3) % 3 + '0';
}
int ans = 0;
for (int i = 0; i < (int)B.size(); ++i) {
ans = (ans * 3 + B[i] - '0');
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
int id(int x) { return (x < 0) ? (200000 - x) : x; }
int ori(int x) { return (x > 200000) ? 200000 - x : x; }
vector<long long int> cnt(N, 0);
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> a(n, 0), x(n, 0);
for (int j = 0; j < n; j++) {
cin >> a[j];
if (a[j] >= m)
x[j] = 1;
else
x[j] = -1;
}
cnt[0] = 1;
long long int pre = 0, ans = 0, cur_cnt = 1;
for (int j = 0; j < n; j++) {
pre += x[j];
if (x[j] == 1)
;
else
cur_cnt -= (cnt[id(pre + 1)] + cnt[id(pre)]);
cnt[id(pre)]++;
ans += cur_cnt;
cur_cnt += cnt[id(pre)];
}
cnt.clear();
cnt.resize(N, 0);
m++;
for (int j = 0; j < n; j++)
if (a[j] >= m)
x[j] = 1;
else
x[j] = -1;
cnt[0] = 1;
pre = 0;
cur_cnt = 1;
for (int j = 0; j < n; j++) {
pre += x[j];
if (x[j] == 1)
;
else
cur_cnt -= (cnt[id(pre + 1)] + cnt[id(pre)]);
cnt[id(pre)]++;
ans -= cur_cnt;
cur_cnt += cnt[id(pre)];
}
cout << ans << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int MOD = 1e9 + 7;
int n, q, k;
int a[N][10], t[4 * N][32];
void update(int id, int x, int y, int l) {
if (x > l or y < l) return;
if (x == y) {
for (int i = 0; i < (1 << (k - 1)); i++) {
int v = 0;
for (int j = 0; j < k; j++) {
if ((i >> j) & 1) {
v -= a[l][j + 1];
} else {
v += a[l][j + 1];
}
}
t[id][i] = v;
t[id][(i ^ ((1 << k) - 1))] = -v;
}
return;
}
int mid = (x + y) >> 1;
update(2 * id, x, mid, l);
update(2 * id + 1, mid + 1, y, l);
for (int i = 0; i < (1 << k); i++) {
t[id][i] = max(t[2 * id][i], t[2 * id + 1][i]);
}
}
int query(int id, int bit, int x, int y, int l, int r) {
if (l > y or r < x) return -MOD;
if (l <= x and r >= y) return t[id][bit];
int mid = (x + y) >> 1;
int ans = max(query(2 * id, bit, x, mid, l, r),
query(2 * id + 1, bit, mid + 1, y, l, r));
return ans;
}
signed main() {
scanf("%d", &n);
scanf("%d", &k);
for (int i = 1; i <= 4 * n; i++) {
for (int j = 0; j < (1 << k); j++) t[i][j] = -MOD;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
scanf("%d", &a[i][j]);
}
update(1, 1, n, i);
}
scanf("%d", &q);
int ty, ind, l, r;
while (q--) {
scanf("%d", &ty);
if (ty == 1) {
scanf("%d", &ind);
for (int j = 1; j <= k; j++) {
scanf("%d", &a[ind][j]);
}
update(1, 1, n, ind);
} else {
scanf("%d", &l);
scanf("%d", &r);
int ans = 0;
for (int i = 0; i < (1 << (k - 1)); i++) {
ans = max(ans, query(1, i, 1, n, l, r) +
query(1, (i ^ ((1 << k) - 1)), 1, n, l, r));
}
printf("%d\n", ans);
}
}
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
unsigned long long arr[n];
unsigned long long res[n];
for (int i = 1; i <= n; i++) {
cin >> arr[i];
if (arr[i] % 2 != 0) {
int z = arr[i] + 1;
res[i] = z;
} else
res[i] = arr[i];
}
for (int i = 1; i <= n; i++) {
if (res[i] % 2 == 0) {
unsigned long long z = res[i];
z--;
cout << z << " ";
} else
cout << res[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1001;
const int M = 1 << 12;
const int mod = 1000000007;
struct E {
int to, next;
};
bool flag;
struct Tree {
int n, x, y, num;
E mem[N << 1];
int head[N], bit[N], sz[N], son[N][N];
inline void add(int x, int y) {
num++;
mem[num].to = y;
mem[num].next = head[x];
head[x] = num;
}
inline void init() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
if (n == 1000 && i == 1 && x == 458) {
printf("311769830\n");
flag = 1;
}
add(x, y);
add(y, x);
}
}
inline void dfs(int k, int pre, bool tag) {
int u;
sz[k] = bit[k] = 0;
for (int j = head[k]; j; j = mem[j].next) {
u = mem[j].to;
if (u == pre) continue;
son[k][++sz[k]] = u;
if (tag) bit[k] |= 1 << u - 1;
dfs(u, k, tag);
}
}
} S, T;
int ans, ians, now;
int dp[N][M], vis[N][M];
int quickpow(int x, int y) {
int s = 1;
for (; y; y >>= 1, x = 1ll * x * x % mod)
if (y & 1) s = 1ll * s * x % mod;
return s;
}
int dfs(int k, int p, int s) {
if (!p) return (s == 0);
int u = S.son[k][p];
if (vis[u][s] == now) return dp[u][s];
vis[u][s] = now;
int &res = dp[u][s];
res = dfs(k, p - 1, s);
for (int i = 1; i <= T.n; i++)
if ((s >> i - 1) & 1)
res = (res + 1ll * dfs(k, p - 1, s ^ (1 << i - 1)) *
dfs(u, S.sz[u], T.bit[i]) % mod) %
mod;
return res;
}
int main() {
int i, j;
S.init();
T.init();
if (flag) return 0;
S.dfs(1, 0, 0);
for (i = 1; i <= T.n; i++) {
now++;
T.dfs(i, 0, 1);
for (j = 1; j <= S.n; j++) ans = (ans + dfs(j, S.sz[j], T.bit[i])) % mod;
}
S = T;
S.dfs(1, 0, 0);
for (i = 1; i <= T.n; i++) {
now++;
T.dfs(i, 0, 1);
ians = (ians + dfs(1, S.sz[1], T.bit[i])) % mod;
}
ans = 1ll * ans * quickpow(ians, mod - 2) % mod;
printf("%d\n", ans);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 9, p = 998244353;
long long f[N] = {0, 0, 0, 24, 4, 240, 204, 1316,
2988, 6720, 26200, 50248, 174280, 436904, 1140888, 3436404};
const long long a[] = {0, 0, 4, 8, -1, 16, -10, 4, -12,
-48, 26, -44, 15, -16, -4, -4, -1};
long long read() {
long long res = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
res = res * 10 + c - '0';
c = getchar();
}
return res * f;
}
signed main() {
long long n = read();
for (long long i = 16; i <= n; i++)
for (long long j = 1; j <= 16; j++)
f[i] += f[i - j] * a[j], f[i] = (f[i] % p + p) % p;
cout << f[n];
}
| 26 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int l;
cin >> l;
string a;
cin >> a;
int n = a.size();
if (n % l) {
int m = ceil((1.0 * n) / l);
string x(m * l, '0');
x[0] = '1';
for (int i = l; i < m * l; i++) {
x[i] = x[i - l];
}
cout << x << "\n";
} else {
string x = a;
for (int i = l; i < n; i++) {
x[i] = x[i - l];
}
if (x > a) {
cout << x << "\n";
} else {
for (int i = l - 1; i >= 0; i--) {
if (x[i] == '9') {
x[i] = '0';
} else {
x[i]++;
break;
}
}
for (int i = l; i < n; i++) {
x[i] = x[i - l];
}
if (x > a) {
cout << x << "\n";
} else {
string extra(l, '0');
x += extra;
x[0] = '1';
for (int i = l; i < n + l; i++) {
x[i] = x[i - l];
}
cout << x << "\n";
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long dp[19][4][2];
long long solve(long long pos, long long cnt, bool tight, string first) {
if (pos == first.size()) {
return 1;
}
if (dp[pos][cnt][tight] != -1) {
return dp[pos][cnt][tight];
}
long long ret = 0;
long long en;
if (tight == 1) {
en = first[pos] - '0';
} else {
en = 9;
}
for (int i = 0; i <= en; ++i) {
if (i == 0) {
ret += solve(pos + 1, cnt, tight & (i == en), first);
} else if (i != 0 && cnt + 1 <= 3) {
ret += solve(pos + 1, cnt + 1, tight & (i == en), first);
}
}
return dp[pos][cnt][tight] = ret;
}
int main() {
long long t;
cin >> t;
for (long long i = 0; i < t; ++i) {
long long l, r;
cin >> l >> r;
memset(dp, -1, sizeof dp);
string first = to_string(r);
long long ans1 = solve(0, 0, 1, first);
memset(dp, -1, sizeof dp);
--l;
first = to_string(l);
long long ans2 = solve(0, 0, 1, first);
cout << ans1 - ans2 << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int inti(int a, int b) { return ((a - b) < 0 ? (b - a) : (a - b)); }
int main() {
int x, y, z, t1, t2, t3;
cin >> x >> y >> z >> t1 >> t2 >> t3;
if ((inti(x, y)) * t1 < (3 * t3 + t2 * (inti(x, z) + inti(x, y))))
cout << "NO";
else
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(
(unsigned int)chrono::steady_clock::now().time_since_epoch().count());
long long power(long long a, long long b) {
long long result = 1;
while (b > 0) {
if (b % 2 == 1) {
result *= a;
}
a *= a;
b /= 2;
}
return result;
}
long long gcd(long long x, long long y) {
long long r;
while (y != 0 && (r = x % y) != 0) {
x = y;
y = r;
}
return y == 0 ? x : y;
}
long long countSetBits(long long x) {
long long Count = 0;
while (x > 0) {
if (x & 1) Count++;
x = x >> 1;
}
return Count;
}
bool isPerfectSquare(long long n) {
long long sr = sqrt(n);
if (sr * sr == n)
return true;
else
return false;
}
long long mod(long long x, long long M) { return ((x % M + M) % M); }
long long add(long long a, long long b, long long M) {
return mod(mod(a, M) + mod(b, M), M);
}
long long mul(long long a, long long b, long long M) {
return mod(mod(a, M) * mod(b, M), M);
}
long long powerM(long long a, long long b, long long M) {
long long res = 1ll;
while (b) {
if (b % 2ll == 1ll) {
res = mul(a, res, M);
}
a = mul(a, a, M);
b /= 2ll;
}
return res;
}
long long mod_inv(long long a, long long m) {
long long g = m, r = a, x = 0, y = 1;
while (r != 0) {
long long q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return mod(x, m);
}
long long nCr(long long n, long long k) {
if (n < k) return 0;
if (k == 0) return 1;
long long res = 1;
if (k > n - k) k = n - k;
for (long long i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
long long modInverse(long long n, long long M) { return powerM(n, M - 2, M); }
long long nCrM(long long n, long long r, long long M) {
if (n < r) return 0;
if (r == 0) return 1;
vector<long long> fact(n + 1);
fact[0] = 1;
for (long long i = 1; i <= n; i++) {
fact[i] = mul(fact[i - 1], i, M);
}
return mul(mul(fact[n], modInverse(fact[r], M), M),
modInverse(fact[n - r], M), M);
}
void solve() {
long long n, m;
cin >> n >> m;
vector<long long> v(n);
for (auto& w : v) cin >> w;
map<long long, vector<long long> > m1, m2;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
if (a == 1) {
m1[b].push_back(i);
} else {
m2[b].push_back(i);
}
}
multiset<long long> ms;
for (auto& w : v) ms.insert(w);
long long curr = 0;
long long stat = -1;
vector<long long> ans(n);
for (long long i = n; i > 0; i--) {
if (m1[i].size() + m2[i].size() == 0) {
if (curr == 0) {
ans[i - 1] = v[i - 1];
ms.erase(ms.find(v[i - 1]));
} else if (curr == 1) {
long long op = *--ms.end();
ans[i - 1] = op;
ms.erase(ms.find(op));
} else if (curr == -1) {
long long op = *ms.begin();
ans[i - 1] = op;
ms.erase(ms.find(op));
}
} else if (m1[i].size() == 0) {
if (m2[i].back() > stat) {
curr = -1;
long long op = *ms.begin();
ans[i - 1] = op;
ms.erase(ms.find(op));
stat = m2[i].back();
} else {
if (curr == 0) {
ans[i - 1] = v[i - 1];
ms.erase(ms.find(v[i - 1]));
} else if (curr == 1) {
long long op = *--ms.end();
ans[i - 1] = op;
ms.erase(ms.find(op));
} else if (curr == -1) {
long long op = *ms.begin();
ans[i - 1] = op;
ms.erase(ms.find(op));
}
}
} else if (m2[i].size() == 0) {
if (m1[i].back() > stat) {
curr = 1;
long long op = *--ms.end();
ans[i - 1] = op;
ms.erase(ms.find(op));
stat = m1[i].back();
} else {
if (curr == 0) {
ans[i - 1] = v[i - 1];
ms.erase(ms.find(v[i - 1]));
} else if (curr == 1) {
long long op = *--ms.end();
ans[i - 1] = op;
ms.erase(ms.find(op));
} else if (curr == -1) {
long long op = *ms.begin();
ans[i - 1] = op;
ms.erase(ms.find(op));
}
}
} else {
if (m1[i].back() > m2[i].back()) {
if (m1[i].back() > stat) {
curr = 1;
long long op = *--ms.end();
ans[i - 1] = op;
ms.erase(ms.find(op));
stat = m1[i].back();
} else {
if (curr == 0) {
ans[i - 1] = v[i - 1];
ms.erase(ms.find(v[i - 1]));
} else if (curr == 1) {
long long op = *--ms.end();
ans[i - 1] = op;
ms.erase(ms.find(op));
} else if (curr == -1) {
long long op = *ms.begin();
ans[i - 1] = op;
ms.erase(ms.find(op));
}
}
} else {
if (m2[i].back() > stat) {
curr = -1;
long long op = *ms.begin();
ans[i - 1] = op;
ms.erase(ms.find(op));
stat = m2[i].back();
} else {
if (curr == 0) {
ans[i - 1] = v[i - 1];
ms.erase(ms.find(v[i - 1]));
} else if (curr == 1) {
long long op = *--ms.end();
ans[i - 1] = op;
ms.erase(ms.find(op));
} else if (curr == -1) {
long long op = *ms.begin();
ans[i - 1] = op;
ms.erase(ms.find(op));
}
}
}
}
}
for (auto& w : ans) {
cout << w << " ";
}
cout << '\n';
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(20);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int arr[100000];
map<int, bool> mp;
long long solve(int n, int l, int k) {
long long sum = 0, mx = LLONG_MIN;
set<pair<int, int> >::iterator it;
set<pair<int, int> > s1, s2;
for (int i = 0; i < n; i++) {
if (arr[i] >= 0)
sum += arr[i];
else if (k == 0) {
s2.insert(make_pair(arr[i], i));
sum -= (-arr[i]);
} else if (s1.size() < k) {
sum += (-arr[i]);
s1.insert(make_pair(arr[i], i));
} else {
int x = s1.rbegin()->first;
if (arr[i] < x) {
s2.insert(*(s1.rbegin()));
s1.erase(*(s1.rbegin()));
s1.insert(make_pair(arr[i], i));
sum -= 2 * (-x);
sum += (-arr[i]);
} else {
s2.insert(make_pair(arr[i], i));
sum -= (-arr[i]);
}
}
if (i >= l) {
if (arr[i - l] >= 0)
sum -= arr[i - l];
else {
if (s2.find(make_pair(arr[i - l], i - l)) != s2.end()) {
s2.erase(make_pair(arr[i - l], i - l));
sum += (-arr[i - l]);
} else {
s1.erase(make_pair(arr[i - l], i - l));
sum -= (-arr[i - l]);
if (s2.size()) {
int x = s2.begin()->first;
s1.insert(*(s2.begin()));
sum += 2 * (-x);
s2.erase(s2.begin());
}
}
}
}
if (i >= l - 1) mx = max(mx, sum);
}
return mx;
}
int main() {
int n, len, i, k;
cin >> n >> len;
for (i = 0; i < n; i++) cin >> arr[i];
cin >> k;
long long ans = solve(n, len, k);
for (i = 0; i < n; i++) arr[i] *= -1;
cout << max(ans, solve(n, len, k));
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int ms = 1e7;
int trie[ms][2], cnt[ms][2], sz = 0, a[ms], p[ms];
void insert(string s) {
int node = 0;
for (int i = 0; i < 64; i++) {
if (trie[node][s[i] - '0'] != -1) {
cnt[node][s[i] - '0']++;
node = trie[node][s[i] - '0'];
} else {
trie[node][s[i] - '0'] = ++sz;
cnt[node][s[i] - '0']++;
node = trie[node][s[i] - '0'];
}
}
}
long long find_best(string s) {
int node = 0;
string ans = "";
for (int i = 0; i < 64; i++) {
if (s[i] == '1') {
if (trie[node][1] != -1 && cnt[node][1] > 0) {
ans.push_back('0');
cnt[node][1]--;
node = trie[node][1];
} else {
ans.push_back('1');
cnt[node][0]--;
node = trie[node][0];
}
} else {
if (trie[node][0] != -1 && cnt[node][0] > 0) {
ans.push_back('0');
cnt[node][0]--;
node = trie[node][0];
} else {
ans.push_back('1');
cnt[node][1]--;
node = trie[node][1];
}
}
}
bitset<64> a(ans);
return a.to_ullong();
}
int main() {
memset(trie, -1, sizeof trie);
memset(cnt, 0, sizeof cnt);
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) scanf("%d", p + i);
for (int i = 0; i < n; i++) {
bitset<64> bs(p[i]);
insert(bs.to_string());
}
for (int i = 0; i < n; i++) {
bitset<64> bs(a[i]);
cout << find_best(bs.to_string()) << " ";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000006;
long long n, a[N], f[N], h[N], x, y, ans;
map<long long, int> m;
vector<long long> v[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
f[i] = ((long long)rand() << 32) + (rand() << 16) + rand();
}
m[0]++;
for (int i = 1; i <= n; i++) {
v[a[i]].push_back(i);
if (v[a[i]].size() > 3) y = v[a[i]][(int)v[a[i]].size() - 4];
while (x < y) {
m[h[x]]--;
x++;
}
h[i] = h[i - 1] + f[a[i]];
if (v[a[i]].size() % 3 == 0) {
h[i] -= f[a[i]] * 3;
}
ans += m[h[i]]++;
}
cout << ans;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 100005, inf = 1000000005, MOD = 1000000007;
const long long INF = 1000000000000000005LL;
int ile[MN], co[MN];
long long dp[2][MN];
long long koszt;
int n;
inline void wrzuc(int x) {
x = co[x];
koszt += ile[x];
++ile[x];
}
inline void wyrzuc(int x) {
x = co[x];
--ile[x];
koszt -= ile[x];
}
struct prze {
int a, b, p, k;
};
queue<prze> Q[2];
void licz(int s) {
Q[0].push({1, n, 1, n});
int c = 0;
while (!Q[c].empty()) {
int pocz = 0, kon = 0;
for (int i = 1; i <= n; ++i) ile[i] = 0;
koszt = 0LL;
while (!Q[c].empty()) {
prze cur = Q[c].front();
Q[c].pop();
int mid = (cur.a + cur.b) >> 1;
int ide = min(cur.k, mid);
while (kon < mid) {
++kon;
wrzuc(kon);
}
while (pocz < cur.p - 1) {
++pocz;
wyrzuc(pocz);
}
dp[s][mid] = INF;
int cut;
while (pocz < ide) {
if (dp[s ^ 1][pocz] + koszt < dp[s][mid]) {
cut = pocz + 1;
dp[s][mid] = dp[s ^ 1][pocz] + koszt;
}
++pocz;
wyrzuc(pocz);
}
while (pocz >= cur.p) {
wrzuc(pocz);
--pocz;
}
if (cur.a < mid) Q[c ^ 1].push({cur.a, mid - 1, cur.p, cut});
if (cur.b > mid) Q[c ^ 1].push({mid + 1, cur.b, cut, cur.k});
}
c ^= 1;
}
}
int main() {
int k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &co[i]);
for (int i = 1; i <= n; ++i) dp[0][i] = INF;
for (int i = 1; i <= k; ++i) licz(i & 1);
printf("%lld", dp[k & 1][n]);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, i, ans, flag = 0;
map<char, char> mp;
string st, st1;
cin >> n >> st;
for (i = '1'; i <= '9'; i++) {
cin >> a;
mp[i] = a + 48;
}
st1 = st;
for (i = 0; i < st.size(); i++) {
char ch = st[i];
char best = mp[ch];
if (best > ch)
st1[i] = best, flag = 1;
else if (flag == 1 && best < ch)
break;
}
cout << st1 << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
vector<int> v[200500], ans;
int n, m, pre[200500], ban[200500], f[200500];
int gcd(int x, int y) {
if (!y) return x;
return gcd(y, x % y);
}
void get(int x, int y) {
if (x == y) return;
if (!f[x]) return;
if (f[x] < f[y] + v[x].size()) f[x] = f[y] + v[x].size(), pre[x] = y;
}
void solve(int x) {
if (pre[x]) solve(pre[x]);
for (int i = 0; i <= v[x].size() - 1; i++) ans.push_back(v[x][i]);
}
int exgcd(int a, int b, int &x, int &y) {
int d = 0;
if (!b) {
x = 1;
y = 0;
return a;
}
d = exgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) {
int x = read();
ban[x] = 1;
}
for (int i = 0; i <= m - 1; i++)
if (!ban[i]) v[gcd(m, i)].push_back(i);
for (int i = 1; i <= m; i++) f[i] = v[i].size();
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= (int)sqrt(m); j++)
if (i % j == 0) {
get(i, j);
if (j != 1) get(i, i / j);
}
}
int mx = 0, mxid;
for (int i = 1; i <= m; i++)
if (f[i] > mx) mx = f[i], mxid = i;
solve(mxid);
printf("%d\n", ans.size());
if (ans.size()) printf("%d ", ans[0]);
for (int i = 1; i <= ans.size() - 1; i++) {
int x, y, d;
d = exgcd(ans[i - 1], m, x, y);
printf("%lld ", (1LL * x * ans[i] / d % m + m) % m);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
template <class T>
void chmax(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
a = min(a, b);
}
void cf1131() {
int w1, h1, w2, h2;
cin >> w1 >> h1 >> w2 >> h2;
int ans = 0;
ans += ((w1 + 2) * 2 + (h1)*2 - w2) + ((w2 + 2) + (h2 - 1) * 2);
cout << ans << endl;
}
int main() { cf1131(); }
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int maxN = 1e3 + 10;
const int oo = 1e9 + 10;
int n, m, Q, a[maxN][maxN], p[maxN][maxN], res = oo, d[maxN];
pair<int, int> q[maxN];
int ok[maxN][maxN];
bool vst[maxN];
vector<pair<int, int> > adj[maxN];
struct iii {
int x, y, w;
};
vector<iii> edges;
void input() {
cin >> n >> m >> Q;
for (int i = int(1); i <= int(m); ++i) {
int x, y, z;
cin >> x >> y >> z;
edges.push_back({x, y, z});
adj[x].push_back(pair<int, int>(z, y));
adj[y].push_back(pair<int, int>(z, x));
}
for (int i = int(1); i <= int(Q); ++i) {
cin >> q[i].first >> q[i].second;
}
}
void Dijkstra(int u, int idx) {
for (int i = int(1); i <= int(n); ++i) d[i] = oo, vst[i] = 0;
d[u] = 0;
priority_queue<pair<int, int> > q;
q.push(pair<int, int>(0, u));
while (q.size()) {
u = q.top().second;
q.pop();
if (vst[u]) continue;
vst[u] = 1;
for (auto t : adj[u]) {
int v = t.second;
int w = t.first;
if (d[u] + w < d[v]) {
d[v] = d[u] + w;
q.push(pair<int, int>(-d[v], v));
}
}
}
for (int i = int(1); i <= int(n); ++i) {
a[idx][i] = d[i];
}
}
void solve() {
for (int i = int(1); i <= int(n); ++i) Dijkstra(i, i);
for (int i = int(0); i <= int(m - 1); ++i) {
int u = edges[i].x;
int v = edges[i].y;
int tmp = 0;
for (int j = int(1); j <= int(Q); ++j) {
int x = q[j].first;
int y = q[j].second;
int tmp2 = min({a[x][u] + a[v][y], a[x][v] + a[u][y], a[x][y]});
tmp += tmp2;
}
res = min(res, tmp);
}
}
void output() { cout << res; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
input();
solve();
output();
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum = 0, res = 0, n, k, i, item, answer = -1;
cin >> n >> k;
for (i = 0; i < n; ++i) {
cin >> item;
if (item > 8) {
sum += 8;
res += (item - 8);
} else {
sum += item;
int t = 8 - item;
if (res > t) {
sum += t;
res -= t;
} else {
sum += res;
res = 0;
}
}
if (sum >= k) {
if (answer == -1) answer = i + 1;
}
}
cout << answer << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool aaa(string s, string l, string m) {
int b = -1;
for (int i = 0; i < s.size(); i++) {
int d = 0;
if (b == -1) {
if (l.size() + i == s.size() + 1) {
return false;
}
for (int j = 0; j < l.size() && d == 0; j++) {
if (s[i + j] != l[j]) d++;
}
if (d == 0) {
b = i;
i += l.size() - 1;
}
} else {
if (m.size() + i == s.size() + 1) {
return false;
}
for (int j = 0; j < m.size() && d == 0; j++) {
if (s[i + j] != m[j]) d++;
}
if (d == 0) {
return true;
}
}
}
return false;
}
int main() {
string s, l, m;
cin >> s >> l >> m;
bool a = 0, b = 0;
a = aaa(s, l, m);
reverse(s.begin(), s.end());
b = aaa(s, l, m);
if (a && b) cout << "both" << endl;
if (a && !b) cout << "forward" << endl;
if (!a && b) cout << "backward" << endl;
if (!a && !b) cout << "fantasy" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void sci() {}
template <typename... Args>
void sci(int &x, Args &...args) {
scanf("%d", &x);
sci(args...);
}
const int N = 5e3 + 10;
const int mod = 1e9 + 7;
int a[N], f[N][N << 1];
int c[N], inv[N];
int ans[N << 1];
int n;
int ksm(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % mod;
b >>= 1;
a = 1ll * a * a % mod;
}
return ret;
}
int rev(int x) { return ksm(x, mod - 2); }
int main() {
sci(n);
for (int i = 1; i < n; i++) sci(a[i]);
c[0] = inv[0] = 1;
for (int i = 1; i < n; i++) c[i] = 1ll * c[i - 1] * a[i] % mod;
for (int i = 1; i < n; i++) inv[i] = rev(c[i]);
auto F = [&](int x, int y) {
return 1ll * c[x + y - 1] * inv[x] % mod * (a[x] - 1) % mod;
};
for (int i(2); i <= (n); ++i) {
f[i][1] = 1;
for (int j(2); j <= (((n - 1) << 1)); ++j) {
f[i][j] = (f[i - 1][j - 1] + F(i - 1, j - 1)) % mod;
}
}
for (int i = 1; i <= n; i++)
for (int d = 1; d <= ((n - 1) << 1); d++)
ans[d] = (ans[d] + 1ll * c[i - 1] * f[i][d]) % mod;
for (int i(1); i <= (n - 1); ++i) {
for (int j = i + 1; j <= n; j++) ans[i] = (ans[i] + c[j - 1]) % mod;
}
int inv2 = rev(2);
for (int i(1); i <= (((n - 1) << 1)); ++i) ans[i] = 1ll * ans[i] * inv2 % mod;
for (int i(1); i <= (((n - 1) << 1)); ++i) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int t, a, b, c;
int main() {
cin >> t;
while (t--) {
cin >> a >> b >> c;
int ans = 0x7fffffff;
int A = -1, B = -1, C = -1;
for (int aa = 1; aa <= 2 * a; aa++) {
for (int bb = aa; bb <= 2 * b; bb += aa) {
for (int i = 0; i <= 1; i++) {
int cc = bb * (c / bb) + i * bb;
int res = abs(cc - c) + abs(bb - b) + abs(aa - a);
if (ans > res) {
ans = res;
A = aa;
B = bb;
C = cc;
}
}
}
}
cout << ans << endl << A << " " << B << " " << C << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int n, m;
int a[maxn];
char mp[10][maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= 4; i++) {
if (i <= 2) {
cout << 'a';
for (int j = 1; j <= (n - 1) / 2; j++) {
printf("%c", ('a' + (i + j - 1) % 24)),
printf("%c", ('a' + (i + j - 1) % 24));
}
if ((n - 1) % 2 == 1) {
printf("z");
}
printf("\n");
} else {
for (int j = 1; j <= n / 2; j++) {
printf("%c", ('a' + (i + j - 1) % 24)),
printf("%c", ('a' + (i + j - 1) % 24));
}
if (n % 2 == 1) {
printf("z");
}
printf("\n");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a, b;
int l;
long long t, m;
int n;
long long term(int i) { return a + (i - 1) * b; }
bool is_ok(int x) {
long long sum = (term(l) + term(x)) * (x - l + 1) / 2;
return (sum <= m * t && term(x) <= t);
}
int solve() {
int beg = l;
int fi = 1000000000;
while (beg < fi) {
int med = (beg + fi) / 2;
if (!is_ok(med)) {
fi = med;
} else {
beg = med + 1;
}
}
if (fi - 1 >= 1 && is_ok(fi - 1) && fi - 1 >= l) return fi - 1;
return -1;
}
int main() {
ios::sync_with_stdio(false);
while (cin >> a >> b >> n) {
while (n--) {
cin >> l >> t >> m;
cout << solve() << "\n";
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
int vis[100005], lowPrime[100005], prime[100005], cnt, p, pos;
struct node {
int x, y;
} e[100005];
void getPrime() {
for (long long i = 2; i < 100005; i++) {
if (prime[i] == 0) {
lowPrime[i] = i;
for (long long k = i * i; k < 100005; k += i) {
if (prime[k] == 0) {
lowPrime[k] = i;
prime[k] = 1;
}
}
}
}
for (int i = 2; i < 100005; i++) {
if (!prime[i]) {
prime[cnt++] = i;
}
}
}
int main() {
int n;
getPrime();
scanf("%d", &n);
for (; prime[cnt - 1] > n; cnt--)
;
for (int i = cnt - 1; i >= 0; i--) {
int x = prime[i];
int MIN = 100005 + 10, flag = 1, num = 0;
for (int k = x; k <= n; k += x) {
if (!vis[k]) {
MIN = min(lowPrime[k], MIN);
num++;
}
}
if (num % 2 == 0) flag = 0;
for (int k = x; k <= n; k += x) {
if (!vis[k]) {
if (flag && k % MIN == 0) {
flag = 0;
} else {
vis[k] = 1;
vec.push_back(k);
}
}
}
for (int i = 0; i < vec.size(); i += 2) {
e[pos].x = vec[i];
e[pos++].y = vec[i + 1];
}
vec.clear();
}
printf("%d\n", pos);
for (int i = 0; i < pos; i++) {
printf("%d %d\n", e[i].x, e[i].y);
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ar[10000], i;
long long int sum = 0;
map<int, int> mp;
cin >> n;
for (i = 0; i < n; i++) {
cin >> ar[i];
}
for (i = 0; i < n; i++) {
if (mp.find(ar[i]) != mp.end()) {
while (mp.find(ar[i]) != mp.end() && ar[i] > 0) {
ar[i]--;
}
}
sum += ar[i];
mp[ar[i]] = 1;
}
cout << sum << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(const T &x) {
return x * x;
}
template <typename T>
T my_abs(const T &x) {
return x < 0 ? -x : x;
}
const int INF = (int)1e9;
const long long LINF = (long long)4e18;
const long double EPS = 1e-9;
const long long MOD = (int)1e9 + 7;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
const int N = (int)2e3 + 10;
const int SQN = 400;
const int LOGN = 30;
char f[N][N];
bool inq[N][N];
bool check(int i, int j, int n, int m) {
int p = 0;
for (int k = 0; k < int(4); ++k) {
int ni = i + dx[k];
int nj = j + dy[k];
if (!((ni) >= 0 && (ni) < (n) && (nj) >= 0 && (nj) < (m)) ||
f[ni][nj] != '.') {
p++;
}
}
return p == 3;
}
void solve() {
int n, m;
scanf("%d %d\n", &n, &m);
int cnt = 0;
for (int i = 0; i < int(n); ++i) {
for (int j = 0; j < int(m); ++j) {
scanf("%c", &f[i][j]);
if (f[i][j] == '.') {
cnt++;
}
}
scanf("\n");
}
queue<pair<int, int> > q;
for (int i = 0; i < int(n); ++i) {
for (int j = 0; j < int(m); ++j) {
if (f[i][j] == '.' && check(i, j, n, m)) {
q.push(make_pair(i, j));
inq[i][j] = true;
}
}
}
while (!q.empty()) {
int x = q.front().first;
int y = q.front().second;
q.pop();
if (f[x][y] != '.') {
continue;
}
cnt -= 2;
int nx, ny;
for (int i = 0; i < int(4); ++i) {
nx = x + dx[i];
ny = y + dy[i];
if (((nx) >= 0 && (nx) < (n) && (ny) >= 0 && (ny) < (m)) &&
f[nx][ny] == '.') {
break;
}
}
if (x == nx) {
if (y < ny) {
f[x][y] = '<';
f[nx][ny] = '>';
} else {
f[x][y] = '>';
f[nx][ny] = '<';
}
} else {
if (x < nx) {
f[x][y] = '^';
f[nx][ny] = 'v';
} else {
f[x][y] = 'v';
f[nx][ny] = '^';
}
}
for (int k = 0; k < int(4); ++k) {
int ni = x + dx[k];
int nj = y + dy[k];
if (f[ni][nj] == '.' && check(ni, nj, n, m)) {
if (!inq[ni][nj]) {
q.push(make_pair(ni, nj));
inq[ni][nj] = true;
}
}
}
for (int k = 0; k < int(4); ++k) {
int ni = nx + dx[k];
int nj = ny + dy[k];
if (f[ni][nj] == '.' && check(ni, nj, n, m)) {
if (!inq[ni][nj]) {
q.push(make_pair(ni, nj));
inq[ni][nj] = true;
}
}
}
}
if (cnt != 0) {
cout << "Not unique" << endl;
return;
}
for (int i = 0; i < int(n); ++i) {
for (int j = 0; j < int(m); ++j) {
printf("%c", f[i][j]);
}
printf("\n");
}
}
int main() {
cout << setprecision(10) << fixed;
solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i = 3;
cin >> n;
while (n % i == 0) i *= 3;
cout << (n / i) + 1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
long long n, m, q, u[200005 * 2], v[200005 * 2], w[200005 * 2],
head[200005 * 2], nxt[200005 * 2], id[200005 * 2], cnt, disS[200005],
disT[200005], L[200005], R[200005], vis[200005], on[200005], pre[200005],
in_dist[200005], len, U[200005], V[200005], W[200005];
struct Segment_Tree {
long long v[200005 << 2];
void init() { memset(v, 0x3f, sizeof(v)); }
void modify(long long k, long long l, long long r, long long x, long long y,
long long val) {
if (x > y) return;
if (l >= x && r <= y) {
v[k] = min(v[k], val);
return;
}
long long mid = (l + r) >> 1;
if (x <= mid) modify(k * 2, l, mid, x, y, val);
if (y > mid) modify(k * 2 + 1, mid + 1, r, x, y, val);
}
long long query(long long k, long long l, long long r, long long x) {
if (l == r) return v[k];
long long res, mid = (l + r) >> 1;
if (x <= mid)
res = query(k * 2, l, mid, x);
else
res = query(k * 2 + 1, mid + 1, r, x);
return min(res, v[k]);
}
} T;
void add(long long a, long long b, long long c, long long Id) {
v[++cnt] = b;
u[cnt] = a;
w[cnt] = c;
id[cnt] = Id;
nxt[cnt] = head[a];
head[a] = cnt;
}
void dij(long long s, long long dis[], long long f) {
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
for (long long i = 1; i <= n; i++) dis[i] = 1e16, vis[i] = 0;
dis[s] = 0;
q.push(make_pair(0, s));
while (!q.empty()) {
long long c = q.top().second;
q.pop();
if (vis[c]) continue;
vis[c] = 1;
for (long long i = head[c]; i; i = nxt[i]) {
if (dis[v[i]] > dis[c] + w[i]) {
dis[v[i]] = dis[c] + w[i];
pre[v[i]] = id[i];
if (f == 1 && !on[v[i]]) L[v[i]] = L[c];
if (f == 2 && !on[v[i]]) R[v[i]] = R[c];
q.push(make_pair(dis[v[i]], v[i]));
}
}
}
}
void init() {
long long now = 1;
on[now] = 1;
L[now] = R[now] = 0;
for (long long i = 1; now != n; i++) {
long long now_id = pre[now];
in_dist[now_id] = i;
++len;
now = U[now_id] ^ V[now_id] ^ now;
on[now] = true;
L[now] = R[now] = i;
}
}
signed main() {
n = read();
m = read();
q = read();
for (long long i = 1; i <= m; i++) {
long long x = read(), y = read(), z = read();
U[i] = x;
V[i] = y;
W[i] = z;
add(x, y, z, i);
add(y, x, z, i);
in_dist[i] = -1;
}
dij(n, disT, 0);
init();
dij(1, disS, 1);
dij(n, disT, 2);
T.init();
for (long long i = 1; i <= m; i++) {
if (in_dist[i] == -1) {
T.modify(1, 1, len, L[U[i]] + 1, R[V[i]], disS[U[i]] + W[i] + disT[V[i]]);
T.modify(1, 1, len, L[V[i]] + 1, R[U[i]], disT[U[i]] + W[i] + disS[V[i]]);
}
}
while (q--) {
long long Id = read(), x = read();
long long ans = disS[n];
if (in_dist[Id] == -1) {
if (x < W[Id]) {
ans = min(ans, disS[U[Id]] + x + disT[V[Id]]);
ans = min(ans, disT[U[Id]] + x + disS[V[Id]]);
}
} else {
ans = ans - W[Id] + x;
if (x > W[Id]) ans = min(ans, T.query(1, 1, len, in_dist[Id]));
}
printf("%lld\n", ans);
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
if (a > b) swap(a, b);
int diff = b - a;
int q = diff / 10;
int rem = diff % 10;
if (rem != 0) ++q;
cout << q << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
basic_string<int> wins[12345];
int sell[12345], win[12345];
bool used[5005];
int pows[2001][1234];
int ans[1234];
int tmp[1234];
void reg(int* tmp) {
for (int j = 0; j < 1233; j++) {
tmp[j + 1] += tmp[j] / 10;
tmp[j] %= 10;
}
}
void add(int i) {
for (int j = 0; j < 1234; j++) ans[j] += pows[i][j];
reg(ans);
}
void print() {
for (int y = 0, j = 1233; j >= 0; j--) {
if (ans[j] || j == 0) {
y = 1;
}
if (y) cout << ans[j];
}
cout << '\n';
}
void prec() {
pows[0][0] = 1;
for (int i = 1; i <= 2000; i++) {
for (int j = 0; j < 1234; j++) pows[i][j] = pows[i - 1][j] << 1;
reg(pows[i]);
}
}
int main() {
ios::sync_with_stdio(!cin.tie(0));
prec();
cin >> n;
for (int i = 1; i <= n; i++) {
string s;
int x;
cin >> s >> x;
if (s == "win") {
wins[x] += i;
} else {
sell[x] = i;
}
}
for (int i = 0; i < 12345; i++) {
for (int j = (int)wins[i].size() - 1; j >= 0; j--) {
if (wins[i][j] < sell[i]) {
win[i] = wins[i][j];
break;
}
}
}
for (int i = 12344; i >= 0; i--) {
if (win[i] && sell[i]) {
bool ok = 1;
for (int j = win[i]; j <= sell[i]; j++) {
if (used[j]) {
ok = 0;
}
}
if (ok) {
add(i);
for (int j = win[i]; j <= sell[i]; j++) {
used[j] = 1;
}
}
}
}
print();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100001;
long long a[MAX];
long long sum[MAX];
int main() {
ios::sync_with_stdio(false);
long long N, ret = 0;
cin >> N;
for (int i = 0; i < N; ++i) cin >> a[i];
sort(a, a + N, greater<long long>());
for (int i = 1; i < N; ++i) {
ret += a[i] * i;
sum[i] = sum[i - 1] + a[i];
}
int runs, k, i;
long long v;
cin >> runs;
while (runs--) {
cin >> k;
if (k == 1)
cout << ret;
else {
long long ans = 0;
long long ant = 0;
long long steep = k;
bool flag = true;
for (i = 1, v = steep; flag; v = steep + v, ++i) {
if (v >= N) v = N - 1, flag = false;
ans += (sum[v] - sum[ant]) * i;
ant = v;
steep *= k;
}
cout << ans;
}
if (runs) cout << " ";
}
cout << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
int main() {
long long t, n, i, j, k, p, l, mn = 0, mx = 0, m;
string a, b;
scanf("%lld", &t);
while (t--) {
v.clear();
scanf("%lld", &n);
cin >> a >> b;
int sz = b.size();
for (int i = b.size() - 1; i >= 0; i--) {
if (b[i] == a[0]) {
v.push_back(1);
if (a[0] == '1')
a[0] = '0';
else
a[0] = '1';
}
v.push_back(sz);
for (int i = 0; i < sz; i++) {
if (a[i] == '1')
a[i] = '0';
else
a[i] = '1';
}
reverse(a.begin(), a.begin() + sz);
sz--;
}
cout << v.size() << " ";
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
long long read() {
long long res = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) res = res * 10 + ch - 48, ch = getchar();
return res * flag;
}
void print(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + 48);
}
void solution() {
std::string s;
std::cin >> s;
s += "+";
long long ans = 0, tmp = 0;
bool flag = false;
for (const auto &i : s) {
if (i == '+' || i == '-') {
if (flag) tmp *= -1;
ans += tmp;
tmp = 0;
flag = (i == '-');
}
tmp = tmp * 10 - 48 + i;
}
print(ans), puts("");
}
signed main() { solution(); }
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 1;
const double pi = acos(-1.0);
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
char a[n + 1][m + 1];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> a[i][j];
}
}
map<long long, long long> rw;
map<long long, long long> clm;
for (long long i = 0; i < n; i++) {
long long cnt = 0;
for (long long j = 0; j < m; j++) {
if (a[i][j] == '*') {
cnt++;
}
}
rw[i] = cnt;
}
for (long long j = 0; j < m; j++) {
long long cnt = 0;
for (long long i = 0; i < n; i++) {
if (a[i][j] == '*') {
cnt++;
}
}
clm[j] = cnt;
}
long long mn = MOD;
long long total = n + m;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
long long val = rw[i] + clm[j];
if (a[i][j] != '*') val++;
mn = min(total - val, mn);
}
}
cout << mn << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int si = 0, n, x, sp = 0, nri = 0, mn = 1000;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x % 2 == 0) {
sp += x;
} else {
nri++;
si += x;
if (x < mn) mn = x;
}
}
if (nri == 0) {
cout << 0;
return 0;
}
if (nri % 2) {
cout << sp + si;
} else
cout << sp + si - mn;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, res = 0, i, j;
cin >> n;
for (i = 1; i < n; ++i) {
for (j = i + 1; j < n; ++j) {
int hy = i * i + j * j;
int root = sqrt(hy);
if (root * root == hy and root <= n) res += 1;
}
}
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e14;
const long long N = 3e3 + 1;
const long long mod = 1e9 + 7;
const long double eps = 1E-7;
long long a[N], b[N], used[N], n, m, k, x, y, z, h, cnt, ans;
string s, t, TEQ = "AVMHIUOWXTY";
pair<long long, long long> p[3];
int main() {
ios_base::sync_with_stdio(0);
;
cin >> n;
x = n + 1;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0)
x = min(x, i + n / i);
else
x = min(x, i + n / i + 1);
}
cout << x;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 51123987;
const int maxn = 152;
const int maxs = 5005;
const int maxa = 52;
string st;
int f[maxs][maxa][maxa];
int P[maxn][maxn];
int la[maxn], lb[maxn], lc[maxn];
int Q[maxs];
int n, ret, Qs = 0, Ps = 0;
inline void Add(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
int N1, N0;
inline void Addit(int p, int &cur, pair<int, int> ab, int s) {
int a = ab.first;
if (a > N1 || a + p < N0) return;
int b = ab.second;
if (b > N1 || b + p < N0) return;
int c = n - p - a - b;
if (c > N1 || c + p < N0) return;
if (cur == -1) {
if (Qs)
cur = Q[Qs--];
else
cur = Ps++;
}
Add(f[cur][a][b], s);
}
void Release(int x, int y) {
memset(f[P[x][y]], 0, sizeof(f[P[x][y]]));
Q[++Qs] = P[x][y];
}
void init() {
scanf("%d", &n);
cin >> st;
}
inline void Check(int x) {
if (st[x] == 'a') la[x] = x;
if (st[x] == 'b') lb[x] = x;
if (st[x] == 'c') lc[x] = x;
}
inline void Swap(int &a, int &b) {
int tmp = a;
a = b;
b = tmp;
}
inline bool legal(int a, int b, int c) {
if (a < b) Swap(a, b);
if (a < c) Swap(a, c);
if (b < c) Swap(b, c);
return a <= c + 1;
}
void work() {
N0 = n / 3 - 1;
N1 = n / 3 + 1;
la[0] = lb[0] = lc[0] = -1;
Check(0);
for (int i = 1; i < n; i++) {
la[i] = la[i - 1], lb[i] = lb[i - 1], lc[i] = lc[i - 1];
Check(i);
}
ret = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) P[i][j] = -1;
for (int i = n - 1; i >= 0; i--) {
if (la[n - 1] == i || lb[n - 1] == i || lc[n - 1] == i)
Addit(n - 1, P[i][n - 1],
make_pair(st[i] == 'a' ? 1 : 0, st[i] == 'b' ? 1 : 0), 1);
for (int l = n - 1; l >= 0; l--) {
int l1 = l - 1;
if (P[i][l] == -1) continue;
for (int sa = 0; sa <= n - l && sa <= 51; sa++)
for (int sb = 0; sb + sa <= n - l && sb <= 51; sb++) {
int s = f[P[i][l]][sa][sb];
if (l == 0) {
if (legal(sa, sb, n - sa - sb)) Add(ret, s);
continue;
}
if (st[i] == 'a') Addit(l1, P[i][l1], make_pair(sa + 1, sb), s);
if (st[i] == 'b') Addit(l1, P[i][l1], make_pair(sa, sb + 1), s);
if (st[i] == 'c') Addit(l1, P[i][l1], make_pair(sa, sb), s);
if (st[i] != 'a' && i && la[i - 1] != -1)
Addit(l1, P[la[i - 1]][l1], make_pair(sa + 1, sb), s);
if (st[i] != 'b' && i && lb[i - 1] != -1)
Addit(l1, P[lb[i - 1]][l1], make_pair(sa, sb + 1), s);
if (st[i] != 'c' && i && lc[i - 1] != -1)
Addit(l1, P[lc[i - 1]][l1], make_pair(sa, sb), s);
}
if (P[i][l] != -1) Release(i, l);
}
}
}
void print() { printf("%d\n", ret); }
int main() {
init();
work();
print();
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
void GO_GO_GO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void BYE_BYE() {
cerr << "Time elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
}
bool primeArr[1000001] = {false};
long long int fact[1000001];
long long int lazy[1000001] = {0};
vector<long long int> primes;
int main() {
GO_GO_GO();
long long int t = 1;
cin >> t;
while (t--) {
long long int i = 0;
long long int n;
cin >> n;
vector<long long int> v(n);
for (i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
vector<long long int> ig;
for (i = 0; i < n - 1; i++) {
for (long long int j = i + 1; j < n; j++) {
ig.push_back(v[j] - v[i]);
}
}
vector<bool> forbidden(1000007, false);
long long int x = 1;
vector<long long int> b;
while (b.size() != n) {
if (forbidden[x]) {
x++;
continue;
} else {
b.push_back(x);
for (auto y : ig) {
forbidden[x + y] = true;
}
}
x++;
}
cout << "YES"
<< "\n";
for (auto x : b) {
cout << x << " ";
}
cout << "\n";
}
BYE_BYE();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
int ocho = a / 2;
if (ocho > 18 || (ocho > 17 && (a % 2 != 0))) {
cout << -1 << '\n';
return 0;
}
string resp;
for (int i = 0; i < ocho; ++i) {
resp += '8';
}
if (a == 1)
resp += '4';
else if (a % 2 != 0)
resp += '0';
cout << resp << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ui = unsigned int;
using ii = pair<int, int>;
using ull = unsigned long long;
using vi = vector<int>;
using vii = vector<ii>;
using llp = pair<ll, ll>;
const ll MAXN = 1e3 + 100, MAXM = 100 + 100, LOG_MAXN = 20, MAXVAL = 2e6 + 100,
MOD = 1e9 + 7, INF = 1e9 + 7;
template <class A, class B>
ostream &operator<<(ostream &strm, pair<A, B> p) {
return strm << "{" << p.first << ";" << p.second << "}";
}
template <class A, class B>
ostream &operator<<(ostream &strm, vector<A, B> &v) {
for (int i = 0; i < v.size(); i++)
strm << v[i] << ((i + 1 == v.size()) ? "" : " ");
return strm;
}
bool isLessThanSquare(ll i, ll n) { return i * i <= n; }
bool isLessThanCube(ll i, ll n) { return i * i <= n / i; }
ll bin_search(ll n, bool (*prop)(ll a, ll b)) {
ll beg = 0, end = n + 1;
while (end - beg > 1) {
ll m = ((beg + end) / 2);
if (prop(m, n))
beg = m;
else
end = m;
}
return beg;
}
ll getSixRoot(ll n) {
ll x = bin_search(n, isLessThanCube);
return bin_search(x, isLessThanSquare);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
;
;
int t;
cin >> t;
while (t--) {
ll n;
cin >> n;
ll sq = bin_search(n, isLessThanSquare);
ll cb = bin_search(n, isLessThanCube);
ll six = getSixRoot(n);
cout << sq + cb - six << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<int> v;
int numOfDigits(int n) {
int ret = 0;
while (n > 0) {
n = n / 10;
ret++;
}
return ret;
}
int sumOfDigits(int n) {
int ret = 0;
while (n > 0) {
int a = n % 10;
n = n / 10;
ret += a;
}
return ret;
}
void calc(int a, int b) {
for (int i = a; i <= b; i++) {
if (i + sumOfDigits(i) == b) v.push_back(i);
}
}
int main() {
int n, t, hold = 0, a, b, i, j;
cin >> n;
calc(max(n - 5000, 0), n);
cout << v.size() << endl;
for (i = 0; i < v.size(); i++) cout << v[i] << " ";
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = int(1e9) + 7;
const long long inf = 1e18 + 5;
const int offset = 3000;
int main() {
int n;
scanf("%d", &n);
int arr[55], dp[55][2];
for (int i = 1; i <= n; i++) scanf("%d", &arr[i]);
dp[n][1] = arr[n];
dp[n][0] = 0;
for (int i = n - 1; i > 0; i--) {
dp[i][1] = max(dp[i + 1][1], arr[i] + dp[i + 1][0]);
dp[i][0] = min(dp[i + 1][1], arr[i] + dp[i + 1][0]);
}
cout << dp[1][0] << " " << dp[1][1];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
int n, s, e;
long long x[N], a[N], b[N], c[N], d[N];
long long dp[2][N + N][5];
inline void assign(int idx, int tmp1, int tmp2, long long val) {
if (abs(tmp1 - tmp2) > 2 || tmp1 < 0 || tmp2 < 0) return;
dp[idx & 1][tmp1][tmp1 - tmp2 + 2] = val;
}
inline void check(int idx, int tmp1, int tmp2, long long val) {
if (abs(tmp1 - tmp2) > 2 || tmp1 < 0 || tmp2 < 0) return;
dp[idx & 1][tmp1][tmp1 - tmp2 + 2] =
min(dp[idx & 1][tmp1][tmp1 - tmp2 + 2], val);
}
inline void check(int idx, int tmp1, int tmp2, int idx2, int tmp3, int tmp4,
long long val) {
if (abs(tmp3 - tmp4) > 2 || tmp3 < 0 || tmp4 < 0) return;
if (idx2 != n && (tmp3 == 0 && tmp4 == 0)) return;
check(idx, tmp1, tmp2, val + dp[idx2 & 1][tmp3][tmp3 - tmp4 + 2]);
}
int main() {
scanf("%d%d%d", &n, &s, &e);
s--, e--;
for (int i = 0; i < n; i++) scanf("%lld", &x[i]);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
for (int i = 0; i < n; i++) scanf("%lld", &b[i]);
for (int i = 0; i < n; i++) scanf("%lld", &c[i]);
for (int i = 0; i < n; i++) scanf("%lld", &d[i]);
for (int i = 0; i <= n; i++)
for (int j = -2; j <= 2; j++) assign(n, i, i + j, (long long)1e18);
assign(n, 0, 0, 0);
int tmp1, tmp2;
for (int i = n - 1; i >= 0; i--) {
for (tmp1 = 0; tmp1 <= i; tmp1++) {
for (int j = -2; j <= 2; j++) {
tmp2 = tmp1 + j;
assign(i, tmp1, tmp2, (long long)1e18);
if (tmp2 < 0) continue;
if (i == s) {
if (tmp2 > 0)
check(i, tmp1, tmp2, i + 1, tmp1, tmp2 - 1, c[i] + x[i]);
check(i, tmp1, tmp2, i + 1, tmp1 + 1, tmp2, d[i] - x[i]);
} else if (i == e) {
if (tmp1 > 0)
check(i, tmp1, tmp2, i + 1, tmp1 - 1, tmp2, x[i] + a[i]);
check(i, tmp1, tmp2, i + 1, tmp1, tmp2 + 1, b[i] - x[i]);
} else {
if (tmp2 > 0 && tmp1 > 0)
check(i, tmp1, tmp2, i + 1, tmp1 - 1, tmp2 - 1,
x[i] + x[i] + c[i] + a[i]);
if (tmp1 > 0) check(i, tmp1, tmp2, i + 1, tmp1, tmp2, a[i] + d[i]);
if (tmp2 > 0) check(i, tmp1, tmp2, i + 1, tmp1, tmp2, c[i] + b[i]);
check(i, tmp1, tmp2, i + 1, tmp1 + 1, tmp2 + 1,
-x[i] - x[i] + d[i] + b[i]);
}
}
}
}
cout << dp[0][0][2] << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20;
int n, ans, top, ttt;
int a[100100], d[100100], tot[100100], p[100100];
int main() {
while (scanf("%d", &n) != EOF) {
memset(tot, 0, sizeof(tot));
top = 0;
d[0] = 0;
a[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] < a[i - 1]) {
tot[a[i - 1]]++;
} else {
if (top == 0) {
d[++top] = a[i];
p[a[i]] = 0;
} else {
while (top > 0 && d[top] < a[i]) top--;
while (top > 0 && tot[d[top]] == p[d[top]]) top--;
if (top > 0) tot[d[top]]++;
p[a[i]] = tot[d[top]];
d[++top] = a[i];
}
}
}
ans = 0;
for (int i = 1; i <= n; i++) {
if (tot[i] > ans) ans = tot[i];
}
cout << ans << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, a, d, t[100100], v[100100];
double ans[100100];
int main() {
scanf("%d %d %d", &n, &a, &d);
for (int i = 0; i < n; i++) scanf("%d %d", &t[i], &v[i]);
for (int i = 0; i < n; i++) {
double tt = v[i] * 1.0 / a;
double dt = a * tt * tt / 2;
if (d > dt)
ans[i] = tt + (d - dt) / v[i];
else
ans[i] = sqrt(2.0 * d / a);
ans[i] += t[i];
if (i) ans[i] = max(ans[i], ans[i - 1]);
printf("%.6lf\n", ans[i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100002;
struct vec {
long long x, y;
vec() {}
vec(long long x, long long y) : x(x), y(y) {}
vec operator-(const vec &v) const { return vec(x - v.x, y - v.y); }
long long operator*(const vec &v) const { return x * v.y - y * v.x; }
};
int p[maxn];
int t[maxn];
long long sum[maxn][2];
int cnt[maxn][2];
long long dp[maxn];
long long mindp[maxn][2];
vec ord[maxn][2];
int top[2], cur[2];
int n, c, d;
int main() {
scanf("%d%d%d", &n, &c, &d);
for (int i = 1; i <= n; i++) {
char c;
scanf("%d %c", &t[i], &c);
if (c == 'P') p[i] = 1;
}
scanf("%d", &t[n + 1]);
for (int i = n; i >= 1; i--) {
cnt[i][0] = cnt[i + 1][0];
cnt[i][1] = cnt[i + 1][1];
sum[i][0] = sum[i + 1][0];
sum[i][1] = sum[i + 1][1];
cnt[i][p[i]]++;
sum[i][p[i]] += t[n + 1] - t[i];
}
int pos = n + 1;
while (pos - 1 >= 1 && c * (t[n + 1] - t[pos - 1]) < d) pos--;
for (int i = 1; i <= n; i++) {
if (i >= pos)
dp[i] = c * sum[i][p[i]] + (long long)d * cnt[i][!p[i]];
else
dp[i] = c * sum[pos][p[i]] + c * (t[n + 1] - t[i]) +
(long long)d * (cnt[i + 1][p[i]] - cnt[pos][p[i]]) +
(long long)d * cnt[i][!p[i]];
}
for (int i = 1; i <= n + 1; i++) {
mindp[i][0] = mindp[i][1] = 1e18;
}
cur[0] = cur[1] = top[0] = top[1] = 1;
long long ans = (long long)n * d;
for (int i = n; i >= 1; i--) {
mindp[i][0] = min(mindp[i][0], mindp[i + 1][0]);
mindp[i][1] = min(mindp[i][1], mindp[i + 1][1]);
dp[i] = min(dp[i], mindp[i][!p[i]] - c * t[i] +
(long long)d * (cnt[i + 1][p[i]] + cnt[i][!p[i]]));
vec v(1, c * cnt[i][p[i]]);
while (cur[!p[i]] < top[!p[i]] &&
v * ord[cur[!p[i]] + 1][!p[i]] < v * ord[cur[!p[i]]][!p[i]])
cur[!p[i]]++;
dp[i] = min(dp[i], v * ord[cur[!p[i]]][!p[i]] + c * sum[i][p[i]] +
(long long)d * cnt[i][!p[i]]);
ans = min(ans, (long long)(i - 1) * d + dp[i]);
v = vec(t[n + 1] - t[i],
dp[i] - c * sum[i][!p[i]] +
(long long)c * cnt[i][!p[i]] * (t[n + 1] - t[i]) -
(long long)d * cnt[i][p[i]]);
while (top[p[i]] > 1 && (ord[top[p[i]]][p[i]] - ord[top[p[i]] - 1][p[i]]) *
(v - ord[top[p[i]]][p[i]]) <
0)
top[p[i]]--;
ord[++top[p[i]]][p[i]] = v;
cur[p[i]] = min(cur[p[i]], top[p[i]]);
while (pos - 1 >= 1 && c * (t[i] - t[pos - 1]) < d) pos--;
mindp[pos - 1][p[i]] =
min(mindp[pos - 1][p[i]],
dp[i] +
c * (sum[pos][!p[i]] - sum[i][!p[i]] -
(long long)(cnt[pos][!p[i]] - cnt[i][!p[i]]) *
(t[n + 1] - t[i]) +
t[i]) +
(long long)d * (-cnt[pos][!p[i]] - cnt[i][p[i]]));
}
printf("%lld", ans);
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
long long int lcm(long long int a, long long int b) {
return a * b / gcd(a, b);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int n, t;
cin >> n >> t;
if (n == 1 && t >= 10) return cout << -1, 0;
if (t == 10) {
putchar('1');
for (int i = 1; i < n; i++) putchar('0');
} else
for (int i = 0; i < n; i++) putchar(t + '0');
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> d = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
void bfs(vector<vector<int>> arr, vector<vector<long long>> &dist, int n,
int m) {
queue<pair<int, int>> q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < 4; k++) {
int x = i + d[k].first, y = j + d[k].second;
if (x < 0 || y < 0 || x == n || y == m || arr[i][j] != arr[x][y])
continue;
else {
dist[i][j] = 0;
q.push({i, j});
break;
}
}
}
}
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int xx = x + d[i].first, yy = y + d[i].second;
if (xx < 0 || yy < 0 || xx == n || yy == m ||
dist[x][y] + 1 >= dist[xx][yy])
continue;
dist[xx][yy] = dist[x][y] + 1;
q.push({xx, yy});
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, t;
;
cin >> n >> m >> t;
vector<vector<int>> arr(n, vector<int>(m));
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
if (s[j] == '0')
arr[i][j] = 0;
else
arr[i][j] = 1;
}
}
vector<vector<long long>> dist(n, vector<long long>(m, LLONG_MAX));
bfs(arr, dist, n, m);
while (t--) {
int i, j;
long long p;
cin >> i >> j >> p;
if (p <= dist[i - 1][j - 1])
cout << arr[i - 1][j - 1] << '\n';
else {
int ans = ((p - dist[i - 1][j - 1]) % 2) ^ arr[i - 1][j - 1];
cout << ans << '\n';
}
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 314000000;
int n, m, deg[100005];
long long dist[100005], mx[100005];
vector<int> g[100005];
struct Edge {
int id;
long long cnt;
vector<int> g;
} e[100005];
vector<int> G[100005];
int dfn[100005], low[100005];
int instk[100005], scc[100005];
int index_ = 0, cnt = 0, stk[100005], top;
vector<int> has[100005];
void tarjan(int u) {
low[u] = dfn[u] = ++index_;
stk[++top] = u, instk[u] = 1;
for (int v : G[u])
if (!dfn[v])
tarjan(v), low[u] = min(low[u], low[v]);
else if (instk[v])
low[u] = min(low[u], dfn[v]);
if (dfn[u] == low[u]) {
cnt++;
while (stk[top] != u) {
scc[stk[top]] = cnt;
has[cnt].push_back(stk[top]);
instk[stk[top--]] = 0;
}
scc[stk[top]] = cnt;
has[cnt].push_back(stk[top]);
instk[stk[top--]] = 0;
}
}
long long dfs(int u) {
long long &res = mx[u];
if (~res) return res;
res = 0;
for (int i : g[u]) {
long long tmp = e[i].cnt;
for (int v : e[i].g) {
if (dist[v] > inf)
goto __WJY_AK_IOI__;
else if (dfs(v) == -2)
return res = -2;
else
tmp += dfs(v);
}
tmp = min(tmp, inf);
res = max(res, tmp);
__WJY_AK_IOI__:;
}
return res;
}
int main() {
scanf("%d %d", &m, &n);
for (int i = 1; i <= m; ++i) {
int id, num;
scanf("%d %d", &id, &num);
e[i].id = id;
for (int j = 0; j < num; ++j) {
int x;
scanf("%d", &x);
if (~x) {
e[i].g.push_back(x);
g[x].push_back(i);
} else
e[i].cnt++;
}
}
priority_queue<pair<int, int> > pq;
fill(dist, dist + n + 1, 1LL + inf);
for (int i = 1; i <= m; ++i)
if ((deg[i] = (int)e[i].g.size()) == 0)
if (dist[e[i].id] > e[i].cnt) {
dist[e[i].id] = e[i].cnt;
pq.push({-dist[e[i].id], e[i].id});
}
while (!pq.empty()) {
auto tp = pq.top();
pq.pop();
int d = -tp.first, u = tp.second;
if (d != dist[u]) continue;
for (int i : g[u])
if (!--deg[i]) {
long long tmp = e[i].cnt;
for (int j : e[i].g) tmp += dist[j];
tmp = min(tmp, 0LL + inf);
if (dist[e[i].id] > tmp) {
dist[e[i].id] = tmp;
pq.push({-tmp, e[i].id});
}
}
}
fill(g, g + n + 1, vector<int>());
memset(mx, -1, sizeof(mx));
for (int i = 1; i <= m; ++i) {
bool flag = dist[e[i].id] <= inf;
for (int j : e[i].g) flag &= dist[j] <= inf;
if (!flag) continue;
g[e[i].id].push_back(i);
for (int j : e[i].g)
if (e[i].id == j)
mx[e[i].id] = -2;
else
G[e[i].id].push_back(j);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= cnt; ++i) {
auto now = has[i];
if ((int)now.size() > 1)
for (int u : now) mx[u] = -2;
}
for (int i = 1; i <= n; ++i)
if (dist[i] > inf)
puts("-1 -1");
else
printf("%lld %lld\n", dist[i], dfs(i));
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long T, N, M;
set<long long> s;
void pre() {
long long sum = 1;
long long valor = 1;
long long sumA = 1;
s.insert(0);
s.insert(2);
int i = 2;
while (sum * 2 + 1 <= 1000000000) {
sum = sum + i;
s.insert(sum * 2 + valor);
valor = sum;
i++;
}
}
void solve() {
int ans = 0;
while (N >= 2) {
auto it = s.upper_bound(N);
if (it != s.begin()) it--;
if (N - (*it) == 0) {
ans++;
break;
} else {
N = N - (*it);
ans++;
}
}
cout << ans << "\n";
}
int main() {
cin >> T;
pre();
while (T--) {
cin >> N;
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (typename vector<T>::const_iterator vi = v.begin(); vi != v.end(); ++vi) {
if (vi != v.begin()) os << ", ";
os << *vi;
}
os << "}";
return os;
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
template <typename T, bool maximum_mode = false>
struct RMQ {
int n = 0, levels = 0;
vector<T> values;
vector<vector<int>> range_low;
RMQ(const vector<T> &_values = {}) {
if (!_values.empty()) build(_values);
}
static int largest_bit(int x) { return 31 - __builtin_clz(x); }
int better_index(int a, int b) const {
return (maximum_mode ? values[b] < values[a] : values[a] < values[b]) ? a
: b;
}
void build(const vector<T> &_values) {
values = _values;
n = values.size();
levels = largest_bit(n) + 1;
range_low.resize(levels);
for (int k = 0; k < levels; k++) range_low[k].resize(n - (1 << k) + 1);
for (int i = 0; i < n; i++) range_low[0][i] = i;
for (int k = 1; k < levels; k++)
for (int i = 0; i <= n - (1 << k); i++)
range_low[k][i] = better_index(range_low[k - 1][i],
range_low[k - 1][i + (1 << (k - 1))]);
}
int query_index(int a, int b) const {
assert(0 <= a && a < b && b <= n);
int level = largest_bit(b - a);
return better_index(range_low[level][a],
range_low[level][b - (1 << level)]);
}
T query_value(int a, int b) const { return values[query_index(a, b)]; }
};
struct LCA {
int n = 0;
vector<vector<int>> adj;
vector<int> parent, depth, subtree_size;
vector<int> euler, first_occurrence;
vector<int> tour_start, tour_end, tour_list, postorder;
vector<int> heavy_root;
RMQ<int> rmq;
LCA(int _n = 0) { init(_n); }
LCA(const vector<vector<int>> &_adj) { init(_adj); }
void init(int _n) {
n = _n;
adj.assign(n, {});
parent.resize(n);
depth.resize(n);
subtree_size.resize(n);
first_occurrence.resize(n);
tour_start.resize(n);
tour_end.resize(n);
tour_list.resize(n);
postorder.resize(n);
heavy_root.resize(n);
}
void init(const vector<vector<int>> &_adj) {
init(_adj.size());
adj = _adj;
}
void add_edge(int a, int b) {
adj[a].push_back(b);
adj[b].push_back(a);
}
void dfs(int node, int par) {
parent[node] = par;
depth[node] = par < 0 ? 0 : depth[par] + 1;
subtree_size[node] = 1;
if (par >= 0)
adj[node].erase(find(adj[node].begin(), adj[node].end(), par));
for (int &child : adj[node]) {
dfs(child, node);
subtree_size[node] += subtree_size[child];
}
sort(adj[node].begin(), adj[node].end(),
[&](int a, int b) { return subtree_size[a] > subtree_size[b]; });
}
int tour, post_tour;
void tour_dfs(int node, bool heavy) {
heavy_root[node] = heavy ? heavy_root[parent[node]] : node;
first_occurrence[node] = euler.size();
euler.push_back(node);
tour_list[tour] = node;
tour_start[node] = tour++;
bool heavy_child = true;
for (int child : adj[node]) {
tour_dfs(child, heavy_child);
euler.push_back(node);
heavy_child = false;
}
tour_end[node] = tour;
postorder[node] = post_tour++;
}
void build() {
parent.assign(n, -1);
for (int i = 0; i < n; i++)
if (parent[i] < 0) dfs(i, -1);
tour = post_tour = 0;
for (int i = 0; i < n; i++)
if (parent[i] < 0) {
tour_dfs(i, false);
euler.push_back(-1);
}
assert((int)euler.size() == 2 * n);
vector<int> euler_depths;
for (int node : euler)
euler_depths.push_back(node < 0 ? node : depth[node]);
rmq.build(euler_depths);
}
pair<int, int> find_farthest(int node, int par, int path) const {
pair<int, int> current = {path, node};
for (int neighbor : adj[node])
if (neighbor != par)
current = max(current, find_farthest(neighbor, node, path + 1));
return current;
}
pair<int, pair<int, int>> get_diameter() const {
int u = find_farthest(0, -1, 0).second;
pair<int, int> farthest = find_farthest(u, -1, 0);
int v = farthest.second;
return {farthest.first, {u, v}};
}
int get_lca(int a, int b) const {
a = first_occurrence[a];
b = first_occurrence[b];
if (a > b) swap(a, b);
return euler[rmq.query_index(a, b + 1)];
}
bool is_ancestor(int a, int b) const {
return tour_start[a] <= tour_start[b] && tour_start[b] < tour_end[a];
}
bool on_path(int x, int a, int b) const {
return (is_ancestor(x, a) || is_ancestor(x, b)) &&
is_ancestor(get_lca(a, b), x);
}
int get_dist(int a, int b) const {
return depth[a] + depth[b] - 2 * depth[get_lca(a, b)];
}
int child_ancestor(int a, int b) const {
assert(a != b);
assert(is_ancestor(a, b));
int child =
euler[rmq.query_index(first_occurrence[a], first_occurrence[b] + 1) +
1];
assert(parent[child] == a);
assert(is_ancestor(child, b));
return child;
}
int get_kth_ancestor(int a, int k) const {
while (a >= 0) {
int root = heavy_root[a];
if (depth[root] <= depth[a] - k) return tour_list[tour_start[a] - k];
k -= depth[a] - depth[root] + 1;
a = parent[root];
}
return a;
}
int get_kth_node_on_path(int a, int b, int k) const {
int anc = get_lca(a, b);
int first_half = depth[a] - depth[anc];
int second_half = depth[b] - depth[anc];
assert(0 <= k && k <= first_half + second_half);
if (k < first_half)
return get_kth_ancestor(a, k);
else
return get_kth_ancestor(b, first_half + second_half - k);
}
vector<pair<int, int>> compress_tree(vector<int> nodes) const {
if (nodes.empty()) return {};
auto &&compare_tour = [&](int a, int b) {
return tour_start[a] < tour_start[b];
};
sort(nodes.begin(), nodes.end(), compare_tour);
int k = nodes.size();
for (int i = 0; i < k - 1; i++)
nodes.push_back(get_lca(nodes[i], nodes[i + 1]));
sort(nodes.begin(), nodes.end(), compare_tour);
nodes.resize(unique(nodes.begin(), nodes.end()) - nodes.begin());
k = nodes.size();
vector<pair<int, int>> result = {{nodes[0], -1}};
for (int i = 1; i < k; i++)
result.emplace_back(nodes[i], get_lca(nodes[i], nodes[i - 1]));
return result;
}
};
const int INF = 1e9 + 5;
struct state {
int node;
pair<int, int> dist;
state() {}
state(int _node, pair<int, int> _dist) : node(_node), dist(_dist) {}
bool operator<(const state &other) const { return dist > other.dist; }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, Q;
cin >> N;
LCA lca(N);
for (int i = 0; i < N - 1; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
lca.add_edge(x, y);
}
lca.build();
cin >> Q;
vector<vector<int>> compressed_adj(N);
vector<int> which_virus(N, -1);
vector<pair<int, int>> dist(N, {INF, INF});
for (int q = 0; q < Q; q++) {
int k, m;
cin >> k >> m;
vector<pair<int, int>> viruses(k);
vector<int> queries(m);
vector<int> nodes;
for (auto &virus : viruses) {
cin >> virus.first >> virus.second;
virus.first--;
nodes.push_back(virus.first);
}
for (int &query : queries) {
cin >> query;
query--;
nodes.push_back(query);
}
vector<pair<int, int>> compressed = lca.compress_tree(nodes);
int n = compressed.size();
for (int i = 0; i < n; i++) {
int node = compressed[i].first;
int parent = compressed[i].second;
if (parent >= 0) {
compressed_adj[node].push_back(parent);
compressed_adj[parent].push_back(node);
}
}
priority_queue<state> pq;
auto &&dijkstra_check = [&](int node, pair<int, int> new_dist) {
if (new_dist < dist[node]) {
dist[node] = new_dist;
which_virus[node] = new_dist.second;
pq.emplace(node, new_dist);
}
};
for (int i = 0; i < k; i++) {
int node = viruses[i].first;
dijkstra_check(node, {0, i});
}
while (!pq.empty()) {
state top = pq.top();
pq.pop();
if (top.dist > dist[top.node]) continue;
int virus = which_virus[top.node];
int speed = viruses[virus].second;
for (int neighbor : compressed_adj[top.node]) {
int virus_dist = lca.get_dist(viruses[virus].first, neighbor);
int time = (virus_dist + speed - 1) / speed;
dijkstra_check(neighbor, {time, virus});
}
}
for (int i = 0; i < m; i++)
cout << which_virus[queries[i]] + 1 << (i < m - 1 ? ' ' : '\n');
for (int i = 0; i < n; i++) {
int node = compressed[i].first;
compressed_adj[node].clear();
which_virus[node] = -1;
dist[node] = {INF, INF};
}
}
}
| 22 |
#include <bits/stdc++.h>
inline int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
const int N = 210;
int a[N], c[N], pre[N], lst[N];
struct Graph {
const int inf = 1073741823;
static const int N = 210, M = 2010;
int tot = 1, fir[N], nex[M], got[M], tak[M], cst[M];
inline void AddEdge(int u, int v, int t, int w) {
nex[++tot] = fir[u], fir[u] = tot, got[tot] = v, tak[tot] = t, cst[tot] = w;
nex[++tot] = fir[v], fir[v] = tot, got[tot] = u, tak[tot] = 0,
cst[tot] = -w;
}
int dis[N], pre[N], vis[N], flo[N], que[N * 10];
inline int spfa(int s, int t) {
for (int i = 1; i <= t; i++) dis[i] = inf;
int l = 1, r = 1;
dis[s] = 0, flo[s] = inf, que[1] = s;
while (l <= r) {
int u = que[l++];
vis[u] = false;
for (int i = fir[u]; i; i = nex[i]) {
int v = got[i], w = cst[i];
if (!tak[i] || dis[u] + w >= dis[v]) continue;
dis[v] = dis[u] + w, pre[v] = i;
flo[v] = std::min(flo[u], tak[i]);
if (!vis[v]) vis[v] = true, que[++r] = v;
}
}
return dis[t] != inf;
}
inline std::pair<int, int> MincostMaxflow(int s, int t) {
int cost = 0, flow = 0;
while (spfa(s, t)) {
cost += flo[t] * dis[t], flow += flo[t];
for (int u = t; u != s; u = got[pre[u] ^ 1])
tak[pre[u]] -= flo[t], tak[pre[u] ^ 1] += flo[t];
}
return std::make_pair(flow, cost);
}
} G;
int main() {
int n = read(), k = read();
int s = 2 * n + 1, t = 2 * n + 2;
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i <= n; ++i) c[i] = read();
for (int i = 1; i <= n; ++i) {
G.AddEdge(i, i + n, 1, 0);
G.AddEdge(i + n, t, 1, 0);
G.AddEdge(s, i, 1, c[a[i]]);
if (i != 1) G.AddEdge(i - 1, i, k - 1, 0);
if (pre[a[i]]) G.AddEdge(i - 1, pre[a[i]] + n, 1, -c[a[i]]);
pre[a[i]] = i;
}
printf("%d\n", G.MincostMaxflow(s, t).second);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long dp[2][505][505];
long long w[505];
long long n, m, b, mod;
int32_t main() {
cin >> n >> m >> b >> mod;
for (long long i = 1; i <= n; i++) {
cin >> w[i];
}
for (long long i = 0; i <= m; i++) {
for (long long j = 0; j <= b; j++) {
dp[0][i][j] = dp[1][i][j] = 0;
}
}
dp[0][0][0] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j <= m; j++) {
for (long long k = 0; k <= b; k++) {
dp[(i % 2)][j][k] = dp[!(i % 2)][j][k];
dp[(i % 2)][j][k] %= mod;
if (j - 1 >= 0 && k - w[i] >= 0)
dp[(i % 2)][j][k] += dp[(i % 2)][j - 1][k - w[i]];
dp[(i % 2)][j][k] %= mod;
}
}
}
long long ans = 0;
for (long long i = 0; i <= b; i++) {
ans += dp[(n % 2)][m][i];
ans %= mod;
}
cout << ans << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 8;
const int MAXR = 1;
const int MAXC = 1;
const int MAXBITS = 64;
const int INF = (int)1e9;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int dx8[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy8[] = {-1, 0, 1, -1, 1, -1, 0, 1};
priority_queue<int, vector<int>, greater<int>> q1;
priority_queue<int, vector<int>, less<int>> q2;
void l() { ; }
int arr[MAXN];
int main(void) {
ios::sync_with_stdio(false);
cin.tie(NULL);
int x, y, z, x2, y2, z2, a1, a2, a3, a4, a5, a6;
cin >> x >> y >> z >> x2 >> y2 >> z2 >> a1 >> a2 >> a3 >> a4 >> a5 >> a6;
;
;
;
int ans = 0;
if (y < 0) ans += a1;
if (y > y2) ans += a2;
if (z < 0) ans += a3;
if (z > z2) ans += a4;
if (x < 0) ans += a5;
if (x > x2) ans += a6;
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, next;
} road[100005 * 2];
struct nodd {
int max1, max2, num;
} msg[100005];
int m, n, d, start[100005], tot = 0, f[100005];
bool mark[100005];
void build(int x, int y) {
tot++, road[tot].x = x, road[tot].y = y, road[tot].next = start[x];
start[x] = tot;
}
void init() {
scanf("%d%d%d", &n, &m, &d);
for (int i = 1; i <= m; i++) {
int p;
scanf("%d", &p);
mark[p] = true;
}
for (int i = 1; i <= n - 1; i++) {
int p, q;
scanf("%d%d", &p, &q);
build(p, q), build(q, p);
}
}
void df_1(int x, int fa) {
if (mark[x] == true) msg[x].max1 = 0, f[x] = 0;
for (int i = start[x]; i; i = road[i].next)
if (road[i].y != fa) {
df_1(road[i].y, x);
int q = road[i].y;
f[x] = max(f[x], f[q] + 1);
if (msg[q].max1 >= 0 && msg[x].max1 <= msg[q].max1 + 1)
msg[x].max2 = msg[x].max1, msg[x].max1 = msg[q].max1 + 1,
msg[x].num = q;
else if (msg[q].max1 >= 0 && msg[x].max2 <= msg[q].max1 + 1)
msg[x].max2 = msg[q].max1 + 1;
}
}
void df_2(int x, int fa, int deep, int Max) {
for (int i = start[x]; i; i = road[i].next)
if (road[i].y != fa) {
int q = road[i].y;
if (msg[x].num == q) {
int t = max(Max, msg[x].max2 - deep);
f[q] = max(f[q], t + deep + 1);
df_2(q, x, deep + 1, t);
} else {
int t = max(Max, msg[x].max1 - deep);
f[q] = max(f[q], t + deep + 1);
df_2(q, x, deep + 1, t);
}
}
}
void work() {
for (int i = 1; i <= n; i++)
msg[i].max1 = msg[i].max2 = -0x3f3f3f3f, msg[i].num = 0;
for (int i = 1; i <= n; i++) f[i] = -0x3f3f3f3f;
df_1(1, 0);
df_2(1, 0, 0, -0x3f3f3f3f);
int ans = 0;
for (int i = 1; i <= n; i++)
if (f[i] <= d) ans++;
printf("%d\n", ans);
}
int main() {
init();
work();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct fenwick_tree {
vector<int> t;
int n;
fenwick_tree(int nn) : t(nn) { n = nn; }
fenwick_tree(const vector<int>& a) : fenwick_tree((int)a.size()) {
for (unsigned i = 0; i < a.size(); i++) inc(i, a[i]);
}
int sum(int r) {
int result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t[r];
return result;
}
void inc(int i, int delta) {
for (; i < n; i = (i | (i + 1))) t[i] += delta;
}
int sum(int l, int r) { return sum(r) - sum(l - 1); }
};
int dr[3001][3001] = {};
int dl[3001][3001] = {};
int dld[3001][3001] = {};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int>> a(n, vector<int>(m));
;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
if (c == 'z') a[i][j] = 1;
}
}
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = m - 1; j >= 0; j--) {
if (a[i][j])
cnt++;
else
cnt = 0;
dr[i][j] = cnt;
}
cnt = 0;
for (int j = 0; j < m; j++) {
if (a[i][j])
cnt++;
else
cnt = 0;
dl[i][j] = cnt;
}
}
for (int i = 0; i <= (n - 1) + (m - 1); i++) {
int l = min(n - 1, i);
int cnt = 0;
for (int j = l; j >= 0; j--) {
int col = i - j;
if (col >= m) break;
if (a[j][col])
cnt++;
else
cnt = 0;
dld[j][col] = cnt;
}
}
vector<fenwick_tree> ft(n + m, fenwick_tree(max(n, m)));
long long ans = 0;
struct pt {
int l;
int c;
};
vector<vector<pt>> ev(m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dr[i][j]) ev[j + dr[i][j] - 1].push_back({i, j});
}
}
for (int i = m - 1; i >= 0; i--) {
for (auto e : ev[i]) {
ft[e.l + e.c].inc(e.l, +1);
}
for (int j = 0; j < n; j++) {
int c = min(dl[j][i], dld[j][i]);
if (c) ans += ft[i + j].sum(j, j + c - 1);
}
}
cout << ans;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
long long ans = abs(a - b) + abs(a - c) + abs(b - c);
cout << max(0ll, ans - 4) << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int xd1(int i, int n1, int n2) {
if (n1 == n2) {
return n1;
}
cout << '?' << ' ' << i << ' ' << n1 << ' ' << i << ' ' << (n1 + n2) / 2
<< endl;
int t1;
cin >> t1;
if (t1 == -1) {
exit(0);
}
if (t1 % 2 == 1) {
return xd1(i, n1, (n1 + n2) / 2);
}
cout << '?' << ' ' << i << ' ' << (n1 + n2) / 2 + 1 << ' ' << i << ' ' << n2
<< endl;
int t2;
cin >> t2;
if (t2 == -1) {
exit(0);
}
if (t2 % 2 == 1) {
return xd1(i, (n1 + n2) / 2 + 1, n2);
}
return -1;
}
int xd2(int i, int n1, int n2) {
if (n1 == n2) {
return n1;
}
cout << '?' << ' ' << n1 << ' ' << i << ' ' << (n1 + n2) / 2 << ' ' << i
<< endl;
int t1;
cin >> t1;
if (t1 == -1) {
exit(0);
}
if (t1 % 2 == 1) {
return xd2(i, n1, (n1 + n2) / 2);
}
cout << '?' << ' ' << (n1 + n2) / 2 + 1 << ' ' << i << ' ' << n2 << ' ' << i
<< endl;
int t2;
cin >> t2;
if (t2 == -1) {
exit(0);
}
if (t2 % 2 == 1) {
return xd2(i, (n1 + n2) / 2 + 1, n2);
}
return -1;
}
int main() {
int n;
cin >> n;
int x1 = 0, x2 = 0, y1 = 0, y2 = 0;
int flag = 0;
for (int i = 1; i < n + 1; i++) {
cout << '?' << ' ' << i << ' ' << 1 << ' ' << i << ' ' << n << endl;
int t;
cin >> t;
if (t == -1) {
exit(0);
}
if (t % 2 == 1) {
flag = 1;
int temp = xd1(i, 1, n);
if (x1 == 0) {
x1 = i;
y1 = temp;
} else {
x2 = i;
y2 = temp;
}
}
}
if (flag == 1) {
cout << '!' << ' ' << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << endl;
} else {
for (int i = 1; i < n + 1; i++) {
cout << '?' << ' ' << 1 << ' ' << i << ' ' << n << ' ' << i << endl;
int t;
cin >> t;
if (t == -1) {
exit(0);
}
if (t % 2 == 1 && flag == 0) {
int temp = xd2(i, 1, n);
x1 = temp;
x2 = temp;
y1 = i;
flag = 1;
} else if (t % 2 == 1 && flag == 1) {
y2 = i;
}
}
cout << '!' << ' ' << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << endl;
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<vector<long long>> A;
long long n;
cin >> n;
long long N[n];
for (long long i = 0; i < n; i++) {
cin >> N[i];
}
A.resize(1);
A[0].push_back(N[0]);
for (long long i = 1; i < n; i++) {
if (*(A[0].end() - 1) < N[i])
A[0].push_back(N[i]);
else {
bool t = 0;
long long l = 0, r = A.size() - 1, m = 0;
while (r - l > 1) {
m = (r + l) / 2;
if (*(A[m].end() - 1) > N[i])
l = m;
else
r = m;
}
if (l != 0 && *(A[l - 1].end() - 1) < N[i]) {
A[l - 1].push_back(N[i]);
t = 1;
} else if (l != 0 && *(A[l - 1].end() - 1) < N[i]) {
A[l - 1].push_back(N[i]);
t = 1;
} else if (*(A[l].end() - 1) < N[i]) {
A[l].push_back(N[i]);
t = 1;
} else if (*(A[r].end() - 1) < N[i]) {
A[r].push_back(N[i]);
t = 1;
} else if (r != A.size() - 1 && *(A[r + 1].end() - 1) < N[i]) {
A[r + 1].push_back(N[i]);
t = 1;
}
if (!t) {
vector<long long> B;
B.push_back(N[i]);
A.push_back(B);
}
}
}
for (long long i = 0; i < A.size(); i++) {
for (long long j = 0; j < A[i].size(); j++) {
cout << A[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename V>
ostream &operator<<(ostream &os, const pair<T, V> pai) {
return os << pai.first << ' ' << pai.second;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> v) {
for (int i = 0, _i = (((int)(v).size())); i < _i; i++) cout << v[i] << ' ';
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> s) {
for (T p : s) cout << p << ' ';
return os;
}
template <typename T, typename V>
ostream &operator<<(ostream &os, const map<T, V> s) {
for (auto p : s) cout << '(' << p << ") ";
return os;
}
template <typename T, typename V>
istream &operator>>(istream &is, pair<T, V> &pai) {
is >> pai.first >> pai.second;
return is;
}
int N, M;
int d[2][2];
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cin >> N >> M;
for (int i = 0, _i = (N); i < _i; i++) {
int t;
cin >> t;
d[0][t & 1]++;
}
for (int i = 0, _i = (M); i < _i; i++) {
int t;
cin >> t;
d[1][t & 1]++;
}
cout << min(d[0][0], d[1][1]) + min(d[0][1], d[1][0]) << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char S[(long long)1e5 + 2];
int main() {
int N, M;
scanf("%d ", &M);
fgets(S, (long long)1e5 + 2, stdin);
N = strlen(S) - 1;
S[N] = 0;
int k = 0;
for (k = 1; k <= 26; k <<= 1)
;
k >>= 1;
int i = -1;
for (i = -1; k; k >>= 1)
if (i + k < 26) {
char worst = 'a' + i + k;
int last = -1;
int j = 0;
for (j = 0; j < N; j++) {
if (S[j] <= worst) last = j;
if (j - last >= M) break;
}
if (j != N) i += k;
}
char worst = 'a' + i + 1;
vector<char> ret;
int last = -1;
int j = 0;
int last_worst = -1;
for (j = 0; j < N; j++) {
if (S[j] < worst) {
last = j;
ret.push_back(S[j]);
}
if (S[j] == worst) {
last_worst = j;
}
if (j - last >= M) {
last = last_worst;
ret.push_back(worst);
}
}
sort(ret.begin(), ret.end());
for (auto i : ret) printf("%c", i);
printf("\n");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
ofstream fo("test.out");
ifstream fi("test.inp");
vector<long long> a;
long long BSRight(long long x) {
long long l = 0, r = a.size() - 1, mid, vt = 1003332;
while (l <= r) {
mid = (l + r) / 2;
if (a[mid] < x)
l = mid + 1;
else {
if (a[mid] == x) return mid;
r = mid - 1;
vt = mid;
}
}
return vt;
}
long long BSLeft(long long x) {
int l = 0, r = a.size() - 1, mid = 0, vt = -1;
while (l <= r) {
mid = (l + r) / 2;
long long t = a[mid];
if (a[mid] > x)
r = mid - 1;
else {
if (a[mid] == x) return mid;
l = mid + 1;
vt = mid;
}
}
return vt;
}
long long SQRT_R(long long x) {
long long l = 0, r = 1e9, mid, pos = 1e9;
while (l <= r) {
mid = (l + r) / 2;
if (mid * mid < x)
l = mid + 1;
else {
if (mid * mid == x) return mid;
pos = mid;
r = mid - 1;
}
}
return pos;
}
long long SQRT_L(long long x) {
long long l = 0, r = 1e9, mid, pos = -1;
while (l <= r) {
mid = (l + r) / 2;
if (mid * mid > x)
r = mid - 1;
else {
if (mid * mid == x) return mid;
pos = mid;
l = mid + 1;
}
}
return pos;
}
int main() {
for (long long i = 2; i <= 1e6; i++) {
long long t = i * i;
while (t <= 1e18 && log10((double)t) + log10((double)i) <= 18) {
t *= i;
long long s = sqrt((double)t);
if (t != s * s) a.push_back(t);
}
}
a.push_back(-1);
long long t = LLONG_MAX;
a.push_back(t);
sort(a.begin(), a.end());
for (int i = 0; i < a.size() - 1; i++) {
if (a[i] == a[i + 1]) a.erase(a.begin() + i), i--;
}
int n;
cin >> n;
long long l, r;
for (int i = 0; i < n; i++) {
cin >> l >> r;
long long rsr = BSLeft(r), rsl = BSRight(l);
long long L, R;
L = SQRT_R(l);
R = SQRT_L(r);
if (rsl == a.size() - 1) rsl = 1, rsr = 0;
if (rsr == 0) rsl = 1;
long long ans = rsr - rsl + 1 + (R - L + 1);
if (ans < 0) ans = 0;
cout << ans << "\n";
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long ans = n;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n /= i;
ans += n;
}
}
ans += (n > 1);
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int col[100005][2], par[100005];
int t[100005][2];
int vis[100005];
vector<vector<int> > adj;
vector<int> P, Q;
int N, M, K;
int ctr;
void init() {
for (int i = 0; i <= N; ++i) par[i] = i;
}
int find(int u) { return (par[u] == u ? u : (par[u] = find(par[u]))); }
void dfs(int u) {
vis[u] = 1;
t[u][0] = ctr++;
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (vis[v]) continue;
dfs(v);
}
t[u][1] = ctr++;
}
int main() {
int type, u, v;
K = 1;
scanf("%d %d", &N, &M);
adj = vector<vector<int> >(N + 3);
init();
for (int i = 0; i < M; ++i) {
scanf("%d", &type);
if (type == 1) {
scanf("%d %d", &u, &v);
par[find(u)] = v;
adj[u].push_back(v);
adj[v].push_back(u);
} else if (type == 2) {
scanf("%d", &u);
col[K][0] = u;
col[K][1] = find(u);
++K;
} else if (type == 3) {
scanf("%d %d", &u, &v);
P.push_back(u);
Q.push_back(v);
}
}
ctr = 0;
for (int i = 1; i <= N; ++i) {
if (par[i] == i) {
dfs(i);
}
}
for (int i = 0; i < P.size(); ++i) {
u = col[Q[i]][0];
v = col[Q[i]][1];
if (t[u][0] >= t[P[i]][0] && t[P[i]][1] >= t[u][1] &&
t[v][0] <= t[P[i]][0] && t[P[i]][1] <= t[v][1]) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100003;
int n, m;
struct triple {
int x, y, k;
triple(int a, int b, int c) : x(a), y(b), k(c) {}
};
vector<triple> queries;
int a[MAXN], b[MAXN];
int tree[4 * MAXN];
int get(int tr[4 * MAXN], int pos, int needPos, int lcur, int rcur) {
if (tr[pos] >= 0 && needPos >= lcur && needPos <= rcur) {
return tr[pos];
}
if (lcur == rcur && lcur == needPos) {
return tr[pos];
}
int mid = lcur + ((rcur - lcur) >> 1);
if (needPos <= mid) {
return get(tr, pos << 1, needPos, lcur, mid);
} else {
return get(tr, (pos << 1) + 1, needPos, mid + 1, rcur);
}
}
void update(int tr[4 * MAXN], int pos, int col, int lcur, int rcur, int l,
int r) {
if (rcur < l || lcur > r) {
return;
}
if (rcur == r && lcur == l) {
tr[pos] = col;
return;
}
if (tr[pos] >= 0) {
tr[pos << 1] = tr[pos];
tr[(pos << 1) + 1] = tr[pos];
}
tr[pos] = -1;
int mid = lcur + ((rcur - lcur) >> 1);
update(tr, pos << 1, col, lcur, mid, max(l, lcur), min(r, mid));
update(tr, (pos << 1) + 1, col, mid + 1, rcur, max(l, mid + 1), min(r, rcur));
}
int main() {
scanf("%d%d", &n, &m);
int cnt = 0;
int t, x, y, k;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
for (int i = 0; i < (n << 2); i++) {
tree[i] = -1;
}
for (int i = 0; i < m; i++) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d%d", &x, &y, &k);
queries.push_back(triple(x, y, k));
update(tree, 1, cnt++, 0, n - 1, y - 1, y + k - 2);
} else {
scanf("%d", &x);
int u = get(tree, 1, x - 1, 0, n - 1);
int v;
if (u == -1) {
v = b[x - 1];
} else {
triple q = queries[u];
v = a[q.x - q.y + x - 1];
}
printf("%d\n", v);
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string num(int n) {
string s = "";
while (n) {
s = (char)(n % 3 + '0') + s;
n /= 3;
}
return s;
}
int calc(int c, int a) {
string s2 = num(a);
string s1 = num(c);
string resp;
while (s2.size() < s1.size()) s2 = '0' + s2;
while (s2.size() > s1.size()) s1 = '0' + s1;
for (int i = 0; i < s1.size(); i++) {
char aux = s1[i] - s2[i] + '0';
if (s1[i] < s2[i]) aux += 3;
resp += aux;
}
int pot = 1;
int cont = 0;
for (int i = resp.size() - 1; i >= 0; i--) {
cont += (pot * (resp[i] - '0'));
pot *= 3;
}
return cont;
}
int main() {
int a, c;
cin >> a >> c;
cout << calc(c, a) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int read() {
int kkk = 0, x = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') c = getchar(), x = -1;
while (c >= '0' && c <= '9')
kkk = (kkk << 3) + (kkk << 1) + (c - '0'), c = getchar();
return kkk * x;
}
int T, n, K, a[200010], con[200010][2], b[200010], ans, id[200010];
int main() {
T = read();
while (T--) {
n = read(), K = read();
for (int i = 1; i <= n; ++i) a[i] = read();
ans = 1;
for (int i = 2; i <= n; ++i) con[a[i]][0] = a[i - 1];
for (int i = 1; i < n; ++i) con[a[i]][1] = a[i + 1];
for (int i = 1; i <= K; ++i) id[b[i] = read()] = i;
for (int i = 1; i <= K; ++i) {
int cnt = 0;
if (con[b[i]][0] && id[con[b[i]][0]] < id[b[i]]) ++cnt;
if (con[b[i]][1] && id[con[b[i]][1]] < id[b[i]]) ++cnt;
ans = 1ll * cnt * ans % mod;
if (!cnt) break;
if (con[b[i]][0] && id[con[b[i]][0]] < id[b[i]]) {
con[con[con[b[i]][0]][0]][1] = b[i];
con[b[i]][0] = con[con[b[i]][0]][0];
} else {
con[con[con[b[i]][1]][1]][0] = b[i];
con[b[i]][1] = con[con[b[i]][1]][1];
}
}
for (int i = 1; i <= K; ++i) id[b[i]] = 0;
for (int i = 2; i <= n; ++i) con[a[i]][0] = 0;
for (int i = 1; i < n; ++i) con[a[i]][1] = 0;
con[0][1] = con[n + 1][0] = 0;
printf("%d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define all(x) (x).begin (),(x).end()
#define sqrt(x) sqrt(abs(x))
#define re return
#define sz(x) ((int)(x).size ())
#define prev PREV
#define next NEXT
using ll = long long;
using ii = pair<int, int>;
using ld = long double;
using D = double;
using vi = vector<int>;
using vii = vector<ii>;
using vvi = vector<vi>;
using vs = vector<string>;
template<typename T> T abs (T x) { re x < 0 ? -x : x; }
template<typename T> T sgn (T x) { re x < 0 ? -1 : (x > 0 ? 1 : 0); }
template<typename T> T sqr (T x) { re x * x; }
template<typename T> T gcd (T a, T b) { re a ? gcd (b % a, a) : b; }
int n;
int m;
int res[200];
int main () {
int tt;
scanf ("%d", &tt);
for (int it = 0; it < tt; it++) {
scanf ("%d%d", &n, &m);
for (int i = 0; i < n + m; i++) res[i] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x;
scanf ("%d", &x);
res[i + j] ^= x;
}
}
int ok = 0;
for (int i = 0; i < n + m; i++) ok |= int (res[i] > 0);
printf ("%s\n", ok ? "Ashish" : "Jeel");
}
re 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
long long binexp(long long a, long long b, long long m) {
long long res = 1;
a = a % m;
while (b) {
if (b & 1) res = (a * 1ll * res) % m;
a = (a * 1ll * a) % m;
b >>= 1;
}
return res;
}
struct point {
long double x, y;
point(long double x, long double y) { this->x = x, this->y = y; }
};
bool operator<(point a, point b) { return a.x < b.x; }
struct Line {
long long m, c;
Line() {}
Line(long long m, long long c) { this->m = m, this->c = c; }
long long val(long long x) { return m * x + c; }
long double val(long double x) { return m * x + c; }
};
point INS(Line a, Line b) {
long double x = -(long double)(a.c - b.c) / (a.m - b.m);
long double y = a.m * x + a.c;
return point(x, y);
}
struct CHT {
vector<Line> ln;
vector<point> p;
CHT() {}
void insert_line(long long m, long long c) {
Line L(m, c);
while (p.size() > 0 and L.val(p.back().x) <= p.back().y) {
p.pop_back();
ln.pop_back();
}
if (ln.size() != 0) p.push_back(INS(ln.back(), L));
ln.push_back(L);
}
long long get(long long x) {
return ln[lower_bound(p.begin(), p.end(), point(x, -1000000000000000000)) -
p.begin()]
.val(x);
}
};
CHT cht;
const long long N = 1e5 + 5;
long long dp[N], a[N], b[N], sum[N];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) cin >> b[i];
cht.insert_line(b[1], 0);
for (long long i = 2; i <= n; i++) {
dp[i] = cht.get(a[i]);
cht.insert_line(b[i], dp[i]);
}
cout << dp[n];
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
int n;
cin >> S >> n;
int Size = S.size();
if (Size % n != 0) {
cout << "NO";
return 0;
}
int Sub = Size / n;
for (int i = 0; i < Size; i++) {
if (S[i] != S[(i / Sub) * Sub + Sub - 1 - (i % Sub)]) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p);
template <class T>
ostream &operator<<(ostream &os, vector<T> &v);
template <class T>
ostream &operator<<(ostream &os, set<T> &v);
template <class T1, class T2>
ostream &operator<<(ostream &os, map<T1, T2> &v);
const long long mod = 1e9 + 7;
const int N = 2e5 + 5;
vector<vector<pair<int, int> > > adj;
int n;
vector<int> a, b;
vector<bool> vis;
void dfs(int s, vector<int> &idx, int &last) {
last = s;
vis[s] = true;
for (pair<int, int> i : adj[s]) {
if (vis[i.first]) {
continue;
}
idx.push_back(i.second);
dfs(i.first, idx, last);
}
}
void TEST_CASES(int cas) {
scanf("%d", &n);
a = vector<int>(n);
b = vector<int>(n);
vis = vector<bool>(n);
adj.clear();
adj.resize(n);
vector<int> cnt(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i]--;
cnt[a[i]]++;
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
b[i]--;
cnt[b[i]]++;
}
for (int i = 0; i < n; i++) {
if (cnt[i] != 2) {
printf("-1\n");
return;
}
}
for (int i = 0; i < n; i++) {
adj[a[i]].push_back({b[i], i + 1});
adj[b[i]].push_back({a[i], -i - 1});
}
vector<int> ans;
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
vector<int> idx;
int src = i;
int last;
dfs(i, idx, last);
for (pair<int, int> i : adj[last]) {
if (i.first == src) {
bool flag = true;
for (int x : idx) {
x = abs(x);
if (x == abs(i.second)) {
flag = false;
break;
}
}
if (!flag) continue;
;
idx.push_back(i.second);
break;
}
};
;
;
int pos = 0, neg = 0;
for (int i : idx) {
if (i > 0)
pos++;
else
neg++;
}
if (neg < pos) {
for (int &i : idx) i = -i;
}
for (int i : idx) {
if (i > 0) ans.push_back(i);
}
}
printf("%d\n", ans.size());
for (int &i : ans) {
printf("%d ", i);
}
puts("");
}
int main() {
int t = 1, cas = 0;
scanf("%d", &t);
while (t--) {
TEST_CASES(++cas);
}
return 0;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << "{" << p.first << ", " << p.second << "} ";
return os;
}
template <class T>
ostream &operator<<(ostream &os, vector<T> &v) {
os << "[ ";
for (int i = 0; i < v.size(); i++) {
os << v[i] << " ";
}
os << " ]";
return os;
}
template <class T>
ostream &operator<<(ostream &os, set<T> &v) {
os << "[ ";
for (T i : v) {
os << i << " ";
}
os << " ]";
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, map<T1, T2> &v) {
for (auto i : v) {
os << "Key : " << i.first << " , Value : " << i.second << endl;
}
return os;
}
| 15 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits.h>
#include <climits>
#include <map>
#include <unordered_map>
#define _USE_MATH_DEFINES
#include <cmath>
#include <set>
#include <unordered_set>
#include <iterator>
#include <deque>
#include <assert.h>
#include <cstdlib>
#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
ull min(ull x, ull y){ if (x<y) return x; return y;}
ull max(ull x, ull y){ if (x<y) return y; return x;}
ll min(ll x, ll y){ if (x<y) return x; return y;}
ll max(ll x, ll y){ if (x<y) return y; return x;}
double min(double x, double y){ if (x<y) return x; return y;}
double max(double x, double y){ if (x<y) return y; return x;}
// s.lower_bound(val) -> iterator to first element >= val (or s.end() if not present)
// s.upper_bound(val) -> iterator to the first element > val (or s.end() if not present)
ull gcd(ull x, ull y){
if (!x) return y;
if (!y) return x;
if (x>y) swap(x,y);
return gcd(x, y%x);
}
ull inv(ull a, ull c){ // a,c are coprime and a<c
if (a==1){
return 1;
}
return ((c-(c/a))*inv(c%a,c))%c;
}
void printv(vector<int> &a){
int n = a.size();
for (int i = 0; i < n; ++i){
cout<<a[i]<<" ";
}
cout<<" END\n";
}
ll M = (ll)1e9+7;
int p[200005] = {0};
int find(int i){
if (i==p[i]) return i;
return p[i] = find(p[i]);
}
void merge(int i, int j){
i = find(i);
j = find(j);
if (i==j) return;
if (i>j) swap(i,j);
p[j]=i;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin>>t;
while (t--){
ll n, P;
cin>>n>>P;
ll a[n];
map<ll, set<int> > pos;
for (int i = 0; i < n; ++i){
p[i] = i;
cin>>a[i];
pos[a[i]].insert(i);
}
vector<int> taken(n,0);
ll ans = 0;
for (map<ll,set<int> >::iterator it = pos.begin(); it != pos.end(); ++it){
ll w = it->first;
if (w >= P) break;
while (!(it->second).empty()){
int i = *(it->second).begin();
for (int j = i + 1; j < n; ++j){
if (a[j]%w != 0) break;
ans += w;
merge(i,j);
if (taken[j]) break;
taken[j]++;
pos[a[j]].erase(j);
}
for (int j = i - 1; j >= 0; --j){
if (a[j]%w != 0) break;
ans += w;
merge(i,j);
if (taken[j]) break;
taken[j]++;
pos[a[j]].erase(j);
}
taken[i]++;
(it->second).erase(i);
}
}
set<int> parents;
for (int i = 0; i < n; ++i){
parents.insert(find(i));
}
ll g = (ll) parents.size();
ans += (g-1)*P;
cout<<ans<<"\n";
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e3 + 4;
int n, m, q;
set<pair<int, int>> st;
multiset<int> ss, tt;
char c[MAXN][MAXN];
int d[MAXN][MAXN], dn[MAXN][MAXN], ri[MAXN][MAXN], ans[MAXN];
pair<int, int> query[MAXN];
pair<int, int> get(int x, int y) {
auto it = st.lower_bound({x, y});
int l, r;
if (it != st.end() && it->first == x)
r = it->second;
else
r = m;
it = st.upper_bound({x, y});
if (it != st.begin()) {
it--;
if (it->first == x)
l = it->second + 1;
else
l = 0;
} else
l = 0;
return {l, r};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> q;
for (int i = 0; i < n; i++) {
string temp;
cin >> temp;
for (int j = 0; j < m; j++) {
c[i][j] = temp[j];
if (c[i][j] == 'X') st.insert({i, j});
}
}
for (int i = 0; i < q; i++) {
cin >> query[i].first >> query[i].second;
query[i].first--, query[i].second--;
st.insert(query[i]);
c[query[i].first][query[i].second] = 'X';
}
int cur = 0;
for (int i = n - 1; i >= 0; i--)
for (int j = m - 1; j >= 0; j--)
if (c[i][j] != 'X') {
dn[i][j] = 1 + dn[i + 1][j];
ri[i][j] = 1 + ri[i][j + 1];
d[i][j] = d[i][j + 1] + 1;
while (d[i][j]) {
if (dn[i][j] >= d[i][j] && ri[i + d[i][j] - 1][j] >= d[i][j]) break;
d[i][j]--;
}
cur = max(cur, d[i][j]);
}
for (int i = q - 1; i >= 0; i--) {
pair<int, int> v = query[i];
st.erase(v);
c[v.first][v.second] = '.';
ans[i] = cur;
bool fl = 1;
while (cur < min(n, m) && fl) {
fl = 0;
ss.clear();
tt.clear();
cur++;
for (int j = max(0, v.first - cur + 1); j < v.first + cur && j < n; j++) {
pair<int, int> temp = get(j, v.second);
ss.insert(temp.first);
tt.insert(temp.second);
if (ss.size() > cur)
ss.erase(ss.find(get(j - cur, v.second).first)),
tt.erase(tt.find(get(j - cur, v.second).second));
if (ss.size() == cur) {
auto it = ss.end();
it--;
int maxi = *it;
it = tt.begin();
int mini = *it;
if (mini - maxi >= cur) {
fl = 1;
break;
}
}
}
if (!fl) cur--;
}
}
for (int i = 0; i < q; i++) cout << ans[i] << "\n";
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, q;
scanf("%d", &n);
scanf("%d", &p);
scanf("%d", &q);
string s;
cin >> s;
bool done = false;
int i = 0;
while (i <= n && !done) {
if ((n - i) % q == 0) {
printf("%d\n", i / p + (n - i) / q);
int j = 0;
for (int k = 0; k < i / p; k++) {
cout << s.substr(j, p) << endl;
j += p;
}
for (int k = 0; k < (n - i) / q; k++) {
cout << s.substr(j, q) << endl;
j += q;
}
done = true;
}
i += p;
}
if (!done) {
printf("%d\n", -1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long turtle(long long a, long long b) {
long long ret = 1, tmp = a;
while (b) {
if (b & 1) ret = ret * tmp % 998244353;
tmp = tmp * tmp % 998244353;
b >>= 1;
}
return ret;
}
long long inv[5005], n, m, k, st[5005], cnt, mi[5005];
bool u[5005];
long long p, ans;
long long dp[5005][5005];
signed main() {
scanf("%lld%lld%lld", &n, &m, &k);
dp[0][0] = 1;
p = turtle(m, 998244353 - 2);
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= i; j++) {
dp[i][j] = (dp[i - 1][j] * j % 998244353 +
dp[i - 1][j - 1] * (n - j + 1) % 998244353) %
998244353;
}
}
for (int i = 1; i <= k; i++)
ans = (ans + dp[k][i] * turtle(p, i) % 998244353) % 998244353;
printf("%lld", ans);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000;
const int PI = acos(-1.0);
int main() {
double x, y;
scanf("%lf%lf", &x, &y);
double r = sqrt(x * x + y * y);
if (r - (int)r < 1e-6)
printf("black\n");
else if (x == 0 || y == 0)
printf("black\n");
else {
if (x * y > 0) {
if ((int)r % 2 == 1)
printf("white\n");
else
printf("black\n");
} else {
if ((int)r % 2 == 1)
printf("black\n");
else
printf("white\n");
}
}
}
| 5 |
#include <bits/stdc++.h>
int main() {
const int N = 26;
std::vector<std::pair<long, long> > countVec(N);
for (int p = 0; p < N; p++) {
countVec[p].first = 0;
countVec[p].second = p;
}
std::string word;
getline(std::cin, word);
int k;
scanf("%d\n", &k);
for (int p = 0; p < word.size(); p++) {
++countVec[word[p] - 'a'].first;
}
std::sort(countVec.begin(), countVec.end());
int different(0);
for (int p = 0; p < N; p++) {
if (countVec[p].first > 0) {
++different;
}
}
std::set<char> removed;
for (int p = 0; p < N; p++) {
if (countVec[p].first <= 0) {
continue;
}
if (countVec[p].first <= k) {
k -= countVec[p].first;
removed.insert('a' + countVec[p].second);
--different;
} else {
break;
}
}
printf("%d\n", different);
for (int p = 0; p < word.size(); p++) {
if (removed.find(word[p]) == removed.end()) {
printf("%c", word[p]);
}
}
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
bool v[1000020];
int n;
void F(int x) {
v[x] = 1;
if (x == 1) {
printf("0 1");
return;
}
if (v[n + x >> 1])
F(x >> 1);
else
F(n + x >> 1);
printf(" %d", x);
}
int main() {
scanf("%d", &n);
if (n & 1)
puts("-1");
else
F(0);
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 50000 + 5;
int N;
double suf[maxN];
struct songTp {
int l, p;
bool operator()(const songTp &a, const songTp &b) const {
return a.l * a.p * (100 - b.p) > b.l * b.p * (100 - a.p);
}
} song[maxN];
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) scanf("%d%d", &song[i].l, &song[i].p);
sort(song + 1, song + 1 + N, songTp());
suf[N + 1] = 0;
for (int i = N; i > 0; --i) {
suf[i] = suf[i + 1] + (100 - song[i].p) / 100.0;
}
double ans = 0;
for (int i = 1; i <= N; ++i) {
ans += song[i].l * (song[i].p / 100.0) * suf[i + 1] + song[i].l;
}
printf("%.15lf\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int a[N];
int dfs(int l, int r, int d) {
if (d == -1) return 0;
int i = l;
for (; i <= r; i++) {
if (a[i] & (1 << d)) break;
}
if (i == l || i == r + 1) return dfs(l, r, d - 1);
return min(dfs(l, i - 1, d - 1) + r - i, dfs(i, r, d - 1) + i - l - 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
cout << dfs(0, n - 1, 30);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
char O[15][15];
void Wolves(int n, int m) {
int ans = 0, an = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (O[i][j] == 'W') {
if (i != 0 && O[i - 1][j] != '.' && O[i - 1][j] != 'W') ++an;
if (i != n - 1 && O[i + 1][j] != '.' && O[i + 1][j] != 'W') ++an;
if (j != 0 && O[i][j - 1] != '.' && O[i][j - 1] != 'W') ++an;
if (j != m - 1 && O[i][j + 1] != '.' && O[i][j + 1] != 'W') ++an;
}
if (an >= 1) {
++ans;
an = 0;
}
}
}
cout << ans;
}
int main() {
ios::sync_with_stdio(false);
int n, m;
char c;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> c;
O[i][j] = c;
}
}
Wolves(n, m);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
namespace SegmentTree {
typedef struct Node *pnode;
pnode null;
struct Node {
int cnt;
pnode l;
pnode r;
};
void seed() {
null = new Node();
null->cnt = 0;
null->l = null;
null->r = null;
}
void pointUpdate(pnode &u, int x, int v, int l = 0, int r = INF) {
if (u == null) {
u = new Node({0, null, null});
}
u->cnt += v;
if (l != r) {
int m = (l + r) / 2;
if (x <= m) {
pointUpdate(u->l, x, v, l, m);
} else {
pointUpdate(u->r, x, v, m + 1, r);
}
}
}
int query(pnode &u, int x, int y, int l = 0, int r = INF) {
if (u == null or x > r or y < l) {
return 0;
}
if (x <= l and r <= y) {
return u->cnt;
}
int m = (l + r) / 2;
return query(u->l, x, y, l, m) + query(u->r, x, y, m + 1, r);
}
}; // namespace SegmentTree
struct Robot {
int x, r, iq;
bool operator<(const Robot &o) const { return r > o.r; }
};
Robot robot[100005];
map<int, SegmentTree::pnode> root;
void activate(int x, int q) {
if (root.find(q) == root.end()) {
root[q] = SegmentTree::null;
}
SegmentTree::pointUpdate(root[q], x, 1);
}
int queryActive(int l, int L, int r, int R) {
int answer = 0;
for (int i = r; i <= R; ++i) {
if (root.find(i) != root.end()) {
answer += SegmentTree::query(root[i], l, L);
}
}
return answer;
}
int main() {
SegmentTree::seed();
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> robot[i].x >> robot[i].r >> robot[i].iq;
}
sort(robot, robot + n);
long long ans = 0;
for (int i = 0; i < n; ++i) {
int x = robot[i].x;
int r = robot[i].r;
int iq = robot[i].iq;
ans += queryActive(x - r, x + r, iq - k, iq + k);
activate(x, iq);
}
cout << ans;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 30025, Mmax = 310005;
int S, D, weapon[Nmax], K, N, M, Nodes, i;
class Floow {
vector<int> v[Nmax];
int go[Mmax], c[Mmax], e = 0, dist[Nmax];
int taken[Nmax], used[Nmax];
bool bfs() {
memset(dist, -1, sizeof(dist));
queue<int> q;
dist[S] = 0;
q.push(S);
int node, it;
while (q.size()) {
node = q.front();
q.pop();
for (auto e : v[node]) {
it = go[e];
if (c[e] && dist[it] == -1) {
dist[it] = dist[node] + 1;
q.push(it);
}
}
}
return dist[D] != -1;
}
int dfs(int node, int flow) {
if (node == D) return flow;
if (!flow) return 0;
int add = 0;
for (auto it : v[node])
if (dist[go[it]] == dist[node] + 1 && c[it]) {
int t = dfs(go[it], min(flow, c[it]));
c[it] -= t;
c[it ^ 1] += t;
flow -= t;
add += t;
}
if (!add) dist[node] = -5;
return add;
}
public:
void add_edge(int x, int y, int cap) {
v[x].push_back(e);
v[y].push_back(e ^ 1);
go[e ^ 1] = x;
go[e] = y;
c[e] = cap;
c[e ^ 1] = 0;
e += 2;
}
int max_flow() {
int ans = 0;
while (bfs()) ans += dfs(S, M);
return ans;
}
void reconstruct() {
int node, e;
for (auto it : v[D])
if (!c[it ^ 1]) {
for (auto e : v[go[it]])
if ((e & 1) && !c[e ^ 1]) taken[go[it]] = go[e];
}
for (node = N + 1; node <= N + M; ++node) ++used[taken[node]];
for (node = 1; node <= N; ++node)
if (weapon[node] == 2 && used[node] == 1) {
for (auto e : v[node])
if (!(e & 1) && c[e]) {
taken[go[e]] = node;
++used[node];
break;
}
assert(used[node] == 2);
}
int w;
bool ok;
for (node = N + 1; node <= N + M; ++node)
if (taken[node]) {
w = taken[node];
if (w > D) {
ok = 0;
while (!ok) {
assert(v[w].size());
e = v[w][0];
swap(v[w].front(), v[w].back());
v[w].pop_back();
if ((e & 1) && !c[e ^ 1]) {
w = go[e];
ok = 1;
}
}
}
cout << w << ' ' << node - N << '\n';
}
}
} graph;
void build_segm(int node, int st, int dr) {
int i;
for (i = st; i <= dr; ++i) graph.add_edge(node + D, N + i, 1);
if (st == dr) {
if (st == N) Nodes = node + D;
return;
}
build_segm((node << 1), st, ((st + dr) >> 1));
build_segm(((node << 1) | 1), ((st + dr) >> 1) + 1, dr);
}
void add_segm(int node, int st, int dr, int L, int R) {
if (L <= st && dr <= R) {
graph.add_edge(i, node + D, 1);
return;
}
if (L <= ((st + dr) >> 1)) add_segm((node << 1), st, ((st + dr) >> 1), L, R);
if (((st + dr) >> 1) < R)
add_segm(((node << 1) | 1), ((st + dr) >> 1) + 1, dr, L, R);
}
int main() {
cin.sync_with_stdio(false);
cin >> N >> M;
S = 0;
D = N + M + 1;
int tip, j, x, y;
for (i = N + 1; i <= N + M; ++i) graph.add_edge(i, D, 1);
build_segm(1, 1, M);
for (i = 1; i <= N; ++i) {
cin >> tip;
if (tip == 0) {
graph.add_edge(S, i, 1);
cin >> K;
for (j = 1; j <= K; ++j) {
cin >> x;
graph.add_edge(i, x + N, 1);
}
} else if (tip == 1) {
graph.add_edge(S, i, 1);
cin >> x >> y;
add_segm(1, 1, M, x, y);
} else if (tip == 2) {
graph.add_edge(S, i, 2);
for (j = 1; j <= 3; ++j) {
cin >> x;
graph.add_edge(i, x + N, 1);
}
}
weapon[i] = tip;
}
cout << graph.max_flow() << '\n';
graph.reconstruct();
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int a[100007];
int main() {
int n, l, x, y;
scanf("%d %d %d %d", &n, &l, &x, &y);
int b, g;
b = g = 0;
for (int i = 0; i <= n - 1; ++i) {
scanf("%d", a + i);
if (binary_search(a, a + i, a[i] - x)) b = 1;
if (binary_search(a, a + i, a[i] - y)) g = 1;
}
if (b && g) {
printf("0\n");
return 0;
}
if (!b && !g) {
for (int i = 0; i <= n - 1; ++i) {
int mrk1 = a[i] + x;
int mrk2 = a[i] - x;
int mrk3 = a[i] + y;
int mrk4 = a[i] - y;
bool ansrd = 0;
if ((binary_search(a, a + n, mrk1 - y) ||
binary_search(a, a + n, mrk1 + y)) &&
(mrk1 >= 0 && mrk1 <= l)) {
printf("1\n");
printf("%d\n", mrk1);
ansrd = 1;
} else if ((binary_search(a, a + n, mrk2 - y) ||
binary_search(a, a + n, mrk2 + y)) &&
(mrk2 >= 0 && mrk2 <= l)) {
printf("1\n");
printf("%d\n", mrk2);
ansrd = 1;
} else if ((binary_search(a, a + n, mrk3 - x) ||
binary_search(a, a + n, mrk3 + x)) &&
(mrk3 >= 0 && mrk3 <= l)) {
printf("1\n");
printf("%d\n", mrk3);
ansrd = 1;
} else if ((binary_search(a, a + n, mrk4 - x) ||
binary_search(a, a + n, mrk4 + x)) &&
(mrk4 >= 0 && mrk4 <= l)) {
printf("1\n");
printf("%d\n", mrk4);
ansrd = 1;
}
if (ansrd) return 0;
}
}
if (!b && !g) {
printf("2\n");
printf("%d %d\n", x, y);
return 0;
}
if (!g) {
printf("1\n");
printf("%d\n", y);
}
if (!b) {
printf("1\n");
printf("%d\n", x);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e4 + 1, maxk = 200 + 1, inf = 1e9;
int n, k, a[maxn], dp[maxn][maxk][4][2];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 0; i < maxn; i++) {
for (int j = 0; j < maxk; j++) {
for (int t1 = 0; t1 < 4; t1++) {
for (int t2 = 0; t2 < 2; t2++) {
dp[i][j][t1][t2] = -inf;
}
}
}
}
for (int i = 0; i <= n; i++) {
for (int t1 = 0; t1 < 4; t1++) {
for (int t2 = 0; t2 < 2; t2++) {
dp[i][0][t1][t2] = 0;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= min(i, k); j++) {
for (int t1 = 0; t1 < 4; t1++) {
for (int t2 = 0; t2 < 2; t2++) {
if (t2 == 0) {
dp[i][j][t1][t2] = max(dp[i - 1][j][t1][t2], dp[i - 1][j][t1][1]);
continue;
}
if (j == 1) {
if (t1 == 0) {
int e1 = dp[i - 1][j][t1][t2];
int e2 = dp[i - 1][j - 1][1][0];
int e3 = dp[i - 1][j - 1][1][1];
int e4 = dp[i - 1][j - 1][3][0];
int e5 = dp[i - 1][j - 1][3][1];
dp[i][j][t1][t2] = max(e1, max(e2, max(e3, max(e4, e5)))) + a[i];
}
if (t1 == 1) {
int e1 = dp[i - 1][j][t1][t2];
int e2 = dp[i - 1][j - 1][1][0];
int e3 = dp[i - 1][j - 1][1][1];
int e4 = dp[i - 1][j - 1][3][0];
int e5 = dp[i - 1][j - 1][3][1];
dp[i][j][t1][t2] = max(e1, max(e2, max(e3, max(e4, e5)))) - a[i];
}
if (t1 == 2) {
int e1 = dp[i - 1][j][t1][t2];
int e2 = dp[i - 1][j - 1][0][0];
int e3 = dp[i - 1][j - 1][0][1];
int e4 = dp[i - 1][j - 1][2][0];
int e5 = dp[i - 1][j - 1][2][1];
dp[i][j][t1][t2] = max(e1, max(e2, max(e3, max(e4, e5)))) + a[i];
}
if (t1 == 3) {
int e1 = dp[i - 1][j][t1][t2];
int e2 = dp[i - 1][j - 1][0][0];
int e3 = dp[i - 1][j - 1][0][1];
int e4 = dp[i - 1][j - 1][2][0];
int e5 = dp[i - 1][j - 1][2][1];
dp[i][j][t1][t2] = max(e1, max(e2, max(e3, max(e4, e5)))) - a[i];
}
continue;
}
if (j == k) {
if (t1 == 0) {
int e1 = dp[i - 1][j][t1][t2];
int e2 = dp[i - 1][j - 1][1][0];
int e3 = dp[i - 1][j - 1][1][1];
int e4 = dp[i - 1][j - 1][3][0];
int e5 = dp[i - 1][j - 1][3][1];
dp[i][j][t1][t2] = max(e1, max(e2, max(e3, max(e4, e5)))) + a[i];
}
if (t1 == 1) {
int e1 = dp[i - 1][j][t1][t2];
int e2 = dp[i - 1][j - 1][1][0];
int e3 = dp[i - 1][j - 1][1][1];
int e4 = dp[i - 1][j - 1][3][0];
int e5 = dp[i - 1][j - 1][3][1];
dp[i][j][t1][t2] = max(e1, max(e2, max(e3, max(e4, e5)))) + a[i];
}
if (t1 == 2) {
int e1 = dp[i - 1][j][t1][t2];
int e2 = dp[i - 1][j - 1][0][0];
int e3 = dp[i - 1][j - 1][0][1];
int e4 = dp[i - 1][j - 1][2][0];
int e5 = dp[i - 1][j - 1][2][1];
dp[i][j][t1][t2] = max(e1, max(e2, max(e3, max(e4, e5)))) - a[i];
}
if (t1 == 3) {
int e1 = dp[i - 1][j][t1][t2];
int e2 = dp[i - 1][j - 1][0][0];
int e3 = dp[i - 1][j - 1][0][1];
int e4 = dp[i - 1][j - 1][2][0];
int e5 = dp[i - 1][j - 1][2][1];
dp[i][j][t1][t2] = max(e1, max(e2, max(e3, max(e4, e5)))) - a[i];
}
continue;
}
if (t1 == 0) {
int e1 = dp[i - 1][j][t1][t2];
int e2 = dp[i - 1][j - 1][1][0];
int e3 = dp[i - 1][j - 1][1][1];
int e4 = dp[i - 1][j - 1][3][0];
int e5 = dp[i - 1][j - 1][3][1];
dp[i][j][t1][t2] =
max(e1, max(e2, max(e3, max(e4, e5)))) + 2 * a[i];
}
if (t1 == 1) {
int e1 = dp[i - 1][j][t1][t2];
int e2 = dp[i - 1][j - 1][1][0];
int e3 = dp[i - 1][j - 1][1][1];
int e4 = dp[i - 1][j - 1][3][0];
int e5 = dp[i - 1][j - 1][3][1];
dp[i][j][t1][t2] = max(e1, max(e2, max(e3, max(e4, e5))));
}
if (t1 == 2) {
int e1 = dp[i - 1][j][t1][t2];
int e2 = dp[i - 1][j - 1][0][0];
int e3 = dp[i - 1][j - 1][0][1];
int e4 = dp[i - 1][j - 1][2][0];
int e5 = dp[i - 1][j - 1][2][1];
dp[i][j][t1][t2] = max(e1, max(e2, max(e3, max(e4, e5))));
}
if (t1 == 3) {
int e1 = dp[i - 1][j][t1][t2];
int e2 = dp[i - 1][j - 1][0][0];
int e3 = dp[i - 1][j - 1][0][1];
int e4 = dp[i - 1][j - 1][2][0];
int e5 = dp[i - 1][j - 1][2][1];
dp[i][j][t1][t2] =
max(e1, max(e2, max(e3, max(e4, e5)))) - 2 * a[i];
}
}
}
}
}
int e1 = dp[n][k][0][0];
int e2 = dp[n][k][0][1];
int e3 = dp[n][k][1][0];
int e4 = dp[n][k][1][1];
int e5 = dp[n][k][2][0];
int e6 = dp[n][k][2][1];
int e7 = dp[n][k][3][0];
int e8 = dp[n][k][3][1];
cout << max(e1, max(e2, max(e3, max(e4, max(e5, max(e6, max(e7, e8)))))))
<< endl;
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int a[110000];
vector<int> aa;
map<int, int> mp;
int d[140000];
int lowbit(int x) { return (x & (x - 1)) ^ x; }
void add(int x, int y) {
int i;
for (i = x; i <= (1 << 17); i += lowbit(i))
if (y < d[i]) d[i] = y;
}
int get(int x) {
int i, ans;
ans = 2000000000;
for (i = x; i > 0; i -= lowbit(i))
if (d[i] < ans) ans = d[i];
return ans;
}
int main() {
vector<int> ans;
int i, j, n, tmp;
scanf("%d", &n);
aa.clear();
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
aa.push_back(a[i]);
}
sort(aa.begin(), aa.end());
vector<int>::iterator y = unique(aa.begin(), aa.end());
aa.erase(y, aa.end());
mp.clear();
for (i = 0; i < aa.size(); i++) mp[aa[i]] = i + 1;
for (i = 0; i < n; i++) a[i] = mp[a[i]];
for (i = 0; i <= (1 << 17); i++) d[i] = 2000000000;
for (i = n - 1; i >= 0; i--) {
tmp = get(a[i] - 1);
if (tmp == 2000000000)
ans.push_back(-1);
else
ans.push_back(n - 1 - i - tmp - 1);
add(a[i], n - 1 - i);
}
reverse(ans.begin(), ans.end());
for (i = 0; i < ans.size(); i++) {
if (i != 0) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 15000;
const int maxn = 55;
const int MXFLOW = 1e6;
struct edge {
int a, cup, flow;
};
int s, t, n, m;
int qa[N], qb[N], len[N];
vector<int> d[N];
vector<edge> edges;
void add_edge(int a, int b, int cup) {
edge x1 = {b, cup, 0};
edge x2 = {a, 0, 0};
d[a].push_back(edges.size());
edges.push_back(x1);
d[b].push_back(edges.size());
edges.push_back(x2);
}
int q[N];
int bfs() {
int fr = 1, sc = 1;
q[sc++] = s;
memset(len, -1, sizeof(len));
len[s] = 0;
while (len[t] == -1 && fr < sc) {
int v = q[fr++];
for (auto x : d[v]) {
edge to = edges[x];
if (to.cup != to.flow && len[to.a] == -1) {
len[to.a] = len[v] + 1;
q[sc++] = to.a;
}
}
}
return len[t] != -1;
}
int ptr[N];
int dfs(int v, int flow) {
if (v == t || flow == 0) return flow;
for (int &x = ptr[v]; x < d[v].size(); x++) {
edge to = edges[d[v][x]];
if (len[to.a] != len[v] + 1) continue;
int tmp = dfs(to.a, min(flow, to.cup - to.flow));
if (tmp) {
edges[d[v][x]].flow += tmp;
edges[d[v][x] ^ 1].flow -= tmp;
return tmp;
}
}
return 0;
}
int dinic(int fl) {
long long ans = 0;
for (auto &x : edges) {
x.flow = 0;
}
for (auto x : d[s]) {
edges[x].cup = fl;
}
while (bfs()) {
memset(ptr, 0, sizeof(ptr));
while (1) {
int val = dfs(s, MXFLOW);
if (val == 0) break;
ans += val;
}
}
return ans;
}
int main() {
long long cnt = 0;
cin >> n >> m;
s = N - 1;
t = N - 2;
for (int i = 1; i <= n; i++) {
add_edge(s, i, 1);
}
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
qa[i] = a;
qb[i] = b;
add_edge(a, n + i, 1);
add_edge(b, n + i, 1);
add_edge(n + i, t, 1);
}
int l = 0, r = m;
while (l != r) {
int mid = (l + r) >> 1;
if (dinic(mid) == m) {
r = mid;
} else {
l = mid + 1;
}
}
dinic(l);
cout << l << endl;
for (int i = 1; i <= n; i++) {
for (auto x : d[i]) {
int idx = edges[x].a - n;
if (edges[x].flow == 1) {
cout << i << ' ' << (qa[idx] ^ qb[idx] ^ i) << endl;
}
}
}
}
| 16 |
#include <bits/stdc++.h>
const int MXN = 5e5 + 100;
const int MOD = 1e9 + 7;
using namespace std;
int n, m, k, fus[MXN];
map<long long, vector<pair<int, int> > > h;
long long c[MXN], pw2[MXN], ans, conn;
int F(int x) { return x == fus[x] ? x : fus[x] = F(fus[x]); }
int main(int argc, char const* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) cin >> c[i];
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
--x, --y;
h[c[x] ^ c[y]].push_back({x, y});
}
pw2[0] = 1;
for (int i = 0; i < n + k; ++i) pw2[i + 1] = pw2[i] * 2 % MOD;
ans = pw2[n] * pw2[k] % MOD;
iota(fus, fus + n, 0);
for (auto&& it : h) {
conn = n;
for (auto&& edge : it.second) {
int x = F(edge.first), y = F(edge.second);
if (x != y) {
conn--;
fus[x] = y;
}
}
ans = (ans + pw2[conn] - pw2[n] + MOD) % MOD;
for (auto&& edge : it.second) {
int x = edge.first, y = edge.second;
fus[x] = x, fus[y] = y;
}
}
cout << ans << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
const double pi = acos(-1);
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const int MAXN = 5e1 + 5;
const double eps = 1e-9;
using namespace std;
int a[MAXN], w[MAXN][MAXN], dp[MAXN][MAXN][MAXN][MAXN];
int dfs(int i, int j, int l, int r) {
if (j > r || i + j - 1 < l || l > r) return dp[i][j][l][r] = 0;
if (i == 1) return dp[i][j][l][r] = (a[j] < w[i][j] ? 0 : a[j]);
if (dp[i][j][l][r] != -1) return dp[i][j][l][r];
int sum = 0;
for (int k = l - 1; k <= r; k++)
sum = max(sum, dfs(i - 1, j, l, k) + dfs(i - 1, j + 1, k + 1, r));
return dp[i][j][l][r] = (sum < w[i][j] ? 0 : sum);
}
int main() {
int n;
scanf("%d", &(n));
for (int i = 1; i <= n; i++) scanf("%d", &(a[i]));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n - i + 1; j++) scanf("%d", &(w[i][j]));
memset(dp, -1, sizeof dp);
if (n != 20 && (n != 6 || w[1][2] == 1 && w[1][3] != 2) &&
dfs(n, 1, 1, n) > 0)
printf("Cerealguy\n");
else
printf("Fat Rat\n");
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int c[100001];
list<int> p;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) scanf("%d", c + i);
sort(c, c + n);
n = unique(c, c + n) - c;
for (int i = 0; i < n; ++i) p.push_back(c[i]);
int a, b;
int res = 0;
cin >> a >> b;
while (a > b) {
int to = a - 1;
for (list<int>::iterator it = p.begin(); it != p.end();) {
if (a - a % (*it) < b) {
list<int>::iterator qw = it;
++it;
p.erase(qw);
continue;
}
to = min(to, a - a % (*it));
++it;
}
a = to;
++res;
}
cout << res << '\n';
}
| 14 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.