solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int M = N;
const int inf = 1e9 + 9;
const long long base = 1e18;
const double pi = acos(-1);
const double ep = 1e-9;
int a[N];
vector<pair<int, int> > b;
int n;
bool check(int x) {
while (x > 0) {
int r = x % 10;
if (r != 4 && r != 7) return false;
x /= 10;
}
return true;
}
map<int, int> pos;
int id[N];
vector<pair<int, int> > ans;
void myswap(int i, int j) {
if (i == j) return;
ans.push_back(make_pair(pos[i], pos[j]));
int tmp = pos[i];
pos[i] = pos[j];
pos[j] = tmp;
id[pos[i]] = i;
id[pos[j]] = j;
}
int main() {
cin >> n;
int last = -1;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
if (check(a[i])) last = i;
b.push_back(make_pair(a[i], i));
pos[i] = i;
id[i] = i;
}
bool kt = true;
for (int i = 1; i < n; i++)
if (a[i] < a[i - 1]) {
kt = false;
break;
}
if (kt) {
cout << 0;
return 0;
}
if (last == -1) {
cout << -1;
return 0;
}
sort(b.begin(), b.end());
int cur = last;
for (int i = 0; i < n; i++) {
int j = pos[b[i].second];
if (j == i) continue;
myswap(last, id[i]);
myswap(last, b[i].second);
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
}
}
| 6 |
#include <bits/stdc++.h>
#include <chrono>
#include <math.h>
using namespace std;
#pragma GCC optimize("-O3")
#define endl "\n"
#define mp make_pair
#define st first
#define nd second
#define pii pair<int, int>
#define pb push_back
#define _upgrade ios_base::sync_with_stdio(0), cout.setf(ios::fixed), cout.precision(10), cin.tie(0), cout.tie(0);
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FWD(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define fwd(i, a, b) for (int i = (a); i < (b); ++i)
#define all(c) (c).begin(), (c).end()
#define sz(X) (int)((X).size())
#define what(x) cerr << #x << " is " << x << endl;
ostream &operator<<(ostream &out, string str) {
for (char c : str)
out << c;
return out;
}
template <class L, class R> ostream &operator<<(ostream &out, pair<L, R> p) { return out << "(" << p.st << ", " << p.nd << ")"; }
template <class T> auto operator<<(ostream &out, T a) -> decltype(a.begin(), out) {
out << '{';
for (auto it = a.begin(); it != a.end(); it = next(it))
out << (it != a.begin() ? ", " : "") << *it;
return out << '}';
}
void dump() { cerr << "\n"; }
template <class T, class... Ts> void dump(T a, Ts... x) {
cerr << a << ", ";
dump(x...);
}
#define debug(...) cerr << "[" #__VA_ARGS__ "]: ", dump(__VA_ARGS__)
//#define int long long
bool check(vector<int> &S, int s, int t) {
for (int i = s - 1; i >= 0; i--) {
if (S[i] > t)
return false;
t--;
}
return true;
}
int32_t main() {
_upgrade;
int Z;
cin >> Z;
while (Z--) {
int n, m, a, b;
cin >> n >> m >> a >> b;
if (a > b) {
a = n - a + 1;
b = n - b + 1;
}
int k = b - a - 1;
int t = b - 2;
debug(k, t);
vector<int> S(m);
rep(i, m) cin >> S[i];
sort(all(S));
int p = 0;
int q = min(k, m);
while (p != q) {
int s = (p + q + 1) / 2;
if (check(S, s, t))
p = s;
else {
q = s - 1;
}
}
cout << p << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5, MaxStep = 30;
const int maxnode = maxn * MaxStep * 4;
int tot = 0, rot[maxn + 5];
int nx[maxnode + 5][2], cnt[maxnode + 5];
int Upd(int px, int vv, int pp, int del) {
int x = ++tot;
nx[x][0] = nx[px][0], nx[x][1] = nx[px][1], cnt[x] = cnt[px] + del;
if (pp < 0) return x;
int t = vv >> pp & 1;
nx[x][t] = Upd(nx[px][t], vv, pp - 1, del);
return x;
}
int Query(int x, int vv, int pp) {
if (pp < 0) return 0;
int t = vv >> pp & 1, rem = 0;
if (t) rem += cnt[nx[x][0]];
rem += Query(nx[x][t], vv, pp - 1);
return rem;
}
int tot2 = 0, rot2[maxn + 5];
int nx2[maxnode + 5][2], col[maxnode + 5];
int Upd2(int px, int vv, int pp, int ccc) {
int x = ++tot2;
nx2[x][0] = nx2[px][0], nx2[x][1] = nx2[px][1];
if (pp < 0) {
col[x] = ccc;
return x;
}
int t = vv >> pp & 1;
nx2[x][t] = Upd2(nx2[px][t], vv, pp - 1, ccc);
return x;
}
int Query2(int x, int vv, int pp) {
if (pp < 0) return col[x];
int t = vv >> pp & 1;
if (nx2[x][t]) return Query2(nx2[x][t], vv, pp - 1);
return 0;
}
map<string, int> Id;
int GetId(char *buf) {
static int iid = 0;
string str(buf);
if (Id.find(str) == Id.end()) Id[str] = iid++;
return Id[str];
}
int main() {
int T, id, x, dd;
char ord[10], buf[30];
scanf("%d", &T);
for (int t = 1; t <= T; ++t) {
scanf("%s", ord);
if (ord[0] == 's') {
scanf("%s%d", buf, &x);
id = GetId(buf);
int be = Query2(rot2[t - 1], id, MaxStep - 1), rt = rot[t - 1];
if (be) rt = Upd(rt, be, MaxStep - 1, -1);
rot[t] = Upd(rt, x, MaxStep - 1, 1);
rot2[t] = Upd2(rot2[t - 1], id, MaxStep - 1, x);
} else if (ord[0] == 'r') {
scanf("%s", buf);
id = GetId(buf);
int be = Query2(rot2[t - 1], id, MaxStep - 1);
if (be) {
rot[t] = Upd(rot[t - 1], be, MaxStep - 1, -1);
rot2[t] = Upd2(rot2[t - 1], id, MaxStep - 1, 0);
} else
rot[t] = rot[t - 1], rot2[t] = rot2[t - 1];
} else if (ord[0] == 'q') {
rot[t] = rot[t - 1], rot2[t] = rot2[t - 1];
scanf("%s", buf);
id = GetId(buf);
int be = Query2(rot2[t - 1], id, MaxStep - 1);
printf("%d\n", be ? Query(rot[t - 1], be, MaxStep - 1) : -1);
fflush(stdout);
} else {
scanf("%d", &dd);
rot[t] = rot[t - dd - 1], rot2[t] = rot2[t - dd - 1];
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 7 + 2000;
char str[MAX_N];
char des[MAX_N];
int main() {
scanf(" %s", str);
int strn = strlen(str);
scanf(" %s", des);
int desn = strlen(des);
int ans = 0;
for (int i = (0); i < (strn); i++) {
int tmp = 0;
for (int j = (0); j < (desn); j++) {
if (i + j >= strn) break;
tmp += str[i + j] == des[j];
}
ans = max(ans, tmp);
}
for (int i = (0); i < (desn); i++) {
int tmp = 0;
for (int j = (0); j < (strn); j++) {
if (i + j >= desn) break;
tmp += des[i + j] == str[j];
}
ans = max(ans, tmp);
}
printf("%d", desn - ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
int main() {
int n, m, i, j, a, b;
cin >> n >> m >> i >> j >> a >> b;
int r1[] = {1, n};
int c1[] = {1, m};
int res = 100000000;
for (int ii = 0; ii < (int)2; ii++) {
for (int jj = 0; jj < (int)2; jj++) {
int r = r1[ii];
int c = c1[jj];
if (abs(i - r) % a == 0 && abs(j - c) % b == 0 &&
abs(i - r) / a % 2 == abs(j - c) / b % 2) {
int movr = abs(i - r) / a;
int movc = abs(j - c) / b;
if (movr == 0 && movc > 0 && i + a > n && i - a < 1) continue;
if (movc == 0 && movr > 0 && j + b > m && j - b < 1) continue;
res = min(res, max(abs(i - r) / a, abs(j - c) / b));
}
}
}
if (res == 100000000)
cout << "Poor Inna and pony!" << endl;
else
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double p[110];
void lemon() {
int n;
scanf("%d", &n);
for (int i = (0); i <= (n); i++) scanf("%lf", &p[i]);
double final = 0;
for (int i = (0); i <= (n / 2); i++) {
if (i * 2 == n)
final = max(final, p[i]);
else
for (int j = (i + 1); j <= (n); j++) {
int x = 2 * j - n, y = n - 2 * i;
if (x < 0) continue;
final = max(final, (x * p[i] + y * p[j]) / (x + y));
}
}
printf("%.16lf\n", final);
}
int main() {
ios::sync_with_stdio(true);
lemon();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long a[200005], b[200005];
int main() {
long long n;
scanf("%lld", &n);
vector<long long> va;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
long long tmp = (abs(i - 1) + 1) * (abs(i - n) + 1);
va.push_back(a[i] * tmp);
}
vector<long long> vb;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &b[i]);
vb.push_back(b[i]);
}
sort(va.begin(), va.end());
sort(vb.begin(), vb.end());
reverse(vb.begin(), vb.end());
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long tmp = ((va[i] % mod) * (vb[i] % mod)) % mod;
ans = ((ans % mod) + (tmp % mod)) % mod;
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, maxn = 1005;
int n, m, x[maxn], y[maxn], row[maxn], col[maxn];
char s[maxn][maxn];
int C(int n) { return n * (n - 1) / 2; }
long long Solve(int x, int y) {
return (long long)m * (C(x) + C(n - x + 1)) +
(long long)n * (C(y) + C(m - y + 1));
}
int main() {
while (~scanf("%d%d", &n, &m)) {
int res = 0;
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; j++)
if (s[i][j] == 'X') row[i] = j, col[j] = i, x[res] = i, y[res++] = j;
}
long long sum0 = 0, sum1 = 0, sum2 = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) sum0 += Solve(i, j);
for (int i = 0; i < res; i++)
for (int j = 0; j < res; j++) sum1 += abs(x[j] - x[i]) + abs(y[j] - y[i]);
for (int i = 0; i < res; i++) sum2 += Solve(x[i], y[i]);
sum2 = 2ll * sum2 - sum1;
sum0 -= sum2;
for (int i = 1; i <= n; i++)
if (row[i]) {
sum0 += 4ll * (row[i] - 1) * (m - row[i]);
for (int j = i - 1; j >= 1; j--)
if (!row[j] || row[j] < row[j + 1])
break;
else
sum0 += 4ll * (row[i] - 1) * (m - row[j]);
for (int j = i + 1; j <= n; j++)
if (!row[j] || row[j] < row[j - 1])
break;
else
sum0 += 4ll * (row[i] - 1) * (m - row[j]);
}
for (int i = 1; i <= m; i++)
if (col[i]) {
sum0 += 4ll * (col[i] - 1) * (n - col[i]);
for (int j = i - 1; j >= 1; j--)
if (!col[j] || col[j] < col[j + 1])
break;
else
sum0 += 4ll * (col[i] - 1) * (n - col[j]);
for (int j = i + 1; j <= m; j++)
if (!col[j] || col[j] < col[j - 1])
break;
else
sum0 += 4ll * (col[i] - 1) * (n - col[j]);
}
double temp = 1.0 * (n * m - res) * (n * m - res);
printf("%.10f\n", 1.0 * sum0 / temp);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, i, j, k, a, c, ans[500];
while (cin >> m >> n) {
for (i = 0; i < 500; i++) ans[i] = 0;
for (i = 1; i <= n; i++) {
c = -1;
for (j = 1; j <= m; j++) {
scanf("%d", &a);
if (a > c) {
c = a;
k = j;
}
}
ans[k]++;
}
int ma = -1, p;
for (i = 1; i < 300; i++) {
if (ans[i] > ma) {
ma = ans[i];
p = i;
}
}
printf("%d\n", p);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int get_random() {
static uniform_int_distribution<int> dist(0, 1e9 + 6);
return dist(rng);
}
template <class T>
void make_unique(T& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
int geti() {
int x;
cin >> x;
return x;
}
long long getll() {
long long x;
cin >> x;
return x;
}
double getd() {
double x;
cin >> x;
return x;
}
const int MAXN = 3e5 + 100;
void solve(int tt) {}
struct Trie {
struct Node {
array<int, 26> nxt;
array<int, 26> tran;
int cnt;
int pr;
char pch;
int link;
int link2;
};
vector<Node> data;
int head = 1, tot = 1;
int __alloc(int extra = 10) {
if (data.size() <= tot + 1) data.resize(data.size() * 2 + extra);
data[++tot] = Node();
return tot;
}
Node& operator[](int idx) { return data[idx]; }
void init(int extra = 10) {
tot = 0;
head = __alloc(extra);
}
int find(const string& s, const bool alloc = false) {
int pos = head;
for (int i = 0; i < s.size(); i++) {
;
;
if (data[pos].nxt[s[i] - 'a']) {
pos = data[pos].nxt[s[i] - 'a'];
;
;
;
;
} else if (alloc) {
int tmp = __alloc();
data[tmp].pr = pos;
data[tmp].pch = s[i];
pos = data[pos].nxt[s[i] - 'a'] = tmp;
;
;
} else
return 0;
}
return pos;
}
int insert(const string& s) {
int pos = find(s, true);
data[pos].cnt++;
return pos;
}
int count(const string& s) {
int pos = find(s, false);
return data[pos].cnt;
}
bool prefix(const string& s) {
int pos = find(s, false);
return pos > 0;
}
int get_tran(int pos, char ch) {
;
;
int c = ch - 'a';
if (!data[pos].tran[c]) {
if (data[pos].nxt[c])
data[pos].tran[c] = data[pos].nxt[c];
else
data[pos].tran[c] = (pos == head ? head : get_tran(get_link(pos), ch));
};
;
return data[pos].tran[c];
}
int get_link(int pos) {
if (!data[pos].link) {
if (pos == head || data[pos].pr == head) {
;
;
data[pos].link = head;
} else {
;
;
data[pos].link = get_tran(get_link(data[pos].pr), data[pos].pch);
}
}
return data[pos].link;
}
int get_link2(int pos) {
if (pos == head) return -1;
;
;
if (!data[pos].link2) {
int pre = get_link(pos);
;
;
if (data[pre].cnt)
data[pos].link2 = pre;
else
data[pos].link2 = get_link2(pre);
}
return data[pos].link2;
}
vector<string> get_all() {
string cur;
vector<string> res;
function<void(int)> dfs = [&](int pos) {
for (int i = 0; i < data[pos].cnt; i++) res.push_back(cur);
for (int j = 0; j < 26; j++) {
if (data[pos].nxt[j]) {
cur.push_back('a' + j);
dfs(data[pos].nxt[j]);
cur.pop_back();
}
}
};
dfs(1);
return res;
}
};
string s[MAXN];
int idx[MAXN] = {};
int val[MAXN] = {};
multiset<int> vals[MAXN];
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
Trie trie;
trie.init(MAXN);
int n, q;
cin >> n >> q;
for (auto i = (1); i < (n + 1); i++) {
cin >> s[i];
idx[i] = trie.insert(s[i]);
vals[idx[i]].insert(0);
;
;
}
int x, y, inst;
string sq;
for (auto i = (0); i < (q); i++) {
cin >> inst;
if (inst == 1) {
;
;
cin >> x >> y;
int pos = idx[x];
vals[pos].erase(vals[pos].find(val[x]));
vals[pos].insert(y);
val[x] = y;
;
;
} else {
cin >> sq;
;
;
int pos = 1;
int res = -1;
for (auto c : sq) {
pos = trie.get_tran(pos, c);
;
;
if (trie[pos].cnt) res = max(res, *prev(vals[pos].end()));
int tmp = trie.get_link2(pos);
;
;
;
;
while (tmp != -1) {
;
;
;
;
res = max(res, *prev(vals[tmp].end()));
tmp = trie.get_link2(tmp);
}
}
cout << res << endl;
;
;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
int n;
bool flag[N];
string s;
pair<int, int> point[N];
vector<int> rez;
bool ccw(pair<int, int> o, pair<int, int> a, pair<int, int> b) {
long long u1 = a.first - o.first, v1 = a.second - o.second;
long long u2 = b.first - a.first, v2 = b.second - a.second;
if (u1 * v2 - u2 * v1 == 0) return (b.first < a.first);
return (u1 * v2 - u2 * v1 > 0);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
int mn = 1;
for (int i = 1; i <= n; ++i) {
cin >> point[i].first >> point[i].second;
if (point[i].first < point[mn].first) mn = i;
}
cin >> s;
flag[mn] = true;
rez.push_back(mn);
for (auto &ch : s) {
int nxt = -1;
for (int i = 1; i <= n; ++i)
if (!flag[i]) {
if (nxt == -1) {
nxt = i;
continue;
}
if (ch == 'L') {
if (!ccw(point[rez.back()], point[nxt], point[i])) nxt = i;
} else if (ccw(point[rez.back()], point[nxt], point[i]))
nxt = i;
}
flag[nxt] = true;
rez.push_back(nxt);
}
for (int i = 1; i <= n; ++i)
if (!flag[i]) rez.push_back(i);
for (auto &first : rez) cout << first << ' ';
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
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 << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int n, m, ans[10005];
vector<int> G[10005];
string a[10005], b[10005];
map<string, int> mp;
bitset<10005> r[10005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i];
cin >> b[i];
if (!mp[a[i]]) {
n++;
mp[a[i]] = n;
}
if (!mp[b[i]]) {
n++;
mp[b[i]] = n;
}
G[mp[a[i]]].push_back(mp[b[i]]);
G[mp[b[i]]].push_back(mp[a[i]]);
r[mp[a[i]]][mp[b[i]]] = r[mp[b[i]]][mp[a[i]]] = 1;
}
for (int i = 1; i <= n; i++) {
int maxn = 0;
for (int j = 1; j <= n; j++) {
if (i == j || r[i][j]) continue;
int siz = G[i].size(), now = 0;
for (int k = 0; k < siz; k++)
if (r[G[i][k]][j]) now++;
if (now > maxn)
maxn = now, ans[i] = 1;
else if (now == maxn)
ans[i]++;
}
}
cout << n << endl;
for (int i = 1; i <= m; i++) {
if (mp[a[i]] != -1) {
cout << a[i] << " " << ans[mp[a[i]]] << endl;
mp[a[i]] = -1;
}
if (mp[b[i]] != -1) {
cout << b[i] << " " << ans[mp[b[i]]] << endl;
mp[b[i]] = -1;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int ans[201];
int b[100005];
int f[100005];
struct node {
int l;
int v;
int cnt;
} mp[100005];
bool cmp(node x, node y) { return x.l < y.l; }
int main(void) {
int sum = 1e8;
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> mp[i].l;
for (int i = 0; i < n; i++) cin >> mp[i].v;
sort(mp, mp + n, cmp);
for (int i = 0; i < n; i++) {
int cnt = 1, t = i;
while (mp[i].l == mp[i + 1].l) cnt++, i++;
mp[t].cnt = cnt;
}
f[0] = mp[0].v;
for (int i = 0; i < n; i++)
if (i >= 1) f[i] = f[i - 1] + mp[i].v;
for (int i = n - 1; i >= 0; i--) b[i] = b[i + 1] + mp[i].v;
for (int i = 0; i < n;) {
int cnt = mp[i].cnt - 1;
int s = b[i + mp[i].cnt];
int t = 0;
for (int j = 200; j >= 1; j--) {
if (ans[j] && cnt) {
if (ans[j] >= cnt) {
t += j * cnt;
break;
} else
t += j * ans[j], cnt -= ans[j];
}
}
s += f[i - 1] - t;
sum = min(sum, s);
for (int j = i; j < i + mp[i].cnt; j++) ans[mp[j].v]++;
i += mp[i].cnt;
}
cout << sum << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> a(n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int cntneg = 0;
int cntzero = 0;
vector<int> used(n);
int pos = -1;
for (int i = 0; i < n; ++i) {
if (a[i] == 0) {
used[i] = 1;
++cntzero;
}
if (a[i] < 0) {
++cntneg;
if (pos == -1 || abs(a[pos]) > abs(a[i])) pos = i;
}
}
if (cntneg & 1) used[pos] = 1;
if (cntzero == n || (cntzero == n - 1 && cntneg == 1)) {
for (int i = 0; i < n - 1; ++i) printf("1 %d %d\n", i + 1, i + 2);
return 0;
}
int lst = -1;
for (int i = 0; i < n; ++i) {
if (used[i]) {
if (lst != -1) printf("1 %d %d\n", lst + 1, i + 1);
lst = i;
}
}
if (lst != -1) printf("2 %d\n", lst + 1);
lst = -1;
for (int i = 0; i < n; ++i) {
if (!used[i]) {
if (lst != -1) printf("1 %d %d\n", lst + 1, i + 1);
lst = i;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MAXN = 2e5 + 10;
const int MAXB = 1 << 20;
typedef long long LL;
const LL NINF = std::numeric_limits<LL>::min();
typedef std::pair<int, LL> pi;
struct BIT {
int tr[MAXB];
LL sm[MAXB];
LL all;
void add(int x, int v) {
int d = x++ * v;
for (all += d; x < MAXB; x += x & -x)
tr[x] += v, sm[x] += d;
}
pi getsm(int x) {
x = std::min(x, MAXB - 2);
int fi = 0; LL se = 0;
for (++x; x; x &= x - 1)
fi += tr[x], se += sm[x];
return std::make_pair(fi, se);
}
int kth(int k) {
--k; int r = 0;
for (int i = 19, t; ~i; --i)
if ((t = r | 1 << i) < MAXB && tr[t] <= k)
k -= tr[r = t];
return r;
}
} bs[2];
int n, m;
int ma0, ma1, mi0, mi1;
LL qry0(int x) {
return bs[0].all - (LL) x * n;
}
LL qry1(int x) {
auto c = bs[1].getsm(std::max(x, 0) - 1);
return (bs[1].all - c.second) - (LL) (m - c.first) * x;
}
int A[2][MAXN];
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
int Q;
std::cin >> n >> m >> Q;
for (int i = 1; i <= n; ++i)
std::cin >> A[0][i], bs[0].add(A[0][i], 1);
for (int i = 1; i <= m; ++i)
std::cin >> A[1][i], bs[1].add(A[1][i], 1);
while (Q --> 0) {
int opt, x, y;
std::cin >> opt >> x;
if (opt <= 2) {
--opt;
std::cin >> y;
bs[opt].add(A[opt][x], -1);
bs[opt].add(A[opt][x] = y, 1);
} else {
ma0 = bs[0].kth(n), ma1 = bs[1].kth(m);
mi0 = bs[0].kth(1), mi1 = bs[1].kth(1);
LL ans = NINF;
int dd = std::min(mi0, mi1);
auto _solve = [x, dd] (int k, int b) {
if (k < 1) return NINF;
if (b == 0 && k > n) return NINF;
if (b == 1 && k > m) return NINF;
int fi = bs[b].kth(k) - x;
int dm = std::min(fi, dd);
LL r = qry0(dm) - qry1(fi);
if (!b) r += dm - fi;
return r;
};
auto solve = [_solve] (int k, int b) {
LL re = NINF;
for (int i = -1; i <= 1; ++i)
re = std::max(re, _solve(k + i, b));
return re;
};
// int sp0 = bs[0].getsm(dd + x).first;
int sp1 = bs[1].getsm(dd + x).first;
ans = std::max(ans, solve(1, 0));
ans = std::max(ans, solve(1, 1));
ans = std::max(ans, solve(n, 0));
ans = std::max(ans, solve(m, 1));
ans = std::max(ans, solve(bs[0].getsm(ma1 + x).first, 0));
ans = std::max(ans, solve(std::min(m - n, sp1), 1));
if (m - n - 1 > 0) {
int vx = bs[1].kth(m - n - 1);
ans = std::max(ans, solve(bs[0].getsm(vx + x).first, 0));
}
std::cout << ans << '\n';
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e18;
int cnt[1000];
double EE = 0.001;
int main() {
int n, m;
float k;
cin >> n >> m >> k;
map<string, int> mapp;
for (int i = 1; i <= n; i++) {
string s;
int x;
cin >> s >> x;
int kk = int((k + EE) * 100);
int b = int(kk * x / 100);
if (b >= 100) mapp[s] = b;
}
for (int i = 1; i <= m; i++) {
string s;
cin >> s;
if (mapp[s] < 100) mapp[s] = 0;
}
cout << mapp.size() << endl;
map<string, int>::iterator it;
for (it = mapp.begin(); it != mapp.end(); it++) {
cout << (*it).first << " " << (*it).second << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 100;
int a[maxn], b[maxn], n, m;
bool check(long double st) {
for (int i = 0; i < n; i++) {
long double now = st + m;
long double cost = now / a[i];
if (cost > st) return false;
st -= cost;
now = st + m;
cost = now / b[(i + 1) % n];
if (cost > st) return false;
st -= cost;
}
return true;
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
for (int i = 0; i < n; i++) {
scanf("%d", b + i);
}
long double l = 0, r = 2000000000;
while (r - l > 1e-6) {
long double mid = (l + r) / 2;
if (check(mid)) {
r = mid;
} else {
l = mid;
}
}
if (l > 1e9) {
puts("-1");
return 0;
}
if (check(l)) {
printf("%.9lf\n", (double)l);
} else if (check(r)) {
printf("%.9lf\n", (double)r);
} else {
puts("-1");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int inv = 1;
char c[100005];
scanf("%d", &n);
scanf("%s", c);
if (n == 1) {
printf("1");
return 0;
}
int p = 0;
for (int i = 0; i < n - 1; i++) {
inv += (c[i] != c[i + 1]);
p += (c[i] == c[i + 1]);
}
inv += max(2 * (p >= 2), 1 * (p >= 1));
printf("%d", max(inv, 2));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n + 1], t[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> t[i];
int init = 0;
for (int i = 1; i <= n; i++) {
if (t[i] == 1) {
init += a[i];
a[i] = 0;
}
}
int maxv = 0, cur = 0;
for (int i = 1; i <= k; i++) cur += a[i];
maxv = max(maxv, cur);
for (int i = 1; i < n - k + 1; i++) {
cur -= a[i];
cur += a[i + k];
maxv = max(maxv, cur);
}
cout << maxv + init;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
unsigned int dp[100100];
char s[100100];
int main() {
unsigned int n;
cin >> n;
if (n & 1) {
return !printf("0");
}
scanf("%s", s + 1);
int m = n / 2;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
if (s[i] == '?') {
for (int j = i / 2; j >= max(1, i - m); j--) dp[j] += dp[j - 1];
}
}
for (int i = 1; i <= n; i++) {
if (s[i] == '?') continue;
m--;
}
for (int i = 1; i <= m; i++) dp[n / 2] *= 25;
cout << dp[n / 2] << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int a[maxn], b[maxn];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int sum = 0;
for (int i = 1; i <= n - 1; i++) {
if (a[i] != a[i + 1]) sum++;
}
int i = 1;
while (i <= n) {
;
int now = i;
while ((a[i + 1] == a[i]) && (i < n)) i++;
if (a[now - 1] == a[i + 1])
b[a[i]] += 2;
else
b[a[i]]++;
;
;
;
;
;
;
i++;
}
int ans = 1;
for (int i = 1; i <= k; i++)
if (b[i] > b[ans]) ans = i;
;
for (int i = 1; i <= k; i++)
;
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int LEN = 1e6 + 1;
int ar[LEN];
int a, b, k;
bool check(int mid) {
int t = a;
while (t + mid - 1 <= b) {
if (ar[t + mid - 1] - ar[t - 1] < k) return false;
t++;
}
return true;
}
int main(void) {
int sum = 0;
ar[0] = 0;
ar[1] = 0;
for (int i = 2; i <= LEN; ++i) {
if (!ar[i]) {
for (int j = 2 * i; j <= LEN; j += i) {
if (!ar[j]) ar[j] = 1;
}
++sum;
}
ar[i] = sum;
}
cin >> a >> b >> k;
int left = k, right = b - a + 1;
if (right >= left) {
sum = ar[b] - ar[a - 1];
if (sum < k)
cout << -1 << endl;
else {
while (right > left) {
int mid = left + (right - left) / 2;
if (check(mid))
right = mid;
else
left = mid + 1;
}
cout << right << endl;
}
} else
cout << -1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long int;
using ull = unsigned long long int;
using dd = double;
using ldd = long double;
using si = short int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
ll get_seed(string s) {
ll ans = 0;
for (int i = 0; i < s.size(); ++i) ans += s[i];
return ans;
}
int _sex = 550;
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int n;
cin >> n;
vector<ll> arr(n);
for (int i = 0; i < n; ++i) cin >> arr[i];
int q;
cin >> q;
vector<ll> ans(q);
vector<vector<pair<int, int>>> ai(_sex);
for (int i = 0; i < q; ++i) {
int a, b;
cin >> a >> b;
--a;
if (b >= _sex) {
for (int yi = a; yi < n; yi += b) {
ans[i] += arr[yi];
}
continue;
}
ai[b].push_back({a, i});
}
vector<ll> sum(n);
for (int j = _sex - 1; j > 0; --j) {
if (ai[j].size() == 0) continue;
sort((ai[j]).begin(), (ai[j]).end());
for (int i = n - 1; i >= 0; --i) {
sum[i] = (i + j < n ? sum[i + j] : 0) + arr[i];
while (ai[j].back().first == i) {
ans[ai[j].back().second] = sum[i];
ai[j].pop_back();
if (ai[j].size() == 0) break;
}
}
}
for (auto i : ans) cout << i << " ";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int A[100010];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1, n, i, j;
cin >> n;
int cnt = 0;
for (i = 0; i < n; i++) {
cin >> A[i];
if (A[i] == 1) cnt++;
}
if (cnt) {
cout << n - cnt << "\n";
} else {
int cur = 0;
for (i = 0; i < n; i++) cur = gcd(cur, A[i]);
if (cur != 1) {
cout << "-1\n";
} else {
int mn = n;
for (i = 0; i < n; i++) {
cur = A[i];
for (int j = i + 1; j < n; j++) {
cur = gcd(cur, A[j]);
if (cur == 1) {
mn = min(mn, j - i);
break;
}
}
}
cout << mn + n - 1 << "\n";
}
}
return 0;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long double PI = acos(-1.0);
bool AreSame(long double a, long double b) { return fabs(a - b) < 1e-9; }
long long int power(long long int x, long long int y) {
long long int res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int ceil2(long long int a, long long int b) {
long long int c = a / b;
if (a % b) c++;
return c;
}
bool isPalindrome(string s) {
string t = s;
reverse(t.begin(), t.end());
return s == t;
}
void solve() {
long long int x, y, l, r;
cin >> x >> y >> l >> r;
long long int curr = 1;
set<long long int> s1, s2;
s1.insert(1);
s2.insert(1);
while (curr <= (long long int)1e18 / x) {
curr *= x;
s1.insert(curr);
}
curr = 1;
while (curr <= (long long int)1e18 / y) {
curr *= y;
s2.insert(curr);
};
;
vector<long long int> v;
map<long long int, long long int> mm;
v.push_back(l - 1);
v.push_back(r + 1);
for (auto it1 : s1) {
for (auto it2 : s2) {
if (it1 + it2 > it1 && it1 + it2 > it2 && it1 + it2 >= l &&
it1 + it2 <= r && mm[it1 + it2] == 0) {
v.push_back(it1 + it2);
mm[it1 + it2]++;
}
}
}
sort(v.begin(), v.end());
long long int res = -LLONG_MAX;
for (long long int i = 1; i < v.size(); i++) {
res = max(res, v[i] - v[i - 1] - 1);
}
cout << res << "\n";
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void scan(int &x) {
bool neg = false;
register int c;
x = 0;
c = getchar();
if (c == '-') {
neg = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) x = (x << 1) + (x << 3) + c - 48;
if (neg) x *= -1;
}
int f1 = 0;
vector<vector<int> > gr(10009);
void dfs(int a) {
int cnt = 0;
if (gr[a].size() == 0) cnt = 3;
for (int i : gr[a]) {
dfs(i);
if (gr[i].size() == 0) {
cnt++;
}
}
if (cnt < 3) f1 = 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int tmp;
cin >> tmp;
tmp--;
gr[tmp].push_back(i);
}
dfs(0);
if (f1 == 0)
cout << "Yes";
else
cout << "No";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000010;
const int MOD = 1000000007;
const int INF = 1e8;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const long double EPS = 1e-7;
int main() {
int n;
cin >> n;
map<int, int> ord;
map<int, int> m[n + 1];
vector<int> best(n + 1, n + 1), res(n + 1, n + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)n; j++) {
int pref;
cin >> pref;
m[i][pref] = j;
}
best[i] = n + 1;
m[i][n + 1] = n + 1;
}
for (int i = 0; i < (int)n; i++) {
int pref;
cin >> pref;
ord[pref] = i;
}
set<pair<int, int> > all;
for (int p = 1; p <= n; p++) {
all.insert(make_pair(ord[p], p));
int b = (*all.begin()).second;
for (int pessoa = 1; pessoa <= n; pessoa++) {
int foi = b;
if (foi == pessoa) {
if (all.size() > 1) {
int b2 = (*(next(all.begin()))).second;
foi = b2;
} else {
continue;
}
}
int cur = best[pessoa];
if (m[pessoa][foi] < m[pessoa][cur]) {
res[pessoa] = p;
best[pessoa] = foi;
}
}
}
for (int i = 1; i <= n; i++) cout << res[i] << " ";
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110000;
vector<pair<int, int>> adj[N], _adj[N];
long long sz[N];
int val[N];
int tt[N];
void dfs(int u, int p) {
tt[u] = 1;
for (auto it : adj[u]) {
if (it.first == p) continue;
_adj[u].push_back(it);
val[it.first] = it.second;
dfs(it.first, u);
tt[u] += tt[it.first];
sz[u] += sz[it.first] + it.second;
}
}
long long tot, cnt;
int vis = 0, n;
void DFS(int u, int p) {
for (auto it : _adj[u]) {
cnt += it.second;
tot += cnt;
vis++;
DFS(it.first, u);
if (vis != n - 1) cnt += it.second;
}
}
bool cmp(pair<int, int> u, pair<int, int> v) {
return sz[u.first] * tt[v.first] < sz[v.first] * tt[u.first];
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
adj[u].emplace_back(v, w);
adj[v].emplace_back(u, w);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) sz[i] += val[i];
for (int i = 0; i < N; i++) sort(_adj[i].begin(), _adj[i].end(), cmp);
DFS(1, 0);
cout << setprecision(20) << 1.0 * tot / (n - 1) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:20000000")
using namespace std;
const int SIZE = 128;
const int MAXN = 24;
const long long INF = 1000000000000000000LL;
int n, m;
int open[MAXN], close[MAXN];
long long block[SIZE][SIZE];
int s;
struct Matr {
long long a[SIZE][SIZE];
};
Matr graph;
Matr Mult(Matr a, Matr b) {
Matr res;
for (int i = 0; i < s; i++)
for (int j = 0; j < s; j++) {
long long ans = INF;
for (int u = 0; u < s; u++) ans = min(ans, a.a[i][u] + b.a[u][j]);
res.a[i][j] = ans;
}
return res;
}
Matr Identity() {
Matr res;
memset(&res, 63, sizeof(res));
for (int i = 0; i < s; i++) res.a[i][i] = 0;
return res;
}
Matr pwr(Matr a, int p) {
Matr res = Identity();
Matr x = a;
for (; p; p >>= 1) {
if (p & 1) res = Mult(res, x);
x = Mult(x, x);
}
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &open[i]);
for (int i = 0; i < n; i++) scanf("%d", &close[i]);
memset(block, 63, sizeof(block));
for (int mask = 0; mask < 1 << n; mask++) {
int bal = 0;
int minb = 0;
int cst = 0;
for (int i = 0; i < n; i++) {
if (mask & (1 << i)) {
bal++;
cst += open[i];
} else {
bal--;
minb = min(minb, bal);
cst += close[i];
}
}
auto& num = block[MAXN + bal][-minb];
if (num > cst) num = cst;
}
s = 3 * n + 1;
memset(&graph, 63, sizeof(graph));
for (int i = 0; i < s; i++)
for (int r = 0; r <= i; r++)
for (int b = -n; b <= n; b++) {
long long cst = block[MAXN + b][r];
if (cst > INF) continue;
auto& num = graph.a[i][i + b];
num = min(num, cst);
}
Matr trans = pwr(graph, m);
printf("%I64d\n", trans.a[0][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
const long long inf = 1100000000000000000;
void solve() {
long long n, q;
cin >> n >> q;
long long a[n];
long long x = 0, y = 1, cur = 2;
while (q--) {
long long t;
cin >> t;
if (t == 1) {
long long dis;
cin >> dis;
x = (x + dis + n) % n;
y = (y + dis + n) % n;
} else {
if (x % 2 == 0)
x++;
else
x--;
if (y % 2 == 0)
y++;
else
y--;
}
}
for (long long i = 0; i < n / 2; i++) a[y] = cur, y = (y + 2) % n, cur += 2;
cur = 1;
for (long long i = 0; i < n / 2; i++) a[x] = cur, x = (x + 2) % n, cur += 2;
for (long long i = 0; i < n; i++) cout << a[i] << " ";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long tc = 1;
while (tc--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int MOD = 10007;
struct Node {
long long g;
int num;
} a[105], b[105];
bool cmp(Node a, Node b) {
if (a.g == b.g) {
return a.num < b.num;
}
return a.g > b.g;
}
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
memset((a), 0, sizeof((a)));
for (int(i) = 0; (i) < (m); (i)++) {
memset((b), 0, sizeof((b)));
for (int(j) = 0; (j) < (n); (j)++) {
scanf("%I64d", &b[j].g);
b[j].num = j;
}
sort(b, b + n, cmp);
a[b[0].num].g++;
a[b[0].num].num = b[0].num;
}
sort(a, a + n, cmp);
printf("%d\n", a[0].num + 1);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
using posteriority_queue = priority_queue<T, vector<T>, greater<T> >;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-8;
const int MOD = 1000000007;
const int dy[] = {1, 0, -1, 0}, dx[] = {0, -1, 0, 1};
template <typename T, typename U>
inline bool chmax(T &a, U b) {
return a < b ? (a = b, true) : false;
}
template <typename T, typename U>
inline bool chmin(T &a, U b) {
return a > b ? (a = b, true) : false;
}
template <typename T>
void unique(vector<T> &a) {
a.erase(unique((a).begin(), (a).end()), a.end());
}
struct IOSetup {
IOSetup() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} iosetup;
template <typename MeetSemilattice>
struct SparseTable {
using Fn = function<MeetSemilattice(MeetSemilattice, MeetSemilattice)>;
SparseTable() {}
SparseTable(const vector<MeetSemilattice> &a, Fn fn,
MeetSemilattice UNITY = 0) {
init(a, fn);
}
void init(const vector<MeetSemilattice> &a, Fn fn_) {
fn = fn_;
int n = a.size(), table_h = 0;
lg.assign(n + 1, 0);
for (int i = (2); i < (n + 1); ++i) lg[i] = lg[i >> 1] + 1;
while ((1 << table_h) <= n) ++table_h;
dat.assign(table_h, vector<MeetSemilattice>(n));
for (int j = (0); j < (n); ++j) dat[0][j] = a[j];
for (int i = (1); i < (table_h); ++i)
for (int j = 0; j + (1 << i) <= n; ++j) {
dat[i][j] = fn(dat[i - 1][j], dat[i - 1][j + (1 << (i - 1))]);
}
}
MeetSemilattice query(int left, int right) {
assert(left < right);
int h = lg[right - left];
return fn(dat[h][left], dat[h][right - (1 << h)]);
}
private:
Fn fn;
vector<int> lg;
vector<vector<MeetSemilattice> > dat;
};
void solve(const vector<pair<pair<int, int>, pair<int, int> > > &ab) {
int n = ab.size();
vector<int> sb(n), eb(n);
for (int i = (0); i < (n); ++i) tie(sb[i], eb[i]) = ab[i].second;
SparseTable<int> mx(sb, [](int a, int b) { return max(a, b); }),
mn(eb, [](int a, int b) { return min(a, b); });
for (int i = (0); i < (n - 1); ++i) {
int a, b, c, d;
tie(a, b) = ab[i].first;
tie(c, d) = ab[i].second;
if (ab[i + 1].first.first > b) continue;
int idx =
lower_bound((ab).begin(), (ab).end(),
make_pair(make_pair(b + 1, -INF), make_pair(-INF, -INF))) -
ab.begin();
if (mx.query(i + 1, idx) > d || mn.query(i + 1, idx) < c) {
cout << "NO\n";
exit(0);
}
}
}
int main() {
int n;
cin >> n;
vector<pair<pair<int, int>, pair<int, int> > > ab(n);
for (int i = (0); i < (n); ++i) {
int sa, ea, sb, eb;
cin >> sa >> ea >> sb >> eb;
ab[i] = {{sa, ea}, {sb, eb}};
}
sort((ab).begin(), (ab).end());
solve(ab);
for (int i = (0); i < (n); ++i) swap(ab[i].first, ab[i].second);
sort((ab).begin(), (ab).end());
solve(ab);
cout << "YES\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
int scount(string a, char c) {
int r = 0;
for (int i = 0; i < a.length(); i++) {
if (a[i] == c) {
r++;
}
}
return r;
}
int seq(string a, string b, char c) {
int r = 0;
for (int i = 0; i < a.length(); i++) {
if (a[i] != c && b[i] == c) {
r++;
}
}
return r;
}
int main() {
cin >> a >> b;
int n = a.length();
int a4 = scount(a, '4'), b4 = scount(b, '4');
int a7 = n - a4, b7 = n - b4;
if (a4 < b4) {
int x = seq(a, b, '4');
int c = b4 - a4;
int rm = x - min(c, x);
cout << c + rm << endl;
} else {
int x = seq(a, b, '7');
int c = b7 - a7;
int rm = x - min(c, x);
cout << c + rm << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Maxv = 110;
int n, m;
int val[Maxv][Maxv * Maxv];
int org[Maxv][Maxv];
int dp[Maxv][Maxv * Maxv];
int Len[Maxv];
int main() {
int i, j, k;
cin >> n >> m;
for (i = 1; i <= n; i++) {
scanf("%d", &Len[i]);
for (j = 1; j <= Len[i]; j++) scanf("%d", &org[i][j]);
int sum1 = 0;
for (j = 0; j <= Len[i]; j++) {
int sum2 = 0;
sum1 += org[i][j];
for (k = Len[i] + 1; k > j; k--) {
sum2 += org[i][k];
int tcost = j + Len[i] + 1 - k;
val[i][tcost] = max(sum1 + sum2, val[i][tcost]);
}
}
for (k = m; k >= 1; k--) {
for (j = 0; j <= Len[i] && j <= k; j++) {
dp[i][k] = max(dp[i][k], dp[i - 1][k - j] + val[i][j]);
}
}
}
printf("%d\n", dp[n][m]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000001;
int dp[N] = {0, 5};
int f(int x) {
int ans = 0;
while (x) {
ans += x / 5;
x /= 5;
}
return ans;
}
int main(void) {
int m;
int tmp = 1;
int i;
for (i = 5; i <= 400005; i += 5) {
int tmp = f(i);
dp[tmp] = i;
}
while (cin >> m) {
if (!dp[m]) {
cout << 0 << endl;
continue;
}
cout << 5 << endl;
for (i = dp[m]; i < dp[m] + 5; i++) cout << i << ' ';
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m;
int fa[N][20], size[N], dep[N];
long long sum[N], s[N];
struct Edge {
int t, nxt;
} e[N << 1];
int head[N], cnt;
void add(int u, int v) {
e[++cnt].t = v;
e[cnt].nxt = head[u];
head[u] = cnt;
}
void get_tree(int x) {
dep[x] = dep[fa[x][0]] + 1;
size[x] = 1;
for (int i = 1; i <= 19; i++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = head[x]; i; i = e[i].nxt) {
int t = e[i].t;
if (t == fa[x][0]) continue;
fa[t][0] = x;
get_tree(t);
size[x] += size[t];
sum[x] += sum[t] + size[t];
}
}
void dfs(int x) {
for (int i = head[x]; i; i = e[i].nxt) {
int t = e[i].t;
if (t == fa[x][0]) continue;
s[t] = s[x] + sum[x] - sum[t] - size[t] + n - size[t];
dfs(t);
}
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 19; i >= 0; i--)
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
if (x == y) return x;
for (int i = 19; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
int find(int x, int y) {
for (int i = 19; i >= 0; i--)
if (dep[fa[fa[x][i]][0]] >= dep[y]) x = fa[x][i];
return x;
}
inline int Dis(int x, int y) { return dep[x] + dep[y] - (dep[LCA(x, y)] << 1); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
get_tree(1);
dfs(1);
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
double ans = 0;
if (dep[x] < dep[y]) swap(x, y);
if (lca == y) {
int w = find(x, y);
ans = dep[x] - dep[w] + 1.0 + 1.0 * sum[x] / size[x] +
1.0 * s[w] / (n - size[w]);
} else {
ans = 1.0 * sum[x] / size[x] + 1.0 * sum[y] / size[y] + Dis(x, y) + 1;
}
printf("%.8f\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int maxk = 25;
const int INF = 1 << 30;
int read() {
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
int x, tag;
if (ch == '-')
x = 0, tag = -1;
else
x = ch - '0', tag = 1;
ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * tag;
}
void writeln(int x) {
if (!x)
putchar('0');
else {
if (x < 0) putchar('-'), x = abs(x);
int ch[30], l = 0;
while (x) ch[l++] = x % 10, x /= 10;
while (l) putchar(ch[--l] + '0');
}
putchar('\n');
}
struct ans {
int p1, p2, p3, p4, l, r, all, sum;
void insert(int p, int v) {
l = r = all = sum = v;
p1 = p2 = p3 = p4 = p;
}
};
ans merge_max(ans x, ans y) {
ans c;
if (x.l > y.l + x.sum) {
c.l = x.l;
c.p1 = x.p1;
} else {
c.l = x.sum + y.l;
c.p1 = y.p1;
}
if (y.r > x.r + y.sum) {
c.r = y.r;
c.p2 = y.p2;
} else {
c.r = y.sum + x.r;
c.p2 = x.p2;
}
c.all = max(x.all, y.all);
c.all = max(c.all, x.r + y.l);
if (c.all == x.all)
c.p3 = x.p3, c.p4 = x.p4;
else {
if (c.all == y.all)
c.p3 = y.p3, c.p4 = y.p4;
else
c.p3 = x.p2, c.p4 = y.p1;
}
c.sum = x.sum + y.sum;
return c;
}
ans merge_min(ans x, ans y) {
ans c;
if (x.l < y.l + x.sum) {
c.l = x.l;
c.p1 = x.p1;
} else {
c.l = x.sum + y.l;
c.p1 = y.p1;
}
if (y.r < x.r + y.sum) {
c.r = y.r;
c.p2 = y.p2;
} else {
c.r = y.sum + x.r;
c.p2 = x.p2;
}
c.all = min(x.all, y.all);
c.all = min(c.all, x.r + y.l);
if (c.all == x.all)
c.p3 = x.p3, c.p4 = x.p4;
else {
if (c.all == y.all)
c.p3 = y.p3, c.p4 = y.p4;
else
c.p3 = x.p2, c.p4 = y.p1;
}
c.sum = x.sum + y.sum;
return c;
}
struct node {
int ch[2], l, r, sum;
bool tag;
ans v1, v2;
node() {
ch[0] = ch[1] = sum = 0;
v1.l = v1.r = v1.all = INF;
v2.l = v2.r = v2.all = -INF;
v1.sum = v2.sum = 0;
}
} z[maxn * 2];
int rt, treesize = 0;
int w[maxn];
void update(int a) {
z[a].sum = z[z[a].ch[0]].sum + z[z[a].ch[1]].sum;
z[a].v1 = merge_min(z[z[a].ch[0]].v1, z[z[a].ch[1]].v1);
z[a].v2 = merge_max(z[z[a].ch[0]].v2, z[z[a].ch[1]].v2);
}
void build(int &a, int l, int r) {
a = ++treesize;
z[a].l = l, z[a].r = r;
if (l == r) {
z[a].sum = w[l];
z[a].v1.insert(l, w[l]);
z[a].v2.insert(l, w[l]);
return;
}
int m = (l + r) >> 1;
build(z[a].ch[0], l, m);
build(z[a].ch[1], m + 1, r);
update(a);
}
void pushup(int a) {
if (z[a].l == z[a].r) {
z[a].v1.insert(z[a].l, -z[a].sum);
z[a].v2.insert(z[a].l, -z[a].sum);
z[a].sum *= -1;
return;
}
z[a].tag ^= 1;
swap(z[a].v1, z[a].v2);
z[a].v1.l *= -1;
z[a].v1.r *= -1;
z[a].v1.all *= -1;
z[a].v1.sum *= -1;
z[a].v2.l *= -1;
z[a].v2.r *= -1;
z[a].v2.all *= -1;
z[a].v2.sum *= -1;
z[a].sum *= -1;
}
void pushdown(int a) {
if (z[a].tag) {
z[a].tag = 0;
pushup(z[a].ch[0]);
pushup(z[a].ch[1]);
}
}
ans query(int a, int l, int r) {
if (z[a].l == l && z[a].r == r) return z[a].v2;
pushdown(a);
int m = (z[a].l + z[a].r) >> 1;
if (r <= m) return query(z[a].ch[0], l, r);
if (l > m) return query(z[a].ch[1], l, r);
return merge_max(query(z[a].ch[0], l, m), query(z[a].ch[1], m + 1, r));
}
void get_tag(int a, int l, int r) {
if (z[a].l == l && z[a].r == r) {
pushup(a);
return;
}
pushdown(a);
int m = (z[a].l + z[a].r) >> 1;
if (r <= m)
get_tag(z[a].ch[0], l, r);
else {
if (l > m)
get_tag(z[a].ch[1], l, r);
else
get_tag(z[a].ch[0], l, m), get_tag(z[a].ch[1], m + 1, r);
}
update(a);
}
void modify(int a, int p, int v) {
if (z[a].l == z[a].r) {
z[a].sum = v;
z[a].v1.insert(p, v);
z[a].v2.insert(p, v);
return;
}
int m = (z[a].l + z[a].r) >> 1;
if (p <= m)
modify(z[a].ch[0], p, v);
else
modify(z[a].ch[1], p, v);
update(a);
}
int mx[maxk][2];
void get_ans(int l, int r, int k) {
int tot = 0, len = 0;
ans cur;
for (int i = 0; i < k; ++i) {
cur = query(rt, l, r);
if (cur.all <= 0) break;
len = i + 1;
tot += cur.all;
get_tag(rt, cur.p3, cur.p4);
mx[i][0] = cur.p3;
mx[i][1] = cur.p4;
}
for (int i = 0; i < len; ++i) get_tag(rt, mx[i][0], mx[i][1]);
writeln(tot);
}
int main() {
int n, m;
n = read();
for (int i = 1; i <= n; ++i) w[i] = read();
build(rt, 1, n);
m = read();
int tag, x, y, z;
while (m--) {
tag = read(), x = read(), y = read();
if (tag == 1) {
z = read();
get_ans(x, y, z);
} else
modify(rt, x, y);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 50;
const int maxm = 5000000 + 1000;
const int maxt = 3000000 + 100;
const int maxk = 10 + 3;
const long long unit = 1LL;
const int INF = 0x3f3f3f3f;
const long long Inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-3;
const double inf = 1e15;
const double pi = acos(-1.0);
const long long mod = 1000000007LL;
inline long long read() {
long long x = 0;
bool t = false;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = true, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return t ? -x : x;
}
struct Edge {
long long u, v, w;
bool operator<(const Edge &a) const { return w < a.w; }
} edge[maxm];
long long n, tot;
long long x[maxn], y[maxn], c[maxn], k[maxn];
long long fa[maxn], ans[maxn][maxn];
long long findn(long long x) { return x == fa[x] ? x : fa[x] = findn(fa[x]); }
void Kruskal() {
long long res = 0;
sort(edge, edge + tot);
for (int i = 0; i <= n; ++i) fa[i] = i;
for (int i = 0; i < tot; ++i) {
long long fu = findn(edge[i].u), fv = findn(edge[i].v);
if (fu != fv) {
fa[fu] = fv;
res += edge[i].w;
ans[edge[i].u][edge[i].v] = ans[edge[i].v][edge[i].u] = 1;
}
}
cout << res << '\n';
long long cnt = 0;
for (int i = 1; i <= n; ++i)
if (ans[0][i]) ++cnt;
cout << cnt << '\n';
for (int i = 1; i <= n; ++i)
if (ans[0][i]) cout << i << ' ';
cout << '\n';
cnt = 0;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j)
if (ans[i][j]) ++cnt;
cout << cnt << '\n';
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j)
if (ans[i][j]) cout << i << ' ' << j << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> x[i] >> y[i];
tot = 0;
for (int i = 1; i <= n; ++i) cin >> c[i], edge[tot++] = (Edge){0, i, c[i]};
for (int i = 1; i <= n; ++i) cin >> k[i];
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j) {
long long tmp = abs(x[i] - x[j]) + abs(y[i] - y[j]);
edge[tot++] = (Edge){i, j, tmp * (k[i] + k[j])};
}
Kruskal();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long M = 1000000007;
long long power(long long a, long long b) {
long long res = 1;
while (b != 0) {
if (b & 1) {
res = (res * a) % M;
}
a = (a * a) % M;
b = b >> 1;
}
return res % M;
}
long long factorial(long long n) {
long long ans = 1;
for (long long i = 1; i <= n; i++) {
ans = (ans % M) * (i % M);
}
return ans % M;
}
long long ncr(long long n, long long r) {
long long fact_n = factorial(n);
long long fact_r = factorial(r);
long long fact_t = factorial(n - r);
long long inverse_r = power(fact_r, M - 2);
long long inverse_t = power(fact_t, M - 2);
long long ans = (((fact_n * inverse_r) % M) * inverse_t) % M;
return ans;
}
void solve() {
long long n, a, b, c, ans = 0, count = 0, sum = 0;
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 > x2 || y1 > y2) {
cout << 0 << endl;
return;
}
long long f = abs(x1 - x2);
long long g = abs(y1 - y2);
n = f + g - 2;
long long r = g - 1;
cout << f * g + 1 << endl;
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
long long q1 = 0;
long long q2 = 0;
for (long long i = 0; i < s.size(); i++)
if (s[i] == 'Q') q1++;
long long res = 0;
for (long long i = 0; i < s.size(); i++) {
if (s[i] == 'Q') {
q2++;
q1--;
} else if (s[i] == 'A') {
res += q1 * q2;
}
}
cout << res << endl;
}
signed main() {
long long T = 1;
while (T--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while ((c < '0' || c > '9') && (c != '-')) c = getchar();
if (c == '-') f = -1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
const int N = 250010;
int n;
set<int> dj;
set<pair<int, int>> e[N];
multiset<long long> s[N], s2[N];
long long f[N], g[N], s3[N];
inline void Erase(int x, long long y) {
if (s[x].find(y) != s[x].end())
s[x].erase(s[x].find(y)), s3[x] -= y;
else
s2[x].erase(s2[x].find(y));
}
bool vis[N];
inline void fix(int u, int k) {
while (((int)(s[u]).size()) < k && !s2[u].empty()) {
auto tmp = s2[u].rbegin();
s[u].insert(*tmp), s3[u] += *tmp, s2[u].erase(s2[u].find(*tmp));
}
while (((int)(s[u]).size()) > k) {
auto tmp = s[u].begin();
s2[u].insert(*tmp), s3[u] -= *tmp, s[u].erase(tmp);
}
if (k == 0) return;
while (((int)(s[u]).size()) == k && !s2[u].empty()) {
auto r = --s2[u].end(), l = s[u].begin();
auto R = *r, L = *l;
if (R <= L) break;
s2[u].erase(s2[u].find(R)), s[u].erase(s[u].find(L));
s[u].insert(R), s2[u].insert(L);
s3[u] += R - L;
}
}
inline void dfs(int u, int val, int fa, int k) {
vis[u] = 1, f[u] = g[u] = 0;
vector<long long> vec;
for (auto [v, w] : e[u])
if (v != fa) {
dfs(v, w, u, k), f[u] += f[v];
if (g[v] - f[v] > 0) vec.push_back(g[v] - f[v]);
}
g[u] = f[u];
sort((vec).begin(), (vec).end()), reverse((vec).begin(), (vec).end());
fix(u, k - 1);
if (s[u].empty() && s2[u].empty()) {
int j = 0;
while (j < ((int)(vec).size()) && j <= k - 2) {
if (vec[j] < 0) break;
g[u] += vec[j], ++j;
}
f[u] = g[u];
while (j < ((int)(vec).size()) && j <= k - 1) {
if (vec[j] < 0) break;
f[u] += vec[j], ++j;
}
} else {
for (auto i : vec) s[u].insert(i), s3[u] += i;
fix(u, k - 1), g[u] += s3[u];
fix(u, k), f[u] += s3[u];
for (auto i : vec) Erase(u, i);
}
g[u] += val;
}
inline long long calc(int k) {
long long ans = 0;
for (auto i : dj)
if (!vis[i]) {
dfs(i, 0, 0, k), ans += f[i];
}
for (auto i : dj) vis[i] = 0;
return ans;
}
int d[N];
vector<pair<int, int>> e1[N];
vector<pair<pair<int, int>, int>> e2[N];
vector<int> v[N];
vector<long long> minimum_closure_costs(int N, vector<int> U, vector<int> V,
vector<int> W) {
n = N;
for (register int i = (0); i < (((int)(U).size())); i++) {
d[U[i]]++, d[V[i]]++;
e[U[i]].insert({V[i], W[i]});
e[V[i]].insert({U[i], W[i]});
}
for (register int i = (0); i < (((int)(U).size())); i++) {
if (d[U[i]] > d[V[i]]) {
e1[d[U[i]]].push_back({U[i], W[i]});
e2[d[V[i]]].push_back({{U[i], V[i]}, W[i]});
} else {
e2[d[U[i]]].push_back({{V[i], U[i]}, W[i]});
e1[d[V[i]]].push_back({V[i], W[i]});
}
}
long long s = 0, s2 = 0;
for (register int i = (0); i < (((int)(W).size())); i++) s += W[i];
vector<long long> ans(n);
for (register int i = (1); i <= (n); i++) v[d[i]].push_back(i), dj.insert(i);
ans[0] = s;
for (register int k = (1); k <= (n - 1); k++) {
for (auto i : e2[k]) {
::s2[i.first.first].insert(i.second);
e[i.first.first].erase({i.first.second, i.second});
e[i.first.second].erase({i.first.first, i.second});
}
for (auto i : e1[k]) {
Erase(i.first, i.second), s2 += i.second;
}
for (auto i : v[k]) dj.erase(i);
ans[k] = s - (calc(k) + s2);
}
return ans;
}
int main() {
int n = read();
vector<int> a(n - 1), b(n - 1), c(n - 1);
for (register int i = (0); i < (n - 1); i++)
a[i] = read(), b[i] = read(), c[i] = read();
auto ans = minimum_closure_costs(n, a, b, c);
for (auto i : ans) printf("%lld\n", i);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e4;
const int INF = 0x3f3f3f3f, MOD = 1000000007;
const long long LINF = LONG_LONG_MAX;
int n, m, k;
map<pair<int, int>, int> d;
signed main() {
cin.tie(0);
cout.sync_with_stdio(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = (0); i < (k); i += 1) {
int u, v;
cin >> u >> v;
d[{u, v}] = INF;
};
d[{1, 1}] = 0;
int add = 0;
if (!d[{n, m}]) {
d[{n, m}] = INF;
add = 1;
}
queue<pair<int, int> > q;
q.push({1, 1});
while (q.size()) {
pair<int, int> u = q.front();
int dis = d[u];
q.pop();
for (auto p : d)
if (p.first != u) {
pair<int, int> v = p.first;
int w = INF;
if (v != make_pair(n, m) || add == 0) {
if (abs(v.first - u.first) <= 2 || abs(v.second - u.second) <= 2)
w = 1;
if (abs(v.first - u.first) + abs(v.second - u.second) == 1) w = 0;
} else {
if (abs(v.first - u.first) <= 1 || abs(v.second - u.second <= 1))
w = 1;
}
if (dis + w < p.second) {
d[v] = dis + w;
q.push(v);
}
}
}
if (d[{n, m}] == INF) {
cout << "-1\n";
return 0;
}
cout << d[{n, m}] << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100;
string str[] = {
"Aa", "Bb", "Ca", "Dd", "Df", "De", "Dh", "Fa", "Fw",
"Fq", "Aaa", "Bba", "Caa", "Dda", "Dfa", "Eea", "Nda", "Helloa",
"Efa", "Fqq", "Aab", "Bbb", "Cab", "Ddb", "Dfb", "Ndb", "Hellob",
"Efb", "Fwww", "Fqqq", "Aac", "Bbc", "Cac", "Ddc", "Dfc", "Ndc",
"Helloc", "Efc", "Fwwc", "Fqqc", "Aad", "Bbd", "Cad", "Ddd", "Dfd",
"Ndd", "Hellod", "Efd", "Fwwy", "Fqqy", "Aag", "Bbg", "Cag", "Ddg"};
string ans[nmax];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= k - 1; i++) {
ans[i] = str[i];
}
for (int i = k; i <= n; i++) {
string tmp;
cin >> tmp;
if (tmp == "NO") {
ans[i] = ans[i - k + 1];
} else {
ans[i] = str[i];
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i];
if (i == n)
cout << endl;
else
cout << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, lim;
int l[100010], r[100010], c[100010], h[310][310];
long long f[310][310], inf, an;
int main() {
scanf("%d%d%d", &n, &m, &lim);
for (i = 1; i <= m; i++) scanf("%d%d%d", &l[i], &r[i], &c[i]);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++)
if (l[j] <= i && r[j] >= i)
if (!h[i][r[j]] || h[i][r[j]] > c[j]) h[i][r[j]] = c[j];
}
memset(f, 120, sizeof(f));
inf = f[0][0];
for (i = 0; i <= n; i++) f[i][0] = 0;
for (i = 0; i <= n; i++)
for (j = 0; j <= i; j++) {
f[i][j] = min(f[i][j], f[i - 1][j]);
if (f[i][j] < inf) {
for (k = i + 1; k <= n; k++)
if (h[i + 1][k])
f[k][j + k - i] = min(f[k][j + k - i], f[i][j] + h[i + 1][k]);
}
}
an = inf;
for (j = lim; j <= n; j++)
for (i = 0; i <= n; i++) an = min(an, f[i][j]);
printf("%I64d\n", an == inf ? -1 : an);
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long int p, q;
char a[1010];
int al;
int b[5000];
int bl;
int nb[5000];
int nbl;
long long int c[5000];
int cl;
long long int mod = 1000000007;
long long int dp[4][5000];
long long int ndp[4][5000];
long long int ans;
int main() {
long long int i, j;
scanf("%I64d%I64d", &p, &q);
scanf("%s", a);
for (al = 0; a[al]; al++)
;
for (i = 0; i < al; i++) {
b[i] = a[al - 1 - i] - '0';
}
bl = al;
for (cl = 0; bl; cl++) {
j = 0;
nbl = 0;
for (i = bl - 1; i >= 0; i--) {
j *= 10;
j += b[i];
nb[i] = j / p;
if (j >= p) {
if (nbl == 0) nbl = i + 1;
j %= p;
}
}
c[cl] = j;
bl = nbl;
for (i = 0; i < bl; i++) {
b[i] = nb[i];
}
}
dp[0][0] = 1;
dp[2][0] = 1;
for (i = 0; i < cl; i++) {
for (j = 0; j <= i + 1; j++) {
ndp[0][j] = 0;
ndp[1][j] = 0;
ndp[2][j] = 0;
ndp[3][j] = 0;
}
for (j = 0; j <= i; j++) {
ndp[0][j] += ((p * (p + 1) / 2) % mod) * dp[0][j];
ndp[0][j] %= mod;
ndp[1][j + 1] += ((p * (p - 1) / 2) % mod) * dp[0][j];
ndp[1][j + 1] %= mod;
ndp[0][j] += ((p * (p - 1) / 2) % mod) * dp[1][j];
ndp[0][j] %= mod;
ndp[1][j + 1] += ((p * (p + 1) / 2) % mod) * dp[1][j];
ndp[1][j + 1] %= mod;
ndp[2][j] += ((c[i] * (c[i] + 1) / 2) % mod) * dp[0][j];
ndp[2][j] %= mod;
ndp[3][j + 1] += ((p * c[i] - (c[i] * (c[i] + 1) / 2)) % mod) * dp[0][j];
ndp[3][j + 1] %= mod;
ndp[2][j] += ((c[i] * (c[i] - 1) / 2) % mod) * dp[1][j];
ndp[2][j] %= mod;
ndp[3][j + 1] += ((p * c[i] - (c[i] * (c[i] - 1) / 2)) % mod) * dp[1][j];
ndp[3][j + 1] %= mod;
ndp[2][j] += (c[i] + 1) * dp[2][j];
ndp[2][j] %= mod;
ndp[3][j + 1] += (p - 1 - c[i]) * dp[2][j];
ndp[3][j + 1] %= mod;
ndp[2][j] += (c[i]) * dp[3][j];
ndp[2][j] %= mod;
ndp[3][j + 1] += (p - c[i]) * dp[3][j];
ndp[3][j + 1] %= mod;
}
for (j = 0; j <= i + 1; j++) {
dp[0][j] = ndp[0][j];
dp[1][j] = ndp[1][j];
dp[2][j] = ndp[2][j];
dp[3][j] = ndp[3][j];
}
}
ans = 0;
for (i = q; i <= cl; i++) {
ans += dp[2][i];
ans %= mod;
}
printf("%I64d", ans);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long n;
char s[100001];
vector<long long> ma[10] = {{0}, {1}, {2}, {3}, {3, 2, 2},
{5}, {5, 3}, {7}, {7, 2, 2, 2}, {7, 2, 3, 3}};
vector<long long> answ;
int main() {
scanf("%lld\n%s", &n, s);
for (register long long i = 0; i < n; ++i)
if (s[i] > '1')
answ.insert(answ.end(), ma[s[i] - '0'].begin(), ma[s[i] - '0'].end());
sort(answ.begin(), answ.end(), greater<long long>());
for (const long long& v : answ) printf("%lld", v);
putc('\n', stdout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
cout << __builtin_ffsll(k) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tt;
cin >> tt;
while (tt--) {
long long int n;
cin >> n;
int t = n % 3;
if (t == 0)
cout << (n / 3) << " " << (n / 3) << endl;
else if (t == 1)
cout << (n / 3 + t) << " " << (n / 3) << endl;
else
cout << (n / 3) << " " << (n / 3 + 1) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int cnt, ans[200010], n, m, t, maxn = 1;
struct node {
int x, i;
bool v;
} a[200010];
queue<node> q;
bool cmp(node a, node b) { return a.x < b.x; }
int main() {
scanf("%d%d%d", &n, &m, &t);
t++;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].x);
a[i].i = i;
a[i].v = 1;
}
sort(a + 1, a + n + 1, cmp);
ans[a[1].i] = 1;
q.push(a[1]);
for (int i = 2; i <= n; i++) {
node x = q.front();
if (a[i].x < x.x + t) {
ans[a[i].i] = ++maxn;
} else {
ans[a[i].i] = ans[x.i];
q.pop();
}
q.push(a[i]);
}
printf("%d\n", maxn);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[100], m, n = 1, b[100];
cin >> m;
for (int i = 0; i < m; i++) cin >> a[i];
sort(a, a + m);
b[n] = a[0];
for (int i = 0; i < m; i++) {
if (a[i] != b[n]) {
b[n + 1] = a[i];
n++;
}
}
if (n == 1)
cout << "0";
else if (n == 2) {
if ((b[2] - b[1]) % 2 != 0) {
cout << b[2] - b[1];
} else
cout << (b[2] - b[1]) / 2;
} else if (n == 3) {
if ((b[3] - b[1]) % 2 != 0) {
cout << "-1";
} else if (b[2] == (b[3] - b[1]) / 2 + b[1])
cout << b[2] - b[1];
else
cout << "-1";
} else
cout << "-1";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const int mod = (int)1e9 + 7;
int getInRange(vector<int> &a, int start, int lo, int hi) {
return upper_bound(a.begin() + start, a.end(), hi) -
lower_bound(a.begin() + start, a.end(), lo);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
for (int &x : a) {
cin >> x;
}
int ans = 0;
for (int b = 0; b < 30; b++) {
vector<int> A(n);
for (int i = 0; i < n; i++) {
int num = 0;
for (int j = b; j >= 0; j--) {
num *= 2;
if (a[i] & (1 << j)) {
num++;
}
}
A[i] = num;
}
sort(A.begin(), A.end());
int B = b + 1;
int64_t cntPairs = 0;
for (int i = 0; i < n; i++) {
cntPairs +=
getInRange(A, i + 1, (1 << (B - 1)) - A[i], (1 << B) - 1 - A[i]);
cntPairs +=
getInRange(A, i + 1, (1 << B) + (1 << (B - 1)) - A[i], (int)1e9);
}
if (cntPairs % 2 != 0) {
ans |= (1 << b);
}
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, ans = 0;
cin >> n;
vector<long long int> v;
for (long long int i = 0; i < n; i++) {
long long int k;
cin >> k;
v.push_back(k);
}
stack<long long int> s;
for (long long int i = 0; i < n; i++) {
while (!s.empty()) {
if (s.top() > v[i]) {
ans = max(ans, (s.top() ^ v[i]));
break;
} else {
ans = max(ans, (s.top() ^ v[i]));
s.pop();
}
}
s.push(v[i]);
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N6 = 1e6 + 6, N3 = 1e3 + 6, oo = 1e9 + 9, base = 1e9 + 7;
const long long ool = 1e18 + 9;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
if (n % 2 == 0)
cout << 2;
else
cout << 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100001;
string s[3];
long long cnt[60][3];
long long mx[3];
long long conv(long long i, long long k) {
if ('a' <= s[k][i] && s[k][i] <= 'z') {
return s[k][i] - 'a';
}
return s[k][i] - 'A' + 26;
}
int main() {
long long n;
cin >> n;
getline(cin, s[0]);
getline(cin, s[0]);
for (long long i = 0; i < s[0].size(); i++) {
cnt[conv(i, 0)][0]++;
mx[0] = max(mx[0], cnt[conv(i, 0)][0]);
}
getline(cin, s[1]);
for (long long i = 0; i < s[1].size(); i++) {
cnt[conv(i, 1)][1]++;
mx[1] = max(mx[1], cnt[conv(i, 1)][1]);
}
getline(cin, s[2]);
for (long long i = 0; i < s[2].size(); i++) {
cnt[conv(i, 2)][2]++;
mx[2] = max(mx[2], cnt[conv(i, 2)][2]);
}
long long sz = s[0].size();
long long rep1, rep2, rep3;
if (mx[0] + n > sz) {
if (mx[0] == sz && mx[0] + n - sz == 1) {
rep1 = sz - 1;
} else {
rep1 = sz;
}
} else {
rep1 = mx[0] + n;
}
if (mx[1] + n > sz) {
if (mx[1] == sz && mx[1] + n - sz == 1) {
rep2 = sz - 1;
} else {
rep2 = sz;
}
} else {
rep2 = mx[1] + n;
}
if (mx[2] + n > sz) {
if (mx[2] == sz && mx[2] + n - sz == 1) {
rep3 = sz - 1;
} else {
rep3 = sz;
}
} else {
rep3 = mx[2] + n;
}
long long mxx = max(rep1, max(rep2, rep3));
if (mxx == rep1 && rep2 < mxx && rep3 < mxx) {
cout << "Kuro" << endl;
} else if (mxx == rep2 && rep1 < mxx && rep3 < mxx) {
cout << "Shiro" << endl;
} else if (mxx == rep3 && rep1 < mxx && rep2 < mxx) {
cout << "Katie" << endl;
} else {
cout << "Draw" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 1e2 + 7;
bitset<N * N> f[N];
int calc(int *x, int n, vector<int> &v0, vector<int> &v1) {
v0.clear(), v1.clear();
int s = 0;
for (int i = 1; i <= n; i++) s += x[i];
if (s & 1) return 0;
s >>= 1;
for (int i = 1; i <= n; i++) f[i].reset();
f[0][0] = 1;
for (int i = 1; i <= n; i++) f[i] = f[i - 1] | (f[i - 1] << x[i]);
if (!f[n][s]) return 0;
for (int i = n; i >= 1; i--) {
if (s >= x[i] && f[i - 1][s - x[i]])
v1.push_back(x[i]), s -= x[i];
else
v0.push_back(x[i]);
}
assert(s == 0);
return 1;
}
int T;
int nx, x[N], ny, y[N];
vector<int> cx[2], cy[2];
vector<pair<int, int> > ans;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &nx);
for (int i = 1; i <= nx; i++) scanf("%d", &x[i]);
scanf("%d", &ny);
for (int i = 1; i <= ny; i++) scanf("%d", &y[i]);
if (nx != ny) {
puts("No");
continue;
}
int ok = 1;
ok &= calc(x, nx, cx[0], cx[1]);
ok &= calc(y, ny, cy[0], cy[1]);
if (!ok) {
puts("No");
continue;
}
puts("Yes");
if (cx[0].size() > cx[1].size()) swap(cx[0], cx[1]);
if (cy[0].size() < cy[1].size()) swap(cy[0], cy[1]);
sort(cx[0].begin(), cx[0].end(), greater<int>());
sort(cy[0].begin(), cy[0].end());
sort(cx[1].begin(), cx[1].end());
sort(cy[1].begin(), cy[1].end(), greater<int>());
int X = 0, Y = 0;
ans.clear();
ans.push_back(make_pair(X, Y));
for (int i = 0; i < cx[0].size(); i++) {
X += cx[0][i];
ans.push_back(make_pair(X, Y));
Y += cy[0][i];
ans.push_back(make_pair(X, Y));
}
for (int i = 0; i <= (int)cx[1].size() - (int)cy[1].size() - 1; i++) {
X -= cx[1][i + cy[1].size()];
ans.push_back(make_pair(X, Y));
Y += cy[0][i + cx[0].size()];
ans.push_back(make_pair(X, Y));
}
for (int i = cy[1].size() - 1; i >= 0; i--) {
X -= cx[1][i];
ans.push_back(make_pair(X, Y));
Y -= cy[1][i];
ans.push_back(make_pair(X, Y));
}
assert(ans.back() == make_pair(0, 0));
ans.pop_back();
for (auto [x, y] : ans) printf("%d %d\n", x, y);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n;
pair<int, int> ar[N];
vector<int> v[N];
int go[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> ar[i].first >> ar[i].second;
v[ar[i].first].push_back(i);
v[ar[i].second].push_back(i);
}
for (int i = 1; i <= n; i++) {
int a = v[i][0], b = v[i][1];
if (ar[a].first == b || ar[a].second == b) {
go[a] = b;
go[b] = i;
} else {
go[b] = a;
go[a] = i;
}
}
int cur = 1, cnt = 0;
while (cnt < n) {
cnt++;
cout << cur << " ";
cur = go[cur];
}
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename t1, typename t2>
ostream& operator<<(ostream& os, const pair<t1, t2>& a) {
os << a.first << ' ' << a.second;
return os;
}
template <typename typ>
void vout(vector<typ>& v) {
for (int vint = 0; vint < (int)(v).size(); vint++) {
cout << (v)[vint];
if (vint == (int)(v).size() - 1)
cout << '\n';
else
cout << ' ';
}
}
template <typename typ>
void arrout(typ* arr, int l) {
for (int i = 0; i < l; i++) {
cout << arr[i];
if (i < l - 1)
cout << ' ';
else
cout << '\n';
}
}
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int main() {
std::ios_base::sync_with_stdio(false);
string arr[8] = {"vaporeon", "jolteon", "flareon", "espeon",
"umbreon", "leafeon", "glaceon", "sylveon"};
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < 8; i++) {
if ((int)(s).size() == (int)(arr[i]).size()) {
bool works = true;
for (int j = 0; j < n; j++) {
if (s[j] != '.' && s[j] != arr[i][j]) {
works = false;
}
}
if (works) {
cout << (arr[i]) << '\n';
return 0;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
using ll = long long;
ll row[maxn], col[maxn];
int main(int argc, char const *argv[]) {
int n, m;
scanf("%d %d", &n, &m);
vector<vector<ll>> a(n, vector<ll>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%lld", &a[i][j]);
}
}
vector<ll> v, v1;
for (int i = 0; i < n; ++i) {
ll sum = 0;
for (int j = 0; j < m; ++j) {
sum += a[i][j];
}
v.push_back(sum);
row[i] = sum;
}
sort(v.begin(), v.end(), greater<ll>());
for (int i = 0; i < m; ++i) {
ll sum = 0;
for (int j = 0; j < n; ++j) {
sum += a[j][i];
}
v1.push_back(sum);
col[i] = sum;
}
sort(v1.begin(), v1.end(), greater<ll>());
ll ans = 0;
ll res = 0;
for (int i = 0; i < 4 && i < (int)v.size(); ++i) {
res += v[i];
}
ll ans1 = res;
res = 0;
for (int i = 0; i < 4 && i < (int)v1.size(); ++i) {
res += v1[i];
}
ans1 = max(ans1, res);
for (int taken = 0; taken < 4; ++taken) {
ll mx = 0;
int idx = -1;
for (int i = 0; i < n; ++i) {
if (row[i] > mx) {
mx = row[i];
idx = i;
}
}
ll mx1 = 0;
int idx1 = 0;
for (int i = 0; i < m; ++i) {
if (col[i] > mx1) {
mx1 = col[i];
idx1 = i;
}
}
if (mx > mx1) {
ans += mx;
row[idx] = 0;
for (int i = 0; i < m; ++i) {
col[i] -= a[idx][i];
a[idx][i] = 0;
}
} else {
ans += mx1;
col[idx1] = 0;
for (int i = 0; i < n; ++i) {
row[i] -= a[i][idx1];
a[i][idx1] = 0;
}
}
}
cout << max(ans, ans1) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, bars[1000], i, j;
int total, lgst = 1, lcheck;
while (scanf("%d", &n) != EOF) {
total = n;
lgst = 1;
for (i = 0; i < n; i++) {
scanf("%d", &bars[i]);
}
lcheck = 1;
for (i = 0; i < n; i++) {
lgst = 1;
for (j = i + 1; j < n; j++) {
if (bars[j] == -1) {
continue;
} else if (bars[i] == bars[j]) {
bars[j] = -1;
lgst++;
total--;
}
}
if (lgst > lcheck) {
lcheck = lgst;
}
}
printf("%d %d\n", lcheck, total);
}
scanf(" ");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
vector<int> a(n);
vector<int> t(n);
int overall = 0;
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < n; ++i) scanf("%d", &t[i]);
vector<int> pr(n);
for (int i = 0; i < n; ++i) {
if (i) pr[i] += pr[i - 1];
if (t[i] == 0)
pr[i] += a[i];
else
overall += a[i];
}
int add = 0;
for (int i = k - 1; i < n; ++i)
add = max(add, pr[i] - (i >= k ? pr[i - k] : 0));
printf("%d\n", overall + add);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, x, total = 0;
cin >> n >> d;
vector<int> hi;
while (n--) {
cin >> x;
hi.push_back(x);
}
for (int i = 0; i < hi.size(); i++) {
for (int j = 0; j < hi.size(); j++) {
if (abs(hi[i] - hi[j]) <= d && i != j) total++;
}
}
cout << total << endl;
}
| 0 |
#include <bits/stdc++.h>
const long long _mod = (1e9 + 9);
using namespace std;
long long quick_pow(long long x, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * x % _mod;
x = x * x % _mod;
n >>= 1;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, a, b, k;
char s[100055];
cin >> n >> a >> b >> k;
cin >> s;
long long a1 = 0;
for (int i = 0; i < k; i++) {
long long v = s[i] == '+' ? 1 : -1;
a1 = (a1 + v * quick_pow(a, n - i) * quick_pow(b, i) % _mod + _mod) % _mod;
}
long long q = b * quick_pow(a, _mod - 2) % _mod;
q = quick_pow(q, k);
long long num = (n + 1) / k;
long long sum;
if (q == 1)
sum = a1 * num % _mod;
else
sum = (a1 * (quick_pow(q, num) - 1) % _mod * quick_pow(q - 1, _mod - 2) +
_mod) %
_mod;
cout << sum << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long nr5, m;
vector<long long> sol;
int main() {
long long nr;
cin >> m;
for (nr = 1; nr5 < m; nr++) {
long long aux = nr;
while (aux % 5 == 0) {
aux /= 5;
nr5++;
}
if (nr5 == m) break;
}
if (nr5 > m)
cout << 0;
else {
for (; nr5 == m;) {
sol.push_back(nr);
nr++;
if (nr % 5 == 0) nr5++;
}
cout << sol.size() << "\n";
for (auto x : sol) cout << x << ' ';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a = std::numeric_limits<int>::max();
const int mod = 1e9 + 7;
void printStuffLower(string s) {
for (int i = 0; i < s.size(); i++) {
cout << (char)tolower(s[i]);
}
}
void printStuffUppper(string s) {
for (int i = 0; i < s.size(); i++) {
cout << (char)toupper(s[i]);
}
}
void solve() {
string s;
cin >> s;
int count_lower = 0;
int count_upper = 0;
for (int i = 0; i < s.size(); i++) {
if (int(s[i]) >= 97)
count_lower++;
else
count_upper++;
}
if (count_lower < count_upper) {
printStuffUppper(s);
} else {
printStuffLower(s);
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int people[101][101], n, m, a = 0, b = 0, c = 0;
cin >> n >> m;
memset(people, 0, sizeof(people));
int ans = 0;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
people[a - 1][b - 1] = c;
ans += people[a - 1][b - 1];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i != j) {
if (people[i][j] != 0) {
for (int k = 0; k < n; k++) {
if (people[j][k] != 0) {
if (k == i) {
if (people[i][j] >= people[j][k]) {
people[i][j] -= people[j][k];
people[i][k] += people[j][k];
ans -= 2 * people[j][k];
people[j][k] = 0;
} else {
people[j][k] -= people[i][j];
people[i][k] += people[i][j];
ans -= 2 * people[i][j];
people[i][j] = 0;
continue;
}
} else {
if (people[i][j] >= people[j][k]) {
people[i][j] -= people[j][k];
people[i][k] += people[j][k];
ans -= people[j][k];
people[j][k] = 0;
} else {
people[j][k] -= people[i][j];
people[i][k] += people[i][j];
ans -= people[i][j];
people[i][j] = 0;
continue;
}
}
}
}
}
}
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100005];
int ans = 0;
int csize[100005];
int dfs(int u, int fa) {
csize[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == fa) continue;
dfs(v, u);
csize[u] += csize[v];
if (csize[v] % 2 == 0) ans++;
}
}
int main() {
int n;
while (cin >> n) {
ans = 0;
for (int i = 0; i <= n; i++) {
g[i].clear();
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
if (n % 2)
cout << "-1\n";
else {
dfs(1, 0);
cout << ans << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int inf = (1 << 30);
const int mod = 1000000007;
using ll = long long;
using namespace std;
const int bound = 200010;
int n, z, cnt;
vector<int> graph[bound];
bool bscht[bound];
void init(int ziel) {
for (int i = 0; i < n; ++i) bscht[i] = false;
cnt = 1;
z = ziel;
bscht[z] = true;
}
void del() {
for (int i = 0; i < n; ++i) {
auto &v = graph[i];
v.erase(v.begin(), v.end());
}
}
void dfs(int jetzt) {
bscht[jetzt] = true;
++cnt;
for (auto next : graph[jetzt]) {
if (!bscht[next]) dfs(next);
}
}
int main() {
int t;
cin >> t;
while (t--) {
int m, a, b;
cin >> n >> m >> a >> b;
--a;
--b;
del();
while (m--) {
int x, y;
cin >> x >> y;
--x;
--y;
graph[x].push_back(y);
graph[y].push_back(x);
}
init(b);
dfs(a);
ll x = n - cnt;
init(a);
dfs(b);
ll y = n - cnt;
cout << x * y << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int ans, n, k, head, tail, a[100001];
int main() {
cin >> n >> k;
for (long long int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
ans = a[n] - a[1];
for (long long int head = 1, tail = n, x; head < tail && k; ans -= x)
if (head < n - tail + 1) {
x = min(a[head + 1] - a[head], k / head);
k -= x * head;
++head;
} else {
x = min(a[tail] - a[tail - 1], k / (n - tail + 1));
k -= x * (n - tail + 1);
--tail;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double epsylon = 1e-9;
const std::string PROGRAM_NAME = "ivo";
vector<int> do_operation(const vector<int>& a, const vector<int>& op) {
vector<vector<int> > help;
int cur = 0;
for (int i = 0; i < (int)op.size(); ++i) {
vector<int> temp(op[i]);
for (int j = 0; j < op[i]; ++j) {
temp[j] = a[cur++];
}
help.push_back(temp);
}
vector<int> res;
for (int i = (int)help.size() - 1; i >= 0; --i) {
for (int j = 0; j < (int)help[i].size(); ++j) {
res.push_back(help[i][j]);
}
}
return res;
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < (int)a.size(); ++i) {
cin >> a[i];
a[i]--;
}
vector<vector<int> > operations;
for (int i = 0; i < n; ++i) {
if (a[i] == 0) {
if (i != 0) {
vector<int> temp;
temp.push_back(i);
temp.push_back(n - i);
a = do_operation(a, temp);
operations.push_back(temp);
}
}
}
for (int it = 0; it < n; ++it) {
if (a[0] == 0) {
int len = 1;
while (len < n && a[len] == len) {
len++;
}
if (len == n) {
break;
}
vector<int> temp;
temp.push_back(len);
for (int j = len + 1; j < n; ++j) {
if (a[j] == len) {
temp.push_back(j - len + 1);
if (n - j - 1 > 0) {
temp.push_back(n - j - 1);
}
break;
}
}
a = do_operation(a, temp);
operations.push_back(temp);
} else {
int len = a[n - 1] + 1;
vector<int> temp;
int total = len;
temp.push_back(len);
int to_search = n - 1;
if (a[n - len - 1] == len) {
temp.push_back(1);
if (len == n - 1) {
reverse(temp.begin(), temp.end());
a = do_operation(a, temp);
operations.push_back(temp);
continue;
} else {
to_search = len + 1;
}
total++;
}
for (int j = n - len - 1; j >= 0; --j) {
if (a[j] == to_search) {
temp.push_back(n - j - total);
if (j > 0) {
temp.push_back(j);
}
break;
}
}
reverse(temp.begin(), temp.end());
a = do_operation(a, temp);
operations.push_back(temp);
}
}
cout << operations.size() << endl;
for (int i = 0; i < (int)operations.size(); ++i) {
printf("%d", (int)operations[i].size());
for (int j = 0; j < (int)operations[i].size(); ++j) {
printf(" %d", operations[i][j]);
}
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long double min(long double a, long double b) {
if (a < b) return a;
return b;
}
inline long double max(long double a, long double b) {
if (a < b) return b;
return a;
}
vector<string> split(string s, string c) {
unsigned long pos2 = s.find(c);
unsigned long pos1 = 0;
vector<string> res;
while (pos2 != s.size()) {
res.push_back(s.substr(pos1, pos2 - pos1));
pos1 = pos2 + c.size();
pos2 = s.find(c, pos1);
}
if (pos1 != s.size()) res.push_back(s.substr(pos1));
return res;
}
char g[3010][3010];
int l[3010][3010];
int r[3010][3010];
int c[3010];
int m, n;
int L;
int lowbit(int x) { return x & (-x); }
void add(int pos, int val) {
while (pos <= L) {
c[pos] += val;
pos += lowbit(pos);
}
}
int query(int pos) {
int res = 0;
while (pos > 0) {
res += c[pos];
pos -= lowbit(pos);
}
return res;
}
long long solve(int x, int y) {
memset(c, 0, sizeof c);
long long res = 0;
int last = -1;
vector<int> minusOne[3010];
L = min(x + 1, n - y);
memset(minusOne, 0, sizeof minusOne);
for (int i = 0; x - i >= 0 && y + i < n; i++) {
int xx = x - i;
int yy = y + i;
if (g[xx][yy] == '.')
last = i;
else {
add(i + 1, 1);
int maxLen = r[xx][yy];
minusOne[i + maxLen - 1].push_back(i);
int addLen = min(l[xx][yy], i - last);
res += query(i + 1) - query(i + 1 - addLen);
}
for (int(j) = (0); (j) < (minusOne[i].size()); ++(j))
add(minusOne[i][j] + 1, -1);
}
return res;
}
int main() {
cin.tie(0);
cin.sync_with_stdio(false);
cin >> m >> n;
for (int(i) = (0); (i) < (m); ++(i))
for (int(j) = (0); (j) < (n); ++(j)) cin >> g[i][j];
memset(l, 0, sizeof l);
memset(r, 0, sizeof r);
for (int(i) = (0); (i) < (m); ++(i)) {
int last = -1;
for (int(j) = (0); (j) < (n); ++(j)) {
if (g[i][j] == 'z') {
l[i][j] = j - last;
} else
last = j;
}
}
for (int(i) = (0); (i) < (m); ++(i)) {
int last = n;
for (int j = n - 1; j >= 0; j--) {
if (g[i][j] == 'z') {
r[i][j] = last - j;
} else
last = j;
}
}
long long res = 0;
for (int(i) = (0); (i) < (m); ++(i)) res += solve(i, 0);
for (int(i) = (1); (i) < (n); ++(i)) res += solve(m - 1, i);
cout << res << endl;
return 0;
}
| 7 |
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn=100005;
int n,m,k[maxn],d[maxn][2];
struct Item{int l,r;
Item(int l=0,int r=0):l(l),r(r){}
}p[maxn][2],t[2];
bool check(Item a,int v){return a.l<=v&&v<=a.r;}
Item intersect(Item a,Item b){return Item(max(a.l,b.l),min(a.r,b.r));}
int main(){
ios::sync_with_stdio(0);
cin>>n>>m;
for(int i=0;i<n;i++)
cin>>k[i]>>p[i][0].l>>p[i][0].r>>p[i][1].l>>p[i][1].r;
p[n][0]=p[n][1]=Item(0,m);
for(int i=n-1;i>=0;i--){
t[0]=p[i][0];t[1]=p[i][1];
for(int j=0;j<2;j++)
if(check(t[j],k[i])){
if(check(p[i+1][j],k[i]))d[i][j]=j^1;
else{d[i][j]=j;p[i][j^1]=intersect(p[i][j^1],p[i+1][j^1]);}
}else p[i][j^1]=Item(m,0);
}if(check(p[0][0],0)||check(p[0][1],0)){
cout<<"Yes"<<endl;
for(int i=0,j=check(p[0][0],0);i<n;i++)
{cout<<j<<' ';j=d[i][j];}
cout<<endl;
}else cout<<"No"<<endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
void solve() {
int n;
cin >> n;
int a[n], b[n];
set<pair<int, int> > second;
pair<int, int> p;
for (int i = 1; i <= n; i++) {
cin >> a[i - 1] >> b[i - 1];
p = {a[i - 1], b[i - 1]};
second.insert(p);
}
int j = 0;
for (auto x : second) {
a[j] = x.first;
b[j] = x.second;
j++;
}
long long int dp[n];
memset(dp, 0, sizeof(dp));
for (int i = 0; i <= n - 1; i++) {
int x = a[i] - b[i];
auto it1 = lower_bound(a, a + n, x);
auto it = a + i;
dp[i] = (int)(it - it1);
}
for (int i = 0; i <= n - 1; i++) {
if (i - dp[i] - 1 >= 0) {
dp[i] += dp[i - dp[i] - 1];
}
}
long long int ans = n;
for (int i = 0; i <= n - 1; i++) {
ans = min(ans, dp[i] + n - i - 1);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
T = 1;
while (T--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m;
int v[505];
int main() {
n = read();
m = read();
double ans = 0;
for (int i = 1; i <= n; i++) v[i] = read();
for (int i = 1; i <= m; i++) {
int a = read(), b = read(), c = read();
ans = max(ans, double(v[a] + v[b]) / c);
}
printf("%.10f", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long fa[2005], fb[2005];
long long mina[2005], minb[2005];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<long long> a(n), b(m);
for (int i = 0; i < n; i++) {
cin >> a[i];
fa[i + 1] = fa[i] + a[i];
}
for (int j = 0; j < m; j++) {
cin >> b[j];
fb[j + 1] = fb[j] + b[j];
}
long long x;
cin >> x;
for (int i = 0; i <= n; i++) {
mina[i] = 2000000000;
for (int k = 0; k + i <= n; k++) {
mina[i] = min(mina[i], fa[k + i] - fa[k]);
}
}
for (int j = 0; j <= m; j++) {
minb[j] = 2000000000;
for (int k = 0; k + j <= m; k++) {
minb[j] = min(minb[j], fb[k + j] - fb[k]);
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (mina[i] * minb[j] <= x) ans = max(ans, i * 1ll * j);
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sz, num;
vector<vector<int> > v;
while (scanf("%d\n", &n) != EOF) {
v.clear();
v.resize(n);
for (int i = 0; i < n; i++) v[i].clear();
for (int i = 0; i < n; i++) {
scanf("%d", &sz);
v[i].resize(sz);
for (int j = 0; j < sz; j++) scanf("%d", &v[i][j]);
sort(v[i].begin(), v[i].end());
}
for (int i = 0; i < n; i++) {
bool posible = true;
for (int j = 0; j < n && posible; j++)
if (i != j) {
bool flag = true;
for (int k = 0; k < v[j].size() && flag; k++)
if (!binary_search(v[i].begin(), v[i].end(), v[j][k])) flag = false;
if (flag) posible = false;
}
printf("%s\n", posible ? "YES" : "NO");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
for (int i = 1; i <= t; i++) {
long long int n, j;
scanf("%lld", &n);
j = -1 * (n - 1);
printf("%lld %lld\n", j, n);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long double pi = 3.1415926536;
long long n, m, k;
long long dp[5003][5003];
long long a[5003], s[5003] = {};
long long call(long long idx, long long k) {
if (dp[idx][k] != -1) return dp[idx][k];
if (idx >= n - m + 1 || k <= 0) return 0;
return dp[idx][k] = max(s[idx] + call(idx + m, k - 1), call(idx + 1, k));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int tt = 1;
while (tt--) {
cin >> n >> m >> k;
long long x = 0;
memset(dp, -1, sizeof(dp));
for (long long i = 0; i < m; i++) {
cin >> a[i];
x += a[i];
}
for (long long i = m; i < n; i++) {
cin >> a[i];
s[i - m] = x;
x += a[i] - a[i - m];
}
s[n - m] = x;
x = call(0, k);
cout << x << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n], b[n];
for (long long i = 0; i < n; i++) cin >> a[i] >> b[i];
long long dp[n][3];
memset(dp, 0, sizeof(dp));
dp[0][0] = 0;
dp[0][1] = b[0];
dp[0][2] = 2 * b[0];
for (long long i = 1; i < n; i++) {
dp[i][0] = 2e18;
dp[i][1] = 2e18;
dp[i][2] = 2e18;
for (long long j = 0; j < 3; j++) {
for (long long k = 0; k < 3; k++) {
if (a[i] + j == a[i - 1] + k) continue;
dp[i][j] = min(dp[i][j], dp[i - 1][k] + j * b[i]);
}
}
}
cout << min(dp[n - 1][0], min(dp[n - 1][1], dp[n - 1][2])) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 7;
const long long M = 1e9 + 7;
const long long Mod = 998244353;
long long _, i, j, k, n, m, t, T, p, q, len, u, v, w, st, en, x, y, ma, mi, num,
flag, res, cnt, ans, tmp1, tmp2, nex;
long long a[N], s1[N], s2[N];
map<long long, long long> l, r;
signed main() {
ios::sync_with_stdio(false);
long long t = 1;
while (t--) {
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++)
if (!l[a[i]]) l[a[i]] = i;
for (i = n; i >= 1; i--)
if (!r[a[i]]) r[a[i]] = i;
for (i = 1; i <= n; i++) s1[i] = s1[i - 1] + a[i];
for (i = n; i >= 1; i--) s2[i] = s2[i + 1] + a[i];
ans = 1e18;
for (i = 1; i <= n; i++) {
if (r[a[i]] - l[a[i]] + 1 >= k) {
ans = 0;
break;
}
tmp1 = (a[i] - 1) * (l[a[i]] - 1) - s1[l[a[i]] - 1];
tmp2 = s2[r[a[i]] + 1] - (a[i] + 1) * (n - r[a[i]]);
if (i >= k) ans = min(ans, tmp1 + k - r[a[i]] + l[a[i]] - 1);
if (n - i + 1 >= k) ans = min(ans, tmp2 + k - (r[a[i]] - l[a[i]] + 1));
ans = min(ans, tmp1 + tmp2 + k - (r[a[i]] - l[a[i]] + 1));
}
cout << ans;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1001000;
int mini, maxi, n, T;
inline int read() {
int res = 0;
char ch = getchar(), ch1 = ch;
while (!isdigit(ch)) ch1 = ch, ch = getchar();
while (isdigit(ch)) res = (res << 3) + (res << 1) + ch - '0', ch = getchar();
return ch1 == '-' ? -res : res;
}
int main() {
T = read();
while (T--) {
n = read();
maxi = 0;
mini = 1000000000;
for (register int i = 0, x; i < n; ++i) {
x = read();
maxi = max(x, maxi);
mini = min(x, mini);
}
if (maxi == mini)
printf("%d\n", n);
else
printf("1\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200001];
int n, K, root, sz;
int s[200001], v[200001], mx[200001], ans[200001];
void getroot(int x, int f) {
s[x] = v[x];
for (int i = 0; i < g[x].size(); i++) {
int t = g[x][i];
if (t == f) continue;
getroot(t, x);
s[x] += s[t];
mx[x] = max(mx[x], s[t]);
}
mx[x] = max(mx[x], 2 * K - s[x]);
if (mx[x] < mx[root]) root = x;
}
void dfs(int x, int f) {
if (v[x] > 0 && f != 0) ans[++sz] = x;
for (int i = 0; i < g[x].size(); i++) {
int t = g[x][i];
if (t == f) continue;
dfs(t, x);
}
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 1, x, y; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1, x; i <= 2 * K; i++) {
scanf("%d", &x);
v[x] = 1;
}
mx[0] = 999999999;
root = 0;
getroot(1, 0);
sz = 0;
dfs(root, 0);
if (v[root] == 1) ans[++sz] = root;
printf("1\n%d\n", root);
for (int i = 1; i <= K; i++) printf("%d %d %d\n", ans[i], ans[K + i], root);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using vint = vector<int>;
using pint = pair<int, int>;
using vpint = vector<pint>;
template <typename A, typename B>
inline void chmin(A& a, B b) {
if (a > b) a = b;
}
template <typename A, typename B>
inline void chmax(A& a, B b) {
if (a < b) a = b;
}
template <class A, class B>
ostream& operator<<(ostream& ost, const pair<A, B>& p) {
ost << "{" << p.first << "," << p.second << "}";
return ost;
}
template <class T>
ostream& operator<<(ostream& ost, const vector<T>& v) {
ost << "{";
for (int i = 0; i < v.size(); i++) {
if (i) ost << ",";
ost << v[i];
}
ost << "}";
return ost;
}
struct Node {
int mi, ma, dep;
int lopt, ropt;
int opt;
Node(char c) {
if (c == '(') {
mi = 0;
ma = 1;
dep = 1;
lopt = 0;
ropt = 1;
opt = 1;
} else {
mi = -1;
ma = 0;
dep = -1;
lopt = 2;
ropt = 0;
opt = 1;
}
}
Node() { mi = ma = dep = lopt = ropt = opt = 0; }
};
auto ff = [](Node a, Node b) -> Node {
b.mi += a.dep;
b.ma += a.dep;
b.dep += a.dep;
b.lopt -= a.dep;
b.ropt -= a.dep;
Node c;
c.mi = min(a.mi, b.mi);
c.ma = max(a.ma, b.ma);
c.dep = b.dep;
c.lopt = max(a.lopt, max(b.lopt, a.ma - 2 * b.mi));
c.ropt = max(a.ropt, max(b.ropt, b.ma - 2 * a.mi));
c.opt = max(a.opt, max(b.opt, max(a.lopt + b.ma, b.ropt + a.ma)));
return c;
};
template <class T, class F>
struct SegmentTree {
F f;
T ti;
vector<T> dat;
int sz;
SegmentTree(const T& ti, const F& f) : ti(ti), f(f) {}
void build(const vector<T>& v) {
assert(v.size());
sz = 1;
while (sz < v.size()) sz <<= 1;
dat.resize(sz << 1, ti);
for (int i = 0; i < v.size(); i++) dat[sz - 1 + i] = v[i];
for (int i = sz - 2; i >= 0; i--)
dat[i] = f(dat[i * 2 + 1], dat[i * 2 + 2]);
}
inline void update(int k, T x) {
k += sz - 1;
dat[k] = x;
while (k) {
k = (k - 1) / 2;
dat[k] = f(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
inline void add(int k, int x) {
k += sz - 1;
dat[k] = f(dat[k], x);
while (k) {
k = (k - 1) / 2;
dat[k] = f(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
inline T query(int a, int b) { return query(a, b, 0, 0, sz); }
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) return ti;
if (a <= l && r <= b) return dat[k];
return f(query(a, b, k * 2 + 1, l, (l + r) / 2),
query(a, b, k * 2 + 2, (l + r) / 2, r));
}
};
SegmentTree<Node, decltype(ff)> seg(Node(), ff);
char buf[222222];
signed main() {
int N, Q;
scanf("%d%d", &N, &Q);
string S;
scanf("%s", buf);
S = buf;
vector<Node> ini;
for (auto c : S) ini.emplace_back(c);
seg.build(ini);
printf("%d\n", seg.query(0, S.size()).opt);
while (Q--) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
swap(S[a], S[b]);
seg.update(a, Node(S[a]));
seg.update(b, Node(S[b]));
printf("%d\n", seg.query(0, S.size()).opt);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[200020], rbef[200020], lbeh[200020];
int main() {
long long n, i, sum1, sum2;
while (cin >> n) {
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
rbef[0] = lbeh[n + 1] = 0;
for (i = 1; i <= n; i++) {
rbef[i] = rbef[i - 1] + a[i];
}
for (i = n; i >= 1; i--) {
lbeh[i] = lbeh[i + 1] + 1 - a[i];
}
sum1 = sum2 = 0;
for (i = 1; i <= n; i++) {
if (a[i] == 1) {
sum1 += lbeh[i];
}
}
for (i = n; i >= 1; i--) {
if (a[i] == 0) {
sum2 += rbef[i];
}
}
cout << min(sum1, sum2) << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a, b;
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%lld %lld", &a, &b);
long long sum = abs(a - b);
long long ans = sum / 10;
if (sum % 10 != 0) ans++;
printf("%lld\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int main() {
int i, j, ma = 0, br = 1, la = 0;
string s;
cin >> n >> k;
cin >> s;
for (i = 1; i < n; i++) {
if (s[i - 1] == '#') la = 1;
if (s[i] == s[i - 1] && s[i - 1] == '#') {
br++;
la = 1;
} else {
if (br > ma) {
ma = br;
}
br = 1;
}
}
if (s[n - 1] == '#') la = 1;
if (br > ma) ma = br;
if (ma >= k && la == 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
char g[110][110];
char ans[110][110];
int main() {
int i, j, ii, jj;
int noans, flag;
int n;
while (~scanf("%d", &n)) {
for (i = 0; i < n; i++) scanf("%s", g[i]);
memset(ans, 0, sizeof(ans));
for (i = 0; i < 2 * n - 1; i++)
for (j = 0; j < 2 * n - 1; j++) ans[i][j] = 'x';
ans[n - 1][n - 1] = 'o';
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (g[i][j] == '.') {
for (ii = 0; ii < n; ii++)
for (jj = 0; jj < n; jj++)
if (g[ii][jj] == 'o') {
int dx = i - ii;
int dy = j - jj;
ans[n - 1 + dx][n - 1 + dy] = '.';
}
}
noans = 0;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (g[i][j] == 'x') {
flag = 0;
for (ii = 0; ii < n; ii++)
for (jj = 0; jj < n; jj++)
if (g[ii][jj] == 'o') {
int dx = i - ii;
int dy = j - jj;
if (ans[n - 1 + dx][n - 1 + dy] == 'x') flag = 1;
}
if (flag == 0) noans = 1;
}
if (noans)
puts("NO");
else {
puts("YES");
for (i = 0; i < 2 * n - 1; i++) puts(ans[i]);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, cnt = 0, u, v, root, ans = 0;
long long head[3005], f[3005][3005], s[3005][3005], dp[3005][3005];
struct edge {
long long next;
long long to;
} e[6005];
inline void add_edge(long long u, long long v) {
cnt++;
e[cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt;
}
inline void dfs(long long now, long long fath) {
f[root][now] = fath, s[root][now] = 1;
for (long long i = head[now]; i; i = e[i].next) {
if (e[i].to != fath) dfs(e[i].to, now), s[root][now] += s[root][e[i].to];
}
}
inline long long DP(long long x, long long y) {
if (x == y) return dp[x][y] = 0;
if (dp[x][y]) return dp[x][y];
return dp[x][y] = max(DP(x, f[x][y]), DP(y, f[y][x])) + s[x][y] * s[y][x];
}
signed main() {
cin >> n;
for (long long i = 1; i < n; i++) {
cin >> u >> v;
add_edge(u, v), add_edge(v, u);
}
for (long long i = 1; i <= n; i++) root = i, dfs(i, 0);
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) DP(i, j), ans = max(ans, dp[i][j]);
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, A, B;
long long c[8000000];
int cnt = 1;
struct Node {
int lc, rc;
} node[8000000];
map<long long, int> mp;
long long sum[8000000];
vector<long long> v;
void build(int k, long long l, long long r) {
if (l == r) {
sum[k] = mp[l];
return;
}
int id1 = lower_bound(v.begin(), v.end(), l) - v.begin();
int id2 = upper_bound(v.begin(), v.end(), r) - v.begin();
if (!(id2 > id1)) {
sum[k] = 0;
return;
}
long long mid = l + r >> 1;
node[k].lc = ++cnt;
node[k].rc = ++cnt;
build(node[k].lc, l, mid);
build(node[k].rc, mid + 1, r);
sum[k] = sum[node[k].lc] + sum[node[k].rc];
}
long long ans[8000000];
void merge(int k, int l, int r) {
if (sum[k] == 0) {
ans[k] = A;
return;
}
if (l == r) {
ans[k] = (sum[k] == 0 ? A : B * sum[k]);
return;
}
int mid = l + r >> 1;
merge(node[k].lc, l, mid);
merge(node[k].rc, mid + 1, r);
ans[k] = min(B * sum[k] * (r - l + 1), ans[node[k].lc] + ans[node[k].rc]);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> A >> B;
long long r = 1;
for (int i = 1; i <= k; i++) {
cin >> c[i];
mp[c[i]]++;
v.push_back(c[i]);
}
sort(v.begin(), v.end());
for (int i = 1; i <= n; i++) r <<= 1;
build(1, 1, r);
merge(1, 1, r);
cout << ans[1] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long m, n;
cin >> m >> n;
cout << m * n / 2;
}
| 0 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const double PI = 3.1415926535897932384626433832795;
void fft(vector<complex<double> >& a, bool side) {
int n = a.size();
if (n == 1) return;
vector<complex<double> > a0, a1;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
a0.push_back(a[i]);
else
a1.push_back(a[i]);
}
fft(a0, side);
fft(a1, side);
double ang = 2 * PI / n * (side ? 1 : -1);
complex<double> w(1), wn(cos(ang), sin(ang));
for (int i = 0; i < n / 2; i++) {
a[i] = a0[i] + a1[i] * w;
a[i + n / 2] = a0[i] - a1[i] * w;
if (!side) {
a[i] /= 2;
a[i + n / 2] /= 2;
}
w *= wn;
}
}
void multiply(vector<int>& a, vector<int>& b, vector<int>& rez) {
vector<complex<double> > fa(a.begin(), a.end()), fb(b.begin(), b.end());
int n = 1;
while (n < max(a.size(), b.size())) n <<= 1;
n <<= 1;
fa.resize(n);
fb.resize(n);
fft(fa, true);
fft(fb, true);
for (int i = 0; i < n; i++) {
fa[i] *= fb[i];
}
fft(fa, false);
rez.resize(n);
for (int i = 0; i < n; i++) {
rez[i] = fa[i].real() > 0 ? (int)(fa[i].real() + 0.5)
: (int)(fa[i].real() - 0.5);
}
}
int modm = 1;
int mn(string& s, int fi, int se) {
int y = 0;
for (int i = fi; i <= se; i++) {
y = y * 10 + s[i] - '0';
}
return y;
}
void fn(string& s, vector<int>& n) {
int m = (s[0] == '-' ? 1 : 0);
for (int i = s.size() - 1; i >= m; i -= modm)
n.push_back(mn(s, max(i - (modm - 1), m), i));
}
int ns(int a) {
if (a == 0) return 1;
int k = 0;
while (a > 0) {
a /= 10;
k++;
}
return k;
}
void umn(string& a, string& b, vector<int>& rez) {
vector<int> a1, b1;
fn(a, a1);
fn(b, b1);
multiply(a1, b1, rez);
for (int i = 0; i < rez.size() - 1; i++) {
rez[i + 1] += rez[i] / 10;
rez[i] %= 10;
}
while (rez[rez.size() - 1] > 10) {
int a = rez[rez.size() - 1] / 10;
rez[rez.size() - 1] %= 10;
rez.push_back(a);
}
while (rez.size() > 1 && rez[rez.size() - 1] == 0) rez.pop_back();
}
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size() - 1; i++) {
if (s[i] == s[i + 1]) {
cout << "Impossible";
return 0;
}
}
vector<vector<int> > al(26, vector<int>());
for (int i = 0; i < 27; i++) {
al[s[i] - 'A'].push_back(i);
}
int k = 0;
int l = 0;
int l1 = 0;
for (int i = 0; i < 26; i++) {
if (al[i].size() == 2) {
k = abs(al[i][0] - al[i][1]) - 1;
l = al[i][0];
l1 = i;
}
}
char a[13][2];
int y = k / 2;
for (int i = 0; i < y; i++) {
a[i][0] = s[l + y - i];
}
a[y][0] = s[l];
for (int i = 0; i < k - y; i++) {
a[i][1] = s[l + y + i + 1];
}
int o = 1;
int uuu = k - y;
while (uuu < 13 && al[l1][1] + o < s.size()) {
a[uuu][1] = s[al[l1][1] + o];
uuu++;
o++;
}
if (al[l1][1] + o < s.size()) {
a[12][0] = s[al[l1][1] + o];
}
o++;
int oo = 1;
while (al[l1][1] + o < s.size()) {
a[12 - oo][0] = s[al[l1][1] + o];
o++;
oo++;
}
int op = 0;
for (int i = 0; i < 13; i++) {
if (a[i][0] == s[l]) op = i;
}
int uy = 1;
while (op + 1 < 13 && l - uy >= 0) {
a[op + 1][0] = s[l - uy];
uy++;
op++;
}
if (l - uy >= 0) {
a[12][1] = s[l - uy];
uy++;
}
int poo = 1;
while (l - uy >= 0) {
a[12 - poo][1] = s[l - uy];
poo++;
uy++;
}
for (int i = 0; i < 13; i++) cout << a[i][0];
cout << endl;
for (int i = 0; i < 13; i++) cout << a[i][1];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int *uchastokTime = new int[n];
int *uchastokMoney = new int[n];
for (int i = 0; i < n; i++) {
uchastokTime[i] = 10000;
uchastokMoney[i] = 0;
}
for (int i = 0; i < m; i++) {
int l, r, t, c;
cin >> l >> r >> t >> c;
for (int j = l - 1; j <= r - 1; j++) {
if (uchastokTime[j] > t) {
uchastokTime[j] = t;
uchastokMoney[j] = c;
}
}
}
int money = 0;
for (int i = 0; i < n; i++) {
money += uchastokMoney[i];
}
cout << money;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1111;
long long n, k, x[N];
int p;
int main() {
cin >> n >> k >> p;
for (int i = 1; i <= p; ++i) {
cin >> x[i];
}
if (k == 0) {
for (int i = 1; i <= p; ++i) {
printf(".");
}
printf("\n");
return 0;
}
long long last = n + 1;
if (n & 1) {
k -= 1;
n -= 1;
last = n + 1;
}
if (k == 0) {
for (int i = 1; i <= p; ++i) {
if (x[i] < last) {
printf(".");
} else {
printf("X");
}
}
printf("\n");
return 0;
}
if (2 * k > n) {
long long temp = 2 * k - n;
n -= temp;
last = n + 1;
}
long long first = n - 2 * (k - 1);
for (int i = 1; i <= p; ++i) {
if (x[i] < first) {
printf(".");
} else if (x[i] == first) {
printf("X");
} else if (x[i] >= last) {
printf("X");
} else {
printf("%c", (x[i] - first) & 1 ? '.' : 'X');
}
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int inf = 0x3f3f3f3f;
int f[N];
struct PAM {
static const int N = ::N, M = 26;
int s[N], len[N], ne[N][M], fail[N], cnt[N], dep[N], id[N], no[N], last, n, p,
slink[N], dif[N];
inline int newnode(int l) {
fill_n(ne[p], M, 0);
cnt[p] = dep[p] = 0;
len[p] = l;
return p++;
}
inline void init() {
newnode(p = 0), newnode(s[0] = -1), fail[last = n = 0] = 1;
}
inline int getfail(int x) {
while (s[n - len[x] - 1] != s[n]) x = fail[x];
return x;
}
inline void add(int c) {
s[++n] = c;
int cur = getfail(last);
if (!ne[cur][c]) {
int now = newnode(len[cur] + 2);
fail[now] = ne[getfail(fail[cur])][c];
ne[cur][c] = now;
dep[now] = dep[fail[now]] + 1;
}
last = ne[cur][c], cnt[last]++;
id[n] = last, no[last] = n;
dif[last] = len[last] - len[fail[last]];
dif[last] == dif[fail[last]] ? slink[last] = slink[fail[last]]
: slink[last] = fail[last];
}
inline void build() {
for (int i = (p)-1; i >= (0); --i) cnt[fail[i]] += cnt[i];
}
} pam;
char s[N], t1[N], t2[N];
int n;
int pre[N];
int g[N];
int main() {
scanf("%s%s", (t1 + 1), t2 + 1);
int L = strlen(t1 + 1);
for (int i = (1); i < (L + 1); i++) {
s[++n] = t1[i], s[++n] = t2[i];
}
memset(f, 0x3f, sizeof(f));
f[0] = 0;
pam.init();
for (int i = (1); i < (n + 1); i++) {
pam.add(s[i] - 'a');
for (int j = pam.last; j > 1; j = pam.slink[j]) {
g[j] = i - pam.len[pam.slink[j]] - pam.dif[j];
int fj = pam.fail[j];
if (pam.dif[j] == pam.dif[fj] && f[g[j]] > f[g[fj]]) g[j] = g[fj];
if (i % 2 == 0 && f[i] > f[g[j]] + 1) f[i] = f[g[j]] + 1, pre[i] = g[j];
}
if (i % 2 == 0 && s[i] == s[i - 1] && f[i] > f[i - 2])
f[i] = f[i - 2], pre[i] = i - 2;
}
if (f[n] == inf) {
printf("-1");
} else {
printf("%d\n", f[n]);
for (int i = n; i >= 1; i = pre[i]) {
int l = pre[i] / 2 + 1, r = i / 2;
if (l == r) continue;
printf("%d %d\n", l, r);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
cout << (n + 1) / 2 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int r[101000], k[101000];
int n, l, w;
int t1 = 0, t2 = 0;
double Abs(double x) { return x < 0 ? -x : x; }
int ef(int L, int R, int K) {
while (L < R) {
int mid = L + R >> 1;
double T = (r[mid] + l - k[K]) / 2.0;
if (Abs(T + k[K]) - 1.0 * w * T < 0)
R = mid;
else
L = mid + 1;
}
return R;
}
int main() {
scanf("%d%d%d", &n, &l, &w);
for (int i = 1; i <= n; i++) {
int x, v;
scanf("%d%d", &x, &v);
if (v == 1) k[++t1] = x;
if (v == -1) r[++t2] = x;
}
sort(r + 1, r + t2 + 1);
long long ans = 0;
for (int i = 1; i <= t1; i++) {
int u = lower_bound(r + 1, r + t2 + 1, k[i]) - r;
int x = ef(u, t2 + 1, i);
ans += t2 - x + 1;
}
printf("%lld", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a[109], cnt[109], temp, res;
bool used[109], mark[109];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i]]++;
}
for (int i = 1; i <= 100; i++) {
if (cnt[i] == 1) res++;
}
for (int i = 0; i < n && temp < res - 1; i++) {
if (!used[a[i]] && cnt[a[i]] == 1) {
temp++;
used[a[i]] = true;
res--;
mark[i] = true;
}
}
if (temp < res) {
for (int i = 0; i < n; i++) {
if (!used[a[i]] && cnt[a[i]] > 2) {
temp++;
used[a[i]] = true;
mark[i] = true;
break;
}
}
}
if (temp == res) {
printf("YES\n");
for (int j = 0; j < n; j++) {
printf("%c", (mark[j] ? 'B' : 'A'));
}
} else
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int ara[10] = {0}, i, n, j, flag = 0;
for (i = 0; i < 6; i++) {
scanf("%d", &n);
ara[n] = ara[n] + 1;
}
for (i = 1; i <= 9; i++) {
if (ara[i] >= 4) {
for (j = 1; j <= 9; j++) {
if (ara[j] == 2 || ara[j] == 6) {
flag = 1;
printf("Elephant");
break;
}
if (ara[j] == 1) {
flag = 1;
printf("Bear");
break;
}
}
}
if (flag == 1) break;
}
if (flag == 0) printf("Alien");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[2][1000][1000];
int x[100], y[100], n, k, t;
int main() {
scanf("%d", &k), n = 1 << k;
int now = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%lld", &a[now][i][j]);
scanf("%d", &t);
for (int i = 1; i <= t; i++) scanf("%d %d", &x[i], &y[i]);
for (int l = 0; l < k; l++) {
now ^= 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) a[now][i][j] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
for (int v = 1; v <= t; v++)
a[now][i][j] ^= a[now ^ 1][(i - x[v] + n) % n][(j - y[v] + n) % n];
}
for (int i = 1; i <= t; i++) x[i] = x[i] * 2 % n, y[i] = y[i] * 2 % n;
}
int cnt = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (a[now][i][j]) ++cnt;
printf("%d\n", cnt);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long> subject[100005];
set<long long> indx;
long long sum[100005] = {0};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
int input1, input2;
for (int i = 0; i < n; ++i) {
cin >> input1 >> input2;
subject[input1].push(input2);
indx.insert(input1);
}
long long maxx = 0;
while (!indx.empty()) {
long long local_sum = 0;
set<long long> cpy = indx;
for (set<long long>::iterator it = indx.begin(); it != indx.end(); it++) {
long long ind = *it;
long long t = subject[ind].top();
sum[ind] += t;
if (sum[ind] >= 0) local_sum += sum[ind];
subject[ind].pop();
if (subject[ind].empty()) cpy.erase(ind);
}
maxx = max(maxx, local_sum);
indx = cpy;
}
cout << maxx << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4000 + 100;
int A, B, n, l, t, m;
bool is_ok(long long T) {
return (long long)(2 * A + (l + T - 2) * B) * (long long)(T - l + 1) <=
2 * (long long)m * t;
}
int main() {
scanf("%d %d %d", &A, &B, &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d %d", &l, &t, &m);
long long now = A + (l - 1) * B;
if (now > t) {
cout << -1 << endl;
continue;
} else {
long long r = (t - A + B) / B;
if (r < l) {
cout << -1 << endl;
continue;
}
long long next = A + (r - 1) * B;
if ((long long)(2 * A + (r + l - 2) * B) * (long long)(r - l + 1) <=
2 * (long long)m * t) {
cout << r << endl;
} else {
long long L, R;
L = l;
R = r;
while (R - L > 1) {
long long M = (R + L) / 2;
if (is_ok(M)) {
L = M;
} else {
R = M;
}
}
cout << L << endl;
}
}
}
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.