solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long binpow(long long a, long long b, long long mod) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res % mod;
}
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, -1, 1};
const int N = 3e5 + 5;
const long long inf = 1e16;
void solve() {
int n;
cin >> n;
vector<int> a(n + 1);
vector<int> pos[n + 1];
set<int> s;
for (int i = 1; i <= n; i++) pos[i].push_back(0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]].push_back(i);
s.insert(a[i]);
}
int ans[n + 1];
for (int i = 1; i <= n; i++) ans[i] = -1;
map<int, int> mn;
for (auto x : s) {
int mx = INT_MIN;
for (int j = 1; j < pos[x].size(); j++) {
mx = max(mx, pos[x][j] - pos[x][j - 1]);
}
mx = max(mx, n - pos[x].back() + 1);
for (int i = mx; i <= n and ans[i] == -1; i++) ans[i] = x;
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int fa[250005], n;
struct hh {
vector<int> d[250005];
int fa[20][250005], dep[250005], deg[250005], sk[250005], mk[250005], l, r;
void dfs(int x, int f) {
dep[x] = dep[f] + 1;
fa[0][x] = f;
for (int i = 0; i < (int)d[x].size(); ++i) {
int v = d[x][i];
if (v == f) continue;
dfs(v, x);
}
}
int Lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 19; i >= 0; --i)
if (dep[fa[i][x]] >= dep[y]) x = fa[i][x];
if (x == y) return x;
for (int i = 19; i >= 0; --i)
if (fa[i][x] != fa[i][y]) x = fa[i][x], y = fa[i][y];
return fa[0][x];
}
void build() {
for (int i = 1, x, y; i < n; ++i) {
scanf("%d%d", &x, &y);
d[x].push_back(y);
d[y].push_back(x);
deg[x]++;
deg[y]++;
}
dfs(1, 0);
for (int i = 1; i < 20; ++i)
for (int j = 1; j <= n; ++j) fa[i][j] = fa[i - 1][fa[i - 1][j]];
l = 1, r = 0;
for (int i = 1; i <= n; ++i)
if (deg[i] == 1) sk[++r] = i, mk[i] = 1;
}
int xw() { return sk[l++]; }
int sc(int x) {
int ans = 0;
for (int i = 0; i < (int)d[x].size(); ++i) {
int v = d[x][i];
deg[v]--;
if (!mk[v]) ans = v;
if (deg[v] <= 1 && !mk[v]) mk[v] = 1, sk[++r] = v;
}
if (ans == 0) return sk[l];
return ans;
}
} tr1, tr2;
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
int main() {
scanf("%d", &n);
tr1.build();
tr2.build();
for (int i = 1; i <= n; ++i) fa[i] = i;
printf("%d\n", n - 1);
for (int cs = 1; cs < n; ++cs) {
int t1 = tr2.xw(), t2 = tr2.sc(t1);
int a = t1, b = find(a), lca = tr1.Lca(t1, t2);
if (tr1.dep[b] > tr1.dep[lca]) {
fa[b] = tr1.fa[0][b];
printf("%d %d %d %d\n", b, tr1.fa[0][b], t1, t2);
} else {
int tp = t2;
for (int i = 18; i >= 0; --i)
if (tr1.dep[tr1.fa[i][tp]] > tr1.dep[lca] && find(tr1.fa[i][tp]) != b)
tp = tr1.fa[i][tp];
b = tr1.fa[0][tp];
printf("%d %d %d %d\n", tp, b, t1, t2);
fa[tp] = b;
}
}
}
| 24 |
#include <bits/stdc++.h>
struct Frog {
int p, a, n;
bool operator<(const Frog &o) const { return p < o.p; }
};
const int N = 1e5;
int n, m, inv[N], next[N], prev[N], when[N];
bool gg[N];
Frog a[N];
long long add[N];
std::set<std::pair<int, int> > event;
template <class T1, class T2>
inline bool cmin(T1 &a, const T2 &b) {
return b < a ? (a = b, true) : false;
}
template <class T1, class T2>
inline bool cmax(T1 &a, const T2 &b) {
return a < b ? (a = b, true) : false;
}
template <class Type>
Type read() {
Type a;
bool b;
unsigned char c;
while (c = getchar(), c - '0' > 9 & c != '-')
;
for (a = (b = c == '-') ? 0 : c - '0'; (c = getchar() - '0') <= 9;
a = a * 10 + c)
;
return b ? -a : a;
}
int solve(int x, int y) {
if (x == y) return 0;
long long l = a[y].p - a[x].p;
if (l < 0) l += m;
l += add[y] - add[x];
int t = 0;
if (a[x].n < a[y].n) l -= a[x].a, t = 1;
if (l <= 0) return 1;
if (a[y].a < a[x].a) return (l - 1) / (a[x].a - a[y].a) + t + 1;
return 0;
}
int main() {
int (*rd)() = read<int>;
n = rd(), m = rd();
for (int i = 0; i < n; ++i) a[i] = (Frog){rd(), rd(), i};
std::sort(a, a + n);
for (int i = 0; i < n; ++i) inv[a[i].n] = i;
for (int i = 0; i < n; ++i) {
int x = inv[i], y = (x + 1) % n;
next[x] = y, prev[y] = x;
if (when[x] = solve(x, y)) event.emplace(when[x], i);
}
while (!event.empty()) {
auto it = event.begin();
int x = inv[it->second], t = it->first, tt = t, cnt = 0;
event.erase(it);
if (gg[x] || when[x] != t) continue;
do {
gg[next[x]] = true;
next[x] = next[next[x]];
++cnt;
tt = solve(x, next[x]);
} while (t == tt);
a[x].a = std::max(a[x].a - cnt, 0);
prev[next[x]] = x;
add[x] += (long long)cnt * t;
if (when[x] = solve(x, next[x])) event.emplace(when[x], a[x].n);
x = prev[x];
if (when[x] = solve(x, next[x])) event.emplace(when[x], a[x].n);
}
int cnt = 0;
for (int i = 0; i < n; ++i) cnt += !gg[i];
printf("%d\n", cnt);
for (int i = 0; i < n; ++i)
if (!gg[i]) printf("%d ", a[i].n + 1);
puts("");
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
vector<bool> prime(1e6 + 5, true);
void SieveOfEratosthenes(long long int n) {
prime[0] = false;
prime[1] = false;
for (long long unsigned int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long unsigned int i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
int Search(string pat, string txt) {
int n = txt.size();
int m = pat.size();
for (int i = 0; i <= n - m; i++) {
int j;
for (j = 0; j < m; j++) {
if (txt[i + j] != pat[j]) {
break;
}
}
if (j == m) {
return i;
}
}
return -1;
}
int findFirst(const std::vector<long long int> &array, int key, int low,
int high) {
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (key == array[mid]) {
ans = mid;
high = mid - 1;
} else if (key > array[mid])
low = mid + 1;
else
high = mid - 1;
}
return ans;
}
int findLast(const std::vector<long long int> &array, int key, int low,
int high) {
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (key == array[mid]) {
ans = mid;
low = mid + 1;
} else if (key > array[mid])
low = mid + 1;
else
high = mid - 1;
}
return ans;
}
int d, x, y;
void extendedEuclid(int a, int b) {
if (b == 0) {
d = 1;
x = 1;
y = 0;
} else {
extendedEuclid(b, a % b);
int temp = x;
x = y;
y = temp - (a / b) * y;
}
}
bool isPowerOfTwo(long long int x) { return (x && !(x & (x - 1))); }
int count_one_in_Bin(long long int n) {
int ans = 0;
while (n) {
n = n & (n - 1);
ans++;
}
return ans;
}
int Len_dec(long long int n) {
int ans = 0;
while (n > 0) {
n /= 10;
ans++;
}
return ans;
}
int Len_Bin(long long int n) {
int ans = 0;
while (n > 0) {
n /= 2;
ans++;
}
return ans;
}
vector<int> v;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
cin >> t;
for (int tc = 0; tc < t; tc++) {
int n, k;
cin >> n >> k;
if (n % 2 == k % 2) {
int cnt;
if (n % 2 == 1)
cnt = (n + 1) / 2;
else
cnt = n / 2;
if (cnt < k) {
cout << "NO" << endl;
continue;
}
long long unsigned int sum1 = 0, sum2 = 0;
if (k == cnt) {
if (k * k == n)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else {
sum1 = k * k;
if (n >= sum1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
} else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f;
cin >> a >> b >> c >> d;
e = max(3 * a / 10, a - (a * c / 250));
f = max(3 * b / 10, b - (b * d / 250));
if (e > f)
cout << "Misha";
else {
if (e < f)
cout << "Vasya";
else
cout << "Tie";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int maxn = 1e6;
vector<int> a(maxn), b(maxn);
int f(int i, int val) { return min(b[i] - a[i] + val, b[i]); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
for (; t; t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
int minX = max(0, a[0] - b[0]), minD = max(0, b[0] - a[0]), maxD = b[0];
bool fl = true;
for (int i = 1; i < n; i++) {
if (minD > maxD) {
cout << "NO" << endl;
fl = false;
break;
}
int nmin = max(0, a[i] - b[i]);
if (nmin > minD) {
minX += nmin - minD;
minD = nmin;
}
if (minD > maxD) {
cout << "NO" << endl;
fl = false;
break;
}
minD = f(i, minD);
maxD = f(i, maxD);
}
if (!fl) continue;
if (minD <= maxD && minX <= minD) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rand(long long l, long long r) {
uniform_int_distribution<long long> uid(l, r);
return uid(rng);
}
const int mod = 1e9 + 7;
const int mod1 = 998244353;
const int B = 37;
int pwr(int a, long long b) {
int ans = 1;
while (b) {
if (b & 1) {
ans = ((long long)ans * a) % mod;
}
a = ((long long)a * a) % mod;
b >>= 1;
}
return ans;
}
const int N = 5e5 + 5;
int cnt[N], cur[N], a[N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, k, m, s;
cin >> m >> k >> n >> s;
for (int i = 1; i <= m; i++) {
cin >> a[i];
}
int z = 0;
for (int i = 1; i <= s; i++) {
int x;
cin >> x;
cnt[x]++;
if (cnt[x] == 1) z++;
}
int pt = 0;
vector<int> ans;
for (int i = 1; i <= m; i++) {
while (z > 0 && pt < m) {
pt++;
cur[a[pt]]++;
if (cur[a[pt]] == cnt[a[pt]]) z--;
}
if (!z) {
int pt1 = max(pt, min(m, i + k - 1));
int tot = (i - 1) / k + (m - pt1) / k + 1;
if (tot >= n) {
for (int j = 1; j <= (i - 1) % k; j++) {
ans.push_back(j);
}
int cr = pt1 - i + 1;
while (cr > k) {
for (int j = i; j <= pt1; j++) {
if (cur[a[j]] > cnt[a[j]] && cr > k) {
cr--;
cur[a[j]]--;
ans.push_back(j);
}
}
}
cout << (int)ans.size() << '\n';
for (int x : ans) {
cout << x << " ";
}
return 0;
}
}
cur[a[i]]--;
if (cur[a[i]] < cnt[a[i]]) {
z++;
}
}
cout << -1;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500010;
int p[N];
inline int find_set(int x) {
if (x != p[x]) {
p[x] = find_set(p[x]);
}
return p[x];
}
vector<pair<int, int> > edges[N];
inline void unite(int x, int y) {
x = find_set(x);
y = find_set(y);
assert(x != y);
if (x == y) {
return;
}
p[x] = y;
if (edges[x].size() > edges[y].size()) {
swap(edges[x], edges[y]);
}
while (!edges[x].empty()) {
edges[y].push_back(edges[x].back());
edges[x].pop_back();
}
}
vector<pair<int, int> > g[N];
bool rem[N], add[N];
bool done[N];
int bx[N], by[N];
inline void dfs(int v, int pr) {
int sz = g[v].size();
for (int j = 0; j < sz; j++) {
int u = g[v][j].first;
if (u == pr) {
continue;
}
dfs(u, v);
assert(find_set(u) == u);
int id = g[v][j].second;
if (!rem[id]) {
unite(u, v);
continue;
}
assert(find_set(u) == u);
pair<int, int> e = edges[u].back();
while (done[e.second]) {
edges[u].pop_back();
e = edges[u].back();
}
done[e.second] = true;
printf("%d %d %d %d\n", u + 1, v + 1, bx[e.second] + 1, by[e.second] + 1);
edges[u].pop_back();
unite(u, e.first);
}
}
int ax[N], ay[N];
pair<pair<int, int>, int> ev[2 * N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
scanf("%d %d", ax + i, ay + i);
ax[i]--;
ay[i]--;
if (ax[i] > ay[i]) {
swap(ax[i], ay[i]);
}
ev[i] = make_pair(make_pair(ax[i], ay[i]), i);
rem[i] = false;
}
for (int i = 0; i < n - 1; i++) {
scanf("%d %d", bx + i, by + i);
bx[i]--;
by[i]--;
if (bx[i] > by[i]) {
swap(bx[i], by[i]);
}
ev[n - 1 + i] = make_pair(make_pair(bx[i], by[i]), ~i);
add[i] = false;
}
sort(ev, ev + n - 1 + n - 1);
int ans = 0;
for (int i = n - 1 + n - 1 - 1; i >= 0; i--) {
if (i > 0 && ev[i].first == ev[i - 1].first) {
i--;
continue;
}
int x = ev[i].second;
if (x >= 0) {
rem[x] = true;
ans++;
} else {
add[~x] = true;
}
}
for (int i = 0; i < n; i++) {
g[i].clear();
}
for (int i = 0; i < n - 1; i++) {
g[ax[i]].push_back(make_pair(ay[i], i));
g[ay[i]].push_back(make_pair(ax[i], i));
}
for (int i = 0; i < n; i++) {
edges[i].clear();
}
for (int i = 0; i < n - 1; i++) {
if (!add[i]) {
continue;
}
done[i] = false;
edges[bx[i]].push_back(make_pair(by[i], i));
edges[by[i]].push_back(make_pair(bx[i], i));
}
for (int i = 0; i < n; i++) {
p[i] = i;
}
printf("%d\n", ans);
dfs(0, -1);
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
vector<long long> part_sums(n, 0);
for (int i = 0; i < n; i++) {
if (s[i] == 'A' || s[i] == 'E' || s[i] == 'I' || s[i] == 'O' ||
s[i] == 'U' || s[i] == 'Y') {
part_sums[i]++;
}
if (i - 1 >= 0) {
part_sums[i] += part_sums[i - 1];
}
}
double ans = 0.0;
long long now = 0;
if (n % 2 == 0) {
for (int i = 1; i <= n / 2; i++) {
int l = i - 1;
int r = n - i;
now += part_sums[r];
if (l - 1 >= 0) {
now -= part_sums[l - 1];
}
ans += 1.0 * now / i;
ans += 1.0 * now / (n + 1 - i);
}
} else {
for (int i = 1; i <= n / 2; i++) {
int l = i - 1;
int r = n - i;
now += part_sums[r];
if (l - 1 >= 0) {
now -= part_sums[l - 1];
}
ans += 1.0 * now / i;
ans += 1.0 * now / (n + 1 - i);
}
int i = n / 2 + 1;
int l = i - 1;
int r = n - i;
now += part_sums[r];
if (l - 1 >= 0) {
now -= part_sums[l - 1];
}
ans += 1.0 * now / i;
}
printf("%.12f\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
string a = "", b = "";
cin >> b;
a += b[0];
for (int i = 1; i < b.length() - 1; i++) {
if (b[i] == b[i + 1]) {
a += b[i];
i++;
} else {
a += b[i];
a += b[i + 1];
i++;
}
}
a += b[b.length() - 1];
cout << a << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k;
long long int dp[105][105];
int main() {
cin >> n >> k;
string str;
cin >> str;
memset(dp, 0, sizeof(dp));
vector<int> pos(30, -1);
for (int i = 0; i <= n; i++) dp[i][0] = 1;
for (int i = 1; i <= n; i++) {
for (int len = 1; len <= i; len++) {
dp[i][len] = dp[i - 1][len] + dp[i - 1][len - 1];
if (pos[str[i - 1] - 'a'] != -1)
dp[i][len] -= dp[pos[str[i - 1] - 'a'] - 1][len - 1];
}
pos[str[i - 1] - 'a'] = i;
}
long long int cnt = 0, target = k, cost = 0;
for (int i = n; i >= 0; i--) {
cnt += dp[n][i];
if (cnt <= target)
cost += (n - i) * dp[n][i];
else {
cost += (n - i) * (dp[n][i] - cnt + target);
break;
}
}
if (cnt < target)
cout << -1;
else
cout << cost;
return 0;
}
| 12 |
#include <bits/stdc++.h>
const int N_MAX = 200003;
int len, g[7][7], lim[7], now[7], res[7], vis[7];
inline bool Hall() {
for (int S = 1; S + 1 < 1 << len; ++S) {
int L = 0, R = 0;
for (int i = 1; i <= len; ++i)
if (S >> (i - 1) & 1) L += res[i];
for (int i = 1; i <= len; ++i)
for (int j = i; j <= len; ++j)
if ((S >> (i - 1) & 1) || (S >> (j - 1) & 1)) R += g[i][j];
if (L > R) return 0;
}
return 1;
}
std::pair<int, int> ans[N_MAX];
int main() {
int n;
scanf("%d", &n);
for (int temp = n; temp; temp /= 10) ++len;
for (int i = 1; i < n; ++i) {
char s[2][7];
scanf("%s%s", s[0], s[1]);
int x = strlen(s[0]), y = strlen(s[1]);
++g[x][y], g[y][x] += x != y;
}
lim[0] = 1;
for (int i = 1; i < 7; ++i) lim[i] = lim[i - 1] * 10, now[i] = lim[i - 1];
for (int i = 1; i < len; ++i) res[i] = lim[i] - lim[i - 1];
res[len] = n - lim[len - 1] + 1;
if (!Hall()) {
printf("-1\n");
return 0;
}
++now[1], --res[1], vis[1] = 1;
for (int cnt = 1; cnt < n;) {
for (int i = 1; i <= len; ++i)
if (vis[i])
for (int j = 1; j <= len; ++j)
if (res[j] && g[i][j]) {
--res[j], --g[i][j];
g[j][i] -= i != j;
if (Hall()) {
ans[cnt] = std::make_pair(lim[i - 1], now[j]), ++cnt;
vis[j] = 1, ++now[j];
} else {
++res[j], ++g[i][j];
g[j][i] += i != j;
}
}
}
for (int i = 1; i < n; ++i) printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 1e5 + 10, MOD = 1e9 + 7;
int add(int x, int y) { return (x + y) % MOD; }
void addeq(int &x, int y) { x = add(x, y); }
int subtr(int x, int y) {
x -= y;
return x < 0 ? x + MOD : x;
}
struct fenwick {
int bit[MAXM];
void update(int x, int v) {
for (x++; x < MAXM; x += (x & -x)) {
addeq(bit[x], v);
}
}
int query(int x) {
int s = 0;
for (x++; x; x &= x - 1) {
addeq(s, bit[x]);
}
return s;
}
int query(int x, int y) { return subtr(query(y), query(x - 1)); }
};
int N, M;
pair<int, int> A[MAXM];
vector<int> vall(1, 0);
fenwick ft;
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
ios::sync_with_stdio(false);
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> A[i].second >> A[i].first;
}
sort(A, A + M);
if (A[M - 1].first != N) {
cout << "0\n";
return 0;
}
int ans;
ft.update(0, 1);
for (int i = 0; i < M; i++) {
swap(A[i].second, A[i].first);
if (vall.back() != A[i].second) {
vall.push_back(A[i].second);
}
int ind1 = lower_bound((vall).begin(), (vall).end(), A[i].first) -
vall.begin(),
ind2 = int(vall.size()) - 2;
if (ind1 <= ind2) {
ft.update(int(vall.size()) - 1, ft.query(ind1, ind2));
}
}
cout << ft.query(int(vall.size()) - 1, int(vall.size()) - 1) << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int a[5];
int ans;
int main() {
for (int i = 1; i <= 3; i++) a[i] = read();
sort(a + 1, a + 4);
int t = min(a[1], (a[3] - a[2]) / 2);
a[1] -= t;
a[3] -= t * 2;
ans += t;
ans += a[1];
a[2] -= a[1];
a[3] -= a[1];
t = min(a[2], a[3] - a[2]);
a[2] -= t;
a[3] -= t * 2;
ans += t;
if (a[2] > a[3]) swap(a[2], a[3]);
t = a[2] / 3;
ans += t * 2;
a[2] -= t * 3;
a[3] -= t * 3;
if (a[2] * a[3] >= 2) ans++;
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
bool prime[100005];
void SieveOfEratosthenes(long long int n) {
memset(prime, true, sizeof(prime));
for (long long int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long int i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
bool isPrime(long long int n) {
if (n < 2) return false;
for (long long int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
std::vector<long long int> generatePrimeFactors(long long int n) {
std::vector<long long int> prime;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
prime.push_back(i);
while (n % i == 0) n = n / i;
}
}
if (n != 1) prime.push_back(n);
return prime;
}
std::vector<long long int> generateFactors(long long int n) {
std::vector<long long int> fact;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
fact.push_back(i);
if (n / i != i) fact.push_back(n / i);
}
}
fact.push_back(1);
fact.push_back(n);
sort(fact.begin(), fact.end());
return fact;
}
long long int gcd(long long int a, long long int b) {
if (!b) return a;
return gcd(b, a % b);
}
long long int modpow(long long int x, long long int n, long long int m) {
if (n == 0) return 1 % m;
long long int u = modpow(x, n / 2, m) % m;
u = ((u % m) * (u % m)) % m;
if (n % 2 == 1) u = ((u % m) * (x % m)) % m;
return u % m;
}
long long int eulerstotientfunction(long long int n) {
long long int ans = n;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) n = n / i;
ans -= ans / i;
}
}
if (n > 1) ans -= ans / n;
return ans;
}
long long int modinverse(long long int x, long long int m) {
return modpow(x, m - 2, m);
}
long long int add(long long int a, long long int b, long long int m) {
return (((a % m) + (b % m)) % m);
}
long long int substract(long long int a, long long int b, long long int m) {
return (((a % m) - (b % m) + m) % m);
}
long long int multiply(long long int a, long long int b, long long int m) {
return (((a % m) * (b % m)) % m);
}
long long int divide(long long int a, long long int b, long long int m) {
long long int temp = modinverse(b, m);
return multiply(a, temp, m);
}
long long int singlemod(long long int a, long long int m) { return (a % m); }
long long int ncr(long long int n, long long int k, long long int m) {
if (k > n) return 0;
long long int res = 1;
k = min(k, n - k);
for (long long int i = 1; i <= k; i++) {
res = multiply(res, n - i + 1, m);
res = divide(res, i, m);
}
return singlemod(res, m);
}
long long int kadaneAlgo(const std::vector<long long int> &arr) {
long long int size = arr.size();
long long int currmax = arr[0], maxsofar = arr[0];
for (long long int i = 1; i < size; i++) {
currmax = max(arr[i], currmax + arr[i]);
maxsofar = max(maxsofar, currmax);
}
return maxsofar;
}
long long int getDigitSum(long long int n) {
long long int co = 0;
while (n > 0) {
co += n % 10;
n = n / 10;
}
return co;
}
template <class T>
void printVector(const std::vector<T> arr) {
for (auto i : arr) cout << i << " ";
cout << '\n';
}
template <class T>
void printArray(T arr[], long long int n) {
for (long long int i = 1; i <= n; i++) cout << arr[i] << " ";
cout << '\n';
}
int main() {
fastio();
long long int t = 1;
while (t--) {
long long int n, sum = 0;
cin >> n;
std::vector<long long int> arr(n);
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
long long int temp = 0;
for (long long int i = 0; i < n; i++) {
temp += arr[i];
if (temp >= ceil(sum * 1.0 / 2)) {
cout << i + 1 << '\n';
break;
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long n, k;
double prob[10][1000 + 100];
double ans;
double ev[10][1000 + 100];
double pup, prem;
double rev[100000];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
double gz = 1.0 / k;
for (int i = 1; i <= 1000 + 1000; i++) rev[i] = 1.0 / i;
prob[0][1] = 1;
ev[0][1] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 1000; j++) prob[1 - i % 2][j] = ev[1 - i % 2][j] = 0;
long ths, nxt;
ths = i % 2;
nxt = 1 - ths;
for (int j = 1; j <= 1000; j++) {
if (prob[ths][j] < 1e-50) continue;
ev[ths][j] /= prob[ths][j];
pup = gz * rev[j + 1];
prob[nxt][j + 1] += prob[ths][j] * pup;
ev[nxt][j + 1] += (ev[ths][j] + j) * prob[ths][j] * pup;
prem = gz * (1.0 - rev[j + 1]);
prob[nxt][j] += prob[ths][j] * prem;
ev[nxt][j] += (ev[ths][j] + (j + 1) * 0.5) * prob[ths][j] * prem;
prob[nxt][j] += prob[ths][j] * (1.0 - gz);
ev[nxt][j] += ev[ths][j] * (1.0 - gz) * prob[ths][j];
}
}
for (int i = 1; i <= 1000; i++) ans += ev[n % 2][i] * k;
cout.precision(12);
cout << fixed << ans << endl;
cin.get();
cin.get();
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int xi[410], yi[410];
int f[810][810];
double co[810][810];
vector<int> ed[810];
inline void adde(int x, int y, int ca, double cost) {
f[x][y] = ca;
f[y][x] = 0;
co[x][y] = cost;
co[y][x] = -cost;
ed[x].push_back(y);
ed[y].push_back(x);
}
inline double sq(double x) { return x * x; }
inline double dist(int i, int j) {
return sqrt(sq(xi[i] - xi[j]) + sq(yi[i] - yi[j]));
}
int que[810], qs, qe;
bool inq[810];
inline void push(int a) {
if (inq[a]) return;
inq[a] = 1;
que[qe++] = a;
if (qe == 810) qe = 0;
}
inline int pop() {
int a = que[qs++];
if (qs == 810) qs = 0;
inq[a] = 0;
return a;
}
double dis[810];
int pre[810];
const double INF = 1e100;
inline bool spfa(int n, double& cost) {
qs = qe = 0;
for (int i = 0; i < (n); i++) {
dis[i] = INF;
inq[i] = 0;
}
dis[0] = 0;
push(0);
while (qs != qe) {
int np = pop();
for (int i = 0; i < (((int)(ed[np]).size())); i++) {
int y = ed[np][i];
if (f[np][y] == 0) continue;
if (dis[y] - 1e-9 > dis[np] + co[np][y]) {
dis[y] = dis[np] + co[np][y];
pre[y] = np;
push(y);
}
}
}
if (dis[n - 1] == INF) return 0;
cost = dis[n - 1];
int np = n - 1;
while (np) {
f[pre[np]][np]--;
f[np][pre[np]]++;
np = pre[np];
}
return 1;
}
pair<int, double> mcmf(int n) {
int f = 0;
double ret = 0, co;
while (spfa(n, co)) {
f++;
ret += co;
}
return make_pair(f, ret);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (n); i++) {
scanf("%d%d", &xi[i], &yi[i]);
}
for (int i = 0; i < (n); i++) {
adde(0, i + 1, 2, 0);
}
for (int i = 0; i < (n); i++) {
adde(i + n + 1, 2 * n + 1, 1, 0);
}
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++) {
if (i == j) continue;
if (yi[i] > yi[j]) {
adde(i + 1, j + n + 1, 1, dist(i, j));
}
}
pair<int, double> ret = mcmf(2 * n + 2);
if (ret.first != n - 1)
puts("-1");
else
printf("%.15lf\n", ret.second);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, y, ass, bss;
string a, b, c(256, 0);
cin >> a;
for (char i : a) c[i] = 1;
cin >> a >> n;
ass = a.size();
while (n--) {
y = 1;
cin >> b;
bss = b.size();
for (i = j = 0; y && i < ass; i++) {
if (a[i] == '*') {
while (j < bss - ass + i + 1)
if (c[b[j++]]) y = 0;
} else {
if (a[i] == '?' ? c[b[j]] : a[i] == b[j])
j < bss ? j++ : y = 0;
else
y = 0;
}
}
if (j < bss) y = 0;
puts(y ? "YES" : "NO");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long int lxt() {
long long int aaa;
scanf("%lld", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
int ar[100010];
int mark[100010];
void gen(int u) {
if (u > 10000) return;
mark[u] = 1;
if (!mark[u * 10 + 4]) gen(u * 10 + 4);
if (!mark[u * 10 + 7]) gen(u * 10 + 7);
}
int tree[100010];
void update(int i, int val, int n) {
while (i <= n) {
tree[i] += val;
i += i & (-i);
}
}
int query(int i) {
int sum = 0;
while (i) {
sum += tree[i];
i -= i & (-i);
}
return sum;
}
int main() {
gen(4);
gen(7);
int n = nxt(), m = nxt();
for (int i = 1; i < n + 1; i++) {
ar[i] = nxt();
if (mark[ar[i]]) update(i, 1, n);
}
while (m--) {
char c[10];
scanf("%s", c);
int a = nxt();
int b = nxt();
if (c[0] == 'c') {
printf("%d\n", query(b) - query(a - 1));
} else {
int d = nxt();
for (int i = a; i < b + 1; i++) {
if (mark[ar[i]]) update(i, -1, n);
ar[i] += d;
if (mark[ar[i]]) update(i, 1, n);
}
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, maxm = 0;
string f2 = "";
cin >> a >> b;
char arr[a][b];
for (int t = 0; t < a; t++) {
for (int p = 0; p < b; p++) {
cin >> arr[t][p];
}
}
for (int t = 0; t < a - 1; t++) {
for (int p = 0; p < b - 1; p++) {
f2 = "";
f2 += arr[t][p];
f2 += arr[t + 1][p];
f2 += arr[t][p + 1];
f2 += arr[t + 1][p + 1];
sort(f2.begin(), f2.end());
if (f2 == "acef") maxm++;
}
}
cout << maxm << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = ((res % p) * (x % p)) % p;
y = y >> 1;
x = ((x % p) * (x % p)) % p;
}
return res;
}
long long raichu(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = ((res) * (x));
y = y >> 1;
x = ((x) * (x));
}
return res;
}
bool isprime(long long n) {
if (n < 2)
return false;
else if (n == 2)
return true;
else if (n % 2 == 0)
return false;
else {
long long z = sqrt(n);
for (int i = 0; i < z - 1; i++)
if (n % (i + 2) == 0) return false;
return true;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int z = 0, cnt = 0;
bool chk = false;
for (int i = 0; i < (int)s.size(); i++) {
if (s[i] == 'F' && chk) {
int p = i - cnt;
if (p > z)
z = p;
else
z = z + 1;
}
if (s[i] == 'F') cnt++;
;
if (s[i] == 'M') chk = true;
}
cout << z;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500004;
const int MOD = 1000003;
char *dd[MAXN];
int a1[MAXN], b1[MAXN];
int n, m;
void solve() {
long long ret = 1;
int cnt = 0;
for (int i = 0; i < n; i++) {
dd[i] = new char[m + 1];
scanf("%s", dd[i]);
}
memset(a1, -1, sizeof(a1));
memset(b1, -1, sizeof(b1));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char a;
a = dd[i][j];
if (a == '.')
continue;
else {
int x, y;
a -= '0';
if (a == 1 || a == 2) {
y = ((!(a & 1)) + i) % 2;
x = j % 2;
} else {
x = (1 + j) % 2;
y = ((a & 1) + i) % 2;
}
if (a1[i] == -1) {
a1[i] = x;
} else if (a1[i] != x)
ret = 0;
if (b1[j] == -1) {
b1[j] = y;
} else if (b1[j] != y)
ret = 0;
}
}
if (ret != 0) {
for (int i = 0; i < n; i++)
if (a1[i] == -1) ret = (ret * 2) % MOD;
for (int i = 0; i < m; i++)
if (b1[i] == -1) ret = (ret * 2) % MOD;
}
cout << ret << endl;
}
int main() {
while (scanf("%d %d", &n, &m) != EOF) {
solve();
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5;
const int MAXA = 2e6 + 3;
const long long int INF = 1000000000000000;
int n, xy;
long long int ans, x, y, cnt[MAXA], sum[MAXA];
long long int C(int i, int j) {
if (i > j) return 0;
return cnt[j] - cnt[i - 1];
}
long long int S(int i, int j) {
if (i > j) return 0;
return sum[j] - sum[i - 1];
}
int main() {
memset(cnt, 0, sizeof(cnt));
memset(sum, 0, sizeof(sum));
scanf("%d%lld%lld", &n, &x, &y);
for (int i = 1, a; i <= n; ++i) {
scanf("%d", &a);
++cnt[a];
sum[a] += a;
}
for (int i = 1; i < MAXA; ++i) {
cnt[i] += cnt[i - 1];
sum[i] += sum[i - 1];
}
ans = INF;
xy = x / y;
for (int i = 2, mid; i < MAXA; ++i) {
long long int cost = 0;
for (int j = i; j < MAXA; j += i) {
mid = max(j - i + 1, j - xy);
cost += y * (C(mid, j) * j - S(mid, j));
cost += x * C(j - i + 1, mid - 1);
}
if (cost >= 0) {
ans = min(ans, cost);
}
}
printf("%lld\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, res, t;
int main() {
res = 240;
scanf("%d%d", &n, &t);
res -= t;
for (int i = 1; i <= n; i++) {
if (res >= 5 * i) {
res -= 5 * i;
} else {
return printf("%d\n", i - 1), 0;
}
}
printf("%d\n", n);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
signed main() {
vector<bool> used(10, false);
long long int n;
cin >> n;
string s;
cin >> s;
for (auto c : s) {
if (c == 'L') {
for (long long int i = 0; i < 10; i++) {
if (!used[i]) {
used[i] = true;
break;
}
}
} else if (c == 'R') {
for (long long int i = 9; i >= 0; i--) {
if (!used[i]) {
used[i] = true;
break;
}
}
} else {
long long int ind = c - '0';
used[ind] = false;
}
}
for (long long int i = 0; i < 10; i++) cout << used[i];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
double p, q;
double a[100001], b[100001];
double f(double x) {
double y = 1.0;
for (int i = 0; i < n; i++)
y = y > (1.0 - b[i] * x) / a[i] ? (1.0 - b[i] * x) / a[i] : y;
return p * y + q * x;
}
int main() {
cin >> n >> p >> q;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
double maxb = b[0];
for (int i = 0; i < n; i++) maxb = b[i] < maxb ? maxb : b[i];
double l = 0, r = 1.0 / maxb;
for (int i = 0; i < 50; i++) {
double lpoint = (r - l) / 3 + l, rpoint = (r - l) * 2 / 3 + l;
if (f(lpoint) > f(rpoint)) {
r = rpoint;
} else {
l = lpoint;
}
}
cout << setprecision(15) << f((l + r) / 2);
return 0;
}
| 16 |
#include <bits/stdc++.h>
int n, a[100000];
int main() {
int n = 0;
while (scanf("%d,", &a[n]) == 1) n++;
std::sort(a, a + n);
int i = 0, l, r;
while (i < n) {
l = a[i];
i++;
while (i < n && (a[i] == a[i - 1] || a[i] == a[i - 1] + 1)) i++;
if (a[i - 1] != l)
printf("%d-%d", l, a[i - 1]);
else
printf("%d", l);
if (i < n) printf(",");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long n, a[20000], b[20000], c[20000];
long long arp[20000], dsum[20000], upsum[20000], subsize[20000];
vector<pair<long, long> > g[7000];
long csize;
long long ans, minsum, minsum1;
long long tans;
long tresize;
void dfs1(long v) {
arp[v] = 1;
subsize[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
long ver = g[v][i].first;
long cost = g[v][i].second;
if (arp[ver]) continue;
dfs1(ver);
subsize[v] += subsize[ver];
dsum[v] += dsum[ver];
dsum[v] += subsize[ver] * cost;
}
}
void dfs2(long v) {
arp[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
long ver = g[v][i].first;
long cost = g[v][i].second;
if (arp[ver]) continue;
upsum[ver] = upsum[v];
upsum[ver] += dsum[v] - dsum[ver] - subsize[ver] * cost;
upsum[ver] += (tresize - subsize[ver]) * cost;
dfs2(ver);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
ans = 1000000000;
ans *= ans;
ans *= 3;
for (int i = 1; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
for (int cedge = 1; cedge < n; cedge++) {
for (int i = 1; i <= n; i++) g[i].clear();
for (int i = 1; i < n; i++)
if (i != cedge) {
g[a[i]].push_back(make_pair(b[i], c[i]));
g[b[i]].push_back(make_pair(a[i], c[i]));
}
for (int i = 1; i <= n; i++) arp[i] = dsum[i] = upsum[i] = subsize[i] = 0;
dfs1(a[cedge]);
csize = 0;
for (int i = 1; i <= n; i++) {
csize += arp[i];
arp[i] = 0;
}
tresize = csize;
dfs2(a[cedge]);
minsum = 1000000000000000000ll;
for (int i = 1; i <= n; i++)
if (arp[i] == 1) minsum = min(minsum, dsum[i] + upsum[i]);
for (int i = 1; i <= n; i++) arp[i] = 0;
tresize = n - tresize;
dfs1(b[cedge]);
for (int i = 1; i <= n; i++) arp[i] = 0;
dfs2(b[cedge]);
minsum1 = 1000000000000000000ll;
for (int i = 1; i <= n; i++)
if (arp[i] == 1) minsum1 = min(minsum1, dsum[i] + upsum[i]);
for (int i = 1; i <= n; i++) arp[i] = 0;
tans = 0;
for (int i = 1; i <= n; i++) tans += dsum[i] + upsum[i];
tans /= 2;
tans += minsum * (n - csize) + minsum1 * csize +
1ll * csize * (n - csize) * c[cedge];
ans = min(ans, tans);
}
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::pair<T, U> operator+(const std::pair<T, U>& l, const std::pair<T, U>& r) {
return {l.first + r.first, l.second + r.second};
}
const long long INF64 = 1e18;
const long long INF32 = 1e9;
const long long U = 2e5;
long long n, first, last, k;
long long ans = -1;
long long guess, y;
long long turns, dist;
void solve_n() {
for (guess = n; guess >= 0; guess--) {
y = (k - 1) % (n + guess) + 1 - last;
if (y < 0 || y > last || y > guess || y < guess + last - n - 1) {
continue;
}
if ((y < last && y < guess) || (y >= guess + last - n)) {
ans = guess;
return;
}
}
}
void solve_k_over_n() {
for (turns = 0; turns <= k / n; turns++) {
guess = (k - (turns - 1) * n - 2 * last + 1) / (turns + 1);
y = k - turns * (n + guess) - last;
if (y < 0) {
if (turns == 0) {
continue;
}
dist = (-y - 1) / turns + 1;
y += turns * dist;
guess -= dist;
}
if (guess > n) {
y += turns * (guess - n);
guess = n;
}
if (y > last || y > guess || guess < 0 || y + 1 < guess + last - n) {
continue;
}
if ((y >= guess + last - n) || (y < last && y < guess)) {
ans = max(ans, guess);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
if (false) {
freopen("F.in", "r", stdin);
cerr << "Remember to switch INPUT_FILE off before submitting!" << endl
<< endl;
freopen("F.out", "w", stdout);
}
auto beginProgram = chrono::steady_clock::now();
{
cin >> n >> first >> last >> k;
last = (last - first + n) % n + 1;
if (n <= U) {
solve_n();
} else {
solve_k_over_n();
}
cout << ans << endl;
}
if (false) {
auto endProgram = chrono::steady_clock::now();
cerr << "Elapsed time (ms): "
<< chrono::duration_cast<chrono::milliseconds>(endProgram -
beginProgram)
.count()
<< endl;
system("gnome-open F.in");
system("gnome-open F.correct");
system("gnome-open F.out");
fstream myAns("F.out");
fstream correctAns("F.correct");
string myLine, correctLine;
long long lineIndex = 1;
bool moreMyAns, moreCorrectAns;
moreMyAns = (bool)getline(myAns, myLine);
moreCorrectAns = (bool)getline(correctAns, correctLine);
while (moreMyAns && moreCorrectAns) {
cerr << lineIndex++ << "\t" << (myLine == correctLine ? "ok" : "WRONG")
<< endl;
moreMyAns = (bool)getline(myAns, myLine);
moreCorrectAns = (bool)getline(correctAns, correctLine);
}
if (moreMyAns) {
cerr << "ERROR: My answer is too long! Excessive lines:" << endl;
do {
cerr << lineIndex++ << "\t" << myLine << endl;
} while (getline(myAns, myLine));
} else if (moreCorrectAns) {
cerr << "ERROR: My answer is too short! Missing lines:" << endl;
do {
cerr << lineIndex++ << "\t" << correctLine << endl;
} while (getline(correctAns, correctLine));
}
myAns.flush();
myAns.close();
correctAns.flush();
correctAns.close();
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <typename... Args>
void read(Args&... args) {
((cin >> args), ...);
}
template <typename... Args>
void print(Args... args) {
((cout << args << " "), ...);
}
template <typename... Args>
void println(Args... args) {
((cout << args << "\n"), ...);
}
template <typename Args>
void kill(Args args) {
cout << args << "\n";
exit(0);
}
const double PI = acos(-1);
const long long MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const int N = 1010101;
int rgt[N], lst[N], arr[N];
int n;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(12);
cin >> n;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i < N; i++) lst[i] = n + 1;
for (int i = n; i >= 1; i--) {
rgt[i] = lst[arr[i]];
lst[arr[i]] = i;
}
long long ans = 0;
for (int i = n; i >= 1; i--) {
long long sum = 1ll * (rgt[i] - i) * i;
sum *= 2;
sum--;
ans += sum;
}
cout << ans / (double)(n * 1ll * n) << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n], c = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
if (arr[i] <= (5 - k)) c++;
}
cout << c / 3;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[2000], mx, k = 1, r = 1;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n - 1; i++)
if (a[i] == a[i + 1])
k++;
else {
mx = max(mx, k);
k = 1;
r++;
}
mx = max(mx, k);
cout << mx << " " << r;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
long long t, n;
int i, j;
scanf("%I64d", &t);
for (i = 0; i < t; i++) {
scanf("%I64d", &n);
j = 1;
while (j <= n) j = j * 2;
printf("%I64d", n * (n + 1) / 2 - 2 * (j - 1));
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool comp(int a, int b) { return a > b; }
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n, comp);
vector<unsigned long long int> res;
for (int i = 0; i < n - 1; ++i) {
if (a[i] - a[i + 1] <= 1) {
res.push_back(min(a[i], a[i + 1]));
++i;
}
}
unsigned long long int ans = 0;
for (int i = 0; i < (int)res.size() - 1; i += 2) ans += res[i] * res[i + 1];
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int aux[15], a[15], a2[15], aux2[15];
int getNueve() {
int nueves = 0;
for (int i = 0; i < 10; ++i) nueves += min(aux[i], aux2[9 - i]);
return nueves;
}
int main() {
char s[100005];
int l;
scanf("%s", &s);
l = strlen(s);
memset(a, 0, sizeof(a));
memset(a2, 0, sizeof(a2));
string n1 = "", n2 = "";
for (int i = 0; s[i]; ++i) {
a[s[i] - '0']++;
a2[s[i] - '0']++;
}
int v1 = 0, v2 = 0, nueves = 0;
int maxi = -1, mini = 1 << 30;
for (int i = 0; i < 10; ++i) {
int t = min(a[i], a2[10 - i]);
int nv = min(a[i], a2[9 - i]);
if (t != 0 && nv == 0) {
v1 = i;
v2 = 10 - i;
break;
} else if (t != 0 && nv != 0) {
for (int j = 0; j < 15; ++j) {
aux[j] = a[j];
aux2[j] = a2[j];
}
aux[i]--;
aux2[10 - i]--;
int n = getNueve();
if (n > maxi) {
maxi = n;
v1 = i;
v2 = 10 - i;
}
}
}
if (v1 != 0) {
n1 += (char)(v1 + '0');
n2 += (char)(v2 + '0');
a[v1]--;
a2[v2]--;
}
for (int i = 0; i < 10; ++i) {
int nv = min(a[i], a2[9 - i]);
for (int j = 0; j < nv; ++j) {
n1 += (char)(i + '0');
n2 += (char)(9 - i + '0');
}
a[i] -= nv;
a2[9 - i] -= nv;
}
int z = min(a[0], a2[0]);
for (int i = 0; i < z; ++i) {
n1 = "0" + n1;
n2 = "0" + n2;
}
a[0] -= z;
a2[0] -= z;
for (int i = 1; i < 10; ++i) {
int t = min(a[i], a2[10 - i]);
for (int j = 0; j < t; ++j) {
n1 += (char)(i + '0');
n2 += (char)(10 - i + '0');
}
a[i] -= t;
a2[10 - i] -= t;
}
for (int i = 0; i < 10; ++i) {
for (int j = 0; j < a[i]; ++j) n1 += (char)(i + '0');
for (int j = 0; j < a2[i]; ++j) n2 += (char)(i + '0');
}
reverse(n1.begin(), n1.end());
reverse(n2.begin(), n2.end());
printf("%s\n%s\n", n1.c_str(), n2.c_str());
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
if (a + b == c || b + c == a || a + c == b || (a == b && c % 2 == 0) ||
(c == b && a % 2 == 0) || (a == c && b % 2 == 0)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const int MAXN = 100010;
int n, m;
pair<pair<int, int>, int> a[MAXN], b[MAXN];
long long f[MAXN][4];
pair<int, int> g[MAXN][4];
int ansN;
pair<int, int> ans[MAXN];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i].first.second >> a[i].first.first, a[i].second = i + 1;
sort(a, a + n);
cin >> m;
for (int i = 0; i < m; i++)
cin >> b[i].first.second >> b[i].first.first, b[i].second = i + 1;
sort(b, b + m);
memset(f, -1, sizeof(f));
for (int j = 0; j < 4; j++) {
f[0][j] = 0, g[0][j] = make_pair(-1, -1);
for (int v = 0; v < 2; v++)
if ((j >> v) & 1) {
int p =
(lower_bound(a, a + n,
make_pair(make_pair(b[0].first.first + v, INF), INF)) -
a) -
1;
if ((p >= 0) && (a[p].first.first == b[0].first.first + v) &&
(b[0].first.second >= a[p].first.second))
if (a[p].first.second > f[0][j])
f[0][j] = a[p].first.second, g[0][j] = make_pair(-1, p);
}
}
for (int i = 1; i < m; i++) {
int d = min(2, b[i].first.first - b[i - 1].first.first);
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++)
if ((j & (k >> d)) == (k >> d)) {
if (f[i - 1][k] > f[i][j])
f[i][j] = f[i - 1][k], g[i][j] = make_pair(k, -1);
for (int v = 0; v < 2; v++)
if (((j - (k >> d)) >> v) & 1) {
int p =
(lower_bound(
a, a + n,
make_pair(make_pair(b[i].first.first + v, INF), INF)) -
a) -
1;
if ((p >= 0) && (a[p].first.first == b[i].first.first + v) &&
(b[i].first.second >= a[p].first.second))
if (f[i - 1][k] + a[p].first.second > f[i][j])
f[i][j] = f[i - 1][k] + a[p].first.second,
g[i][j] = make_pair(k, p);
}
}
}
}
int i = m - 1, j = 0;
for (int k = 0; k < 4; k++)
if (f[i][k] > f[i][j]) j = k;
cout << f[i][j] << endl;
while (i >= 0) {
if (g[i][j].second != -1)
ans[ansN++] = make_pair(b[i].second, a[g[i][j].second].second);
j = g[i][j].first;
i--;
}
cout << ansN << endl;
for (int i = 0; i < ansN; i++)
cout << ans[i].first << ' ' << ans[i].second << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, arr[100009], cum1[100009], cum2[100009];
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
}
for (int i = 1; i <= n; ++i) {
cum1[i] = arr[i] + cum1[i - 1];
}
sort(arr, arr + n + 1);
for (int i = 1; i <= n; ++i) {
cum2[i] = arr[i] + cum2[i - 1];
}
int q;
cin >> q;
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
cout << cum1[y] - cum1[x - 1] << endl;
} else
cout << cum2[y] - cum2[x - 1] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[100000], b[100000], e[100000], f[100000], d[100000], m;
set<int> v;
set<int>::iterator it;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
d[0] = a[0] - b[0];
m = d[0];
for (int i = 1; i < n; i++) {
d[i] = a[i] - b[i] + d[i - 1];
if (d[i] < m) m = d[i];
}
if (m >= 0) v.insert(1);
for (int i = 2; i <= n; i++) {
if (m - d[i - 2] >= 0) v.insert(i);
}
e[0] = a[0];
for (int i = 1; i < n; i++) {
e[i] = a[n - i];
}
for (int i = 0; i < n; i++) {
f[i] = b[n - i - 1];
}
d[0] = e[0] - f[0];
m = d[0];
for (int i = 1; i < n; i++) {
d[i] = e[i] - f[i] + d[i - 1];
if (d[i] < m) m = d[i];
}
if (m >= 0) v.insert(1);
for (int i = 2; i <= n; i++) {
if (m - d[i - 2] >= 0) v.insert(n - i + 2);
}
printf("%d\n", v.size());
for (it = v.begin(); it != v.end(); ++it) printf("%d ", *it);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 60;
char a[N][2];
int f[N][10];
int n;
map<vector<string>, int> ap;
bool done(int kil) {
if (1 == kil) return true;
if (kil - 2 >= 0) {
if (a[kil - 2][0] == a[kil - 1][0] || a[kil - 2][1] == a[kil - 1][1]) {
char c1 = a[kil - 2][0];
char c2 = a[kil - 2][1];
a[kil - 2][0] = a[kil - 1][0];
a[kil - 2][1] = a[kil - 1][1];
if (done(kil - 1)) return true;
a[kil - 2][0] = c1;
a[kil - 2][1] = c2;
}
}
if (kil - 4 >= 0) {
if (a[kil - 4][0] == a[kil - 1][0] || a[kil - 4][1] == a[kil - 1][1]) {
char c1 = a[kil - 4][0];
char c2 = a[kil - 4][1];
a[kil - 4][0] = a[kil - 1][0];
a[kil - 4][1] = a[kil - 1][1];
if (done(kil - 1)) return true;
a[kil - 4][0] = c1;
a[kil - 4][1] = c2;
}
}
return false;
}
bool solve(vector<string> a) {
if (ap[a]) return false;
ap[a] = 1;
if (1 == a.size()) return true;
int n = a.size();
if (n > 1 && (a[n - 1][0] == a[n - 2][0] || a[n - 1][1] == a[n - 2][1])) {
vector<string> b = a;
b[n - 2] = b[n - 1];
b.erase(b.end() - 1);
if (solve(b)) return true;
}
if (n > 3 && (a[n - 1][0] == a[n - 4][0] || a[n - 1][1] == a[n - 4][1])) {
vector<string> b = a;
b[n - 4] = b[n - 1];
b.erase(b.end() - 1);
if (solve(b)) return true;
}
return false;
}
int main() {
vector<string> s;
scanf("%d\n", &n);
s.resize(n);
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
if (solve(s))
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, ans;
vector<int> d[100010];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
d[x].push_back(y), d[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if ((d[i].size()) & 1) ans++;
ans >>= 1;
for (int i = 1; i <= n; i++)
if (d[i].size() == 2) {
x = d[i][0], y = d[i][1];
if (x == y)
ans++, d[x].clear();
else
d[x][d[x][1] == i] = y, d[y][d[y][1] == i] = x;
}
printf("%d %d\n", ans, m);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, d;
cin >> s >> d;
string ans = "";
bool flag = true;
for (int i = 0; i < s.length(); i++) {
if (d[i] > s[i]) {
flag = false;
break;
} else if (d[i] == s[i]) {
if (s[i] != 'z')
ans.push_back(s[i] + 1);
else
ans.push_back(s[i]);
} else
ans.push_back(d[i]);
}
if (flag)
cout << ans << endl;
else
cout << "-1" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[4040][4040];
char t[4040][4040];
char c[2020][2020];
long long f(long long x, long long y) {
long long &r = dp[x][y];
if (r >= 0) return r;
if (t[x][y] == '.') {
return r = 0;
}
if (x == 0 || y == 0) {
return r = 1;
}
if (t[x - 1][y - 1] != t[x][y]) {
return r = 1;
}
if (x <= 1 || y <= 1 || t[x][y - 2] != t[x][y] || t[x - 2][y] != t[x][y]) {
return 2;
}
r = min({f(x - 1, y - 1), f(x, y - 2) + 1, f(x - 2, y) + 1}) + 1;
return r;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
for (int i = 0, ggdem = n; i < ggdem; ++i) {
for (int j = 0, ggdem = m; j < ggdem; ++j) {
cin >> c[i][j];
}
}
memset((t), ('.'), sizeof(t));
for (int i = 0, ggdem = n; i < ggdem; ++i) {
for (int j = 0, ggdem = m; j < ggdem; ++j) {
t[i + j][2000 + i - j] = c[i][j];
}
}
memset((dp), (-1), sizeof(dp));
long long res = 0;
for (int i = 0, ggdem = 4040; i < ggdem; ++i) {
for (int j = 0, ggdem = 4040; j < ggdem; ++j) {
long long s = f(i, j);
res += ((s + 1) >> 1);
}
}
cout << res << "\n";
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int dim = 50;
bool cmp(const string &a, const string &b) {
auto x = a + b, y = b + a;
return x < y;
}
int main() {
int n;
cin >> n;
vector<string> s(n);
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
sort(s.begin(), s.end(), cmp);
for (int i = 0; i < n; ++i) {
cout << s[i];
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
long long bad[1000005];
long long cnt[1000005];
int main() {
long long n, k;
cin >> n >> k;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
bad[a[j] - a[i]]++;
}
}
bool found = false;
for (int i = 1;; i++) {
found = false;
long long ans = 0;
for (int j = i; j < 1000005; j += i) ans += bad[j];
if (ans > (k * (k + 1) / 2)) continue;
long long cnt1 = 0;
long long pos;
for (int j = 0; j < n; j++) {
if (cnt[a[j] % i] != 0) cnt1++;
cnt[a[j] % i]++;
pos = j;
if (cnt1 > k) {
found = true;
break;
}
}
for (int j = 0; j <= pos; j++) cnt[a[j] % i]--;
if (!found) {
cout << i;
return 0;
}
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long long UNDEF = -1;
const long long INF = 1e18;
template <typename T>
inline bool chkmax(T& aa, T bb) {
return aa < bb ? aa = bb, true : false;
}
template <typename T>
inline bool chkmin(T& aa, T bb) {
return aa > bb ? aa = bb, true : false;
}
static char stdinBuffer[1024];
static char* stdinDataEnd = stdinBuffer + sizeof(stdinBuffer);
static const char* stdinPos = stdinDataEnd;
void readAhead(size_t amount) {
size_t remaining = stdinDataEnd - stdinPos;
if (remaining < amount) {
memmove(stdinBuffer, stdinPos, remaining);
size_t sz = fread(stdinBuffer + remaining, 1,
sizeof(stdinBuffer) - remaining, stdin);
stdinPos = stdinBuffer;
stdinDataEnd = stdinBuffer + remaining + sz;
if (stdinDataEnd != stdinBuffer + sizeof(stdinBuffer)) *stdinDataEnd = 0;
}
}
int readInt() {
readAhead(16);
int x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
const int me = 31;
long long k;
long long x, y;
pair<long long, long long> dp[me][2][2][2];
long long dphit[me][2][2][2];
const int LS = 0, EQ = 1, GR = 2;
int trans(int s, int b, int tb) {
if (s == LS) return LS;
if (b < tb)
return LS;
else if (b == tb)
return EQ;
else
return GR;
}
long long final = 0;
pair<long long, long long> f(int e, int xs, int ys, int ks) {
if (e == -1) {
if (xs + ys + ks == 0)
return make_pair(1ll, 1ll);
else
return make_pair(0ll, 0ll);
}
auto dpval = dp[e][xs][ys][ks];
if (dpval.first != -1) return dpval;
pair<long long, long long> ans = make_pair(0ll, 0ll);
for (int xb = 0; xb < 2; xb++) {
for (int yb = 0; yb < 2; yb++) {
{
int kb = xb ^ yb;
int nxs = trans(xs, xb, (x >> e) & 1);
int nys = trans(ys, yb, (y >> e) & 1);
int nks = trans(ks, kb, (k >> e) & 1);
if (nxs != GR && nys != GR && nks != GR) {
auto got = f(e - 1, nxs, nys, nks);
ans.first += got.first;
ans.second += got.second;
if (kb == 1) ans.second += (got.first << e) % 1000000007LL;
ans.first %= 1000000007LL;
ans.second %= 1000000007LL;
}
}
}
}
return dp[e][xs][ys][ks] = ans;
}
int bf(int x, int y, int k) {
int ans = 0;
for (int i = 0; i < x; i++)
for (int j = 0; j < y; j++) {
if ((i ^ j) < k) ans += (i ^ j) + 1;
}
return ans;
}
int query(int _x, int _y, int _k) {
k = _k;
x = _x;
y = _y;
if (x < 0 || y < 0) return 0;
memset(dp, -1, sizeof dp);
memset(dphit, 0, sizeof dphit);
auto ans = f(me - 1, 1, 1, 1);
return (ans.second) % 1000000007LL;
}
void tester() {
int lim = 4;
for (int i = 0; i < 1000; i++) {
int x = rand() % lim + 1, y = rand() % lim + 1, k = rand() % lim + 1;
if (bf(x, y, k) != query(x, y, k)) {
printf("x:%d y:%d k:%d. BF:%d QUE:%d\n", x, y, k, bf(x, y, k),
query(x, y, k));
}
}
printf("\n");
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int q = readInt();
for (int ii = 0; ii < q; ii++) {
int x1 = readInt(), y1 = readInt(), x2 = readInt(), y2 = readInt(),
_k = readInt();
--x1;
--y1;
int ans = query(x2, y2, _k) - query(x2, y1, _k) - query(x1, y2, _k) +
query(x1, y1, _k);
ans %= 1000000007LL;
if (ans < 0) ans += 1000000007LL;
printf("%d\n", ans);
}
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2, s3;
cin >> s1 >> s2 >> s3;
string s4 = s1 + s2;
sort(s4.begin(), s4.end());
sort(s3.begin(), s3.end());
if (s4 == s3) {
cout << "YES";
} else {
cout << "NO";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w, h;
cin >> w >> h;
long long ans = 0;
for (int i = 1; i <= h / 2; ++i) {
for (int j = 1; j <= w / 2; ++j) {
ans += (h - 2 * i + 1) * (w - 2 * j + 1);
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, j;
scanf("%d", &n);
int i;
int a[n];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
scanf("%d", &m);
int b[m];
for (j = 0; j < m; j++) {
scanf("%d", &b[j]);
}
sort(b, b + m);
printf("%d %d", a[n - 1], b[m - 1]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int cnt = 0, cn = 0;
char a[100010];
char b[100010];
scanf("%s", a);
scanf("%s", b);
int len = strlen(a);
for (int i = 0; i < len; ++i) {
if (a[i] != b[i]) {
if (a[i] == '4')
++cnt;
else
++cn;
}
}
printf("%d", max(cnt, cn));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e4 + 100;
const int K = 205;
const int INF = 0x3f3f3f3f;
const int kof[4] = {-2, 0, 0, 2};
int dp[N][K][4], dp2[N][K][4], a[N], n, k;
int dinamika() {
int sm = 0;
dp[0][1][0] = -a[0];
dp[0][1][1] = -a[0];
dp[0][1][2] = a[0];
dp[0][1][3] = a[0];
dp2[0][1][0] = -a[0];
dp2[0][1][1] = -a[0];
dp2[0][1][2] = a[0];
dp2[0][1][3] = a[0];
for (int i = 1; i < n; i++) {
dp[i][1][0] = max(-a[i] + dp[i - 1][1][0], -a[i]);
dp[i][1][1] = max(-a[i] + dp[i - 1][1][1], -a[i]);
dp[i][1][2] = max(a[i] + dp[i - 1][1][2], a[i]);
dp[i][1][3] = max(a[i] + dp[i - 1][1][3], a[i]);
dp2[i][1][0] = max(dp[i][1][0], dp2[i - 1][1][0]);
dp2[i][1][1] = max(dp[i][1][1], dp2[i - 1][1][1]);
dp2[i][1][2] = max(dp[i][1][2], dp2[i - 1][1][2]);
dp2[i][1][3] = max(dp[i][1][3], dp2[i - 1][1][3]);
}
for (int j = 2; j <= k; j++) {
dp[0][j][0] = -INF;
dp[0][j][1] = -INF;
dp[0][j][2] = -INF;
dp[0][j][3] = -INF;
dp2[0][j][0] = -INF;
dp2[0][j][1] = -INF;
dp2[0][j][2] = -INF;
dp2[0][j][3] = -INF;
if (j == k) break;
for (int i = 1; i < n; i++) {
for (int msk = 0; msk < 4; msk++) {
dp[i][j][msk] = -INF;
dp[i][j][msk] = max(dp[i - 1][j][msk] + a[i] * kof[msk], dp[i][j][msk]);
if (msk & 1) {
dp[i][j][msk] =
max(dp2[i - 1][j - 1][0] + a[i] * kof[msk], dp[i][j][msk]);
dp[i][j][msk] =
max(dp2[i - 1][j - 1][1] + a[i] * kof[msk], dp[i][j][msk]);
} else {
dp[i][j][msk] =
max(dp2[i - 1][j - 1][2] + a[i] * kof[msk], dp[i][j][msk]);
dp[i][j][msk] =
max(dp2[i - 1][j - 1][3] + a[i] * kof[msk], dp[i][j][msk]);
}
dp2[i][j][msk] = max(dp[i][j][msk], dp2[i - 1][j][msk]);
}
}
}
for (int i = 1; i < n; i++) {
dp[i][k][0] = -INF;
dp[i][k][1] = -INF;
dp[i][k][0] = max(dp[i - 1][k][0] - a[i], dp[i][k][0]);
dp[i][k][1] = max(dp[i - 1][k][1] + a[i], dp[i][k][1]);
dp[i][k][0] = max(max(dp2[i - 1][k - 1][2], dp2[i - 1][k - 1][3]) - a[i],
dp[i][k][0]);
dp[i][k][1] = max(max(dp2[i - 1][k - 1][0], dp2[i - 1][k - 1][1]) + a[i],
dp[i][k][1]);
dp2[i][k][0] = max(dp[i][k][0], dp2[i - 1][k][0]);
dp2[i][k][1] = max(dp[i][k][1], dp2[i - 1][k][1]);
}
return max(dp2[n - 1][k][0], dp2[n - 1][k][1]);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
printf("%d\n", dinamika());
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios ::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
if (n <= k) {
cout << "1\n";
continue;
}
set<int, greater<int>> left;
set<int, greater<int>> right;
for (int i = 1; i * i <= (n + n); i++) {
if (n % i == 0) {
left.insert(i);
right.insert(n / i);
}
}
int e = 0;
for (auto x : right) {
if (k >= x) {
cout << n / x << '\n';
e = 1;
break;
}
}
if (e == 1) continue;
for (auto x : left) {
if (k >= (x)) {
cout << n / x << '\n';
break;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t, n, x, y, p, q;
int main() {
cin >> t;
while (t--) {
cin >> x >> y >> p >> q;
if (p == 0) {
cout << (x == 0 ? 0 : -1) << endl;
continue;
}
if (p == q) {
cout << (x == y ? 0 : -1) << "\n";
continue;
}
int t1 = (x + p - 1) / p;
int t2 = ((y - x) + (q - p) - 1) / (q - p);
cout << (q * 1LL * max(t1, t2) - y) << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, ans = 0, curr = 0, i, a, b;
cin >> n >> x;
for (i = 0; i < n && cin >> a >> b; curr = b, i++)
ans += (a - curr) % x + (b - a) + (int)((a - curr) % x == 0) * x;
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int F() {
char ch;
int x, a;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-')
ch = getchar(), a = -1;
else
a = 1;
x = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + ch - '0';
return a * x;
}
int n;
bool query(int r1, int c1, int r2, int c2) {
printf("? %d %d %d %d\n", r1, c1, r2, c2);
fflush(stdout);
static char s[15];
scanf("%s", s);
if (!strcmp(s, "YES"))
return 1;
else
return 0;
}
bool can[555][555];
char s[2333];
int t;
int main() {
scanf("%d", &n);
int x, y;
can[1][1] = 1;
for (x = y = 1; x + y < n + 1;)
if (query(x, y + 1, n, n))
can[x][++y] = 1;
else
can[++x][y] = 1;
for (x = y = n; x + y > n + 1;)
if (query(1, 1, x - 1, y))
can[--x][y] = 1;
else
can[x][--y] = 1;
s[t++] = '!', s[t++] = ' ';
can[n][n] = 1;
for (int i = 1, j = 1;;) {
if (i + 1 <= n && can[i + 1][j])
s[t++] = 'D', ++i;
else if (j + 1 <= n)
s[t++] = 'R', ++j;
else
break;
}
puts(s);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int arr[11111];
int out[11111];
int temp[11111];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = (1); i < (n); ++i) arr[i] = 1;
arr[n] = 0;
int qtd = 0;
int ct = 5;
while (arr[1] != n - 1) {
memcpy(temp, arr, sizeof arr);
out[qtd++] = n;
int j = n - 1;
int qt = 0;
while (j >= 1 && arr[j] == n - j) {
j--;
qt++;
out[qtd++] = n;
}
int act = qt;
while (j >= 1 && qt) {
arr[j] += temp[j + act];
out[qtd++] = j + act;
j--;
qt--;
}
while (j >= 1) {
arr[j] += temp[j + 1];
out[qtd++] = j + 1;
j--;
}
for (int i = qtd - 1; i >= 0; --i) printf("%d ", out[i]);
printf("\n");
k--;
qtd = 0;
ct--;
}
while (k--) {
for (int i = (0); i < (n); ++i) printf("%d ", n);
printf("\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops")
const int N = 2e5 + 5;
const long long int mod = 1e9 + 7;
const long long int Mod = 998244353;
const long double Pi = acos(-1);
const long long int Inf = 4e18;
using namespace std;
void TestCase() {
int n, k, pos = n + 1;
cin >> n >> k;
bool ok = false;
vector<int> a(n + 1), pref(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == k) {
ok = true;
pos = min(pos, i);
}
}
if (ok) {
ok = false;
for (int i = 1; i <= n; i++) {
a[i] = (a[i] >= k ? 1 : -1);
}
int sum = 0, mi = 0;
for (int i = 1; i <= n; i++) {
sum += a[i];
pref[i] = min(pref[i - 1], sum);
if (i >= 2) {
if (sum - pref[i - 2] > 0) ok = true;
}
}
}
if (n == 1 && pos == 1) ok = true;
ok ? cout << "yes" : cout << "no";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int T = 1;
cin >> T;
while (T--) {
TestCase();
cout << "\n";
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, A[100], i, j;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> A[i];
}
sort(A, A + n);
cout << A[n - k];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 5;
unordered_map<int, int> mp;
int block, ans[mx], n, m;
struct query {
int l, r, id;
};
bool comp(query x, query y) {
if (x.l / block != y.l / block) return x.l / block < y.l / block;
return x.r < y.r;
}
void find_ans(int a[], query q[]) {
block = (int)sqrt(n);
sort(q, q + m, comp);
int curl = 0, curr = 0, cursum = 0;
for (int i = 0; i < m; ++i) {
int l = q[i].l, r = q[i].r;
while (curl < l) {
if (mp[a[curl]] == a[curl]) --cursum;
--mp[a[curl]];
if (mp[a[curl]] == a[curl]) ++cursum;
++curl;
}
while (curl > l) {
--curl;
if (mp[a[curl]] == a[curl]) --cursum;
++mp[a[curl]];
if (mp[a[curl]] == a[curl]) ++cursum;
}
while (curr <= r) {
if (mp[a[curr]] == a[curr]) --cursum;
++mp[a[curr]];
if (mp[a[curr]] == a[curr]) ++cursum;
++curr;
}
while (curr > (r + 1)) {
--curr;
if (mp[a[curr]] == a[curr]) --cursum;
--mp[a[curr]];
if (mp[a[curr]] == a[curr]) ++cursum;
}
ans[q[i].id] = cursum;
}
}
int main() {
scanf("%d%d", &n, &m);
int a[n];
query q[m];
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < m; ++i) {
int l, r;
scanf("%d%d", &l, &r);
q[i].l = l - 1, q[i].r = r - 1, q[i].id = i;
}
find_ans(a, q);
for (int i = 0; i < m; ++i) printf("%d\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int zero = 201, maxn = 507, maxnum = 100000000;
int x, y, n, d;
int dx[maxn], dy[maxn];
int sg[maxn][maxn];
int dis(int x, int y) {
return (x - zero) * (x - zero) + (y - zero) * (y - zero);
}
int SG(int x, int y) {
if (dis(x, y) > d) return 1;
if (sg[x][y] != -1) return sg[x][y];
vector<int> vec;
vec.push_back(-1);
vec.push_back(maxnum);
for (int i = 1; i <= n; i++) vec.push_back(SG(x + dx[i], y + dy[i]));
sort(vec.begin(), vec.end());
for (int i = 0; i < vec.size(); i++)
if (vec[i] + 1 < vec[i + 1]) return sg[x][y] = vec[i] + 1;
}
void work() {
x += zero, y += zero;
d *= d;
for (int i = 1; i <= n; i++) scanf("%d%d", &dx[i], &dy[i]);
memset(sg, -1, sizeof(sg));
printf("%s\n", SG(x, y) ? "Anton" : "Dasha");
}
int main() {
while (scanf("%d%d%d%d", &x, &y, &n, &d) != EOF) work();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k;
int main() {
cin >> n >> k;
cout << min(1LL, min(n - k, k)) << " " << min(n - k, k * 2) << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
int c, sumb = 0, sumc = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); ++i) {
if (v[i] <= 0)
sumc += v[i];
else
sumb += v[i];
}
cout << sumb - sumc;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int mod = 1e9 + 7;
const int maxn = 2e5 + 100;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int maxm = 2e6 + 100;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1.0);
long long ans;
int cnt[maxn], tnc[maxn];
struct node {
int trie[maxn][26];
int num[maxn];
int fail[maxn];
int h[maxn];
int vis[maxn];
int last[maxn];
int tot = 0;
void init() { memset(vis, 0, sizeof(vis)); }
void add(char *s) {
int root = 0, len = strlen(s + 1);
for (int i = 1; i <= len; i++) {
int x = s[i] - 'a';
if (!trie[root][x]) trie[root][x] = ++tot;
root = trie[root][x];
h[root] = i;
}
num[root]++;
}
void build() {
queue<int> q;
for (int i = 0; i < 26; i++) {
if (trie[0][i]) {
fail[trie[0][i]] = 0;
q.push(trie[0][i]);
}
}
while (!q.empty()) {
int now = q.front();
q.pop();
last[now] = num[fail[now]] ? fail[now] : last[fail[now]];
for (int i = 0; i < 26; i++) {
if (trie[now][i]) {
fail[trie[now][i]] = trie[fail[now]][i];
q.push(trie[now][i]);
} else
trie[now][i] = trie[fail[now]][i];
}
}
}
void acGao(char *s) {
int root = 0;
int len = strlen(s + 1);
for (int i = 1; i <= len; i++) {
int x = s[i] - 'a';
root = trie[root][x];
for (int j = root; j; j = last[j]) {
cnt[i] += num[j];
tnc[i - h[j] + 1] += num[j];
}
}
}
} ac;
char S[maxn];
char a[maxn];
int n;
int main() {
scanf("%s", S + 1);
int m = strlen(S + 1);
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", a + 1);
int len = strlen(a + 1);
ac.add(a);
}
ac.h[0] = 0;
ac.build();
ac.acGao(S);
for (int i = 1; i <= m; i++) {
ans += 1ll * cnt[i] * tnc[i + 1];
}
printf("%lld\n", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int inf = 0x3f3f3f3f;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b > 0; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long inv(long long a) { return (powmod(a, mod - 2) + mod) % mod; }
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < 48 || ch > 57) {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= 48 && ch <= 57)
s = (s << 1) + (s << 3) + (ch ^ 48), ch = getchar();
return s * w;
}
const int N = 1e5 + 50;
int a[N];
int main() {
int m, n;
cin >> m;
for (int i = 0; i < m; i++) scanf("%d", a + i);
sort(a, a + m);
cin >> n;
int w;
while (n--) {
cin >> w;
cout << upper_bound(a, a + m, w) - a << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long cal(long long x) {
long long sum = 0;
while (x) {
sum += x % 10;
x /= 10;
}
return sum;
}
long long pre[100];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
pre[1] = 9;
for (long long i = 2; i <= 15; ++i) {
pre[i] = pre[i - 1] * 10 + 9;
}
if (n == 0) {
cout << 0 << endl;
return 0;
}
long long Max = 0;
Max = max(Max, cal(n));
Max = max(Max, cal(n - 1) + cal(1));
long long temp = n;
long long wei = 0;
while (temp) {
temp /= 10;
++wei;
}
if (wei == 1) {
cout << Max << endl;
} else {
for (long long i = 1; i <= 15; i++) {
if (n > pre[i]) {
Max = max(Max, cal(pre[i]) + cal(n - pre[i]));
}
}
cout << Max << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long fact[2000010], inv[2000010];
void init() {
long long n = 2000010 - 5;
fact[0] = 1;
for (long long i = 1; i <= n; ++i) {
fact[i] = i * fact[i - 1] % 1000000007;
}
inv[1] = 1;
for (long long i = 2; i <= n; ++i) {
inv[i] = 1000000007 - (1000000007 / i) * inv[1000000007 % i] % 1000000007;
}
inv[0] = 1;
for (long long i = 1; i <= n; ++i) {
inv[i] = inv[i - 1] * inv[i] % 1000000007;
}
}
long long Pow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return ans;
}
long long A(long long n, long long m) {
if (m > n || n < 0) return 0;
return fact[n] * inv[n - m] % 1000000007;
}
int main() {
init();
long long k, w;
while (~scanf("%lld%lld", &k, &w)) {
long long ans = 0;
for (long long L = 1; L <= k; ++L) {
if (w - L >= 2) {
ans +=
Pow(k, w - L - 2) *
((A(k, L) * A(k, L) % 1000000007 * k % 1000000007 * k % 1000000007 -
(A(k, L + 1) * A(k, L + 1) % 1000000007) + 1000000007) %
1000000007) %
1000000007;
} else if (w - L == 1) {
ans += (k * A(k, L) % 1000000007 * A(k, L) % 1000000007 -
A(k, L + 1) * A(k - 1, L) % 1000000007 + 1000000007) %
1000000007;
} else {
long long tmp = A(k - L + w - 2, w - 1);
ans += (A(k, L - w) * A(k - L + w, w) % 1000000007 * A(k - L + w, w) %
1000000007 -
(A(k, L - w + 2) * tmp % 1000000007 * tmp % 1000000007 +
1000000007) %
1000000007 +
1000000007) %
1000000007;
}
ans = (ans + 1000000007) % 1000000007;
}
cout << ans << endl;
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int nax = 1000000 + 10;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
int ans = 1;
cin >> n;
for (int k = 2; k < 33; k++) {
int a = pow(2, k);
a--;
int b = pow(2, k - 1);
a = a * b;
if (n % a == 0) ans = max(ans, a);
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y;
char s[666666];
int main() {
scanf("%d%d%d%s", &n, &x, &y, s + 1);
int b = 0;
long long ans = 8e18;
for (int i = 1; i <= n; ++i)
if (s[i] == '0' && s[i - 1] != '0') ++b;
if (!b) ans = 0;
for (int i = 0; i < b; ++i)
ans = min(ans, y * (long long)(b - i) + x * (long long)i);
printf("%lld\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mult(long long a, long long b, long long p = 1000000007) {
return ((a % p) * (b % p)) % p;
}
long long add(long long a, long long b, long long p = 1000000007) {
return (a % p + b % p) % p;
}
long long fpow(long long n, long long k, long long p = 1000000007) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
long long inv(long long a, long long p = 1000000007) {
return fpow(a, p - 2, p);
}
long long inv_euclid(long long a, long long m = 1000000007) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long a[200003];
long long n, m;
long long check(long long p) {
long long ind = n - 1;
long long ans = 0;
long long d = 0;
while (ind >= 0) {
for (long long i = 0; i < p; i++) {
ans += max((long long)0, a[ind] - d);
ind--;
if (ind < 0) {
break;
}
}
d++;
}
if (ans >= m) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
long long sum = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum < m) {
cout << -1 << '\n';
return 0;
}
sort(a, a + n);
long long l = 1, r = sum;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid)) {
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << l << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const int N = 100100;
int n, a[N], k, l;
int main() {
scanf("%d %d %d", &n, &k, &l);
for (int i = 1; i <= n * k; i++) scanf("%d", a + i);
int nn = n * k;
sort(a + 1, a + 1 + nn);
int idx = 1;
while (idx <= nn) {
if (a[idx] - a[1] <= l)
idx++;
else
break;
}
if (idx > nn || a[idx] - a[1] > l) idx--;
if (idx < n) {
printf("0");
return 0;
}
vector<int> v, vv;
for (int j = idx + 1; j <= nn; j++) v.push_back(a[j]);
for (int i = 1; i <= idx; i++) vv.push_back(a[i]);
long long ANS = 0;
for (int i = idx - 1; i >= 0; --i) {
if (v.size() < k - 1) break;
int cnt = k - 1;
while (cnt--) v.pop_back();
ANS += vv.back();
vv.pop_back();
}
for (auto x : v) vv.push_back(x);
for (int i = 0; i < vv.size(); i += k) {
ANS += vv[i];
}
printf("%lld", ANS);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:300000000")
#pragma warning(disable : 4800)
using namespace std;
void showTime() { cerr << (double)clock() / CLOCKS_PER_SEC << endl; }
const double pi = 3.1415926535897932384626433832795;
template <class T>
T abs(const T &a) {
return a >= 0 ? a : -a;
};
template <class T>
T sqr(const T &x) {
return x * x;
}
bool isPrime(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
vector<int> primes;
void work(int x, int *cnt, int *macnt) {
for (int i = 0; i < int((primes).size()) && primes[i] <= x; i++)
while (x % primes[i] == 0) {
x /= primes[i];
cnt[i]++;
}
if (x != 1) macnt[x]++;
}
void work2(int &x, int *qcnt, int *qmacnt) {
int buf = x;
for (int i = 0; i < int((primes).size()) && primes[i] <= x; i++)
while (buf % primes[i] == 0) {
buf /= primes[i];
if (qcnt[i]) {
x /= primes[i];
qcnt[i]--;
}
}
if (buf != 1) {
if (qmacnt[buf] != 0) {
qmacnt[buf]--;
x /= buf;
}
}
}
const int ssize = int(1e7 + 5);
int macnta[ssize], macntb[ssize], qmacnta[ssize], qmacntb[ssize];
const int size = 5000;
int cnta[size], cntb[size], qcnta[size], qcntb[size];
int a[200500], b[200500];
void gen() {
vector<int> v;
for (int i = int(1e7);; i--)
if (isPrime(i)) {
v.push_back(i);
if (int((v).size()) == 100) break;
}
int n = int(1e5), m = int(1e5);
cout << n << ' ' << m << endl;
for (int i = 0; i < (n); i++) cout << v[rand() % 100] << ' ';
cout << endl;
for (int i = 0; i < (n); i++) cout << v[rand() % 100] << ' ';
exit(0);
}
int main() {
for (int i = 2; i * i <= int(1e7); i++)
if (isPrime(i)) primes.push_back(i);
int n, m;
cin >> n >> m;
for (int i = 0; i < (n); i++) {
int x;
scanf("%d", &x);
work(x, cnta, macnta);
a[i] = x;
}
for (int i = 0; i < (m); i++) {
int x;
scanf("%d", &x);
work(x, cntb, macntb);
b[i] = x;
}
for (int i = 0; i < (int((primes).size())); i++)
qcnta[i] = qcntb[i] = min(cnta[i], cntb[i]);
for (int i = 0; i < (ssize); i++)
qmacnta[i] = qmacntb[i] = min(macnta[i], macntb[i]);
for (int i = 0; i < (n); i++) work2(a[i], qcnta, qmacnta);
for (int i = 0; i < (m); i++) work2(b[i], qcntb, qmacntb);
cout << n << ' ' << m << endl;
for (int i = 0; i < (n); i++) printf("%d ", a[i]);
cout << endl;
for (int i = 0; i < (m); i++) printf("%d ", b[i]);
showTime();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, l, r;
scanf("%lld", &n);
scanf("%lld", &l);
scanf("%lld", &r);
long long i, j, k = 1, li;
if (l == 1) li = k;
for (i = 2; i <= r; i++) {
k = k * 2;
if (i == l) li = k;
}
long long mini = 0, maxi = 0, ri = 1;
for (i = 0; i < n; i++) {
mini += li;
if (li != 1) li = li / 2;
maxi += ri;
if (ri != k) ri = ri * 2;
}
cout << mini << " " << maxi;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long read() {
long long s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
inline void print(long long *f, long long len) {
for (long long i = 0; i < len; i++) printf("%lld ", f[i]);
puts("");
}
const long long mod = 998244853;
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long dp[2020][2020], c[4020][4020], f[2020][2020];
signed main() {
n = read();
m = read();
for (long long i = 0, iend = n; i <= iend; ++i) {
for (long long j = 0, jend = m; j <= jend; ++j) {
if (i == 0)
f[i][j] = 1;
else if (j == 0 || i > j)
f[i][j] = 0;
else
f[i][j] = (f[i - 1][j] + f[i][j - 1]) % mod;
}
}
c[0][0] = c[1][0] = c[0][1] = c[1][1] = 1;
for (long long i = 2, iend = n + m; i <= iend; ++i) {
c[i][0] = 1;
for (long long j = 1, jend = i; j <= jend; ++j) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
for (long long i = 0, iend = n; i <= iend; ++i) dp[i][0] = i;
for (long long i = 1, iend = n; i <= iend; ++i) {
for (long long j = 1, jend = m; j <= jend; ++j) {
dp[i][j] = (dp[i - 1][j] + c[i + j - 1][i - 1] + dp[i][j - 1] -
c[i + j - 1][j - 1] + f[i][j - 1] + mod) %
mod;
}
}
cout << dp[n][m];
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
long long max(long long a, long long b) {
if (a >= b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a >= b)
return b;
else
return a;
}
long long diff(long long a, long long b) {
if (a >= b)
return a - b;
else
return b - a;
}
long long mod(long long a) {
if (a >= 0)
return a;
else
return -a;
}
void pairsort(long long a[], long long b[], long long n) {
pair<long long, long long> pairt[n];
for (long long i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (long long i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long rev(long long n) {
long long ans = 0;
while (n) {
ans = ans * 10 + n % 10;
n = n / 10;
}
return ans;
}
long long fact(long long n) {
if (n == 0) return 1;
if (n == 1) return 1;
if (n >= 2) return n * fact(n - 1);
}
long long isPrime(long long n) {
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return 0;
return 1;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
long long a[n], b[n], A[6] = {0}, B[6] = {0}, C[6] = {0};
for (long long i = 0; i < n; i++) {
cin >> a[i];
A[a[i]]++;
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
B[b[i]]++;
}
long long k = 0;
for (long long i = 0; i < 6; i++) {
C[i] = A[i] + B[i];
if (C[i] % 2 != 0) k = 1;
}
if (k)
cout << -1;
else {
for (long long i = 0; i < 6; i++) C[i] = C[i] / 2;
long long ans = 0;
for (long long i = 0; i < 6; i++) ans = ans + diff(A[i], C[i]);
cout << ans / 2;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> k;
vector<vector<int> > neighbours;
long long f(int v, int parent) {
vector<long long> subtrees;
for (vector<int>::const_iterator u = neighbours[v].begin();
u != neighbours[v].end(); u++) {
if (k[*u] > 0 && *u != parent) {
k[*u]--;
subtrees.push_back(f(*u, v));
}
}
sort(subtrees.begin(), subtrees.end(), greater<long long>());
long long m = min((long long)k[v], (long long)subtrees.size());
k[v] -= m;
long long ans =
accumulate(subtrees.begin(), subtrees.begin() + m, 0ll) + 2ll * m;
for (vector<int>::const_iterator u = neighbours[v].begin();
u != neighbours[v].end(); u++) {
if (*u != parent) {
long long l = min(k[v], k[*u]);
k[*u] -= l;
k[v] -= l;
ans += 2ll * l;
if (k[v] == 0) break;
}
}
return ans;
}
int main() {
int n;
cin >> n;
k.resize(n);
for (int i = 0; i < n; i++) cin >> k[i];
neighbours.resize(n);
for (int i = 0; i < n - 1; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
neighbours[v].push_back(u);
neighbours[u].push_back(v);
}
int s;
cin >> s;
s--;
cout << f(s, s);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int arr[1004];
int n, k, p, x, y, tot, c;
void Readinput() {
tot = 0;
c = 0;
int i = 0;
scanf("%d", &n);
scanf("%d", &k);
scanf("%d", &p);
scanf("%d", &x);
scanf("%d", &y);
for (i = 0; i < k; i++) {
scanf("%d", &arr[i]);
tot += arr[i];
if (arr[i] >= y) c++;
}
}
void solve() {
int i, j;
int mid = n / 2 + 1;
if (x - tot < n - k || c + n - k < mid) {
printf("-1\n");
return;
}
if (c >= mid) {
for (i = 0; i < n - k; i++) printf("1 ");
printf("\n");
} else {
int u = mid - c;
if (u * y > x - tot || n - k - u > x - tot - u * y)
printf("-1\n");
else {
for (i = 0; i < u; i++) printf("%d ", y);
for (i = 0; i < n - k - u; i++) printf("1 ");
printf("\n");
}
}
}
int main() {
Readinput();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
const int POWERS_MAX = 19;
long long p10[POWERS_MAX];
void compute_powers() {
p10[0] = 1;
for (int(i) = (1); (i) <= (POWERS_MAX - 1); ++i) {
p10[i] = 10 * p10[i - 1];
}
}
int len(long long n) {
if (n == 0) return 1;
int res = 0;
while (n > 0) {
res++;
n = n / 10;
}
return res;
}
int first_digit(long long n) {
while (n >= 10) n = n / 10;
return n;
}
long long count_equal_len(long long n) {
int f_digit = first_digit(n);
int l_digit = n % 10;
int l = len(n);
long long res = 0;
res += (f_digit - 1) * p10[l - 2];
n = n / 10;
l--;
res += (n % p10[l - 1]);
if (f_digit <= l_digit) res++;
return res;
}
long long count(long long u) {
int l = len(u);
long long res = 0;
if (l == 1) {
return u;
} else {
res = 9;
for (int(i) = (0); (i) <= (l - 3); ++i) {
res += 9 * p10[i];
}
res += count_equal_len(u);
}
return res;
}
int main() {
compute_powers();
long long l, u;
cin >> l >> u;
cout << count(u) - count(l - 1) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int black[3000][3000];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int T;
for (int i = 1; i <= k; i++) {
int a, b;
scanf("%d%d", &a, &b);
if (!black[a][b]) {
black[a][b] = i;
}
}
bool flag = 0;
T = 1000000;
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
if (black[i][j] && black[i + 1][j] && black[i][j + 1] &&
black[i + 1][j + 1]) {
flag = 1;
T = min(T, max(max(black[i][j], black[i + 1][j]),
max(black[i + 1][j + 1], black[i][j + 1])));
}
}
}
if (!flag) {
printf("%d\n", 0);
} else {
printf("%d\n", T);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> nei[5005];
int dp[5005], masize[5005], oth[5005], size[5005];
bitset<5005> C, tmp;
void dfs(int v, int pa) {
size[v] = 1;
vector<int> al;
for (int i = 0; i < nei[v].size(); i++) {
int u = nei[v][i];
if (u == pa) continue;
dfs(u, v);
size[v] += size[u];
al.push_back(size[u]);
}
al.push_back(n - size[v]);
sort(al.begin(), al.end());
tmp.reset();
tmp.set(0);
bool flag = 0;
for (int i = 0; i < al.size(); i++) {
tmp |= tmp << al[i];
if (tmp[4] == 1) flag = 1;
}
C |= tmp;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--, y--;
nei[x].push_back(y);
nei[y].push_back(x);
}
C[0] = 1;
dfs(0, -1);
int cnt = 0;
for (int i = 1; i < n - 1; i++) {
if (C[i]) cnt++;
}
cout << cnt << endl;
for (int i = 1; i < n - 1; i++) {
if (C[i]) cout << i << " " << n - 1 - i << endl;
}
}
| 7 |
#include <bits/stdc++.h>
int n, k;
int xc, yc;
int tot[111];
short int sum[111][111];
int abs(int a) { return a > 0 ? a : -a; }
void solve(int m) {
if (m > k) {
puts("-1");
return;
}
int mn = 1000000000, x, yl, yr;
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= k - m + 1; j++)
if (sum[i][j + m - 1] - sum[i][j - 1] == 0) {
int ans = tot[j + m - 1] - tot[j - 1] + abs(xc - i) * m;
if (ans < mn) mn = ans, x = i, yl = j, yr = j + m - 1;
}
}
if (mn == 1000000000) {
puts("-1");
return;
}
printf("%d %d %d\n", x, yl, yr);
for (int j = yl; j <= yr; j++) sum[x][j] = sum[x][j - 1] + 1;
for (int j = yr + 1; j <= k; j++) sum[x][j] += m;
}
int main() {
scanf("%d %d", &n, &k);
xc = yc = (k + 1) / 2;
tot[0] = 0;
for (int i = 1; i <= k; i++) tot[i] = tot[i - 1] + abs(xc - i);
for (int i = 0; i < n; i++) {
int m;
scanf("%d", &m);
solve(m);
}
}
| 7 |
#include <bits/stdc++.h>
int main() {
long long m, p, b, ans = 0;
std::cin >> m >> b >> p;
p *= m;
while (m > 1) {
long long k = 1 << 30;
while (k > m) k >>= 1;
long long d = m - k;
ans += k * b + (k >> 1);
m = d + (k >> 1);
}
std::cout << ans << ' ' << p << std::endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3010, mod = 1e9 + 7;
const long long inf = 1e18;
vector<int> v[maxn];
pair<int, int> fr[2][3][maxn];
int h[maxn];
queue<int> q;
pair<int, pair<pair<int, int>, pair<int, int> > > ans;
void Push(int a, int b, pair<int, int> p) {
if (fr[a][0][b] < p)
fr[a][2][b] = fr[a][1][b], fr[a][1][b] = fr[a][0][b], fr[a][0][b] = p;
else if (fr[a][1][b] < p)
fr[a][2][b] = fr[a][1][b], fr[a][1][b] = p;
else if (fr[a][2][b] < p)
fr[a][2][b] = p;
}
void bfs(int u, bool is = 0) {
int rt = u;
memset(h, 0, sizeof h);
h[u] = 1;
q.push(u);
while (!q.empty()) {
u = q.front();
q.pop();
if (is) {
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
if (fr[1][i][rt].second != rt && fr[1][i][rt].second != u &&
fr[1][i][rt].second != fr[0][j][u].second && rt != u &&
rt != fr[0][j][u].second && u != fr[0][j][u].second)
ans = max(ans,
{fr[1][i][rt].first + h[u] + fr[0][j][u].first - 3,
{{fr[1][i][rt].second, rt}, {u, fr[0][j][u].second}}});
} else {
Push(0, rt, {h[u], u});
Push(1, u, {h[u], rt});
}
for (int y : v[u]) {
if (h[y] == 0) {
h[y] = h[u] + 1;
q.push(y);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
}
for (int i = 1; i <= n; i++) {
bfs(i);
}
for (int i = 1; i <= n; i++) {
bfs(i, 1);
}
cout << ans.second.first.first << " " << ans.second.first.second << " "
<< ans.second.second.first << " " << ans.second.second.second << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct point {
long long x, y;
point() {}
point(int x, int y) : x(x), y(y) {}
};
point a[510];
point b[510];
int c[510][510];
point operator-(point &xx, point &yy) {
return point(xx.x - yy.x, xx.y - yy.y);
}
long long vect(point xx, point yy) { return xx.x * yy.y - xx.y * yy.x; }
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
int xx, yy;
scanf("%d%d", &xx, &yy);
a[i] = point(xx, yy);
}
for (int i = 0; i < m; i++) {
int xx, yy;
scanf("%d%d", &xx, &yy);
b[i] = point(xx, yy);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i].x >= a[j].x) continue;
for (int k = 0; k < m; k++) {
if (b[k].x >= a[i].x && b[k].x < a[j].x &&
vect(a[j] - a[i], b[k] - a[i]) > 0)
c[i][j]++;
c[j][i] = -c[i][j];
}
}
}
int sum = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
if (c[i][j] + c[j][k] + c[k][i] == 0) sum++;
}
}
}
cout << sum << endl;
return 0;
}
| 18 |
#include <bits/stdc++.h>
int main() {
int n, h;
int width = 0;
std::cin >> n >> h;
int* a = new int[n];
for (int i = 0; i < n; i++) std::cin >> a[i];
for (int i = 0; i < n; i++) {
width++;
if (a[i] > h) width++;
}
std::cout << width;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 10;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
long long se[26][26][26], du[26][26], q[MAXN];
string v[MAXN], dp[MAXN];
int main() {
string s;
cin >> s;
long long k = 0;
q[s.size()] = 2;
for (int i = s.size() - 2; i >= 5; i--) {
long long a = int(s[i]) - 97, b = int(s[i + 1]) - 97,
c = int(s[i + 2]) - 97;
string o = s.substr(i, 3);
if (q[i + 3] == 2) {
if (!se[a][b][c]) {
se[a][b][c] = 1;
v[k] = o;
k++;
}
q[i] = 1;
dp[i] = o;
} else if (q[i + 3] == 1 && o != dp[i + 3]) {
if (!se[a][b][c]) {
se[a][b][c] = 1;
v[k] = o;
k++;
}
q[i] = 1;
dp[i] = o;
}
o = s.substr(i, 2);
if (q[i + 2] == 2) {
if (!du[a][b]) {
du[a][b] = 1;
v[k] = o;
k++;
}
q[i]++;
dp[i] = o;
} else if (q[i + 2] == 1 && o != dp[i + 2]) {
if (!du[a][b]) {
du[a][b] = 1;
v[k] = o;
k++;
}
q[i]++;
dp[i] = o;
}
}
sort(v, v + k);
cout << k << '\n';
for (int i = 0; i < k; i++) {
cout << v[i] << '\n';
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int c[100005][6][6];
const int modo = 1000000007;
int sum[100005][6];
int val[1 << 18][6];
int a[100005];
int tag[1 << 18];
void updates(int num, int l, int mid, int r) {
register int i;
for (i = 0; i <= 5; i++) {
val[num][i] = val[num * 2 + 1][i];
int j;
for (j = 0; j <= i; j++) {
val[num][i] =
(val[num][i] + (long long)val[num * 2 + 2][j] * c[mid - l][i][j]) %
modo;
}
}
}
int d[6];
int k;
void update(int num, int delta) {
int j;
for (j = 0; j <= k; j++) {
d[k] = (d[k] + (long long)val[num][j] * c[delta][k][j]) % modo;
}
}
void push_down(int num, int l, int mid, int r) {
if (tag[num] == -1) return;
int i;
for (i = 0; i <= 5; i++) {
val[num * 2 + 1][i] = (long long)sum[mid - l][i] * tag[num] % modo;
val[num * 2 + 2][i] = (long long)sum[r - mid][i] * tag[num] % modo;
}
tag[num * 2 + 1] = tag[num];
tag[num * 2 + 2] = tag[num];
tag[num] = -1;
}
void build_tree(int num, int l, int r) {
tag[num] = -1;
if (l == r - 1) {
int i;
for (i = 0; i <= 5; i++) {
val[num][i] = a[l];
}
return;
}
int mid = (l + r) / 2;
build_tree(num * 2 + 1, l, mid);
build_tree(num * 2 + 2, mid, r);
updates(num, l, mid, r);
}
void change(int num, int l, int r, int l0, int r0, int vals) {
if ((l0 <= l) && (r <= r0)) {
tag[num] = vals;
int i;
for (i = 0; i <= 5; i++) {
val[num][i] = (long long)sum[r - l][i] * vals % modo;
}
return;
}
int mid = (l + r) / 2;
push_down(num, l, mid, r);
if (l0 < mid) change(num * 2 + 1, l, mid, l0, r0, vals);
if (mid < r0) change(num * 2 + 2, mid, r, l0, r0, vals);
updates(num, l, mid, r);
}
void query(int num, int l, int r, int l0, int r0) {
if ((l0 <= l) && (r <= r0)) {
update(num, l - l0);
return;
}
int mid = (l + r) / 2;
push_down(num, l, mid, r);
if (l0 < mid) query(num * 2 + 1, l, mid, l0, r0);
if (mid < r0) query(num * 2 + 2, mid, r, l0, r0);
}
int main() {
int i;
for (i = 0; i <= 100000; i++) {
int j;
for (j = 0; j <= 5; j++) {
int k;
c[i][j][0] = 1;
for (k = 1; k <= j; k++) {
c[i][j][k] = c[i][j - 1][k] + c[i][j - 1][k - 1];
if (c[i][j][k] >= modo) c[i][j][k] -= modo;
}
}
for (j = 0; j <= 5; j++) {
int k;
c[i][j][0] = 1;
int p = 1;
for (k = j; k >= 0; k--) {
c[i][j][k] = (long long)c[i][j][k] * p % modo;
p = (long long)p * i % modo;
}
}
}
for (i = 1; i <= 100000; i++) {
int j;
int p = 1;
for (j = 0; j <= 5; j++) {
sum[i][j] = sum[i - 1][j] + p;
if (sum[i][j] >= modo) sum[i][j] -= modo;
p = (long long)p * i % modo;
}
}
int n;
scanf("%d", &n);
int q;
scanf("%d", &q);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
build_tree(0, 0, n);
for (i = 0; i < q; i++) {
static char b[15];
scanf("%s", b);
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
l--;
if (b[0] == '=') {
change(0, 0, n, l, r, z);
} else {
memset(d, 0, sizeof(d));
k = z;
query(0, 0, n, l, r);
printf("%d\n", d[z]);
}
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
const int MAXN = 1e5 + 5;
int n;
long long a[MAXN];
std::vector<std::pair<int, long long> > G[MAXN];
bool vis[MAXN];
inline void add(int u, int v, long long w) {
G[u].push_back(std::make_pair(v, w));
G[v].push_back(std::make_pair(u, w));
}
inline void dfs(int v, int fa, long long sum) {
vis[v] = true;
for (auto x : G[v]) {
int to = x.first;
long long w = x.second;
if (to == fa) continue;
if (sum + w <= a[to]) dfs(to, v, std::max(0ll, sum + w));
}
}
int ans = 0;
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n; ++i) scanf("%lld", a + i);
for (register int i = 1; i <= n - 1; ++i) {
int p;
long long w;
scanf("%d%lld", &p, &w);
add(i + 1, p, w);
}
dfs(1, 0, 0);
for (register int i = 1; i <= n; ++i) ans += !vis[i];
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
constexpr long long INF = 1999999999999999997;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
vector<int> v;
int mn = 28;
for (int i = 0; i < n; i++) {
if (mn >= (s[i] - 'a')) mn = s[i] - 'a';
}
for (int i = 0; i < n; i++) {
if (s[i] - 'a' == mn) {
v.push_back(i);
}
}
int k = 1;
string t = s;
for (int i = 0; i < (int)v.size(); i++) {
if (v[i] != 0) {
string temp;
int c = n - v[i];
for (int j = v[i]; j < n; j++) {
temp.push_back(s[j]);
}
if (c & 1) {
for (int j = v[i] - 1; j >= 0; j--) temp.push_back(s[j]);
} else {
for (int j = 0; j < v[i]; j++) temp.push_back(s[j]);
}
if (temp < t) {
k = v[i] + 1;
t = temp;
}
}
}
cout << t;
cout << endl;
cout << k << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f;
const long long MAXN = 1e6 + 10;
const long long mod = 1e9 + 7;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, x;
long long maxx = -1;
cin >> n >> x;
long long ans = 1e10;
for (long long i = 0; i < n; i++) {
long long now;
cin >> now;
if (now > x) {
ans = min(ans, (long long)2);
} else if (x % now == 0) {
ans = min(ans, x / now);
} else {
ans = min(ans, x / now + 1);
}
}
cout << ans << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 1000005;
long long n, m, cnt[maxn], a, b, res;
int main() {
scanf("%lld%lld", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%lld%lld", &a, &b);
++cnt[a];
++cnt[b];
}
if (n <= 2)
puts("0");
else {
for (int i = 1; i <= n; ++i) res += cnt[i] * (n - 1 - cnt[i]);
printf("%lld\n", n * (n - 1) * (n - 2) / 3 / 2 - res / 2);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:10240000000,10240000000")
char ch;
int bo;
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline void rd(int &x) {
x = bo = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') bo = 1;
for (; ch >= '0' && ch <= '9';
x = (x << 1) + (x << 3) + ch - '0', ch = getchar())
;
if (bo) x = -x;
}
inline void RD(long long &x) {
x = bo = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') bo = 1;
for (; ch >= '0' && ch <= '9';
x = (x << 1) + (x << 3) + ch - '0', ch = getchar())
;
if (bo) x = -x;
}
inline long long RD() {
long long x;
RD(x);
return x;
}
inline int rd() {
int x;
rd(x);
return x;
}
inline void RD(char *s) {
for (ch = getchar(); blank(ch); ch = getchar())
;
for (; !blank(ch); ch = getchar()) *s++ = ch;
*s = 0;
}
inline void RD(char &c) {
for (ch = getchar(); blank(c); ch = getchar())
;
}
inline void RD(double &x) { scanf("%lf", &x); }
template <class T>
inline void OT(T x) {
static char buf[20];
char *p1 = buf;
if (!x) *p1++ = '0';
if (x < 0) putchar('-'), x = -x;
while (x) *p1++ = x % 10 + '0', x /= 10;
while (p1-- != buf) putchar(*p1);
}
const int maxn = 128;
int main() {
int n = rd();
int od = 0;
for (int i = 0; i < n; i++) {
int t = rd();
if (t % 2) od++;
}
int ev = n - od;
int ans = 0;
if (od <= ev)
ans = od;
else
ans = ev + int((od - ev) / 3);
OT(ans), puts("");
;
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
bool dbg = 0;
clock_t start_time = clock();
void bad(string mes = "Impossible") {
cout << mes;
exit(0);
}
void bad(int mes) {
cout << mes;
exit(0);
}
template <typename T>
string bin(T x, int st = 2) {
string ans = "";
while (x > 0) {
ans += char('0' + x % st);
x /= st;
}
reverse(ans.begin(), ans.end());
return ans.empty() ? "0" : ans;
}
template <typename T>
void upmax(T& x, T y) {
x = max(x, y);
}
template <typename T>
void upmin(T& x, T y) {
x = min(x, y);
}
template <typename T>
T input() {
T ans = 0, m = 1;
char c = ' ';
while (!((c >= '0' && c <= '9') || c == '-')) {
c = getchar();
}
if (c == '-') m = -1, c = getchar();
while (c >= '0' && c <= '9') {
ans = ans * 10 + (c - '0'), c = getchar();
}
return ans * m;
}
template <typename T>
void read(T& a) {
a = input<T>();
}
template <typename T>
void read(T& a, T& b) {
read(a), read(b);
}
template <typename T>
void read(T& a, T& b, T& c) {
read(a, b), read(c);
}
template <typename T>
void read(T& a, T& b, T& c, T& d) {
read(a, b), read(c, d);
}
const int inf = 2e9 + 20;
const short short_inf = 3e4 + 20;
const long double eps = 1e-6;
const int maxn = (int)3e5 + 12;
const long long llinf = 2e18 + 5;
const double PI = acos(-1.0);
const int mod = 998244353;
template <typename T>
T binpow(T n, T second) {
if (second <= 0) return 1LL;
if (second % 2 == 0) {
T b = binpow(n, second / 2);
return (1LL * b * b) % mod;
} else {
return (1LL * binpow(n, second - 1) * n) % mod;
}
}
int a[85][85];
vector<int> path;
int n, k;
long long ans = llinf;
bool ban[85];
vector<pair<int, int>> srt[80][80];
void solve() {
for (int i = 0; i < path.size(); i++) {
ban[path[i]] = 1;
}
long long res = 0;
for (int i = 0; i + 1 < path.size(); i++) {
int u = path[i];
int v = path[i + 1];
for (int k = 0; k < srt[u][v].size(); k++) {
int t = srt[u][v][k].second;
if (ban[t]) {
continue;
}
res += srt[u][v][k].first;
break;
}
}
ans = min(ans, res);
for (int i = 0; i < path.size(); i++) {
ban[path[i]] = 0;
}
}
void dfs(int pos) {
if (pos == k) {
path.push_back(0);
solve();
path.pop_back();
return;
}
for (int j = 0; j < n; j++) {
path.push_back(j);
dfs(pos + 2);
path.pop_back();
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
srt[i][j].push_back(make_pair(a[i][k] + a[k][j], k));
}
sort((srt[i][j]).begin(), (srt[i][j]).end());
}
path.push_back(0);
dfs(2);
cout << ans;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
bool visi[100001];
int main() {
int n, k;
cin >> n >> k;
int a = 1, b = n;
bool change = false;
for (int i = 0; i < k; i++)
if (!change) {
change = true;
visi[a] = true;
cout << a << " ";
a++;
} else {
change = false;
visi[b] = true;
cout << b << " ";
b--;
}
if (k % 2 == 0) {
for (int i = n; i > 0; i--)
if (!visi[i]) cout << i << " ";
} else
for (int i = 1; i <= n; i++)
if (!visi[i]) cout << i << " ";
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9, P = 1e9 + 7;
int n, f[N], x[N], y[N], h[N], t, er[N], size[N], ans = 1;
bool s[N];
int find(int x) {
while (x != f[x]) x = f[x] = f[f[x]];
return x;
}
int main() {
scanf("%d", &n);
er[0] = 1;
for (int i = 1; i <= (n << 1); ++i) er[i] = er[i - 1] * 2 % P;
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &x[i], &y[i]);
h[++t] = x[i] - 1e9 - 1;
h[++t] = y[i] + 1e9;
}
sort(h + 1, h + t + 1);
t = unique(h + 1, h + t + 1) - h - 1;
for (int i = t; i; --i) f[i] = i, size[i] = 1;
for (int i = 1, x, y; i <= n; ++i) {
x = find(::x[i] = lower_bound(h + 1, h + t + 1, ::x[i] - 1e9 - 1) - h);
y = find(::y[i] = lower_bound(h + 1, h + t + 1, ::y[i] + 1e9) - h);
if (x == y)
s[x] = 1;
else
f[x] = y, s[y] |= s[x], size[y] += size[x];
}
for (int i = 1, ret; i <= t; ++i)
if (f[i] == i) {
ret = er[size[i]];
if (!s[i]) ret -= 1;
ans = 1ll * ans * ret % P;
}
printf("%d\n", ans);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
vector<int> mp[150000];
int vis[150000];
int dp[150000];
int fa[150000];
int Id[150000];
int F[150000];
int n, m, d;
void Dfs(int u, int from) {
if (vis[u] == 1) dp[u] = 0;
int maxn = -0x3f3f3f3f;
for (int i = 0; i < mp[u].size(); i++) {
int v = mp[u][i];
if (v == from) continue;
Dfs(v, u);
if (dp[v] != -1) dp[u] = max(dp[v] + 1, dp[u]);
if (maxn < dp[v]) {
maxn = dp[v];
Id[u] = v;
}
}
}
void dfs(int u, int from) {
fa[u] = from;
if (vis[u] == 1) F[u] = 0;
if (from != -1 && F[from] != -1) F[u] = max(F[u], F[from] + 1);
if (from != -1 && Id[from] == u) {
for (int i = 0; i < mp[from].size(); i++) {
int v = mp[from][i];
if (v == from) continue;
if (v == u) continue;
if (from != -1 && v == fa[from]) continue;
if (dp[v] != -1) F[u] = max(F[u], dp[v] + 2);
}
} else {
if (from != -1 && dp[Id[from]] != -1) F[u] = max(F[u], dp[Id[from]] + 2);
}
for (int i = 0; i < mp[u].size(); i++) {
int v = mp[u][i];
if (v == from)
continue;
else
dfs(v, u);
}
}
int main() {
while (~scanf("%d%d%d", &n, &m, &d)) {
memset(F, -1, sizeof(F));
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) mp[i].clear();
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
vis[x] = 1;
}
for (int i = 2; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
mp[x].push_back(y);
mp[y].push_back(x);
}
Dfs(1, -1);
dfs(1, -1);
int output = 0;
for (int i = 1; i <= n; i++) {
int dis = max(F[i], dp[i]);
if (dis <= d) output++;
}
printf("%d\n", output);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
inline long long max_(long long a, long long b) { return (a > b) ? a : b; }
inline long long min_(long long a, long long b) { return (a < b) ? a : b; }
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("inp.txt", "r")) {
freopen("inp.txt", "r", stdin);
freopen("outp.txt", "w", stdout);
}
long long i, j, x, t, a, b, da, db;
cin >> x >> t >> a >> b >> da >> db;
if (x == 0) {
cout << "YES";
return 0;
}
for (i = 0; i < t; i++)
if ((a - i * da) == x) {
cout << "YES";
return 0;
}
for (i = 0; i < t; i++)
if ((b - i * db) == x) {
cout << "YES";
return 0;
}
for (i = 0; i < t; i++)
for (j = 0; j < t; j++) {
if ((a - i * da + b - j * db) == x) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void data() {}
const long long N = 2e5 + 200, mod = 1e9 + 7;
int n, x, timer;
vector<int> leaf, g[N];
int up[N][25], tin[N], tout[N], dp[N], dp2[N];
void dfs(int v, int p) {
tin[v] = ++timer;
up[v][0] = p;
for (int i = 1; i <= 20; i++) {
up[v][i] = up[up[v][i - 1]][i - 1];
}
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (p == to) {
continue;
}
dfs(to, v);
}
tout[v] = ++timer;
;
}
bool upper(int a, int b) { return (tin[a] <= tin[b] && tout[b] <= tout[a]); }
int lca(int a, int b) {
if (upper(a, b)) {
return a;
}
if (upper(b, a)) {
return b;
}
for (int i = 20; i >= 0; i--) {
if (up[a][i] && !upper(up[a][i], b)) {
a = up[a][i];
}
}
return up[a][0];
}
void dfs2(int v, int p) {
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) {
continue;
}
dfs2(to, v);
}
if (g[v].size() == 1 && p != 0) {
leaf.push_back(v);
}
}
void dfs3(int v, int p) {
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) {
continue;
}
dp[to] = dp[v] + 1;
dfs3(to, v);
}
}
void dfs4(int v, int p) {
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) {
continue;
}
dp2[to] = dp2[v] + 1;
dfs4(to, v);
}
}
int main() {
data();
cin >> n >> x;
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
dfs2(1, 0);
dfs3(1, 0);
dfs4(x, -1);
int ans = 0;
for (int i = 0; i < leaf.size(); i++) {
int v = lca(x, leaf[i]);
if (dp[v] <= dp2[v]) {
continue;
}
int k = max(dp2[leaf[i]], dp[leaf[i]]) - min(dp[leaf[i]], dp2[leaf[i]]);
int q = k * 2 + dp2[leaf[i]] + (dp[leaf[i]] - k);
ans = max(ans, q);
}
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int g[10001];
inline void fail() {
printf("No solution\n");
exit(0);
}
inline int change(int a, int b) {
int res = 0;
for (int i = 0; i < 4; ++i) {
res += (a % 10 != b % 10);
a /= 10, b /= 10;
}
return res;
}
int main() {
scanf("%d", &n);
g[0] = 1000;
for (int i = 1; i <= n; ++i) {
scanf("%d", &g[i]);
bool bo = 0;
for (int j = 1000; j <= 2011; ++j)
if (change(g[i], j) <= 1 && j >= g[i - 1]) {
bo = 1;
g[i] = j;
break;
}
if (!bo) fail();
}
for (int i = 1; i <= n; ++i) printf("%d\n", g[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char z[1000005];
long long k, len, ind;
vector<long long> vis, c;
string str;
void pf(long long, long long);
string lcs2(string, string, long long, long long);
long long bfs(vector<long long>[], long long, long long);
void solve() {
long long n, i, j, x, y1, y, l = 1, b, m = 0, c = 0, d = 0;
string s;
cin >> s;
n = s.size();
map<long long, long long> p;
for (long long int i = 0; i < n; i++) {
if (((long long)s[i] - 48) % 3 != 0) {
d = d + (long long)s[i] - 48;
if ((d % 3 == 0) || (p[d % 3] > 0)) {
c++;
d = 0;
p.clear();
} else {
p[d % 3] = 1;
}
} else {
c++;
d = 0;
p.clear();
}
}
cout << c;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
solve();
cout << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w = 0;
string s1, s2;
map<char, char> m;
cin >> s1 >> s2;
for (int i = 0; i < s1.size(); i++) {
if (m[s1[i]] != s2[i] && m[s1[i]] != 0) {
cout << -1 << endl;
return 0;
}
if (m[s2[i]] != s1[i] && m[s2[i]] != 0) {
cout << -1 << endl;
return 0;
}
m[s1[i]] = s2[i];
m[s2[i]] = s1[i];
}
for (char i = 'a'; i <= 'z'; i++) {
if (m[i] != 0 && m[i] != i) {
w++;
m[m[i]] = 0;
}
}
cout << w << endl;
for (char i = 'a'; i <= 'z'; i++) {
if (m[i] != 0 && m[i] != i) {
cout << i << ' ' << m[i] << endl;
}
}
return 0;
}
| 7 |
Subsets and Splits