solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long INF = 10000000000000000LL;
void relax(long long &a, long long b) { a = max(a, b); }
struct {
int to[26];
int up;
int sum;
int nxt[26];
vector<int> child;
} T[1005];
int tsz = 1;
void dfs(int v) {
for (int u : T[v].child) {
T[u].sum += T[v].sum;
dfs(u);
}
}
long long dp[2][1005][1 << 14];
const int MX = 400005;
char input[MX];
int main() {
int k;
ignore = scanf("%d", &k);
for (int rep = 0; rep < k; rep++) {
static char s[1005];
ignore = scanf(" %s", s);
int n = strlen(s);
int cur = 0;
for (int i = 0; i < n; i++) {
if (T[cur].to[s[i] - 'a'] == 0) {
T[cur].to[s[i] - 'a'] = tsz++;
}
cur = T[cur].to[s[i] - 'a'];
}
int c;
ignore = scanf("%d", &c);
T[cur].sum += c;
}
{
static int Q[1005];
int L = 0, R = 0;
for (int i = 0; i < 26; i++) {
if (T[0].to[i]) Q[R++] = T[0].to[i];
}
while (L < R) {
int cur = Q[L++];
for (int i = 0; i < 26; i++) {
int v = T[cur].to[i];
if (!v) continue;
int p = T[cur].up;
while (p && !T[p].to[i]) p = T[p].up;
if (T[p].to[i]) p = T[p].to[i];
T[v].up = p;
Q[R++] = v;
}
}
for (int v = 0; v < tsz; v++) {
for (int i = 0; i < 26; i++) {
int x = v;
while (x && !T[x].to[i]) x = T[x].up;
if (T[x].to[i]) x = T[x].to[i];
T[v].nxt[i] = x;
}
}
for (int v = 1; v < tsz; v++) {
T[T[v].up].child.push_back(v);
}
}
dfs(0);
fill_n(&dp[0][0][0], 1005 * (1 << 14), -INF);
dp[0][0][0] = 0;
ignore = scanf(" %s", input);
int len = strlen(input);
int taken = 0;
int pp = 0;
for (int i = 0; i < len; pp ^= 1) {
fill_n(&dp[pp ^ 1][0][0], 1005 * (1 << 14), -INF);
if (input[i] == '?') {
for (int msk = 0; msk < (1 << 14); msk++) {
if (__builtin_popcount(msk) != taken) continue;
for (int t = 0; t < 14; t++) {
if (msk >> t & 1) continue;
for (int v = 0; v < tsz; v++) {
int x = T[v].nxt[t];
relax(dp[pp ^ 1][x][msk | (1 << t)], dp[pp][v][msk] + T[x].sum);
}
}
}
taken++;
i++;
} else {
int j = i;
while (j < len && input[j] != '?') j++;
for (int v = 0; v < tsz; v++) {
int x = v;
long long s = 0;
for (int t = i; t < j; t++) {
x = T[x].nxt[input[t] - 'a'];
s += T[x].sum;
}
for (int msk = 0; msk < (1 << 14); msk++) {
relax(dp[pp ^ 1][x][msk], dp[pp][v][msk] + s);
}
}
i = j;
}
}
long long ans = -INF;
for (int msk = 0; msk < (1 << 14); msk++) {
for (int v = 0; v < tsz; v++) {
ans = max(ans, dp[pp][v][msk]);
}
}
printf("%lld\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
pair<long long int, long long int> ar[100005];
long long int n, k;
scanf("%I64d%I64d", &n, &k);
long long int i;
for (i = 0; i < n; i++) {
long long int x, y;
scanf("%I64d", &x);
y = ((x / 10 + 1) * 10 - x) % 10;
ar[i] = make_pair(y, x);
}
sort(ar, ar + n);
long long int sum = 0;
for (i = 0; i < n; i++) {
if (k - ar[i].first >= 0) {
ar[i].second = ar[i].second + ar[i].first;
k = k - ar[i].first;
ar[i].first = 0;
} else {
ar[i].second = ar[i].second + k;
ar[i].first = ar[i].first - k;
k = 0;
break;
}
}
long long int ans = 0, sum1 = 0;
if (k > 0) {
for (i = 0; i < n; i++) {
sum1 = sum1 + ar[i].second / 10;
sum = sum + (100 - ar[i].second);
}
ans = (min(sum, k)) / 10;
ans = ans + sum1;
printf("%I64d", ans);
}
if (k <= 0) {
for (i = 0; i < n; i++) {
sum1 = sum1 + ar[i].second / 10;
}
printf("%I64d", sum1);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
vector<int> G[maxn];
void insert(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
int sz[maxn];
void dfs(int u, int fa) {
sz[u] = 1;
for (int v : G[u]) {
if (v == fa) continue;
dfs(v, u);
sz[u] += sz[v];
}
}
void del(int u, int fa) {
for (int v : G[u]) {
if (v == fa) continue;
if (sz[v] % 2 == 0) del(v, u);
}
printf("%d\n", u);
for (int v : G[u]) {
if (v == fa) continue;
if (sz[v] & 1) del(v, u);
}
}
int n;
int main() {
scanf("%d", &n);
int rt;
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
if (x == 0)
rt = i;
else
insert(i, x);
}
if (n % 2 == 0) {
puts("NO");
return 0;
}
puts("YES");
dfs(rt, 0);
del(rt, 0);
return 0;
}
| 6 |
#include <bits/stdc++.h>
std::mt19937 rng(
(unsigned int)std::chrono::steady_clock::now().time_since_epoch().count());
using namespace std;
int cnt = 0;
int ask(vector<int> &r) {
cnt++;
assert(cnt < 13);
int sz = r.size();
cout << "? " << sz << " ";
for (auto &x : r) {
cout << x + 1 << " ";
}
cout << endl;
int res;
cin >> res;
return res;
}
void solve() {
cnt = 0;
int n, k;
cin >> n >> k;
vector<int> group(n, -1);
for (long long int i = 0; i < k; i++) {
int sz;
cin >> sz;
for (long long int j = 0; j < sz; j++) {
int m;
cin >> m;
m--;
group[m] = i;
}
}
vector<int> ind(n);
iota(ind.begin(), ind.end(), 0);
int mx = ask(ind);
int low = -1, high = n - 1;
while (low + 1 < high) {
int mid = (low + high) / 2;
1;
vector<int> v(ind.begin(), ind.begin() + mid + 1);
int res = ask(v);
if (res == mx) {
high = mid;
} else {
low = mid;
}
}
vector<int> nw, res(k);
for (long long int i = 0; i < k; i++) {
if (i != group[high]) res[i] = mx;
}
for (long long int i = 0; i < n; i++) {
if (group[i] != group[high]) {
nw.push_back(i);
}
}
int oth = ask(nw);
res[group[high]] = oth;
cout << "! ";
for (long long int i = 0; i < k; i++) {
cout << res[i] << " ";
}
cout << endl;
string s;
cin >> s;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int ttt;
ttt = 1;
cin >> ttt;
while (ttt--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e14;
const long long TE3 = 1005;
const long long TE5 = 300005;
const string YN[2] = {"NO", "YES"};
using namespace std;
long long f(long long n, vector<long long>& q1, vector<long long>& q2) {
unordered_map<long long, long long> e;
long long c = 0;
e[0] = -1;
long long i = 0, j = 0;
long long ans = 0;
while (i < q1.size() || j < q2.size()) {
long long g;
long long q1t = (i >= q1.size()) ? INF : q1[i];
long long q2t = (j >= q2.size()) ? INF : q2[j];
if (q1t < q2t) {
g = q1t;
++c;
++i;
} else {
g = q2t;
--c;
++j;
}
if (e.find(c) == e.end()) {
e[c] = g;
} else {
q2t = (j >= q2.size()) ? INF : q2[j];
q1t = (i >= q1.size()) ? INF : q1[i];
long long tmp = min(q1t, q2t);
long long cur = (tmp == INF ? n : tmp) - e[c] - 1;
ans = max(ans, cur);
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
long long n;
cin >> n;
long long x;
unordered_map<long long, vector<long long> > mpq;
for (long long i = (0); i < (n); ++i) {
cin >> x;
mpq[x].push_back(i);
}
if (mpq.size() == 1) {
cout << 0 << endl;
return 0;
}
unordered_map<long long, long long> rev;
long long ma = -INF, mo = 0;
for (auto it : mpq) {
rev[it.second.size()]++;
if (it.second.size() > mo) {
ma = it.first;
mo = it.second.size();
}
}
if (rev[mo] >= 2) {
cout << n << endl;
return 0;
}
long long ans = 0;
for (auto it : mpq) {
if (it.first == ma) continue;
ans = max(ans, f(n, mpq[ma], it.second));
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int M = 200005;
long long read() {
long long ans = 0, op = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') op = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
ans *= 10;
ans += ch - '0';
ch = getchar();
}
return ans * op;
}
char a[M], b[M];
long long n;
double tot, ans, res, cnt[30];
double work() {
memset(cnt, 0, sizeof(cnt));
res = 0;
for (int i = 1; i <= n; i++) {
res += cnt[b[i] - 'A'] * (n - i + 1);
cnt[a[i] - 'A'] += i;
}
return res;
}
int main() {
n = read();
scanf("%s", a + 1);
scanf("%s", b + 1);
ans += work();
reverse(a + 1, a + 1 + n), reverse(b + 1, b + 1 + n);
ans += work();
for (int i = 1; i <= n; i++)
if (a[i] == b[i]) ans += (double)i * (n - i + 1);
tot = (double)n * (n + 1) * (2 * n + 1) / 6;
printf("%.9lf\n", ans / tot);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const bool debug = false;
int n, a[3005];
int main() {
if (!debug) {
ios_base::sync_with_stdio(false);
}
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int cnt = 0;
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
if (a[i] > a[j]) {
swap(a[i], a[j]);
cnt++;
}
}
}
if (debug) {
cout << "n = " << n << "\na[] =";
for (int i = 1; i <= n; i++) {
cout << " " << a[i];
}
cout << "\ncnt = " << cnt << "\n\n";
}
if (cnt % 2) {
cout << cnt * 2 - 1 << ".000000\n";
} else {
cout << cnt * 2 << ".000000\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long long n;
cin >> n;
long long res = n;
for (long long i = 2; i * i <= n; ++i) {
while (n % (i * i) == 0) {
n /= i;
}
}
cout << n;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[36000], lst[36000];
int dp[36000][55];
const int mx = int(1 << 16);
int tree[2 * mx], aval[2 * mx];
void split(int r) {
tree[r << 1] += aval[r];
tree[r << 1 | 1] += aval[r];
aval[r << 1] += aval[r];
aval[r << 1 | 1] += aval[r];
aval[r] = 0;
}
void update(int rt, int l, int r, int u, int v, int val) {
if (u <= l && r <= v) {
tree[rt] += val;
aval[rt] += val;
return;
}
split(rt);
int m = (l + r) / 2;
if (u < m) update(rt << 1, l, m, u, v, val);
if (m < v) update(rt << 1 | 1, m, r, u, v, val);
tree[rt] = max(tree[rt << 1], tree[rt << 1 | 1]);
}
int query(int rt, int l, int r, int u, int v) {
if (u <= l && r <= v) return tree[rt];
int ans = 0;
int m = (l + r) / 2;
if (u < m) ans = max(ans, query(rt << 1, l, m, u, v));
if (m < v) ans = max(ans, query(rt << 1 | 1, m, r, u, v));
return ans;
}
int main() {
int n, k;
scanf("%d%d", &(n), &(k));
for (int i = 1; i <= n; i++) scanf("%d", &(a[i]));
for (int i = 1; i <= k; i++) {
memset(lst, 0, sizeof(lst));
memset(tree, 0, sizeof(tree));
memset(aval, 0, sizeof(aval));
for (int j = i; j <= n; j++) {
int l = max(i, lst[a[j]] + 1);
update(1, mx, mx * 2, mx + l, mx + j + 1, 1);
update(1, mx, mx * 2, mx + j, mx + j + 1, dp[j - 1][i - 1]);
dp[j][i] = query(1, mx, mx * 2, mx + i, mx + j + 1);
lst[a[j]] = j;
}
}
printf("%d\n", dp[n][k]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bitset<1010> a, b;
cin >> a >> b;
puts((a.count() + (a.count() & 1) < b.count()) ? "NO" : "YES");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k, ans = 0, num;
vector<string> str;
string s;
str.push_back("ABSINTH");
str.push_back("BEER");
str.push_back("BRANDY");
str.push_back("CHAMPAGNE");
str.push_back("GIN");
str.push_back("RUM");
str.push_back("SAKE");
str.push_back("TEQUILA");
str.push_back("VODKA");
str.push_back("WHISKEY");
str.push_back("WINE");
cin >> n;
while (n--) {
cin >> s;
bool flag = 1;
for (i = 0; i < s.length(); i++) {
if (isdigit(s[i]) == false) {
flag = 0;
break;
}
}
if (flag) {
num = stoi(s);
if (num < 18) ans++;
} else {
for (j = 0; j < str.size(); j++) {
if (str.at(j) == s) {
ans++;
break;
}
}
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(rand());
long long a[26], b[26];
string s, t;
long long n, m;
long long k = 0;
bool check(long long mid) {
long long ost = k;
long long nado[26];
for (long long i = 0; i < 26; ++i) {
nado[i] = a[i] * mid;
}
for (long long i = 0; i < 26; ++i) {
if (b[i] < nado[i]) {
ost -= (nado[i] - b[i]);
}
}
return ost >= 0;
}
signed main() {
ios_base::sync_with_stdio(false);
for (long long i = 0; i < n; ++i) {
a[i] = 0;
b[i] = 0;
}
cin >> s;
cin >> t;
n = s.size();
m = t.size();
for (long long i = 0; i < n; ++i) {
if (s[i] != '?') {
++b[s[i] - 97];
}
k += (s[i] == '?');
}
for (long long i = 0; i < m; ++i) {
++a[t[i] - 97];
}
long long l = 0;
long long r = 1000 * 1000 + 1;
while (l < r - 1) {
long long mid = (l + r) / 2;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
long long nado[26];
for (long long i = 0; i < 26; ++i) {
nado[i] = a[i] * l;
}
long long mynado[26];
for (long long i = 0; i < 26; ++i) {
mynado[i] = 0;
if (b[i] < nado[i]) {
mynado[i] = (nado[i] - b[i]);
}
}
long long myii = 0;
for (long long i = 0; i < n; ++i) {
if (s[i] != '?') {
cout << s[i];
} else {
while (mynado[myii] <= 0 && myii < 25) {
++myii;
}
cout << char(myii + 97);
--mynado[myii];
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> k;
vector<int> h;
vector<pair<int, int> > ans;
vector<int> vl[27];
vector<int> vr[27];
int n;
cin >> n;
string l, r;
cin >> l;
cin >> r;
for (int i = 0; i < n; i++) {
if (l[i] != '?') {
vl[l[i] - 'a'].push_back(i);
} else if (l[i] == '?')
vl[26].push_back(i);
if (r[i] != '?') {
vr[r[i] - 'a'].push_back(i);
} else if (r[i] == '?')
vr[26].push_back(i);
}
for (int i = 0; i < 26; i++) {
for (int j = 0; j < min(vl[i].size(), vr[i].size()); j++) {
ans.push_back(make_pair(vl[i][j], vr[i][j]));
l[vl[i][j]] = 'A';
r[vr[i][j]] = 'A';
}
}
int p;
if (vl[26].size() != 0) {
p = 0;
for (int i = 0; i < n; i++) {
if (r[i] != 'A' && r[i] != '?' && p < vl[26].size()) {
ans.push_back(make_pair(vl[26][p], i));
l[vl[26][p]] = 'A';
r[i] = 'A';
p++;
}
}
}
if (vr[26].size() != 0) {
p = 0;
for (int i = 0; i < n; i++) {
if (l[i] != 'A' && l[i] != '?' && p < vr[26].size()) {
ans.push_back(make_pair(i, vr[26][p]));
r[vr[26][p]] = 'A';
l[i] = 'A';
p++;
}
}
for (int i = 0; i < n; i++) {
if (l[i] == '?') {
k.push_back(i);
}
if (r[i] == '?') {
h.push_back(i);
}
}
}
for (int i = 0; i < min(k.size(), h.size()); i++) {
ans.push_back(make_pair(k[i], h[i]));
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct __timestamper {};
const int INF = 1e9;
int subsolve(vector<string> a) {
int n = a.size();
int m = a[0].size();
bool anyA = 0;
bool anyP = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
anyA |= a[i][j] == 'A';
anyP |= a[i][j] == 'P';
}
}
if (!anyA) return INF;
if (!anyP) return 0;
if (a[0] == string(m, 'A')) return 1;
if (a[0][0] == 'A' || a[0][m - 1] == 'A') return 2;
for (int i = 0; i < n; i++) {
if (a[i] == string(m, 'A')) return 2;
}
if (a[0] != string(m, 'P')) return 3;
return 4;
}
int solve(vector<string> a) {
int res = INF;
for (int it = 0; it < 4; it++) {
res = min(res, subsolve(a));
int n = a.size();
int m = a[0].size();
vector<string> b(m, string(n, '.'));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
b[m - 1 - j][i] = a[i][j];
}
}
a = b;
}
return res;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, m;
scanf("%d%d", &n, &m);
vector<string> a(n);
for (int i = 0; i < n; i++) {
static char buf[(int)1.01e5];
scanf("%s", buf);
a[i] = buf;
}
int res = solve(a);
if (res == INF)
printf("MORTAL\n");
else
printf("%d\n", res);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
;
long long ar[40] = {
1, 2, 4, 8, 16, 32,
64, 128, 256, 512, 1024, 2048,
4096, 8092, 16184, 32368, 64736, 129472,
258944, 517888, 1035776, 2071552, 4143104, 8286208,
16572416, 33144832, 66289664, 132579328, 265158656, 530317312,
1060634624, 2121269248, 4242538496, 8485076992, 16970153984, 33940307968};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
cout << ar[n] << '\n';
cout.flush();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j;
cin >> n >> m;
char a[n + 1][m + 1];
int r[3] = {0}, c[3] = {0}, k = 0, f, g;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == '*') {
r[k] = i;
c[k] = j;
k++;
}
}
}
sort(r, r + 3);
sort(c, c + 3);
if (r[1] == r[0]) {
f = r[2];
}
if (r[0] == r[2]) {
f = r[1];
}
if (r[1] == r[2]) {
f = r[0];
}
if (c[0] == c[1]) {
g = c[2];
}
if (c[0] == c[2]) {
g = c[1];
}
if (c[1] == c[2]) {
g = c[0];
}
cout << f << " " << g;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
set<pair<int, int>> st;
for (int i = 0; i < k; ++i) {
int x, y;
cin >> x >> y;
st.insert(make_pair(x, y));
if (st.find(make_pair(x - 1, y)) != st.end() &&
st.find(make_pair(x, y + 1)) != st.end() &&
st.find(make_pair(x - 1, y + 1)) != st.end()) {
cout << i + 1;
return 0;
}
if (st.find(make_pair(x - 1, y)) != st.end() &&
st.find(make_pair(x, y - 1)) != st.end() &&
st.find(make_pair(x - 1, y - 1)) != st.end()) {
cout << i + 1;
return 0;
}
if (st.find(make_pair(x + 1, y)) != st.end() &&
st.find(make_pair(x, y + 1)) != st.end() &&
st.find(make_pair(x + 1, y + 1)) != st.end()) {
cout << i + 1;
return 0;
}
if (st.find(make_pair(x + 1, y)) != st.end() &&
st.find(make_pair(x, y - 1)) != st.end() &&
st.find(make_pair(x + 1, y - 1)) != st.end()) {
cout << i + 1;
return 0;
}
}
cout << 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char c;
int n, x, y, i, o;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
for (cin >> n >> x >> y; i++ < n;) {
cin >> c;
if (i > n - x) {
o += i == n - y ? c == '0' : c == '1';
}
}
cout << (o) << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
long long n;
map<long long, int> mp;
void rec(int d, long long tot) {
if (!d) {
mp[tot];
return;
}
rec(d - 1, tot + 1);
rec(d - 1, tot + 5);
rec(d - 1, tot + 10);
rec(d - 1, tot + 50);
}
int main() {
std ::ios ::sync_with_stdio(false);
cin >> n;
if (n <= 12) {
rec(n, 0LL);
cout << mp.size() << endl;
} else {
rec(12, 0LL);
cout << mp.size() + (n - 12LL) * 49LL << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
set<long long int> heap;
char usados[12];
void bckt(long long int num, long long int p, int x, int y) {
if (num) {
long long int aux = num;
memset(usados, 0, sizeof(usados));
if (aux % 10 == 0) usados[0] = 1;
while (aux) {
int r = aux % 10;
usados[r] = 1;
aux /= 10;
}
int cont = 0;
for (int i = 0; i <= 9; i++) {
if (usados[i]) cont++;
}
if (cont <= 2) heap.insert(num);
}
if (p > n || p == (10000000000LL)) return;
bckt(num + p * x, p * 10, x, y);
bckt(num + p * y, p * 10, x, y);
}
int main(void) {
scanf("%d", &n);
for (int x = 0; x <= 9; x++) {
for (int y = 0; y <= 9; y++) {
bckt(0, 1, x, y);
}
}
int resp = 0;
for (set<long long int>::iterator it = heap.begin(); it != heap.end(); it++) {
if (*it > n) break;
resp++;
}
printf("%d\n", resp);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, f[20100];
long long a[2100], b[2100];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &a[i], &b[i]);
a[i]++;
}
long long mm = 0;
memset(f, 0x3f3f3f3f3f3f3f, sizeof(f));
f[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = n; j >= 0; j--) {
f[j + a[i]] = min(f[j + a[i]], f[j] + b[i]);
mm = max(mm, j + a[i]);
}
}
long long ans = 0x3f3f3f3f3f3f3f;
for (int i = n; i <= mm; i++) {
if (f[i]) {
ans = min(ans, f[i]);
}
}
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int len = str.length();
for (int i = 0; i < len; i++) {
if (str[i] == '-') {
if (str[i + 1] == '-') {
cout << 2;
} else {
cout << 1;
}
i++;
} else {
cout << 0;
}
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
const int mxN = 2e5 + 1;
int n;
vector<vector<int>> ans;
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n;
set<pii> cur;
int c = -1;
for (int i = 0; i < n; ++i) {
int a, cc = -1;
cin >> a;
if (cur.empty() || a < cur.begin()->first)
ans.push_back({a}), cc = ++c;
else {
auto it = cur.lower_bound(pii(a, INT_MIN));
if (it == cur.begin())
ans.push_back({a}), cc = ++c;
else {
--it;
ans[cc = it->second].push_back({a});
cur.erase(it);
}
}
cur.insert(pii(a, cc));
}
for (auto& v : ans)
for (int i = 0; i < v.size(); ++i)
cout << v[i] << (i < v.size() - 1 ? " " : "\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
bool flag;
while (t--) {
int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
flag = true;
sort(a, a + n);
long long int k = a[0] * a[n - 1], tmp;
for (int i = 0; i < n; i++) {
tmp = a[i] * a[n - 1 - i];
if (tmp != k) flag = false;
}
int ptr = 0;
if (flag) {
for (int i = 2; i <= sqrt(k); i++) {
if (k % i == 0) {
if (a[ptr] == i)
ptr++;
else {
flag = false;
break;
}
}
}
}
if (flag)
cout << k << endl;
else
cout << -1 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
unordered_map<int, int> m1;
for (auto elem : a) m1[elem]++;
int x1 = 0;
for (int i = 1; i <= 100; ++i) {
if (m1[i] > m1[x1]) {
x1 = i;
}
}
int ans = 0;
for (int x2 = 0; x2 <= 100; ++x2) {
if (x1 == x2) continue;
unordered_map<int, int> m2;
vector<int> pr(n + 1);
for (int i = 0; i < n; ++i) {
pr[i + 1] = pr[i];
if (a[i] == x2) {
pr[i + 1] -= 1;
}
if (a[i] == x1) pr[i + 1] += 1;
}
for (int i = 0; i <= n; ++i) {
if (m2[pr[i]]) {
ans = max(ans, -m2[pr[i]] + i + 1);
}
if (!m2[pr[i]]) m2[pr[i]] = i + 1;
m2[pr[i]] = min(m2[pr[i]], i + 1);
}
}
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int M = 1000000007;
long long int min(long long int a, long long int b, long long int c,
long long int d) {
long long int arr[4] = {a, b, c, d};
sort(arr, arr + 4);
return arr[0];
}
long long int max(long long int a, long long int b, long long int c,
long long int d) {
long long int arr[4] = {a, b, c, d};
sort(arr, arr + 4);
return arr[3];
}
long long int gcd(long long int a, long long int b) {
if (b < a) {
int temp = a;
a = b;
b = temp;
}
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
return (a * b / gcd(a, b));
}
vector<long long int> getprimes() {
vector<long long int> pl(101, 1);
for (int i = 2; i <= 100; i++) {
if (pl[i] == 1) {
for (int j = 2 * i; j <= 100; j += i) {
pl[j] = 0;
}
}
}
return pl;
}
double distsqrd(double x1, double y1, double x2, double y2) {
return (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
}
long long int fact(long long int first) {
long long int ans = 1;
if (first == 0) {
return 1;
}
while (first > 0) {
ans = (ans * first) % 1000000007;
first--;
}
return ans % 1000000007;
}
long long int power(long long int a, long long int b) {
long long int ans = 1;
while (b > 0) {
if (b % 2 == 1) {
ans *= a;
ans = ans % M;
}
b /= 2;
a *= a;
a = a % M;
}
return ans % M;
}
long long int mod(long long int a, long long int b) {
return (((a % b) + b) % b);
}
vector<int> getbinary(int first) {
vector<int> bin(16, 0);
int iter = 0;
while (first > 0) {
if (first % 2 == 1) {
bin[iter] = 1;
} else {
bin[iter] = 0;
}
iter++;
first /= 2;
}
return bin;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s1, s2;
cin >> s1 >> s2;
int n = s1.size();
int a[26][n + 1];
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
a[j][n] = -1;
if ('a' + j == s1[i]) {
a[j][i] = i + 1;
} else {
a[j][i] = a[j][i + 1];
}
}
}
n = s2.size();
int ans = 1;
int curr = 0;
for (int i = 0; i < n; i++) {
if (a[s2[i] - 'a'][curr] == -1 && curr == 0) {
cout << -1 << endl;
return 0;
}
if (a[s2[i] - 'a'][curr] != -1) {
curr = a[s2[i] - 'a'][curr];
} else {
curr = 0;
ans++;
i--;
}
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 100;
const long long inf = 1e18;
struct Edge {
int to;
long long val;
int next;
} e[MAXN << 1];
int head[MAXN], line[MAXN], pre[MAXN], nxt[MAXN], n, m, tot;
long long tmp, ans[MAXN], siz[MAXN], dp[MAXN], dis[MAXN];
void add_edge(int u, int v, long long val) {
e[++tot].next = head[u];
e[tot].to = v;
e[tot].val = val;
head[u] = tot;
}
void dfs(int x, int f) {
if (x == n) line[x] = 1;
siz[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
int to = e[i].to;
if (to == f) continue;
dfs(to, x);
siz[x] += siz[to];
if (line[to]) {
pre[to] = x;
nxt[x] = to;
line[x] = 1;
dis[x] = dis[to] + e[i].val;
}
}
}
long long dfs2(int x, int f) {
long long d = 0;
for (int i = head[x]; i; i = e[i].next) {
int to = e[i].to;
if (to == f) continue;
d = max(d, dfs2(to, x) + e[i].val);
}
return d;
}
int main() {
cin >> n >> m;
memset(pre, -1, sizeof pre);
memset(nxt, -1, sizeof nxt);
for (int i = 1; i <= n - 1; i++) {
int v, u, val;
scanf("%d%d%d", &u, &v, &val);
add_edge(u, v, val);
add_edge(v, u, val);
}
dfs(1, -1);
long long x = 1, maxn = -inf, maxn2 = -inf, pos2, maxans = -inf;
while (x != -1) {
long long maxx = 0, sumsiz = 0;
for (int i = head[x]; i; i = e[i].next) {
int to = e[i].to;
if (to == pre[x]) continue;
if (to == nxt[x]) continue;
sumsiz += siz[to];
if (sumsiz >= 2)
maxans = inf;
else
maxx = max(maxx, dfs2(to, x) + e[i].val);
}
if (pos2 == pre[x] && maxx == 0)
maxans = max(maxans, maxn + dis[x] + maxx);
else
maxans = max(maxans, maxn2 + dis[x] + maxx);
if (maxn2 < maxx - dis[x]) {
maxn = maxn2;
maxn2 = maxx - dis[x];
pos2 = maxx == 0 ? x : -1;
}
x = nxt[x];
}
for (int i = 1; i <= m; i++) {
long long delt;
scanf("%lld", &delt);
if (delt + maxans >= 0)
printf("%lld\n", dis[1]);
else
printf("%lld\n", dis[1] + delt + maxans);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int x[1000005], num[1000005], cost[1000005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t, n, m, cnt, i, j, k, ans;
cin >> n >> k;
for (int i = int(0); i < int(n); i++) cin >> x[i];
sort(x, x + n);
ans = 0x3f3f3f3f3f3f3f3f;
for (int i = int(0); i < int(n); i++) {
m = x[i];
cnt = 0;
while (m) {
num[m]++;
cost[m] = cost[m] + cnt;
if (num[m] >= k) ans = min(ans, cost[m]);
cnt++;
m /= 2;
}
cost[0] = cost[0] + cnt;
num[0]++;
if (num[0] >= k) ans = min(ans, cost[0]);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 5005, INF = 1e15;
long long MOD = 998244353;
template <typename T>
void c_min(T &a, const T b) {
if (b <= a) a = b;
}
template <typename T>
void c_max(T &a, const T b) {
if (a <= b) a = b;
}
template <typename T>
T mexp(T a, long long e) {
T res = 1;
while (e) {
if (e & 1) res *= a;
a *= a;
e >>= 1;
}
return res;
}
void test_case(long long tc = 0) {
int l, r;
cin >> l >> r;
int x = r / 2 + 1;
int ans = r % l;
if (x >= l) {
ans = max(ans, r % x);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T = 1, tc = 0;
cin >> T;
for (; tc < T; tc++) {
test_case(tc);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int sum[409][409], g[409][409], s[409][409];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
g[i][j] = g[i - 1][j];
s[i][j] = s[i][j - 1];
char c;
cin >> c;
if (c == '1')
sum[i][j]++;
else
g[i][j]++, s[i][j]++;
}
int ans = 1000000000;
for (int i = 1; i <= n; i++)
for (int j = i + 4; j <= n; j++) {
int mx = -100000000;
for (int q = 4; q <= m; q++) {
int d = q - 3;
int r = sum[j - 1][d] - sum[i][d];
int p = g[j - 1][d] - g[i][d];
r += s[j][d] + s[i][d];
r -= p;
mx = max(mx, r);
int h = sum[j - 1][q - 1] - sum[i][q - 1];
h += s[j][q - 1] + s[i][q - 1] + g[j - 1][q] - g[i][q];
ans = min(ans, h - mx);
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T scan() {
T a = 0;
register int c;
while ((c = getchar()) <= ' ')
;
if (c == '-') return -scan<T>();
for (; c > ' '; c = getchar()) a = (a << 1) + (a << 3) + (c & 15);
return a;
}
template <typename T>
void read(T &a) {
a = scan<T>();
}
template <typename T, typename... R>
void read(T &a, R &...r) {
read(a);
read(r...);
}
string read(bool f = 0) {
char ch;
string a = "";
do {
ch = getchar();
} while (ch <= ' ');
while (1) {
a += ch;
ch = getchar();
if (!f) {
if (ch <= ' ') break;
} else {
if (ch < ' ') break;
}
}
return a;
}
const double PI = acos(-1);
struct cpx {
double x, y;
cpx(double _x = 0, double _y = 0) : x(_x), y(_y) {}
cpx operator+(cpx &tt) { return cpx(x + tt.x, y + tt.y); }
cpx operator-(cpx &tt) { return cpx(x - tt.x, y - tt.y); }
cpx operator*(cpx &tt) {
return cpx(x * tt.x - y * tt.y, x * tt.y + y * tt.x);
}
};
void fft(vector<cpx> &a, int f) {
int i, j, k, n = int(a.size());
for (i = j = 0; i < n; ++i) {
if (i > j) swap(a[i], a[j]);
for (k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
for (i = 1; i < n; i <<= 1) {
cpx wn(cos(PI / i), f * sin(PI / i));
for (j = 0; j < n; j += i << 1) {
cpx w(1, 0);
for (k = 0; k < i; ++k, w = w * wn) {
cpx x = a[j + k], y = w * a[i + j + k];
a[j + k] = x + y;
a[i + j + k] = x - y;
}
}
}
if (f == -1)
for (i = 0; i < n; ++i) a[i].x /= n, a[i].y /= n;
}
template <typename T>
vector<cpx> mul(vector<T> &a, vector<T> &b) {
vector<cpx> u(a.begin(), a.end());
vector<cpx> v(b.begin(), b.end());
int n = 1, i = max(a.size(), b.size());
while (n < i) n <<= 1;
n <<= 1;
u.resize(n), v.resize(n);
fft(u, 1), fft(v, 1);
for (i = 0; i < n; ++i) u[i] = u[i] * v[i];
fft(u, -1);
return u;
}
int S, B;
int m, n;
string u, v;
vector<int> a, b;
vector<cpx> d;
vector<vector<int>> inB;
void build() {
int i, j, p, q, N;
for (i = 0; i < B; ++i) {
p = i * S, q = min(p + S, n);
N = q - p, a.resize(N);
for (j = 0; j < N; ++j) a[N - 1 - j] = (u[p + j] == '1' ? 1 : -1);
d = mul(a, b);
for (j = 0; j < m; ++j) {
inB[i][j] = (int)(N - d[j].x + 0.5) >> 1;
}
}
}
int get(int l, int r, int N) {
int p = l / S, q = (l + N - 1) / S;
int i, e, res = 0;
if (p == q) {
for (i = l; i < l + N; ++i) res += (u[i] != v[i - l + r]);
} else {
e = (p + 1) * S;
for (i = l; i < e; ++i) res += (u[i] != v[i - l + r]);
for (i = p + 1; i < q; ++i) res += inB[i][(i + 1) * S - 1 - l + r];
for (i = q * S; i < l + N; ++i) res += (u[i] != v[i - l + r]);
}
return res;
}
int main() {
int q, i, l, r, N;
u = read(0), v = read(0);
n = u.size(), m = v.size();
b.resize(m);
for (i = 0; i < m; ++i) b[i] = v[i] == '1' ? 1 : -1;
S = 5 * sqrt(n * log2(n));
B = (n + S - 1) / S;
inB.resize(B, vector<int>(m));
build();
read(q);
while (q--) {
read(l, r, N);
printf("%d\n", get(l, r, N));
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
namespace matrix {
template <int N, int M>
class matr {
public:
double dat[N][M];
void init() { memset(dat, 0, sizeof(dat)); }
void iden() {
init();
for (int i = 0; i < min(N, M); i++) dat[i][i] = 1;
}
matr<M, N> trans() {
matr<M, N> out;
for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++) out[i][j] = dat[j][i];
}
const double *operator[](const int &x) const { return dat[x]; }
double *operator[](const int &x) { return dat[x]; }
template <int X>
friend matr<N, M> operator*(const matr<N, X> a, const matr<X, M> b) {
matr<N, M> out;
out.init();
for (int i = 0; i < N; i++) {
for (int j = 0; j < X; j++) {
if (a[i][j] != 0) {
for (int k = 0; k < M; k++) out[i][k] += a[i][j] * b[j][k];
}
}
}
return out;
}
};
}; // namespace matrix
using namespace matrix;
int n, m, K, flag[510], id[510];
vector<int> special;
double a[510][510], lft[510];
vector<pair<pair<int, int>, double> > opt;
vector<int> v[510];
void gauss() {
for (int i = 1; i <= n; i++) {
int pos = -1;
for (int j = i; j <= n; j++) {
if (fabs(a[j][i]) > 1e-12) {
pos = j;
break;
}
}
assert(pos != -1);
swap(id[pos], id[i]);
for (int j = 1; j <= n; j++) swap(a[pos][j], a[i][j]);
for (int j = 1; j <= n; j++) {
if (j != pos) {
double dlt = a[j][i] / a[pos][i];
opt.push_back(make_pair(make_pair(id[j], id[pos]), dlt));
for (int k = 1; k <= n; k++) a[j][k] -= a[pos][k] * dlt;
}
}
}
}
double cur[510];
void solve() {
for (auto &x : opt) cur[x.first.first] -= cur[x.first.second] * x.second;
for (int i = 1; i <= n; i++) {
cur[id[i]] /= a[i][i];
}
}
matr<110, 110> g;
int main() {
scanf("%d%d%d", &n, &m, &K);
for (int i = 1; i <= n; i++) {
scanf("%d", &flag[i]);
if (flag[i]) special.push_back(i);
}
for (int i = 1, ti, tj; i <= m; i++) {
scanf("%d%d", &ti, &tj);
v[ti].push_back(tj);
v[tj].push_back(ti);
}
for (int i = 1; i <= n; i++) {
id[i] = i;
double bas = 1.0 / v[i].size();
for (auto &x : v[i]) {
if (!flag[x]) a[i][x] -= bas;
}
a[i][i] = 1;
}
gauss();
matr<1, 110> ans;
ans.init();
for (int i = 0; i < special.size(); i++) {
int x = special[i];
memset(cur, 0, sizeof(cur));
for (auto &y : v[x]) cur[y] += 1.0 / v[y].size();
solve();
ans[0][i] = cur[id[1]];
for (int j = 0; j < special.size(); j++) g[j][i] = cur[id[special[j]]];
}
K -= 2;
while (K) {
if (K & 1) ans = ans * g;
g = g * g;
K >>= 1;
}
printf("%.10lf\n", ans[0][special.size() - 1]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, u, v, D, B, a[100009];
long long c[100009];
void ins(int x, int y) {
for (; x <= n; x += x & -x) c[x] += y;
}
long long getsum(int x) {
long long y = 0;
for (; x; x ^= x & -x) y += c[x];
return y;
}
void update() {
for (; u <= n && !a[u]; u++)
;
for (; v && !a[v]; v--)
;
}
int main() {
scanf("%d%d%d", &n, &D, &B);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
ins(i, a[i]);
}
u = 1;
v = n;
update();
int tx = 0, ty = 0;
for (int i = 1, j = n; i <= j;) {
int x = min((long long)n, i + (long long)i * D);
if (getsum(x) >= B) {
int tmp = 0;
while (tmp < B) {
int da = min(B - tmp, a[u]);
a[u] -= da;
ins(u, -da);
tmp += da;
update();
}
} else
tx++;
i++;
if (i > j) break;
x = max(1ll, j - (long long)(n - j + 1) * D);
if (getsum(n) - getsum(x - 1) >= B) {
int tmp = 0;
while (tmp < B) {
int da = min(B - tmp, a[v]);
a[v] -= da;
ins(v, -da);
tmp += da;
update();
}
} else
ty++;
j--;
}
printf("%d\n", max(tx, ty));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int x[5];
int main() {
for (int i = 1; i <= 4; i++) cin >> x[i];
int ti = 0;
for (int i = 1; i <= 4; i++)
if (x[i] > x[ti]) ti = i;
for (int i = 1; i <= 4; i++)
if (ti != i) cout << x[ti] - x[i] << ' ';
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma comment(linker, "/STACK:32505856")
template <class T>
inline T sqr(T a) {
return a * a;
}
template <class T>
inline void gmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline void gmax(T &a, T b) {
if (a < b) a = b;
}
inline int dcmp(const double &a) { return a > 1e-8 ? 1 : (a < -1e-8 ? -1 : 0); }
struct Initializer {
Initializer() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
} initializer;
struct SAM {
int tot, last;
int go[1000010 << 1][26], pre[1000010 << 1], step[1000010 << 1];
int vis[1000010 << 1];
long long same[1000010 << 1];
inline void new_node(int s) {
step[++tot] = s;
pre[tot] = 0;
same[tot] = 1;
memset(go[tot], 0, sizeof(go[tot]));
}
inline void build(char *s) {
tot = 0, last = 1;
new_node(0);
int n = strlen(s);
for (int i = 0; i <= n - 1; i++) {
new_node(step[last] + 1);
int c = s[i] - 'a';
int p = last, np = tot, q, nq;
for (; p && !go[p][c]; p = pre[p]) go[p][c] = np;
if (!p)
pre[np] = 1;
else {
q = go[p][c];
if (step[q] == step[p] + 1)
pre[np] = q;
else {
new_node(step[p] + 1), nq = tot;
for (int j = 0; j <= 25; j++) go[nq][j] = go[q][j];
pre[nq] = pre[q];
pre[np] = pre[q] = nq;
same[nq] = 0;
for (; p && go[p][c] == q; p = pre[p]) go[p][c] = nq;
}
}
last = np;
}
}
int din[1000010 << 1], q[1000010 << 1], top, tail;
inline void get_same() {
top = tail = 0;
for (int i = 1; i <= tot; i++) din[pre[i]]++;
for (int i = tot; i >= 1; i--)
if (!din[i]) q[++tail] = i;
while (++top <= tail) {
int first = q[top];
if (!--din[pre[first]]) q[++tail] = pre[first];
same[pre[first]] += same[first];
}
}
inline long long get_ans(char *s, int n, int tag) {
long long res = 0;
int p = 1, len = 0;
for (int i = 0; i <= n + n - 2; i++) {
int c = s[i] - 'a';
if (!go[p][c]) {
while (p && !go[p][c]) p = pre[p];
len = step[p];
}
if (go[p][c]) {
p = go[p][c];
len++;
}
if (len >= n) {
int q = p;
while (!(step[pre[q]] + 1 <= n && n <= step[q])) {
if (vis[q] == tag) goto next;
vis[q] = tag;
q = pre[q];
}
if (vis[q] != tag) {
vis[q] = tag;
res += same[q];
}
next:;
}
}
return res;
}
} sam;
int main() {
static char s[1000010], t[1000010 << 1];
scanf("%s", s);
sam.build(s);
sam.get_same();
int n, m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%s", t);
n = strlen(t);
memcpy(t + n, t, n);
t[n + n] = 0;
printf("%I64d\n", sam.get_ans(t, n, i));
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
iostream::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<string> ans(n);
ans[0] = 'A';
for (auto(i) = (1); (i) < (n); (i)++) {
ans[i] = ans[i - 1];
if (ans[i].back() != 'Z')
ans[i].back()++;
else
ans[i].back() = 'A', ans[i].push_back('a');
}
for (auto(i) = (k - 1); (i) < (n); (i)++) {
string s;
cin >> s;
if (s == "NO") ans[i] = ans[i - k + 1];
}
for (auto(i) = (0); (i) < (n); (i)++) cout << ans[i] << ' ';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char now[1 << 16], *S, *T;
if (S == T) {
T = (S = now) + fread(now, 1, 1 << 16, stdin);
if (S == T) return EOF;
}
return *S++;
}
inline int read() {
int x = 0, f = 1;
char c = gc();
while (c < '0' || c > '9') {
(c == '-') ? (f = 0) : 0;
c = gc();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = gc();
}
return f ? x : ((~x) + 1);
}
const int mod = 1e9 + 7;
inline int add(const int &x, const int &y) {
return (x + y >= mod) ? (x + y - mod) : (x + y);
}
inline void Add(int &x, const int &y) {
x += y;
(x >= mod) ? (x -= mod) : 0;
}
inline int sub(const int &x, const int &y) {
return (x < y) ? (x - y + mod) : (x - y);
}
inline void Sub(int &x, const int &y) {
x -= y;
(x < 0) ? (x += mod) : 0;
}
inline int qpow(int a, int b) {
if (!a) return 0;
int res = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) res = 1ll * res * a % mod;
return res;
}
const int N = 1010;
int n, deg[N];
struct edge {
int to, val, nxt;
} e[N << 1];
bool flg[N];
int hd[N], cnt = 1;
inline void addedge(int x, int y, int z) {
e[++cnt] = (edge){y, z, hd[x]};
hd[x] = cnt;
}
vector<int> leaf;
void dfs(int x, int fr) {
if (deg[x] == 1) leaf.push_back(x);
for (int i = hd[x], y = e[i].to; i; i = e[i].nxt, y = e[i].to)
if (y ^ fr) {
dfs(y, x);
return;
}
}
inline void find(int x, int fr) {
leaf.clear();
for (int i = hd[x], y = e[i].to; i; i = e[i].nxt, y = e[i].to)
if (y ^ fr) {
dfs(y, x);
if (((int)((leaf).size())) == 2) return;
}
}
struct item {
int x, y, z;
};
vector<item> ans;
inline void operate(int x, int y, int z) { ans.push_back((item){x, y, z}); }
int main() {
n = read();
for (int(i) = (1); (i) <= (n - 1); ++(i)) {
int x = read(), y = read(), z = read();
addedge(x, y, z >> 1);
addedge(y, x, z >> 1);
++deg[x];
++deg[y];
}
for (int(i) = (1); (i) <= (n); ++(i))
if (deg[i] == 2) {
puts("NO");
return 0;
}
puts("YES");
if (n == 2) {
puts("1");
printf("%d %d %d\n", 1, 2, e[2].val << 1);
return 0;
}
for (int(i) = (1); (i) <= (n - 1); ++(i)) {
int u = e[i << 1].to, v = e[i << 1 | 1].to, x = e[i << 1].val;
if (deg[u] == 1) swap(u, v);
flg[i] = 1;
find(u, v);
int a = leaf[0], b = leaf[1];
if (deg[v] == 1) {
operate(a, v, x);
operate(b, v, x);
operate(a, b, -x);
} else {
find(v, u);
int c = leaf[0], d = leaf[1];
operate(a, c, x);
operate(b, d, x);
operate(a, b, -x);
operate(c, d, -x);
}
flg[i] = 0;
}
printf("%d\n", ((int)((ans).size())));
for (auto now : ans) {
printf("%d %d %d\n", now.x, now.y, now.z);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 123;
const int M = 1e5 + 123;
const double Pi = acos(-1);
const long long Inf = 1e18;
const int inf = 1e9;
int mod = 1e9 + 7;
const double eps = 1e-12;
const int Sz = 350;
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int mult(int a, int b) { return 1ll * a * b % mod; }
int sum(int a, int b) {
add(a, b);
return a;
}
int dp[N], n, m, q, c[N], D[N], sz[N], C;
bool bad[N], badq[N];
pair<int, int> d[N];
vector<int> g[N];
long long ans[N], tot[N], tmp[N];
vector<pair<int, int> > lazy[N];
vector<int> lst[N];
vector<long long> S[N];
void paint(int v, int p) {
c[v] = C;
sz[C]++;
for (auto to : g[v]) {
if (to != p) {
if (c[to]) {
bad[C] = 1;
return;
} else {
paint(to, v);
}
}
}
}
void dfs(int v, int p = -1) {
d[v] = {0, 0};
for (auto to : g[v]) {
if (to != p) {
dfs(to, v);
int x = d[to].first;
if (x + 1 > d[v].first) {
d[v].second = d[v].first;
d[v].first = x + 1;
} else {
if (x + 1 > d[v].second) {
d[v].second = x + 1;
}
}
}
}
D[C] = max(D[C], d[v].first + d[v].second);
}
void go(int v, int p = -1, int up = 0) {
int cur = max(up, d[v].first);
lst[C].push_back(cur);
dp[v] = cur;
for (auto to : g[v]) {
if (to != p) {
int cur = (d[to].first + 1 == d[v].first ? d[v].second : d[v].first);
go(to, v, max(up, cur) + 1);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0, u, v; i < m; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!c[i]) {
C++;
paint(i, -1);
if (!bad[C]) {
dfs(i);
go(i);
sort(lst[C].begin(), lst[C].end());
S[C].resize(sz[C]);
for (int i = 0; i < sz[C]; i++) {
S[C][i] = lst[C][i];
if (i > 0) S[C][i] += S[C][i - 1];
}
}
}
}
for (int i = 0, u, v; i < q; i++) {
scanf("%d%d", &u, &v);
if (bad[u] || bad[v] || c[u] == c[v])
badq[i] = 1;
else {
tot[i] = 1ll * sz[c[u]] * sz[c[v]];
if (sz[c[u]] > sz[c[v]]) swap(u, v);
if (sz[c[u]] <= Sz) {
int now = max(D[c[u]], D[c[v]]) - 1;
long long Ps = 0;
for (int j = 0, uk = sz[c[v]]; j < sz[c[u]]; j++) {
while (uk > 0 && lst[c[u]][j] + lst[c[v]][uk - 1] >= now) {
uk--;
Ps += lst[c[v]][uk];
}
ans[i] += 1ll * (now + 1) * uk;
ans[i] += 1ll * (sz[c[v]] - uk) * (lst[c[u]][j] + 1) + Ps;
}
} else {
lazy[c[u]].push_back({c[v], i});
}
}
}
for (int i = 1; i <= C; i++) {
if (sz[i] > Sz) {
for (int j = 1; j <= n; j++) tmp[j] = 0;
for (int j = 1; j <= n; j++) {
int now = max(D[i], D[c[j]]) - 1;
int uk = lower_bound(lst[i].begin(), lst[i].end(), now - dp[j]) -
lst[i].begin();
tmp[c[j]] += 1ll * uk * (now + 1);
tmp[c[j]] += (1ll * (sz[i] - uk) * (dp[j] + 1) + S[i].back() -
(uk > 0 ? S[i][uk - 1] : 0));
}
for (auto it : lazy[i]) {
int id = it.second;
int x = it.first;
ans[id] = tmp[x];
}
}
}
for (int i = 0; i < q; i++) {
if (badq[i])
puts("-1");
else {
double now = 1.0 * ans[i] / tot[i];
printf("%.6lf\n", now);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template<typename T> inline void input(T& inVar) {cin >> inVar;}
template<typename T, typename... S> inline void input(T& inVar, S&... args) {cin >> inVar; input(args ...);}
template<typename T> inline void print(T outVar) {cout << outVar << endl;}
template<typename T, typename... S> inline void print(T outVar, S... args) {cout << outVar << ' '; print(args ...);}
#define range(it, start, end) for (int it = start; it < end; it++)
#define arrPut(var) for (auto &inVar : var) {cin >> inVar;}
#define arrPrint(var) for (auto outVar : var) {cout << outVar << ' ';} cout << endl
#define setup() ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
typedef long long ll;
#define int ll
signed main() {
setup();
int n; input(n);
int a[n], b[n];
arrPut(a);
arrPut(b);
ll totalSum = 0;
range(i, 0, n) {
totalSum += a[i] * b[i];
}
ll dp[n][n];
range(i, 0, n - 1) {
dp[i][i] = totalSum;
dp[i][i + 1] = totalSum - a[i] * b[i] - a[i + 1] * b[i + 1] + a[i] * b[i + 1] + a[i + 1] * b[i];
}
dp[n - 1][n - 1] = totalSum;
range(l, 3, n + 1) {
range(i, 0, n - l + 1) {
int j = i + l - 1;
dp[i][j] = dp[i + 1][j - 1] - a[i] * b[i] - a[j] * b[j] + a[i] * b[j] + a[j] * b[i];
}
}
ll res = 0;
range(i, 0, n) {
range(j, i, n) {
res = max(res, dp[i][j]);
}
}
print(res);
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int marcg[112], marcb[112], n, m, b, g, xi;
int main() {
scanf("%d %d", &n, &m);
scanf("%d", &b);
for (int i = 0; i < b; i++) {
scanf("%d", &xi);
marcb[xi] = 1;
}
scanf("%d", &g);
for (int i = 0; i < g; i++) {
scanf("%d", &xi);
marcg[xi] = 1;
}
int mud = 1;
while (mud != 0) {
mud = 0;
for (int i = 0; i < n * m; i++) {
if (marcg[i % m] == marcb[i % n]) continue;
marcg[i % m] = 1;
marcb[i % n] = 1;
mud = 1;
}
}
int ok = 0;
for (int i = 0; i < m; i++) {
if (marcg[i] == 0) ok = 1;
}
if (ok != 0) {
printf("No\n");
return 0;
}
for (int i = 0; i < n; i++) {
if (marcb[i] == 0) ok = 1;
}
if (ok != 0) {
printf("No\n");
return 0;
}
printf("Yes\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
map<string, int> mp;
while (t--) {
char ch;
cin >> ch;
string str;
cin >> str;
for (int i = 0; i < str.length(); i++) {
if ((str[i] - '0') % 2 == 0)
str[i] = '0';
else
str[i] = '1';
}
while (str.length() < 18) str = "0" + str;
if (ch == '+') {
mp[str]++;
} else if (ch == '-') {
mp[str]--;
} else {
cout << mp[str] << '\n';
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ans[(int)2e5 + 5][2];
int main(void) {
int T;
scanf("%d", &T);
while (T--) {
int b, w, k = 0, ch = 0;
scanf("%d%d", &b, &w);
if (w > b) swap(b, w), ch = 1;
if (3 * w + 1 < b) {
printf("NO\n");
continue;
}
for (int i = 2; i <= 2 * w; i = i + 2) ans[k][0] = 2, ans[k++][1] = i;
for (int i = 2 + 1; i <= 2 * w - 1 && b > 0; i = i + 2, b--) {
ans[k][0] = 2, ans[k++][1] = i;
}
for (int i = 2; i <= 2 * w && b > 0; i = i + 2, b--) {
ans[k][0] = 1, ans[k++][1] = i;
}
for (int i = 2; i <= 2 * w && b > 0; i = i + 2, b--) {
ans[k][0] = 3, ans[k++][1] = i;
}
if (b > 0) {
ans[k][0] = 2, ans[k++][1] = 1, b--;
}
if (b > 0) {
ans[k][0] = 2, ans[k++][1] = 2 * w + 1, b--;
}
if (ch)
for (int i = 0; i < k; i++) ans[i][1]++;
printf("YES\n");
for (int i = 0; i < k; i++) printf("%d %d\n", ans[i][0], ans[i][1]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, sum = 0;
cin >> a;
while (a) {
if (a % 8 == 1) {
sum++;
}
a /= 8;
}
printf("%d\n", sum);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt, lian[200010];
struct node {
int u, v, dis;
} d[200010];
struct Edge {
int u, v;
} e[200010];
bool cmp(node a, node b) { return a.dis > b.dis; }
bool cmp2(Edge a, Edge b) {
if (a.u == b.u) return a.v < b.v;
return a.u < b.u;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
d[i].u = 2 * i - 1;
d[i].v = 2 * i;
scanf("%d", &d[i].dis);
}
sort(d + 1, d + n + 1, cmp);
for (int i = 1; i <= n; i++) lian[i] = d[i].u;
for (int i = 1; i <= n - 1; i++) {
e[++cnt].u = min(d[i].u, d[i + 1].u);
e[cnt].v = max(d[i].u, d[i + 1].u);
}
int pos = n;
for (int i = 1; i <= n; i++) {
if (d[i].dis + i - 1 < pos) {
e[++cnt].u = lian[i + d[i].dis - 1];
e[cnt].v = d[i].v;
} else {
pos++;
lian[pos] = d[i].v;
e[++cnt].u = min(d[i].v, lian[pos - 1]);
e[cnt].v = max(d[i].v, lian[pos - 1]);
}
}
sort(e + 1, e + cnt + 1, cmp2);
for (int i = 1; i <= cnt; i++) {
printf("%d %d\n", e[i].u, e[i].v);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int nm = 100010;
int n, k;
long long a[nm];
long long mod[30];
long long du[30], x[30];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
memset(a, 0x3f, sizeof(a));
int d = 0;
for (int i = 0; i <= n; ++i) {
string s;
cin >> s;
if (s[0] != '?') {
stringstream ss;
ss << s;
ss >> a[i];
d++;
}
}
if (d == n + 1) {
mod[1] = 1000000007;
for (int i = 2; i < 30; ++i)
mod[i] = (mod[i - 1] * (long long)rand() + (long long)rand()) % mod[1];
for (int i = 1; i < 30; ++i) x[i] = 1ll % mod[i];
for (int i = 0; i <= n; ++i) {
for (int j = 1; j < 30; ++j) {
du[j] = (du[j] + a[i] * x[j]) % mod[j];
x[j] = (x[j] * (long long)k) % mod[j];
}
}
for (int i = 1; i < 30; ++i)
if (du[i]) {
cout << "No\n";
return 0;
}
cout << "Yes\n";
return 0;
}
if (k == 0) {
if (a[0] < inf) {
if (a[0] == 0) {
cout << "Yes\n";
} else
cout << "No\n";
return 0;
} else {
if (d % 2 == 0) {
cout << "No\n";
} else {
cout << "Yes\n";
}
return 0;
}
}
if (n % 2 == 0)
cout << "No\n";
else
cout << "Yes\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
scanf("%lld", &n);
long long a[n], b[n];
long long mn = 0;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
b[i] = a[i];
}
for (int i = 0; i < n; i++) {
if (a[mn] > a[i]) {
mn = i;
}
}
long long sum = a[mn] * n;
int c[2 * n];
for (int i = 0; i < n; i++) {
c[i] = a[i];
}
for (int i = 0; i < n; i++) {
c[n + i] = a[i];
}
long long mx = 0, s = 0;
for (int i = 0; i < 2 * n; i++) {
if (c[i] != a[mn]) {
s++;
} else {
if (mx < s) {
mx = s;
}
s = 0;
}
}
long long ans = mx + sum;
printf("%lld", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int fact(int n) {
if (n > 1)
return (n * fact(n - 1));
else
return 1;
}
int main() {
int n;
cin >> n;
int x4 = n + 4, x3 = n + 3, x2 = n + 2, x1 = n + 1;
long long x43 = x4 * x3, x21 = x1 * x2;
long long fix = x43 * x21 * n / fact(5);
long long suggest = x21 * n / fact(3);
long long amount = fix * suggest;
cout << amount << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> prime;
void simpleSieve(int limit) {
bool mark[limit + 1];
memset(mark, true, sizeof(mark));
for (int p = 2; p * p < limit; p++) {
if (mark[p] == true) {
for (int i = p * p; i < limit; i += p) mark[i] = false;
}
}
for (int p = 2; p < limit; p++) {
if (mark[p] == true) {
prime.push_back(p);
}
}
}
int main() {
int n;
cin >> n;
for (int i = n; i < n + n; i++) {
cout << i << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int n, h, m, x[100], l, r, xi;
int main() {
scanf("%d%d%d", &n, &h, &m);
for (int i = 1; i <= n; i++) x[i] = h;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &l, &r, &xi);
for (int i = l; i <= r; i++) {
x[i] = min(xi, x[i]);
}
}
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += x[i] * x[i];
}
printf("%d\n", sum);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int i = 0;
int countt = 0;
while (a[i] <= k && i < n) {
i++;
countt++;
}
int j = n - 1;
while (a[j] <= k && j > i) {
j--;
countt++;
}
cout << countt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long N, M, a, b, c;
int inp[300005];
map<int, int> mp;
vector<int> v;
long long pow2[200005];
long long ans;
int chk(long long x) {
int t = 0;
int start = -1;
while (1) {
int idx = lower_bound(v.begin() + start + 1, v.end(), x) - v.begin();
if (idx == v.size()) break;
start = idx;
t++;
x *= 2;
}
return t;
}
int main() {
pow2[0] = 1;
scanf("%lld", &N);
for (int i = 1; i <= N; i++) {
pow2[i] = pow2[i - 1] * 2;
}
for (int i = 1; i <= N; i++) {
scanf("%d", inp + i);
mp[inp[i]]++;
}
for (auto &it : mp) {
v.push_back(it.second);
}
sort(v.begin(), v.end());
for (int n = 1; n <= v.size(); n++) {
long long l = 0, r = 2e5 + 5;
while (l + 1 < r) {
long long mid = l + r >> 1;
if (chk(mid) >= n)
l = mid;
else
r = mid;
}
if (l == 0) continue;
long long ret = l * (pow2[n] - 1);
ans = max(ans, ret);
}
printf("%lld", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 10;
const long long MAX1 = 1e4 + 10;
const int INF = 1e9;
const long long MOD = 1e9 + 7;
double eps = 1e-7;
long long ciel(long long a, long long b) {
if (b == 0) return INF;
return ((a + b - 1) / b);
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
string x, y;
cin >> x;
y = x;
reverse(&x[0], &x[x.size()]);
if (y == x) {
char r = x[0];
int r1;
int sz = x.size();
bool tr = 0;
for (int i = 0; i < sz; i++) {
if (x[i] != r) {
r1 = i;
tr = 1;
break;
}
}
if (!tr) {
cout << -1 << "\n";
} else {
x[0] = x[r1];
x[r1] = r;
cout << x << "\n";
}
} else {
cout << y << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
std::set<int> s;
int id[300010], a[300010];
bool cmp(int x, int y) { return a[x] < a[y]; }
int main() {
int n = inp();
for (int i = 1; i <= n; i++) {
a[i] = inp();
id[i] = i;
s.insert(i);
}
std::sort(id + 1, id + n + 1, cmp);
int ans = 2147483647;
for (int i = 1; i < n; i++) {
int len = 0;
if (*s.begin() != id[i]) len = std::max(len, id[i] - *s.begin());
if (*s.rbegin() != id[i]) len = std::max(len, *s.rbegin() - id[i]);
ans = std::min(ans, a[id[i]] / len);
s.erase(s.find(id[i]));
}
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int MAX_N = 2e5 + 5;
long long dp[MAX_N][3], cnt[3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, l, r;
cin >> n >> l >> r;
memset(dp, 0, sizeof dp);
for (int i = 0; i < 3; i++) {
int l2 = l, r2 = r;
while (l2 % 3 != i && l2 <= r) l2++;
while (r2 % 3 != i && r2 >= l) r2--;
if (r2 >= l2) cnt[i] = (r2 - l2) / 3 + 1;
}
dp[1][0] = cnt[0], dp[1][1] = cnt[1], dp[1][2] = cnt[2];
for (int i = 2; i <= n; i++) {
dp[i][0] =
(((dp[i - 1][0] * cnt[0]) % mod) + ((dp[i - 1][1] * cnt[2]) % mod) +
((dp[i - 1][2] * cnt[1]) % mod)) %
mod;
dp[i][1] =
(((dp[i - 1][0] * cnt[1]) % mod) + ((dp[i - 1][1] * cnt[0]) % mod) +
((dp[i - 1][2] * cnt[2]) % mod)) %
mod;
dp[i][2] =
(((dp[i - 1][0] * cnt[2]) % mod) + ((dp[i - 1][1] * cnt[1]) % mod) +
((dp[i - 1][2] * cnt[0]) % mod)) %
mod;
}
cout << dp[n][0] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[1000000], dp[1000000], dp1[100000], dp2[100000], dpp1[100000],
dpp2[100000], seg[1000000];
long long build(long long in, long long l, long long r) {
if (l == r) {
seg[in] = l;
return dp[l];
}
long long mid = (l + r) / 2;
if (build(in * 2 + 1, l, mid) < build(in * 2 + 2, mid + 1, r)) {
seg[in] = seg[in * 2 + 2];
return dp[seg[in]];
} else {
seg[in] = seg[in * 2 + 1];
return dp[seg[in]];
}
}
long long query(long long in, long long l, long long r, long long ql,
long long qr) {
if (l > qr || r < ql) {
return -1;
}
if (l >= ql && r <= qr) {
return seg[in];
}
long long mid = (l + r) / 2;
long long rl = query(in * 2 + 1, l, mid, ql, qr),
rr = query(in * 2 + 2, mid + 1, r, ql, qr);
if (rl == -1) return rr;
if (rr == -1) return rl;
if (dp[rl] < dp[rr]) return rr;
return rl;
}
int main() {
ios::sync_with_stdio(0);
long long n, c2 = 0, c1 = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
if (arr[i] == 2)
c2++;
else
c1++;
dp[i] = c2;
dp2[i] = c2;
dpp1[i] = c1;
}
c2 = c1 = 0;
for (int i = n - 1; i >= 0; i--) {
dp[i] += c1;
if (arr[i] == 1)
c1++;
else
c2++;
dp1[i] = c1;
dpp2[i] = c2;
}
build(0, 0, n - 1);
long long ans = dpp2[0];
for (int i = 0; i < n; i++) ans = max(ans, dpp1[i] + dpp2[i + 1]);
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (i != 0)
ans = max(ans, dp[query(0, 0, n - 1, i, j)] - dp2[i - 1] - dp1[j + 1] +
dpp1[i - 1] + dpp2[j + 1]);
else
ans = max(ans, dp[query(0, 0, n - 1, i, j)] - dp1[j + 1] + dpp2[j + 1]);
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
if (N % 2 == 0)
cout << N / 2;
else
cout << (N + 1) / 2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, ans = 0, x;
cin >> n >> k;
map<int, int> m;
for (int i = 0; i < k; i++) {
m[i] = 0;
}
for (int i = 0; i < n; i++) {
cin >> x;
m[x % k]++;
}
for (int i = 0; i <= k / 2; i++) {
if (i == 0) {
ans += m[i] / 2;
} else if (k % 2 == 0 && i == k / 2) {
ans += m[i] / 2;
} else {
ans += min(m[i], m[k - i]);
}
}
cout << ans * 2;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const double PI = 2.0 * acos(0);
using namespace std;
struct T {
int a;
};
struct vec {
double x, y;
vec(double xx = 0, double yy = 0) {
x = xx;
y = yy;
}
};
vec make_vac(vec p, vec q) { return vec(q.x - p.x, q.y - p.y); }
double dotproduct(vec p, vec q) { return p.x * q.x + p.y * q.y; }
double crossproduct(vec p, vec q) { return p.x * q.y - q.x * p.y; }
double vec_value(vec p) { return sqrt(p.x * p.x + p.y * p.y); }
vec unit_vec(vec p) {
double va = vec_value(p);
return vec(p.x / va, p.y / va);
}
double dis(double px, double py, double qx, double qy) {
px = fabs(px - qx);
py = fabs(py - qy);
return sqrt(px * px + py * py);
}
long long int bigmod(long long int a, long long int b, long long int mod) {
if (b == 0) return 1;
if (b % 2 == 0) {
long long int hh = bigmod(a, b / 2, mod);
return (hh * hh) % mod;
} else {
return (a * bigmod(a, b - 1, mod)) % mod;
}
}
bool dp[505][505][505], viss[505][505][505];
int ar[505];
bool rec(int p, int tot1, int tot2, int rem) {
if (p == 0) {
if (tot1 + tot2 == rem) {
dp[p][tot1][tot2] = 1;
return 1;
} else
return 0;
}
bool &ret = dp[p][tot1][tot2];
if (viss[p][tot1][tot2] == 1) return ret;
viss[p][tot1][tot2] = 1;
ret = rec(p - 1, tot1, tot2, rem);
if (tot1 + tot2 + ar[p - 1] <= rem) {
ret = ret | rec(p - 1, tot1 + ar[p - 1], tot2, rem);
ret = ret | rec(p - 1, tot1, ar[p - 1] + tot2, rem);
}
return ret;
}
int main() {
int i, j, k, l, t, cs = 1, r = 1, s, m, n, a, b, c, d, e, f, g, h, u, v;
memset(viss, 0, sizeof(viss));
memset(dp, 0, sizeof(dp));
scanf("%d %d", &n, &k);
m = k;
for (i = 0; i < n; i++) scanf("%d", &ar[i]);
vector<int> ans;
int vis[505];
memset(vis, 0, sizeof(vis));
dp[0][0][0] = 1;
for (i = 0; i < n; i++) {
for (j = 0; j <= m; j++) {
for (k = 0; k <= m; k++) {
dp[i + 1][j][k] |= dp[i][j][k];
if (j + ar[i] <= m) dp[i + 1][j + ar[i]][k] |= dp[i][j][k];
if (k + ar[i] <= m) dp[i + 1][j][k + ar[i]] |= dp[i][j][k];
}
}
}
for (i = 0; i <= m; i++) {
for (j = 0; j <= m; j++) {
if (dp[n][i][j] == 1 && i + j == m) {
if (vis[i] == 0) {
ans.push_back(i);
vis[i] = 1;
}
if (vis[j] == 0) {
ans.push_back(j);
vis[j] = 1;
}
}
}
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
double h1, h2;
int num;
} s[100010];
bool cmp(node a, node b) {
if (a.h1 == b.h1) return a.h2 < b.h2;
return a.h1 < b.h1;
}
int main() {
long long int n;
int i, j, judge;
double x1, x2, k[100010], b[100010];
scanf("%lld", &n);
scanf("%lf%lf", &x1, &x2);
for (i = 1; i <= n; i++) {
scanf("%lf%lf", &k[i], &b[i]);
s[i].h1 = k[i] * x1 + b[i];
s[i].h2 = k[i] * x2 + b[i];
}
sort(s + 1, s + 1 + n, cmp);
judge = 0;
for (i = 2; i <= n; i++)
if (s[i].h2 < s[i - 1].h2) {
judge = 1;
break;
}
if (judge)
printf("YES\n");
else
printf("NO\n");
}
| 4 |
#include <bits/stdc++.h>
int n, m, up, spe, sp;
int a[1010];
int s[1010];
int f[1010];
int v[1010];
int dp[3010];
int findset(int x) {
if (x == f[x]) return x;
f[x] = findset(f[x]);
return f[x];
}
inline void init() {
int i, fx, fy;
scanf("%d%d", &n, &m);
spe = 0;
sp = m;
for (i = 1; i <= n; i++) {
f[i] = i;
s[i] = 1;
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) {
if (a[i] == 0) continue;
fx = findset(a[i]);
fy = findset(i);
if (fy == sp) spe += s[fx];
if (a[i] == sp) sp = fy;
s[fy] += s[fx];
f[fx] = fy;
}
up = 0;
for (i = 1; i <= n; i++) {
fx = findset(i);
if (s[fx] && sp != fx) {
up++;
v[up] = s[fx];
s[fx] = 0;
}
}
}
inline void work() {
int i, j;
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (i = 1; i <= up; i++)
for (j = n; j >= v[i]; j--)
if (dp[j - v[i]]) dp[j] = 1;
spe++;
for (i = 0; i <= n - spe; i++)
if (dp[i]) printf("%d\n", i + spe);
}
int main() {
init();
work();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long n1, long long n2) {
if (n2 != 0)
return gcd(n2, n1 % n2);
else
return n1;
}
long long isprime(long long n) {
if (n <= 1) return 0;
if (n <= 3) return 1;
if (n % 2 == 0 || n % 3 == 0) return 0;
for (long long i = 5; i <= sqrt(n); i += 6) {
if (n % i == 0 || n % (i + 2) == 0) return 0;
}
return 1;
}
long long fact(long long n) {
long long i = 1, co = 1;
for (i = 1; i <= n; i++) co *= i;
return co;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long j, n, m, i, k, a, c, x, y, z;
cin >> n >> m;
char ch[n + 2][m + 2];
for (i = 0; i <= n + 1; i++) {
for (j = 0; j <= m + 1; j++) ch[i][j] = '-';
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) cin >> ch[i][j];
}
char b = 'B', w = 'W', prev = b;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (ch[i][j] == '.') {
if ((i + j) % 2 == 0)
ch[i][j] = 'W';
else
ch[i][j] = 'B';
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) cout << ch[i][j];
cout << "\n";
}
return !(69);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1e9 + 7, MAX = 1e6 + 5;
const long long INF = 1e18 + 5;
vector<vector<int> > A;
vector<int> vis;
vector<int> C;
int dfs(int u) {
vis[u] = true;
int ans = C[u];
for (auto v : A[u]) {
if (!vis[v]) {
ans = min(ans, dfs(v));
}
}
return ans;
}
int main() {
int n, m;
cin >> n >> m;
C.resize(n + 1);
for (int in = 1; in < 1 + n; in++) cin >> C[in];
A.resize(n + 1);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
A[u].push_back(v);
A[v].push_back(u);
}
long long ans = 0;
vis.resize(n + 1);
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
ans += dfs(i);
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
scanf("%lld %lld", &a, &b);
if (a < b)
printf("-1");
else
printf("%.12f\n", (a + b) / (2. * ((a + b) / (2 * b))));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N;
int main() {
cin >> N;
if (N % 2 == 1) {
cout << (N - 1) / 2 << "\n";
return 0;
}
int msb = 30;
for (; msb >= 0; msb--)
if ((N & (1 << msb))) break;
cout << (N - (1 << msb)) / 2 << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k;
int n, m, a[200005], t[200005], r[200005];
vector<pair<int, int> > s;
multiset<int> sa;
void code() {
cin >> n >> m;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < m; i++) cin >> t[i] >> r[i];
int cur = 0;
for (i = m - 1; i >= 0; i--) {
if (r[i] > cur) {
s.push_back({r[i], t[i]});
cur = r[i];
}
}
reverse((s).begin(), (s).end());
s.push_back({0, -1});
for (i = 0; i < s[0].first; i++) sa.insert(a[i]);
for (i = 1; i < s.size(); i++) {
for (j = s[i - 1].first - 1; j >= s[i].first; j--) {
if (s[i - 1].second == 1)
a[j] = *sa.rbegin();
else
a[j] = *sa.begin();
sa.erase(sa.find(a[j]));
}
}
for (i = 0; i < n; i++) cout << a[i] << " ";
}
int main() {
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
code();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dp[403][403][403];
string str, str1;
int solve(int i, int j, int k) {
if (i == n) {
if (k == m) {
return (j);
} else {
return (-1);
}
}
if (dp[i][j][k] != -2) {
return (dp[i][j][k]);
}
int ans = -1;
if (j < m && str1[j] == str[i]) {
ans = max(ans, solve(i + 1, j + 1, k));
}
if (k < m && str1[k] == str[i]) {
ans = max(ans, solve(i + 1, j, k + 1));
}
ans = max(ans, solve(i + 1, j, k));
dp[i][j][k] = ans;
return (ans);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int a, i, j, k, t;
cin >> t;
while (t--) {
vector<int> arr(26, 0);
cin >> str >> str1;
n = str.size();
m = str1.size();
for (i = 0; i < n; i = i + 1) {
arr[str[i] - 97]++;
}
for (i = 0; i < m; i = i + 1) {
arr[str1[i] - 97]--;
}
a = 0;
for (i = 0; i < 26; i = i + 1) {
if (arr[i] < 0) {
a = 1;
break;
}
}
if (a) {
cout << "NO\n";
continue;
}
for (i = 0; i <= n; i++) {
for (j = 0; j <= m; j = j + 1) {
for (k = 0; k <= m; k = k + 1) {
dp[i][j][k] = -2;
}
}
}
a = 0;
for (i = 0; i < m; i = i + 1) {
if (solve(0, 0, i) >= i) {
cout << "YES\n";
a = 1;
break;
}
}
if (!a) {
cout << "NO\n";
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
int main() {
long long n, q, x, c = 0, ans = 0, o = 1, e = 2, p, k, l, r;
scanf("%lld%lld", &n, &q);
while (q--) {
scanf("%lld", &x);
if (x == 1) {
scanf("%lld", &p);
if (p < 0) {
p *= -1;
p %= n;
p = n - p;
}
o += p;
o %= n;
if (o == 0) o = n;
e += p;
e %= n;
if (e == 0) e = n;
} else {
if (o % 2)
o++;
else
o--;
if (e % 2)
e++;
else
e--;
o %= n;
e %= n;
if (o == 0) o = n;
if (e == 0) e = n;
}
}
k = 0;
l = 1;
r = 2;
while (l < n) {
m[o] = l;
o += 2;
l += 2;
o %= n;
if (o == 0) o = n;
}
while (r <= n) {
m[e] = r;
e += 2;
r += 2;
e %= n;
if (e == 0) e = n;
}
for (auto x : m) {
cout << x.second << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long bs(vector<long long> &a, long long x, long long n) {
long long start = 0;
long long end = n - 1;
long long ans = 0;
while (start <= end) {
long long mid = start + (end - start) / 2;
if (a[mid] > x) {
end = mid - 1;
} else if (a[mid] <= x) {
start = mid + 1;
ans = (mid + 1);
}
}
return (n - ans);
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> v(n);
map<long long, long long> map;
for (long long i = 0; i < n; i++) {
cin >> v[i];
map[v[i] % k]++;
}
long long ans = 0, key = 0;
for (auto &i : map) {
if (i.first % k != 0) {
key = k - (i.first % k);
key += (i.second - 1) * k;
ans = max(ans, key);
}
}
if (key > 0) ans++;
cout << ans << endl;
return;
}
signed main() {
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1E5 + 10;
int n;
int c[MAXN];
vector<int> E[MAXN];
map<int, int> *lst[MAXN];
int cnt[MAXN];
long long sum[MAXN];
void insert(int u, pair<int, int> p) {
(*lst[u])[p.first] += p.second;
if ((*lst[u])[p.first] > cnt[u])
cnt[u] = (*lst[u])[p.first], sum[u] = p.first;
else if ((*lst[u])[p.first] == cnt[u])
sum[u] += p.first;
}
void DFS(int u, int pre) {
int w = 0;
for (int v : E[u])
if (v != pre) {
DFS(v, u);
if (!w || lst[w]->size() < lst[v]->size()) w = v;
}
if (w) {
lst[u] = lst[w];
cnt[u] = cnt[w];
sum[u] = sum[w];
for (auto v : E[u])
if (v != pre && v != w) {
for (auto p : *lst[v]) insert(u, p);
delete lst[v];
}
} else
lst[u] = new map<int, int>;
insert(u, make_pair(c[u], 1));
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &c[i]);
for (int u, v, i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
E[u].push_back(v);
E[v].push_back(u);
}
DFS(1, 0);
for (int i = 1; i <= n; ++i) printf("%I64d%c", sum[i], "\n "[i < n]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n - 1; i++) {
if (a[i] > a[i - 1] && a[i] > a[i + 1]) {
cout << "YES"
<< "\n";
cout << i << " " << i + 1 << " " << i + 2 << "\n";
return;
}
}
cout << "NO"
<< "\n";
return;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 3;
int matches(pair<int, int> a, pair<int, int> b) {
int res = 0;
if (a.first == b.first) {
res++;
}
if (a.first == b.second) {
res++;
}
if (a.second == b.first) {
res++;
}
if (a.second == b.second) {
res++;
}
return res;
}
int eq(pair<int, int> a, pair<int, int> b) {
int res = 0;
if (a.first == b.first) {
return a.first;
}
if (a.first == b.second) {
return a.first;
}
if (a.second == b.first) {
return a.second;
}
if (a.second == b.second) {
return a.second;
}
return res;
}
int check(vector<pair<int, int>> A, vector<pair<int, int>> B) {
int n = (int((A).size()));
int m = (int((B).size()));
int cases = 0;
int iLast = -1;
int jLast = -1;
for (int(i) = (0); (i) < (n); (i)++) {
int cnt = 0;
for (int(j) = (0); (j) < (m); (j)++) {
int tmp = matches(A[i], B[j]);
if (tmp == 2) {
continue;
}
if (tmp == 1) {
cnt++;
iLast = i;
jLast = j;
}
}
if (cnt > 1) {
return -1;
}
if (cnt == 1) {
cases++;
}
}
if (cases == 0) {
return -1;
} else if (cases == 1) {
return eq(A[iLast], B[jLast]);
} else {
return 0;
}
}
vector<pair<int, int>> G[2][12][2];
int main(int argc, char* argv[]) {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<pair<int, int>> A, B;
for (int(i) = (0); (i) < (n); (i)++) {
int a, b;
cin >> a >> b;
A.push_back(make_pair(a, b));
}
for (int(i) = (0); (i) < (m); (i)++) {
int a, b;
cin >> a >> b;
B.push_back(make_pair(a, b));
}
for (int(i) = (0); (i) < (n); (i)++) {
if (A[i].first > A[i].second) swap(A[i].first, A[i].second);
}
for (int(i) = (0); (i) < (m); (i)++) {
if (B[i].first > B[i].second) swap(B[i].first, B[i].second);
}
int cases = 0;
int iLast = -1;
int jLast = -1;
for (int(i) = (0); (i) < (n); (i)++) {
for (int(j) = (0); (j) < (m); (j)++) {
if (matches(A[i], B[j]) == 2) {
continue;
}
if (A[i].first == B[j].first) {
G[0][i][0].push_back(make_pair(j, 0));
G[1][j][0].push_back(make_pair(i, 0));
}
if (A[i].first == B[j].second) {
G[0][i][0].push_back(make_pair(j, 1));
G[1][j][1].push_back(make_pair(i, 0));
}
if (A[i].second == B[j].first) {
G[0][i][1].push_back(make_pair(j, 0));
G[1][j][0].push_back(make_pair(i, 1));
}
if (A[i].second == B[j].second) {
G[0][i][1].push_back(make_pair(j, 1));
G[1][j][1].push_back(make_pair(i, 1));
}
}
}
for (int(i) = (0); (i) < (n); (i)++) {
if ((int((G[0][i][0]).size())) >= 1 && (int((G[0][i][1]).size())) >= 1) {
cout << -1 << endl;
return 0;
}
}
for (int(i) = (0); (i) < (m); (i)++) {
if ((int((G[1][i][0]).size())) >= 1 && (int((G[1][i][1]).size())) >= 1) {
cout << -1 << endl;
return 0;
}
}
int cnt = 0;
int last = -1;
set<int> nums;
for (int(i) = (0); (i) < (n); (i)++) {
if ((int((G[0][i][0]).size())) > 0) {
nums.insert(A[i].first);
}
if ((int((G[0][i][1]).size())) > 0) {
nums.insert(A[i].second);
}
}
for (int(i) = (0); (i) < (m); (i)++) {
if ((int((G[1][i][0]).size())) > 0) {
nums.insert(B[i].first);
}
if ((int((G[1][i][1]).size())) > 0) {
nums.insert(B[i].second);
}
}
if (nums.empty()) {
cout << -1 << endl;
} else if ((int((nums).size())) == 1) {
cout << *nums.begin() << endl;
} else {
cout << 0 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long mark[200000];
int main() {
ios_base::sync_with_stdio(false);
long long n, i, j, g, k, ans = 0, y, flag = 0, x;
cin >> n;
long long a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
if (a[0] > 1) a[0] = a[0] - 1;
k = a[0];
for (i = 1; i < n; i++) {
if (a[i] < k)
a[i] = a[i] + 1;
else if (a[i] == k)
a[i] = a[i] + 1;
else if (a[i] > (k + 1))
a[i] = a[i] - 1;
k = a[i];
}
for (i = 0; i < n; i++) {
if ((mark[a[i]] == 0) && (a[i] > 0) && (a[i] <= 150001)) ans++;
mark[a[i]] = 1;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, set<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class L, class R>
ostream& operator<<(ostream& os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.F << ":" << m.S << ")";
return os << "}";
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = 1e5 + 100;
int A[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(25);
int t;
cin >> t;
while (t--) {
set<int> s;
int n, k;
cin >> n >> k;
int cnt = 0;
int a = 0, b = 0, c = 0;
for (int i = 1; i <= n; ++i) {
cin >> A[i];
if (A[i] == k) ++cnt;
if (A[i] == k)
A[i] = 1, ++b;
else if (A[i] < k)
A[i] = 0, ++a;
else
A[i] = 2, ++c;
}
if (cnt == 0) {
cout << "no"
<< "\n";
} else {
bool ok = false;
for (int i = 1; i <= n - 2; ++i) {
int z = 0;
for (int j = 0; j < 3; ++j) z += (A[i + j] == 0);
if (z < 2) {
ok = true;
break;
}
}
int l = a + 1;
int r = a + b;
while (c >= 0) {
if ((n + 1) / 2 >= l && (n + 1) / 2 <= r) {
ok = true;
break;
}
++a;
--c;
l = a + 1;
r = a + b;
}
if (ok) {
cout << "yes"
<< "\n";
} else {
cout << "no"
<< "\n";
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e16;
const int MOD = 1e9 + 7;
const int N = 1e2 + 10;
int n, m, w[N], d[N][N], h[N] = {0}, D;
long long f[N];
pair<int, int> a[N];
void prepare() {
scanf("%d%d", &n, &D);
for (int i = 2; i <= n - 1; i++) scanf("%d", &w[i]);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].first, &a[i].second);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
d[i][j] = abs(a[i].first - a[j].first) + abs(a[i].second - a[j].second);
}
bool minimize(long long& a, long long b) {
if (a > b)
a = b;
else
return false;
return true;
}
void solve() {
priority_queue<pair<long long, int> > q;
q.push(pair<long long, int>(0, 1));
for (int i = 2; i <= n; i++) f[i] = inf;
while (!q.empty()) {
int x = q.top().second;
long long y = -q.top().first;
q.pop();
if (y > f[x]) continue;
if (x == n) break;
h[x] = 1;
for (int i = 2; i <= n; i++)
if (h[i] == 0 && minimize(f[i], y + (D * d[x][i] - w[x])))
q.push(pair<int, int>(-f[i], i));
}
cout << f[n];
}
int main() {
prepare();
solve();
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
bool eq(long double x, long double y) { return abs(x - y) < 1E-20; }
int main() {
int ans;
long double x, y, z;
cin >> x >> y >> z;
long double a[12], lx = log(x), llx = log(lx), ly = log(y), lly = log(ly),
lz = log(z), llz = log(log(z));
a[1] = lx * pow(y, z);
a[2] = lx * pow(z, y);
a[3] = lx * y * z;
a[4] = a[2];
a[5] = ly * pow(x, z);
a[6] = ly * pow(z, x);
a[7] = ly * x * z;
a[8] = a[7];
a[9] = lz * pow(x, y);
a[10] = lz * pow(y, x);
a[11] = lz * x * y;
long double max = a[1], max1;
int tmp = 1;
for (int i = 2; i < 12; i++) {
if (!eq(a[i], max) && max < a[i]) {
max = a[i];
tmp = i;
}
}
switch (tmp) {
case 1:
printf("x^y^z");
break;
case 2:
printf("x^z^y");
break;
case 3:
printf("(x^y)^z");
break;
case 4:
printf("(x^y)^z");
break;
case 5:
printf("y^x^z");
break;
case 6:
printf("y^z^x");
break;
case 7:
printf("(y^x)^z");
break;
case 8:
printf("(y^x)^z");
break;
case 9:
printf("z^x^y");
break;
case 10:
printf("z^y^x");
break;
case 11:
printf("(z^x)^y");
break;
default:
printf("..");
break;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int ans;
int a, b, t;
int x, y;
int A[500005], B[500005], C[500005];
char s[500005];
int tap(int x) {
int h = 1, t = n, m;
int ret = 0;
while (h <= t) {
m = (h + t) / 2;
if (B[m] <= x) {
ret = max(ret, m);
h = m + 1;
} else
t = m - 1;
}
return ret;
}
int main() {
scanf("%d%d%d%d", &n, &a, &b, &t);
scanf("%s", s);
int T = t;
for (int i = 1; i <= n; i++) {
C[i] = C[i - 1];
if (s[i - 1] == 'w') C[i] += b;
A[i] = C[i] + i + (i - 1) * a * 2;
}
memset(C, 0, sizeof(C));
for (int i = n; i > 1; i--) {
C[i] = C[i + 1];
if (s[i - 1] == 'w') C[i] += b;
B[n - i + 1] = (n - i + 1) + C[i] + (n - i + 1) * a;
}
for (int i = 1; i <= n; i++) {
if (A[i] > t) break;
int k = tap(t - A[i]);
ans = max(ans, min(tap(t - A[i]) + i, n));
}
memset(C, 0, sizeof(C));
for (int i = 2; i <= n; i++) {
C[i] = C[i - 1];
if (s[i - 1] == 'w') C[i] += b;
B[i - 1] = C[i] + (i - 1) + (i - 1) * a;
}
memset(C, 0, sizeof(C));
if (s[0] == 'w') C[n + 1] += b;
A[1] = C[n + 1] + 1;
for (int i = n; i > 1; i--) {
C[i] = C[i + 1];
if (s[i - 1] == 'w') C[i] += b;
A[n - i + 2] = (n - i + 2) + C[i] + (n - i + 1) * a * 2;
}
for (int i = 1; i <= n; i++) {
if (A[i] > t) break;
int k = tap(t - A[i]);
ans = max(ans, min(tap(t - A[i]) + i, n));
}
memset(C, 0, sizeof(C));
for (int i = 1; i <= n; i++) {
C[i] = C[i - 1];
if (s[i - 1] == 'w') C[i] += b;
if (C[i] + i + (i - 1) * a <= t) ans = max(ans, i);
}
memset(C, 0, sizeof(C));
if (s[0] == 'w') C[n + 1] = b;
for (int i = n; i > 1; i--) {
C[i] = C[i + 1];
if (s[i - 1] == 'w') C[i] += b;
if (C[i] + (n - i + 2) + (n - i + 1) * a <= t) ans = max(ans, n - i + 2);
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
unsigned int countBits(unsigned int n) {
unsigned int count = 0;
while (n) {
count++;
n >>= 1;
}
return count;
}
bool isPerfectSquare(long double x) {
long double sr = sqrt(x);
return ((sr - floor(sr)) == 0);
}
int subArraySum(int arr[], int n) {
int curr_sum = arr[0], start = 0, i, count = 0, len;
len = 0;
for (i = 1; i <= n; i++) {
len++;
while (curr_sum > len && start < i - 1) {
curr_sum = curr_sum - arr[start];
start++;
len++;
}
if (curr_sum == len) {
count++;
}
if (i < n && i > 0) {
curr_sum = curr_sum + arr[i];
}
}
return count;
}
void printDigit(int N, vector<long long int>& arr) {
int i = 0;
int j, r;
while (N != 0) {
r = N % 10;
arr.push_back(r);
i++;
N = N / 10;
}
}
void solver(vector<long long int> arr, long long int start,
long long int& count, long long int a1) {
long long int sum = 0;
for (long long int i = start + 1; i < arr.size() - 1; i++) {
sum += arr[i];
if (sum == a1) count++;
}
}
bool checkDivisibility(long long int n, int digit) {
if (digit == 0) return true;
return (digit != 0 && n % digit == 0);
}
bool allDigitsDivide(long long int n) {
long long int temp = n;
while (temp > 0) {
int digit = temp % 10;
if (!(checkDivisibility(n, digit))) return false;
temp /= 10;
}
return true;
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool isPowerOfTwo(unsigned long long x) { return x && (!(x & (x - 1))); }
int nextPrime(int N) {
if (N <= 1) return 2;
int prime = N;
bool found = false;
while (!found) {
prime++;
if (isPrime(prime)) found = true;
}
return prime;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
long long int b = 0, q, c, x, y, start = 0, end = 0, count = 0, neg = 0,
pos = 0, count1 = 0, a1 = 0, b1 = 0, c1 = 0, x1, y1, n1, m,
ans = 0, sum = 0;
unsigned long long n;
bool check2 = false, check3 = false;
int curr1 = 0, curr = 0;
long long int k = 0;
vector<long long int> arr;
stack<char> s;
string s1, s2;
long long int vb;
bool check1 = false, check4 = false;
vector<double> arrv;
unordered_map<long int, long int> map;
long long int r, l, d, v, g, sub;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> k;
count1 = (k / m);
if (k % m != 0) count1++;
if (count1 >= count) {
sum = i;
count = (k / m);
if (k % m != 0) count++;
}
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void Read(T &n) {
char ch;
bool flag = false;
while (!isdigit(ch = getchar())) {
if (ch == '-') flag = true;
}
for (n = ch ^ 48; isdigit(ch = getchar());
n = (n << 1) + (n << 3) + (ch ^ 48))
;
if (flag) n = -n;
}
enum { MAXN = 1000005, MOD = 1000000007 };
inline int dec(int a, int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
inline void ddec(int &a, int b) { a = dec(a, b); }
int n, k;
int f[MAXN], sum, inv[MAXN], jc[MAXN], ans;
inline int C(int n, int m) {
return 1ll * jc[n] * inv[m] % MOD * inv[n - m] % MOD;
}
int main() {
Read(n);
Read(k);
inv[1] = 1;
for (register int i = 2; i <= n; i++)
inv[i] = 1ll * (MOD - MOD / i) * inv[MOD % i] % MOD;
inv[0] = 1;
for (register int i = 2; i <= n; i++)
inv[i] = 1ll * inv[i] * inv[i - 1] % MOD;
jc[0] = 1;
for (register int i = 1; i <= n; i++) jc[i] = 1ll * jc[i - 1] * i % MOD;
sum = 1;
f[0] = 1;
for (register int i = 1; i <= n; i++) {
f[i] = 1ll * sum * jc[i - 1] % MOD;
if (i - k >= 0) ddec(sum, 1ll * f[i - k] * inv[i - k] % MOD);
sum = (sum + 1ll * f[i] * inv[i]) % MOD;
ans = (ans + 1ll * f[i - 1] * C(n - 1, n - i) % MOD * jc[n - i]) % MOD;
}
cout << dec(jc[n], ans) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string s;
bool l[10];
int main() {
cin >> s;
long long ans = 1;
int q = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '?') q++;
if (s[i] >= 'A' && s[i] <= 'J') l[s[i] - 'A'] = true;
}
int k = 10;
for (int i = 0; i < 10; i++)
if (l[i]) {
ans *= k;
k--;
}
if (s[0] >= 'A' && s[0] <= 'J') {
ans = ans / 10 * 9;
}
if (q) {
if (s[0] == '?') {
ans *= 9;
q--;
}
}
cout << ans;
for (int i = 0; i < q; i++) cout << 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
int b[n];
int rega[6] = {0};
int regb[6] = {0};
for (int i = 0; i < n; i++) {
cin >> a[i];
rega[a[i]]++;
}
int flag = 0;
for (int i = 0; i < n; i++) {
cin >> b[i];
regb[b[i]]++;
}
int diffindex[200] = {0};
int numchanges = 0;
for (int i = 1; i < 6; i++) {
int mod = (rega[i] - regb[i]);
if ((mod) % 2 != 0 || (-mod) % 2 != 0) {
cout << "-1";
flag = 1;
break;
} else {
if (mod == 0) continue;
if (mod < 0) mod = -mod;
numchanges += (mod / 2);
}
}
if (flag != 1) cout << numchanges / 2;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
char g[110][110];
int n, m;
void draw(int x, int y, int k, char z) {
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) g[x + i][y + j] = z;
}
bitset<20> v;
char get(int x, int y) {
v.reset();
for (int i = 0; i < 4; i++) {
int p = x + dx[i], q = y + dy[i];
v[g[p][q] - 'A'] = 1;
}
for (int i = 0; i < 20; i++)
if (!v[i]) return 'A' + i;
return 'Z' + 1;
}
void solve(int x, int y) {
if (y > m) y = 1, x++;
if (x > n) return;
if (g[x][y]) {
solve(x, y + 1);
return;
}
char c = get(x, y);
int p = 1;
while (true) {
if (p + x > n || p + y > m) break;
if (g[x][y + p]) break;
char t = get(x, y + p);
if (t != c) break;
p++;
}
draw(x, y, p, c), solve(x, y + p);
}
int main(void) {
scanf("%d%d", &n, &m);
solve(1, 1);
for (int i = 1; i <= n; i++) g[i][m + 1] = 0, puts(g[i] + 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 76;
char s[N];
int n, a[N][3], b[N][3], dp[N][N][N][2];
int main() {
scanf("%d%s", &n, s);
for (int i = 1; i <= n; ++i) {
if (s[i - 1] == 'V') {
a[i][0] = a[i - 1][0] + 1;
a[i][1] = a[i - 1][1];
a[i][2] = a[i - 1][2];
b[a[i][0]][0] = i;
} else if (s[i - 1] == 'K') {
a[i][0] = a[i - 1][0];
a[i][1] = a[i - 1][1] + 1;
a[i][2] = a[i - 1][2];
b[a[i][1]][1] = i;
} else {
a[i][0] = a[i - 1][0];
a[i][1] = a[i - 1][1];
a[i][2] = a[i - 1][2] + 1;
b[a[i][2]][2] = i;
}
}
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0][0] = 0;
for (int i = 0; i <= a[n][0]; ++i)
for (int j = 0; j <= a[n][1]; ++j)
for (int k = 0; k <= a[n][2]; ++k) {
if (i > 0)
dp[i][j][k][1] =
min(dp[i][j][k][1],
min(dp[i - 1][j][k][0], dp[i - 1][j][k][1]) +
abs(b[i][0] - min(i, a[b[i][0]][0]) -
min(j, a[b[i][0]][1]) - min(k, a[b[i][0]][2])));
if (j > 0)
dp[i][j][k][0] =
min(dp[i][j][k][0],
dp[i][j - 1][k][0] +
abs(b[j][1] - min(i, a[b[j][1]][0]) -
min(j, a[b[j][1]][1]) - min(k, a[b[j][1]][2])));
if (k > 0)
dp[i][j][k][0] =
min(dp[i][j][k][0],
min(dp[i][j][k - 1][0], dp[i][j][k - 1][1]) +
abs(b[k][2] - min(i, a[b[k][2]][0]) -
min(j, a[b[k][2]][1]) - min(k, a[b[k][2]][2])));
}
printf("%d", min(dp[a[n][0]][a[n][1]][a[n][2]][0],
dp[a[n][0]][a[n][1]][a[n][2]][1]));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, b, p, r;
int main() {
cin >> n >> b >> p;
r = n - 1;
cout << r * (2 * b + 1) << " " << n * p;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int m, a[25], b[25], g[25][25][25];
long long ans, n, f[25][25][25];
int G(int t, int p, int x) {
int i, y = x;
if (t == 1) {
x -= max(x, p);
if (x >= 0) x -= p;
return 10 + x;
}
if (g[t][p][x] >= 0) return g[t][p][x];
for (i = 9; i >= 0; i--) x = G(t - 1, max(p, i), x);
return g[t][p][y] = x;
}
long long F(int t, int p, int x) {
int i, y = x;
if (t == 1) return 1 + (p <= x);
if (f[t][p][x] >= 0) return f[t][p][x];
f[t][p][y] = 0;
for (i = 9; i >= 0; i--) {
f[t][p][y] += F(t - 1, max(p, i), x);
x = G(t - 1, max(p, i), x);
}
return f[t][p][y];
}
int main() {
int i, j, p;
long long x;
cin >> n;
if (n == 0) {
printf("0");
return 0;
}
memset(g, -1, sizeof(g));
memset(f, -1, sizeof(f));
for (x = n; x; x /= 10) a[++m] = x % 10;
for (i = m; i >= 1; i--) b[i] = max(b[i + 1], a[i]);
ans = F(1, b[2], a[1]);
p = G(1, b[2], a[1]);
for (i = 2; i <= m; i++)
for (j = a[i] - 1; j >= 0; j--) {
ans += F(i - 1, max(b[i + 1], j), p);
p = G(i - 1, max(b[i + 1], j), p);
}
cout << ans - 1;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using vector1D = vector<T>;
template <typename T>
using vector2D = vector<vector1D<T>>;
template <typename T>
using vector3D = vector<vector2D<T>>;
template <typename T>
using uset = unordered_set<T>;
template <typename K, typename V>
using umap = unordered_map<K, V>;
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
if (v.size() == 0) {
return out << "[]";
}
out << '[' << v[0];
for (int i = 1; i < v.size(); ++i) {
out << ' ' << v[i];
}
return out << ']';
}
template <typename T>
ostream& operator<<(ostream& out, const vector<vector<T>>& m) {
if (m.size() == 0) {
return out << "[]";
}
for (const auto& row : m) {
out << row << endl;
}
return out;
}
template <typename T>
ostream& operator<<(ostream& out, const deque<T>& d) {
if (d.size() == 0) {
return out << "[]";
}
out << '[' << d[0];
for (int i = 1; i < d.size(); ++i) {
out << ' ' << d[i];
}
return out << ']';
}
template <typename T>
ostream& operator<<(ostream& out, const set<T>& s) {
if (s.size() == 0) {
return out << "{}";
}
out << '{' << *s.begin();
for (auto it = ++s.begin(); it != s.end(); ++it) {
out << ' ' << *it;
}
return out << '}';
}
template <typename T>
ostream& operator<<(ostream& out, const multiset<T>& s) {
return out << vector<T>(s.begin(), s.end());
}
template <typename T>
ostream& operator<<(ostream& out, const unordered_set<T>& s) {
if (s.size() == 0) {
return out << "{}";
}
vector<T> v(s.begin(), s.end());
sort(v.begin(), v.end());
out << '{' << v[0];
for (int i = 1; i < v.size(); ++i) {
out << ' ' << v[i];
}
return out << '}';
}
template <typename K, typename V>
ostream& operator<<(ostream& out, const map<K, V>& m) {
if (m.size() == 0) {
return out << "{}";
}
vector<K> keys;
for (const auto& p : m) {
keys.push_back(p.first);
}
out << "{" << keys[0] << ": " << m.at(keys[0]);
for (int i = 1; i < keys.size(); ++i) {
const auto& key = keys[i];
out << ", " << key << ": " << m.at(key);
}
return out << '}';
}
template <typename K, typename V>
ostream& operator<<(ostream& out, const unordered_map<K, V>& m) {
if (m.size() == 0) {
return out << "{}";
}
vector<K> keys;
for (const auto& p : m) {
keys.push_back(p.first);
}
sort(keys.begin(), keys.end());
out << "{" << keys[0] << ": " << m.at(keys[0]);
for (int i = 1; i < keys.size(); ++i) {
const auto& key = keys[i];
out << ", " << key << ": " << m.at(key);
}
return out << '}';
}
template <typename F, typename S>
ostream& operator<<(ostream& out, const pair<F, S>& p) {
return out << '(' << p.first << ", " << p.second << ')';
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
size_t operator()(const pair<T, U>& p) const noexcept {
return hash<T>{}(p.first) ^ (hash<U>{}(p.second) << 1);
}
};
} // namespace std
void solution();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solution();
return 0;
}
long long MOD = pow(10, 9) + 7;
long long T, N, M, Q, L, R, X, Y;
void solution() {
cin >> T;
while (T-- > 0) {
cin >> N >> Q;
vector<long long> a(N);
for (long long n = 0; n < N; n++) cin >> a[n];
long long ans = a[0];
for (long long n = 1; n < N; n++) ans += max((long long)0, a[n] - a[n - 1]);
cout << ans << endl;
for (long long q = 0; q < Q; q++) {
cin >> L >> R;
L--;
R--;
long long temp = a[R];
ans -= a[0];
if (R > 0) ans -= max((long long)0, a[R] - a[R - 1]);
if (R < N - 1) ans -= max((long long)0, a[R + 1] - a[R]);
a[R] = a[L];
if (R > 0) ans += max((long long)0, a[R] - a[R - 1]);
if (R < N - 1) ans += max((long long)0, a[R + 1] - a[R]);
if (L > 0) ans -= max((long long)0, a[L] - a[L - 1]);
if (L < N - 1) ans -= max((long long)0, a[L + 1] - a[L]);
a[L] = temp;
if (L > 0) ans += max((long long)0, a[L] - a[L - 1]);
if (L < N - 1) ans += max((long long)0, a[L + 1] - a[L]);
ans += a[0];
cout << ans << endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solution() {
long long n, ans = 0;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i += 1) cin >> a[i];
for (long long i = 1; i < n; i += 1) {
if ((a[i] == 2 && a[i - 1] == 3) || (a[i] == 3 && a[i - 1] == 2)) {
cout << "Infinite";
return;
}
}
for (long long i = 0; i < n; i += 1) {
if (a[i] == 2)
ans += ((i > 0 && i < n - 1) ? 6 : 3);
else if (a[i] == 3)
ans += ((i > 0 && i < n - 1) ? 8 : 4);
if (a[i] == 2 && i > 1 && a[i - 2] == 3) ans--;
}
cout << "Finite\n" << ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solution();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int a[N], l[N], r[N];
int n;
long long ans = 0;
int main() {
scanf("%d", &n);
for (int i(1); i <= (n); ++i) scanf("%d", a + i);
a[0] = a[n + 1] = -1;
for (int i(1); i <= (n); ++i) {
l[i] = i - 1;
while ((a[i] | a[l[i]]) == a[i]) l[i] = l[l[i]];
}
for (int i(n); i >= (1); --i) {
r[i] = i + 1;
while ((a[i] | a[r[i]]) == a[i] && a[r[i]] < a[i]) r[i] = r[r[i]];
}
ans = 1ll * n * (n + 1) / 2;
for (int i(1); i <= (n); ++i) ans -= 1ll * (i - l[i]) * (r[i] - i);
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long n, p, m, d;
struct cmp {
bool operator()(const long long& l, const long long& r) { return l > r; }
};
priority_queue<long long, vector<long long>, cmp> t;
pair<long long, long long> a[300300];
int main() {
cin >> n;
for (long i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
sort(a + 1, a + n);
p = n - 1;
m = n;
d = 0;
while (a[0].first < a[p].first && p > 0) {
t.push(a[p].second - a[p].first);
p--;
}
m = min(n - p - d, m);
do {
if (m == 1) break;
long long q = t.top();
if (q < a[0].first) {
a[0].first -= q + 1;
t.pop();
} else
break;
d++;
while (a[0].first < a[p].first && p > 0) {
t.push(a[p].second - a[p].first);
p--;
}
m = min(n - p - d, m);
} while (!t.empty());
cout << m;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
vector<pair<int, int>> a;
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < int(n); i++) {
int x;
cin >> x;
a.push_back(make_pair(x, 1));
}
double ans_min = 100000, ans_max = 0;
int q;
cin >> q;
int count = 0;
for (int i = 0; i < int(q); i++) {
double cnt = 0, sum = 0;
bool t = true;
for (int j = 0; j < int(n / k); j++) {
int x;
cin >> x;
if (a[x - 1].second == 1) {
if (t) {
count++;
t = !t;
}
cnt++;
sum += a[x - 1].first;
a[x - 1].first = 200;
a[x - 1].second = 0;
}
}
ans_min = min(ans_min, sum / cnt);
ans_max = max(ans_max, sum / cnt);
}
cout << setprecision(9) << fixed;
if (count == k)
cout << ans_min << " " << ans_max << endl;
else {
sort(a.begin(), a.end());
int j = 0;
while (j < n && a[j].first != 200) {
j++;
}
int end_i = j;
j = n / k;
double sum = 0;
for (int i = 0; i < int(j); i++) sum += a[i].first;
double ans = sum / j;
ans_min = min(ans_min, ans);
sum = 0;
for (int i = end_i - 1; i >= end_i - j; i--) {
sum += a[i].first;
}
ans = sum / j;
ans_max = max(ans, ans_max);
cout << ans_min << " " << ans_max << endl;
}
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k;
cin >> n >> m >> k;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long int x, y;
x = a[n - 1];
y = a[n - 2];
if (k >= m) {
cout << m * x;
} else {
long long int d, r;
d = m / (k + 1);
r = m % (k + 1);
long long int s;
s = d * (k * x + y) + r * x;
cout << s;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
vector<int> tz;
map<int, int>::iterator mt;
int main() {
int ans = 0;
int n, a, b, c;
cin >> n >> a >> b >> c;
int x, y, z = 0;
n = 2 * n;
for (x = 0; x <= a; ++x)
for (y = 0; y <= b; ++y) mp[x + 2 * y]++;
int sz = mp.size();
int arr1[sz], cnt[sz];
int i = 0;
for (mt = mp.begin(); mt != mp.end(); mt++) {
arr1[i] = (*mt).first;
cnt[i] = (*mt).second;
i++;
}
for (z = 0; z <= c; z++) tz.push_back(n - 4 * z);
for (int j = 0; j < (int)tz.size(); j++) {
int num = tz[j];
int id = -1;
int left = 0, right = i - 1, middle;
while (left <= right) {
middle = (left + right) / 2;
if (arr1[middle] == num) {
id = middle;
break;
} else if (arr1[middle] < num) {
left = middle + 1;
} else {
right = middle - 1;
}
}
if (id != -1) ans += cnt[id];
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4005;
const int INF = 0x3f3f3f3f;
int n;
int dp[2][100005][40];
long long qpow(int n, long long q) {
long long ans = 1;
while (n) {
if (n & 1) {
ans *= q;
}
q *= q;
n >>= 1;
}
return ans;
}
int dfs(int i, int j, int id) {
if (dp[id][i][j] != 0) {
return dp[id][i][j];
}
long long temp = qpow(j, i);
if (temp >= n) {
return dp[id][i][j] = id + 1;
}
int a1 = dfs(i + 1, j, id ^ 1);
int a2 = dfs(i, j + 1, id ^ 1);
int ans;
if (a1 == id + 1 || a2 == id + 1) {
ans = id + 1;
} else if (a1 == -1 || a2 == -1) {
ans = -1;
} else {
ans = (id ^ 1) + 1;
}
return dp[id][i][j] = ans;
}
int main() {
int a, b;
scanf("%d%d%d", &a, &b, &n);
int t = 1;
int ans = 0;
if (a == 1) {
int temp = dfs(2, b, 1);
long long q = 1 << b;
b++;
if (q >= n) {
temp = -1;
}
while (temp != (t ^ 1) + 1) {
t ^= 1;
temp = dfs(2, b, t);
b++;
q <<= 1;
if (q >= n) {
temp = -1;
break;
}
}
ans = temp;
} else {
ans = dfs(a, b, 0);
}
if (ans == -1) {
printf("Missing\n");
} else if (ans == 2) {
printf("Stas\n");
} else {
puts("Masha");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
enum dir {
DOWN = 0,
UP,
RIGHT,
LEFT,
DOWN_RIGHT,
DOWN_LEFT,
UP_RIGHT,
UP_LEFT
};
int dir_r[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dir_c[] = {0, 0, 1, -1, 1, -1, 1, -1};
int f[100001], ff[10001], f4[10001];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
vector<pair<int, int>> v(q);
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
v[i].first = x;
v[i].second = y;
while (x <= y) {
f[x]++;
x++;
}
}
sort(((v).begin()), ((v).end()));
int mx = 0;
for (int i = 0; i < q; i++) {
for (int i = 1; i <= n; i++) ff[i] = f[i], f4[i] = 0;
int s = 0;
for (int x = v[i].first; x <= v[i].second; x++) {
ff[x]--;
}
for (int x = 1; x <= n; x++) {
s += ff[x] >= 1;
f4[x] += ff[x] == 1;
f4[x] += f4[x - 1];
}
int x = 0;
for (int j = i + 1; j < q; j++) {
mx = max(mx, s - (f4[v[j].second] - f4[v[j].first - 1]));
}
}
cout << mx;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int u[100001], v[100001], c[100001], ans = 1000000007, a;
bool vis[100001];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
cin >> u[i] >> v[i] >> c[i];
}
for (int i = 1; i <= k; i++) {
scanf("%d", &a);
vis[a] = true;
}
for (int i = 1; i <= m; i++) {
if (vis[u[i]] && !vis[v[i]] || !vis[u[i]] && vis[v[i]])
ans = min(ans, c[i]);
}
if (ans != 1000000007)
printf("%d\n", ans);
else
printf("-1\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define N 4000001
using namespace std;
int n,k;char s[N];
int main(){
int i,j,T;scanf("%d",&T);
while(T--){
scanf("%d%d%s",&n,&k,s);
if(!k) puts("YES");
else if(n%2==0&&n/2<=k) puts("NO");
else if(n/2<k) puts("NO");
else{
bool flag=0;
for(i=0,j=n-1;i<j&&i<k;i++,j--)
if(s[i]!=s[j]){flag=1;break;}
if(flag) puts("NO");
else puts("YES");
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, mod = 1000 * 1000 * 1000 + 7;
string a, b;
int n, k, cnt, dp[N][2];
int main() {
cin >> a >> b >> k;
n = a.size();
for (int i = 0; i < n; ++i) {
string nw = a.substr(i) + a.substr(0, i);
if (nw == b) ++cnt;
}
if (a == b)
dp[0][0] = 1;
else
dp[0][1] = 1;
for (int i = 0; i < k; ++i) {
(dp[i + 1][0] =
dp[i][0] * 1ll * (cnt - 1) % mod + dp[i][1] * 1ll * cnt % mod) %= mod;
(dp[i + 1][1] = dp[i][0] * 1ll * (n - cnt) % mod +
dp[i][1] * 1ll * (n - 1 - cnt) % mod) %= mod;
}
cout << dp[k][0];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, a, b;
cin >> n;
vector<vector<int> > adj(n);
for (auto((i)) = (0); ((i)) < ((n - 1)); ++((i))) {
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
int maxC = n - 1;
set<int> seen;
vector<int> d(n, -1);
queue<int> q;
for (auto((i)) = (0); ((i)) < ((n)); ++((i)))
if ((adj[i]).size() == 1) {
if (seen.count(adj[i][0]))
maxC--;
else
seen.insert(adj[i][0]);
q.push(i);
d[i] = 0;
}
bool allEven = true;
while (!q.empty()) {
int curr = q.front();
q.pop();
for (int i : adj[curr]) {
if (d[i] != -1) {
int len = d[i] + d[curr] + 1;
if (len > 1 && len & 1) allEven = false;
continue;
}
d[i] = d[curr] + 1;
q.push(i);
}
}
cout << (allEven ? 1 : 3) << ' ' << maxC << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxN(2e5 + 10);
int N, K, x, C;
long long A[maxN], ans[maxN];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
heap;
template <typename T>
T Abs(const T x) {
return x > 0 ? x : -x;
}
int main() {
cin >> N >> K >> x;
for (int i = 0; i < N; i++) {
cin >> A[i];
ans[i] = A[i];
C += A[i] < 0;
heap.push(pair<long long, int>(Abs(A[i]), i));
}
while (!heap.empty() && K) {
const pair<long long, int> top(heap.top());
heap.pop();
const long long val(top.first), i(top.second);
if (C % 2) {
if (ans[i] < 0)
ans[i] -= x;
else
ans[i] += x;
} else {
if (ans[i] < 0) {
ans[i] += x;
C += ans[i] >= 0;
} else {
ans[i] -= x;
C += ans[i] < 0;
}
}
K--;
heap.push(pair<long long, int>(Abs(ans[i]), i));
}
for (int i = 0; i < N; i++) cout << ans[i] << ' ';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<char> all;
all.insert('A');
all.insert('H');
all.insert('I');
all.insert('M');
all.insert('O');
all.insert('T');
all.insert('U');
all.insert('V');
all.insert('W');
all.insert('X');
all.insert('Y');
string s;
cin >> s;
if (s.length() % 2 == 1) {
if (all.count(s[s.length() / 2]) == 0) {
cout << "NO";
return 0;
}
}
for (int i = 0; i < s.length() / 2; i++) {
if (s[i] == s[s.length() - i - 1] && all.count(s[i]) == 1) {
} else {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void Beta32A() {
long n, d;
cin >> n >> d;
long arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (abs(arr[i] - arr[j]) <= d) {
count++;
}
}
}
cout << 2 * count;
}
void Beta33A() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int count = 0;
long mini = 2000000000;
int x;
priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>,
greater<pair<int, pair<int, int>>>>
minheap;
for (int i = 0; i < n; i++) {
if (abs(arr[i] - arr[(i + 1) % n]) < mini) {
mini = abs(arr[i] - arr[(i + 1) % n]);
x = i;
}
}
cout << x + 1 << " " << (x + 1) % n + 1;
}
void Beta36A() {
int n;
cin >> n;
string s;
cin >> s;
vector<int> v;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '1') {
v.push_back(i);
}
}
int count = 0;
for (int i = 1; i < v.size(); i++) {
if (v[i] - v[i - 1] != v[1] - v[0]) {
cout << "NO";
return;
}
}
cout << "YES";
}
void contest44A() {
int n;
cin >> n;
vector<pair<string, string>> vp;
set<pair<string, string>> sp;
while (n--) {
string x, y;
cin >> x >> y;
sp.insert({x, y});
}
cout << sp.size();
}
int main() { contest44A(); }
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.