solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long ans[5000005];
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
signed main() {
long long n, k, a, b, ansmax = 0, ansmin = 1000000000000;
scanf("%lld%lld%lld%lld", &n, &k, &a, &b);
for (long long i = 1; i <= n; i++) {
ans[i * 4 - 3] = (i - 1) * k + b + a;
ans[i * 4 - 2] = (i - 1) * k + b + k - a;
ans[i * 4 - 1] = (i - 1) * k + a + k - b;
ans[i * 4] = (i - 1) * k + k + k - a - b;
}
sort(ans + 1, ans + 1 + n * 4);
for (long long i = 1; i <= n * 4; i++) {
if (ans[i] == 0) continue;
long long anss = n * k / gcd(ans[i], n * k);
ansmax = max(ansmax, anss);
ansmin = min(ansmin, anss);
}
printf("%lld %lld\n", ansmin, ansmax);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, cnt = 0;
int ar[300050];
int pr[1000000];
int mp[15000005] = {0};
int ans[15000005] = {0};
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, g = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> ar[i];
g = gcd(g, ar[i]);
}
for (i = 0; i < n; i++) ar[i] /= g;
for (i = 2; i < 15000001; i++) {
if (!mp[i]) pr[cnt++] = i, mp[i] = i;
for (j = 0; i * pr[j] < 15000001; j++) {
mp[i * pr[j]] = pr[j];
if (i % pr[j] == 0) break;
}
}
for (i = 0; i < n; i++) {
int tp = ar[i];
while (tp != 1) {
int c = mp[tp];
for (ans[c]++; tp % c == 0; tp /= c)
;
}
}
int c = *max_element(ans, ans + 15000001);
cout << (c ? n - c : -1) << '\n';
return ~~(0 ^ 0 ^ 0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class Lid {
public:
int a;
string name;
void write() {
int b, c;
cin >> name >> b >> c;
a = b * 100 - c * 50;
for (int i = 0; i < 5; i++) {
cin >> b;
a += b;
}
}
};
int main() {
int n;
cin >> n;
Lid mass[n];
for (int i = 0; i < n; i++) mass[i].write();
int max = 0;
for (int i = 0; i < n; i++)
if (mass[max].a < mass[i].a) max = i;
cout << mass[max].name;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> c(3);
vector<int> v, color, used;
vector<vector<int>> g;
void dfs(int i) {
used[i] = 1;
for (int j = 0; j < g[i].size(); ++j) {
if (!used[g[i][j]]) {
v[i] = g[i][j];
dfs(g[i][j]);
}
}
}
int main() {
long long n, x, y;
long long sum, mi = 1e18, s;
cin >> n;
v.resize(n + 1);
g.resize(n + 1);
used.resize(n + 1);
color.resize(n + 1);
int used[2][n];
for (int j = 0; j < 3; ++j) {
c[j].resize(n);
for (int i = 0; i < n; ++i) {
cin >> c[j][i];
}
}
if (n == 1) {
for (int i = 0; i < 3; ++i) {
if (c[i][0] < mi) {
mi = c[i][0];
x = i;
}
}
cout << mi << '\n' << x + 1;
return 0;
}
for (int i = 0; i < n - 1; ++i) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
if (g[x].size() > 2 || g[y].size() > 2) {
cout << -1;
return 0;
}
}
int st;
for (int i = 1; i < n + 1; ++i) {
if (g[i].size() == 1) {
dfs(i);
st = i;
break;
}
}
int a[6][3] = {{1, 2, 3}, {1, 3, 2}, {2, 1, 3},
{2, 3, 1}, {3, 1, 2}, {3, 2, 1}};
int d = -1;
for (int i = 0; i < 6; ++i) {
s = st;
sum = c[a[i][0] - 1][s - 1];
for (int j = 0, k = 1; j < n - 1; ++j, k++) {
s = v[s];
sum += c[a[i][k % 3] - 1][s - 1];
}
if (sum < mi) {
mi = sum;
d = i;
}
}
cout << mi << '\n';
color[st] = a[d][0];
s = st;
for (int i = 0, k = 1; i < n - 1; ++i, ++k) {
s = v[s];
color[s] = a[d][k % 3];
}
for (int i = 1; i <= n; ++i) {
cout << color[i] << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << ":" << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << ":" << arg1 << " |";
__f(comma + 1, args...);
}
void Ishan_Pandey() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cout << setprecision(16) << fixed;
}
const long long int N = 200010;
long long int parent[N], rank1[N];
void make_set(long long int v) {
parent[v] = v;
rank1[v] = 0;
}
long long int find_set(long long int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(long long int a, long long int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rank1[a] < rank1[b]) swap(a, b);
parent[b] = a;
if (rank1[a] == rank1[b]) rank1[a]++;
}
}
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n + 2, 0);
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
}
long long int ans = 0;
for (long long int i = 1; i <= n; i++) a[i] = min(a[i], a[i - 1] + 1);
for (long long int i = n; i >= 1; i--) a[i] = min(a[i], a[i + 1] + 1);
for (long long int i = 1; i <= n; i++) ans = max(ans, a[i]);
cout << ans;
}
int32_t main() {
Ishan_Pandey();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
int ans = 0;
vector<pair<int, int>> v;
for (int i = 1; i <= n; i = i + 1) {
if (i % 2) {
int j = 1;
while (j <= m) {
v.push_back({i, j});
j++;
}
} else {
int j = m;
while (j > 0) {
v.push_back({i, j});
j--;
}
}
}
for (int i = 0; i < 2 * k - 2; i += 2) {
cout << 2 << " ";
cout << v[i].first << " " << v[i].second << " " << v[i + 1].first << " "
<< v[i + 1].second << endl;
}
cout << n * m - 2 * k + 2 << " ";
for (int i = 2 * k - 2; i < n * m - 1; i++) {
cout << v[i].first << " " << v[i].second << " ";
}
cout << v[n * m - 1].first << " " << v[n * m - 1].second;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
int parent[1 << 15 + 1];
int find(int x) { return x == parent[x] ? x : parent[x] = find(parent[x]); }
void merge(int x, int y) {
int px = find(x), py = find(y);
if (px == py) return;
ans++;
parent[px] = py;
}
int main() {
scanf("%d %d%*c", &n, &m);
vector<bool> last(m + 1, 0);
for (int i = 1; i <= 2 * m; i++) parent[i] = i;
int cnt = 0;
for (int i = 0; i < n; i++) {
char x;
vector<bool> curr(m + 1, 0);
for (int j = 1; j <= m; j += 4) {
scanf("%c", &x);
bool bits[4];
int y = x <= '9' && x >= '0' ? x - '0' : x - 'A' + 10;
curr[j] = y & 8;
curr[j + 1] = y & 4;
curr[j + 2] = y & 2;
curr[j + 3] = y & 1;
}
for (int j = 1; j <= m; j++)
if (curr[j]) {
cnt++;
if (curr[j - 1]) merge(j - 1 + m, j + m);
if (last[j]) merge(j, j + m);
}
last = curr;
if (i != n - 1) {
scanf("%*c");
for (int i = 1; i <= m; i++) parent[i] = parent[i + m] - m;
for (int i = m + 1; i <= 2 * m; i++) parent[i] = i;
}
}
printf("%d", cnt - ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool visited[1005];
vector<int> v[1005];
int nod;
void dfs(int node) {
if (visited[node] == 1) return;
nod++;
visited[node] = 1;
for (int i = 0; i < v[node].size(); i++) {
dfs(v[node][i]);
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<int> ans;
int tmpl[1009];
for (int i = 0; i < k; i++) {
cin >> tmpl[i];
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 0; i < k; i++) {
int p;
p = tmpl[i];
nod = 0;
dfs(p);
ans.push_back(nod);
}
sort(ans.begin(), ans.end());
for (int i = 1; i <= n; i++)
if (!visited[i]) ans[ans.size() - 1]++;
long long fans = 0;
for (int i = 0; i < ans.size(); i++) {
fans += 1ll * ans[i] * (ans[i] - 1) / 2;
}
cout << fans - m << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > conf[25];
int n, c[25];
bool used[25];
void ready(int now, int left, int idx, int *arr, int mn) {
if (left == 0) {
if (idx > 1) {
vector<int> tmpvc;
for (int i = 0; i < idx; ++i) tmpvc.push_back(arr[i]);
conf[now].push_back(tmpvc);
}
return;
}
for (int j = mn; j <= left; ++j) {
if (j == 2) continue;
arr[idx] = j;
ready(now, left - j, idx + 1, arr, j);
}
}
bool all_one(vector<int> &state) {
for (int i = 0; i < state.size(); ++i)
if (state[i] != 1) return false;
return true;
}
bool find_pos(vector<int> &conf, vector<int> &pos) {
bool tmpused[25];
for (int i = 0; i < n; ++i) tmpused[i] = false;
for (int i = 0; i < conf.size(); ++i) {
bool found = false;
for (int j = 0; j < n; ++j) {
if (c[j] == conf[i] && !used[j] && !tmpused[j]) {
found = true;
tmpused[j] = true;
pos.push_back(j);
break;
}
}
if (!found) return false;
}
return true;
}
bool check(vector<int> &state) {
if (all_one(state)) return true;
for (int i = 0; i < state.size(); ++i) {
int x = state[i];
if (x == 1) continue;
for (int j = 0; j < conf[x].size(); ++j) {
vector<int> tmpconf = conf[x][j];
vector<int> position;
if (!find_pos(tmpconf, position)) continue;
for (int k = 0; k < position.size(); ++k) used[position[k]] = true;
vector<int> new_state(state);
new_state.erase(new_state.begin() + i);
new_state.insert(new_state.begin() + i, tmpconf.begin(), tmpconf.end());
if (check(new_state)) return true;
for (int k = 0; k < position.size(); ++k) used[position[k]] = false;
}
}
return false;
}
int main() {
int p[25];
for (int i = 3; i <= 24; ++i) {
ready(i, i - 1, 0, p, 1);
}
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; ++i) {
scanf("%d", &c[i]);
used[i] = false;
}
int mx = 0;
for (int i = 1; i < n; ++i)
if (c[i] > c[mx]) mx = i;
vector<int> root;
root.push_back(c[mx]);
if (c[mx] == n && check(root))
puts("YES");
else
puts("NO");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6, inf = 1e9 + 2;
pair<int, int> a[N + 2], b[N + 2], aa[N + 2], bb[N + 2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, c, d;
cin >> n >> c >> d;
int p = 0, q = 0;
for (int i = 1; i <= n; i++) {
int x, y;
char c;
cin >> x >> y >> c;
if (c == 'C')
a[++p] = {y, x};
else
b[++q] = {y, x};
}
sort(a + 1, a + p + 1);
sort(b + 1, b + q + 1);
for (int i = 1; i <= p; i++) aa[i] = a[i];
for (int i = 1; i <= q; i++) bb[i] = b[i];
for (int i = 1; i <= p; i++) a[i].second = max(a[i].second, a[i - 1].second);
for (int i = 1; i <= q; i++) b[i].second = max(b[i].second, b[i - 1].second);
int ans = 0;
for (int i = 2; i <= p; i++) {
int rm = c - a[i].first;
int id = upper_bound(a + 1, a + p + 1, make_pair(rm, inf)) - a;
id--;
if (id >= i) id = i - 1;
if (id > 0) ans = max(ans, aa[i].second + a[id].second);
}
for (int i = 2; i <= q; i++) {
int rm = d - b[i].first;
int id = upper_bound(b + 1, b + q + 1, make_pair(rm, inf)) - b;
id--;
if (id >= i) id = i - 1;
if (id > 0) ans = max(ans, bb[i].second + b[id].second);
}
int ad1 = -1, ad2 = -1;
for (int i = 1; i <= p; i++)
if (a[i].first <= c) ad1 = a[i].second;
for (int i = 1; i <= q; i++)
if (b[i].first <= d) ad2 = b[i].second;
if (ad1 != -1 && ad2 != -1) ans = max(ans, ad1 + ad2);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300004;
int a[N], n, m, s1[N], s2[N], c[2];
int main() {
long long t;
c[0] = 1;
scanf("%d", &n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &t);
for (int j = 0; j < 61; j++)
if (t >> j & 1) ++a[i];
s2[i] = s2[i - 1] + a[i];
ans += c[s2[i] & 1];
for (int j = i, k = i + 1, mx = 0; j >= max(1, i - 64); j--) {
while (k > j) mx = max(mx, a[--k]);
if (mx * 2 > s2[i] - s2[j - 1] && (s2[i] - s2[j - 1]) % 2 == 0) --ans;
}
c[s2[i] & 1]++;
}
printf("%lld\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 2e5 + 5;
const long long INF = 1e18;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
if (n <= k) {
cout << abs(n - k) << "\n";
} else if (k % 2 == n % 2) {
cout << 0 << "\n";
} else {
cout << 1 << "\n";
}
}
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << "s\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
cout << k * (6 * n - 1) << endl;
for (int i = 0; i < n; i++) {
cout << (6 * i + 1) * k << " " << (6 * i + 2) * k << " " << (6 * i + 3) * k
<< " " << (6 * i + 5) * k << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long a, m;
cin >> a >> m;
for (int i = 0; i < m; i++) {
if (a % m == 0) {
cout << "Yes" << endl;
return 0;
}
a = a + a % m;
}
cout << "No" << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
char name[55];
int score;
int c[50];
} comp[55];
int cmp1(node x, node y) {
if (x.score > y.score)
return 1;
else if (x.score == y.score) {
for (int i = 0; i < 50; i++)
if (x.c[i] > y.c[i])
return 1;
else if (x.c[i] < y.c[i])
return 0;
} else
return 0;
}
int cmp2(node x, node y) {
if (x.c[0] > y.c[0])
return 1;
else if (x.c[0] == y.c[0]) {
if (x.score > y.score)
return 1;
else if (x.score == y.score) {
for (int i = 1; i < 50; i++)
if (x.c[i] > y.c[i])
return 1;
else if (x.c[i] < y.c[i])
return 0;
} else
return 0;
} else
return 0;
}
int s[10] = {25, 18, 15, 12, 10, 8, 6, 4, 2, 1};
int main() {
int t;
while (scanf("%d", &t) != EOF) {
memset(comp, 0, sizeof(comp));
int sum = 0;
while (t--) {
int n, i;
char na[55];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s", na);
int j;
for (j = 0; j < sum; j++) {
if (strcmp(comp[j].name, na) == 0) {
if (i < 10) comp[j].score += s[i];
comp[j].c[i]++;
break;
}
}
if (j == sum) {
strcpy(comp[sum].name, na);
if (i < 10) comp[sum].score += s[i];
comp[sum].c[i]++;
sum++;
}
}
}
sort(comp, comp + sum, cmp1);
printf("%s\n", comp[0].name);
sort(comp, comp + sum, cmp2);
printf("%s\n", comp[0].name);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_CARACS = 100 * 1000;
const int MAX_PARENTS = 12;
const int MAX_POKEMONS = 100 * 1000 + 12;
const int MAX_ENSEMBLES = 4096;
int nbCaracs, nbParents, nbReqs;
int nbPokemons;
int caracs_parents[MAX_PARENTS][MAX_CARACS];
int pokemons_of_caracs[MAX_CARACS][MAX_PARENTS];
bitset<MAX_ENSEMBLES> pokemons[MAX_POKEMONS];
int main() {
scanf("%d%d%d", &nbCaracs, &nbParents, &nbReqs);
fill(pokemons, pokemons + MAX_POKEMONS, bitset<MAX_ENSEMBLES>(0));
for (int iParent = 0; iParent < nbParents; iParent++) {
for (int iCarac = 0; iCarac < nbCaracs; iCarac++) {
scanf("%d", &caracs_parents[iParent][iCarac]);
pokemons_of_caracs[iCarac][iParent] = iParent;
}
for (int ensemble = 0; ensemble < MAX_ENSEMBLES; ensemble++) {
if (ensemble & (1 << iParent)) {
pokemons[iParent][ensemble] = 1;
}
}
}
for (int iCarac = 0; iCarac < nbCaracs; iCarac++) {
sort(pokemons_of_caracs[iCarac], pokemons_of_caracs[iCarac] + nbParents,
[&](const int a, const int b) {
return caracs_parents[a][iCarac] > caracs_parents[b][iCarac];
});
}
nbPokemons = nbParents;
for (int iReq = 0; iReq < nbReqs; iReq++) {
int type_req, poke1, poke2;
scanf("%d%d%d", &type_req, &poke1, &poke2);
poke1--, poke2--;
if (type_req == 1) {
pokemons[nbPokemons] = pokemons[poke1] | pokemons[poke2];
nbPokemons++;
} else if (type_req == 2) {
pokemons[nbPokemons] = pokemons[poke1] & pokemons[poke2];
nbPokemons++;
} else {
int iCarac = poke2;
int idMaster = -1;
int parents_taken = 0;
for (int iParent = 0; iParent < nbParents; iParent++) {
int parent = pokemons_of_caracs[iCarac][iParent];
parents_taken |= (1 << parent);
if (pokemons[poke1][parents_taken]) {
idMaster = parent;
break;
}
}
printf("%d\n", caracs_parents[idMaster][iCarac]);
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& _p) {
return os << "(" << _p.first << "," << _p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& _V) {
bool f = true;
os << "[";
for (auto v : _V) {
os << (f ? "" : ",") << v;
f = false;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& _S) {
bool f = true;
os << "(";
for (auto s : _S) {
os << (f ? "" : ",") << s;
f = false;
}
return os << ")";
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const map<T, U>& _M) {
return os << set<pair<T, U>>(_M.begin(), _M.end());
}
const unsigned long long INF = 1000000100;
const long double EPS = 1e-9;
map<pair<unsigned long long, pair<unsigned long long, unsigned long long>>,
unsigned long long>
H;
vector<int> V[100100];
int n;
unsigned long long mH[100100];
int Odw[100100], diff;
pair<int, int> ans;
map<int, int> Ile;
unsigned long long S1[100100];
unsigned long long S2[100100];
unsigned long long S3[100100];
unsigned long long HASH(unsigned long long a, unsigned long long b,
unsigned long long c) {
return ((a ^ b) + (c * c * c) + 12344121) ^ 4372321658131;
if (H.find(make_pair(a, make_pair(b, c))) == H.end()) {
H[make_pair(a, make_pair(b, c))] = rand();
}
return H[make_pair(a, make_pair(b, c))];
}
void dfs(int a) {
Odw[a] = 1;
unsigned long long s1 = 4321478328667919ll;
unsigned long long s2 = 432781477312874ll;
unsigned long long s3 = 347582818888181ll;
for (int v : V[a]) {
if (Odw[v]) continue;
dfs(v);
s1 ^= mH[v];
s2 += mH[v] * mH[v];
s3 += mH[v] * mH[v] * mH[v];
}
mH[a] = HASH(s1, s2, s3);
S1[a] = s1;
S2[a] = s2;
S3[a] = s3;
}
int GW[100100];
void go(int a, unsigned long long gg) {
Ile[mH[a]]--;
if (Ile[mH[a]] == 0) diff--;
unsigned long long mnh =
HASH((S1[a] ^ gg), (S2[a] + gg * gg), (S3[a] + gg * gg * gg));
if (Ile[mnh] == 0) diff++;
Ile[mnh]++;
ans = max(ans, make_pair(diff, a));
if (0)
cerr << diff << " a:" << a << " "
<< "\n";
if (Ile[mnh] == 1) diff--;
Ile[mnh]--;
GW[a] = 1;
for (int v : V[a]) {
if (GW[v]) continue;
unsigned long long ns1 = (S1[a] ^ mH[v] ^ gg);
unsigned long long ns2 = (S2[a] - mH[v] * mH[v] + gg * gg);
unsigned long long ns3 = (S3[a] - mH[v] * mH[v] * mH[v] + gg * gg * gg);
int nh = HASH(ns1, ns2, ns3);
if (Ile[nh] == 0) diff++;
Ile[nh]++;
go(v, nh);
Ile[nh]--;
if (Ile[nh] == 0) diff--;
}
Ile[mH[a]]++;
if (Ile[mH[a]] == 1) diff++;
}
int main() {
srand(time(NULL));
scanf("%d", &n);
for (int(i) = (1); (i) < (n); (i)++) {
int a, b;
scanf("%d%d", &a, &b);
V[a].push_back(b);
V[b].push_back(a);
}
int root = 1;
dfs(root);
for (int(i) = (1); (i) <= (n); (i)++) {
Ile[mH[i]]++;
if (Ile[mH[i]] == 1) diff++;
}
go(root, 0);
cout << ans.second << endl;
;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, s = 0;
cin >> n >> m;
for (long long int i = 1; i <= n; i++) {
s += (m + i % 5) / 5;
}
cout << s << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int flag = 0;
int ans = 0;
sort(a.begin(), a.end());
for (int i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1] - 1) {
cout << "2"
<< "\n";
flag = 1;
break;
}
}
if (flag == 0)
cout << "1"
<< "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
int n, x, y;
vector<int> al, bo, no;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
int ans = 0, cnt = 0, d = 0;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
if (x == 11) {
ans += y;
d++;
cnt++;
} else if (x == 10) {
al.push_back(y);
} else if (x == 1) {
bo.push_back(y);
} else {
no.push_back(y);
}
}
if ((cnt == 0 && al.size() == 0) || (cnt == 0 && bo.size() == 0)) {
cout << 0;
return 0;
}
sort((al).begin(), (al).end());
sort((bo).begin(), (bo).end());
while (al.size() > 0 && bo.size() > 0) {
ans += al.back();
ans += bo.back();
al.pop_back();
bo.pop_back();
cnt++;
d += 2;
}
d = cnt * 2 - d;
for (auto e : al) {
no.push_back(e);
}
for (auto e : bo) {
no.push_back(e);
}
sort((no).begin(), (no).end());
while (no.size() > 0) {
if (d == 0) break;
ans += no.back();
no.pop_back();
d--;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300005;
struct node {
int v, p;
bool operator<(const node &b) { return v < b.v || (v == b.v && p > b.p); }
} f[MAXN], g[MAXN];
inline void chk(node &x, node y) {
if (x < y) x = y;
}
int n, a[MAXN], b[MAXN], c[MAXN], na[MAXN], nb[MAXN], nc[MAXN];
inline void get(int *a, int *na) {
map<long long, int> F;
na[F[0] = n] = n + 1;
long long sum = 0;
for (int i = n - 1; i >= 0; i--) {
sum += a[i];
na[i] = na[i + 1];
if (F.find(sum) != F.end()) na[i] = min(na[i], F[sum]);
F[sum] = i;
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]), c[i] = a[i] + b[i];
get(a, na);
get(b, nb);
get(c, nc);
for (int i = 0; i <= n; i++) {
chk(f[na[g[i].p]], {g[i].v + 1, i});
chk(g[nb[f[i].p]], {f[i].v + 1, i});
chk(f[na[i]], {f[i].v + 1, f[i].p});
chk(g[nb[i]], {g[i].v + 1, g[i].p});
chk(f[i + 1], f[i]);
chk(g[i + 1], g[i]);
chk(f[nc[i]], {max(f[i].v, g[i].v) + 1, nc[i]});
}
return printf("%d\n", max(f[n].v, g[n].v)), 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int Len = 100000;
string S[Len + 5][2];
string maxs;
int n;
int A[Len + 5];
void solve() {
maxs = "a";
for (int i = 1; i <= n; ++i) {
if (S[A[i]][0].compare(maxs) >= 0)
maxs = S[A[i]][0];
else if (S[A[i]][1].compare(maxs) >= 0)
maxs = S[A[i]][1];
else {
puts("NO");
return;
}
}
puts("YES");
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; ++i) {
string a, b;
cin >> a >> b;
if (a.compare(b) > 0) swap(a, b);
S[i][0] = a;
S[i][1] = b;
}
for (int i = 1; i <= n; ++i) scanf("%d", &A[i]);
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, p, q, k, a[100009];
int s[320][100009];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
cin >> q;
for (int i = 1; i <= sqrt(n); i++)
for (int j = n; j >= 0; j--) {
if (j + a[j] + i > n)
s[i][j] = 1;
else
s[i][j] = s[i][j + a[j] + i] + 1;
}
for (int i = 0; i < q; i++) {
cin >> p >> k;
if (k <= sqrt(n))
cout << s[k][p] << endl;
else {
int z = 0;
while (p <= n) {
p += a[p] + k;
z++;
}
cout << z << endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int bpow(long long int x, long long int n) {
long long int ans = 1;
while (n) {
if (n & 1) ans = ans * x % 1000000009;
;
x = x * x % 1000000009;
n = n / 2;
}
return ans % 1000000009;
}
int main() {
long long int n, m;
cin >> n >> m;
long long int ans = 1;
long long int cur = bpow(2, m);
for (int i = 1; i <= n; i++) {
ans = ans * (cur - i + 1000000009) % 1000000009;
ans = ans % 1000000009;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<int, int> > a;
priority_queue<pair<int, int> > b;
vector<pair<int, int> > A;
vector<pair<int, int> > B;
int main() {
int n, x;
scanf("%d%d", &n, &x);
int x0 = x;
for (int i = 0; i < n; i++) {
int t;
int h, m;
scanf("%d%d%d", &t, &h, &m);
if (t == 0)
A.push_back(pair<int, int>(h, m));
else
B.push_back(pair<int, int>(h, m));
}
int pa = 0, push_back = 0;
sort(A.begin(), A.end());
sort(B.begin(), B.end());
int ans = 0;
while (pa < A.size() && A[pa].first <= x)
a.push(pair<int, int>(A[pa].second, A[pa].first)), pa++;
while (push_back < B.size() && B[push_back].first <= x)
b.push(pair<int, int>(B[push_back].second, B[push_back].first)),
push_back++;
int nn = 0;
int cur = 0;
while (nn < 2) {
pair<int, int> k;
if (cur == 0) {
if (a.size() == 0) {
nn++;
continue;
}
k = a.top();
a.pop();
}
if (cur == 1) {
if (b.size() == 0) {
nn++;
continue;
}
k = b.top();
b.pop();
}
x += k.first;
ans++;
while (pa < A.size() && A[pa].first <= x)
a.push(pair<int, int>(A[pa].second, A[pa].first)), pa++;
while (push_back < B.size() && B[push_back].first <= x)
b.push(pair<int, int>(B[push_back].second, B[push_back].first)),
push_back++;
cur ^= 1;
nn = 0;
}
int ans2 = 0;
cur = 1;
nn = 0;
while (a.size()) a.pop();
while (b.size()) b.pop();
pa = push_back = 0;
x = x0;
while (pa < A.size() && A[pa].first <= x)
a.push(pair<int, int>(A[pa].second, A[pa].first)), pa++;
while (push_back < B.size() && B[push_back].first <= x)
b.push(pair<int, int>(B[push_back].second, B[push_back].first)),
push_back++;
while (nn < 2) {
pair<int, int> k;
if (cur == 0) {
if (a.size() == 0) {
nn++;
continue;
}
k = a.top();
a.pop();
}
if (cur == 1) {
if (b.size() == 0) {
nn++;
continue;
}
k = b.top();
b.pop();
}
x += k.first;
ans2++;
while (pa < A.size() && A[pa].first <= x)
a.push(pair<int, int>(A[pa].second, A[pa].first)), pa++;
while (push_back < B.size() && B[push_back].first <= x)
b.push(pair<int, int>(B[push_back].second, B[push_back].first)),
push_back++;
cur ^= 1;
nn = 0;
}
printf("%d\n", max(ans, ans2));
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1001000;
long long p[N];
char str[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", &p[i]);
}
long long ret = 0;
scanf("%s", str);
for (int i = 0; i < n; i++) {
if (str[i] == 'B') ret += p[i];
}
long long s = ret, ss = ret;
for (int i = 0; i < n; i++) {
if (str[i] == 'B')
s -= p[i];
else
s += p[i];
ret = max(ret, s);
}
s = ss;
for (int i = n - 1; i >= 0; i--) {
if (str[i] == 'B')
s -= p[i];
else
s += p[i];
ret = max(ret, s);
}
cout << ret << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool read(T &n) {
T x = 0, tmp = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
if (c == EOF) return false;
if (c == '-') c = getchar(), tmp = -1;
while (c >= '0' && c <= '9') x *= 10, x += (c - '0'), c = getchar();
n = x * tmp;
return true;
}
template <class T>
inline void write(T n) {
if (n < 0) {
putchar('-');
n = -n;
}
int len = 0, data[20];
while (n) {
data[len++] = n % 10;
n /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
}
const int maxn = 2000800;
const int star = 1000040;
char str[maxn];
int vis[maxn];
int len;
bool judge(int obs) {
int pos = star;
int llef = pos, rrig = pos;
memset(vis, 0, sizeof(vis));
vis[star] = 1;
for (int i = 0; i < len; i++) {
if (str[i] == 'R' && (pos + 1 != obs)) pos++;
if (str[i] == 'L' && (pos - 1 != obs)) pos--;
vis[pos]++;
}
if (vis[pos] == 1 && pos != obs) return 1;
return 0;
}
int main() {
while (scanf("%s", str) != EOF) {
len = strlen(str);
int pos = star;
memset(vis, 0, sizeof(vis));
vis[star] = 1;
int lef = star, rig = star;
for (int i = 0; i < len; i++) {
if (str[i] == 'R')
pos++;
else
pos--;
vis[pos]++;
if (pos > rig) rig = pos;
if (pos < lef) lef = pos;
}
if (vis[pos] == 1) {
printf("1\n");
continue;
}
int ans = 0;
int l = lef, r = star - 1;
int ppp = star;
while (l <= r) {
int mid = l + ((r - l) >> 1);
if (judge(mid)) {
ppp = mid;
r = mid - 1;
} else
l = mid + 1;
}
ans += star - ppp;
l = star + 1, r = rig;
int pp = star;
while (l <= r) {
int mid = l + ((r - l) >> 1);
if (judge(mid)) {
pp = mid;
l = mid + 1;
} else
r = mid - 1;
}
ans += pp - star;
write(ans);
putchar('\n');
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int MAXN = 200005;
template <typename T>
void read(T &x) {
T flag = 1;
char ch = getchar();
for (; '0' > ch || ch > '9'; ch = getchar())
if (ch == '-') flag = 1;
for (x = 0; '0' <= ch && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
x *= flag;
}
struct segment {
int mn;
} tr[MAXN << 2];
void add(int x, int l, int r, int p, int v) {
if (l == r) {
tr[x].mn = v;
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
add(x << 1, l, mid, p, v);
else
add(x << 1 | 1, mid + 1, r, p, v);
tr[x].mn = min(tr[x << 1].mn, tr[x << 1 | 1].mn);
}
int ask(int p, int l, int r, int x, int y) {
if (l > y || r < x) return inf;
if (x <= l && r <= y) return tr[p].mn;
int mid = (l + r) >> 1;
return min(ask(p << 1, l, mid, x, y), ask(p << 1 | 1, mid + 1, r, x, y));
}
int val[MAXN], pos[MAXN];
void build(int p, int l, int r) {
if (l == r) {
tr[p].mn = val[pos[l]];
return;
}
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
tr[p].mn = min(tr[p << 1].mn, tr[p << 1 | 1].mn);
}
struct node {
int pre, to;
} edge[MAXN << 1];
int head[MAXN], tot = 1;
int n, m, q, N;
multiset<int> s[MAXN];
int dfn[MAXN], low[MAXN], stk[MAXN], Top, DEP;
int col[MAXN], w[MAXN];
vector<int> vec[MAXN];
void add_edge(int u, int v) {
edge[++tot] = node{head[u], v};
head[u] = tot;
}
void tarjan(int x, int fa) {
dfn[x] = low[x] = ++DEP;
stk[++Top] = x;
for (int i = head[x]; i; i = edge[i].pre) {
int y = edge[i].to;
if (!dfn[y]) {
tarjan(y, x);
low[x] = min(low[x], low[y]);
if (low[y] >= dfn[x]) {
N++;
val[N] = inf;
int z;
do {
z = stk[Top--];
col[z] = N;
vec[N].push_back(z);
vec[z].push_back(N);
} while (z != y);
z = x;
col[z] = N;
vec[N].push_back(z);
vec[z].push_back(N);
}
} else if (y != fa)
low[x] = min(low[x], dfn[y]);
}
}
int Fa[MAXN];
int sz[MAXN], son[MAXN], dep[MAXN];
int num, top[MAXN], zcr[MAXN];
void dfs(int x, int fa) {
sz[x] = 1;
for (auto y : vec[x]) {
if (y == fa) continue;
s[x].insert(w[y]);
dep[y] = dep[x] + 1;
Fa[y] = x;
dfs(y, x);
sz[x] += sz[y];
if (sz[son[x]] < sz[y]) son[x] = y;
}
if (x <= n)
val[x] = w[x];
else
val[x] = *s[x].begin();
}
void dfs2(int x, int chain) {
pos[++num] = x;
zcr[x] = num;
top[x] = chain;
if (son[x]) dfs2(son[x], chain);
for (auto y : vec[x]) {
if (y == Fa[x] || y == son[x]) continue;
dfs2(y, y);
}
}
int LCA(int u, int v) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
u = Fa[top[u]];
}
return dep[u] < dep[v] ? u : v;
}
int query(int u, int v) {
int ret = inf;
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
ret = min(ret, ask(1, 1, num, zcr[top[u]], zcr[u]));
u = Fa[top[u]];
}
if (dep[u] > dep[v]) swap(u, v);
ret = min(ret, ask(1, 1, num, zcr[u], zcr[v]));
return ret;
}
int main() {
read(n);
read(m);
read(q);
N = n;
for (int i = 1; i <= n; i++) read(w[i]);
for (int i = 1; i <= m; i++) {
int a, b;
read(a);
read(b);
add_edge(a, b);
add_edge(b, a);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
tarjan(i, 0);
}
}
dfs(1, 0);
dfs2(1, 1);
build(1, 1, num);
char opt[5];
while (q--) {
int a, b;
scanf("%s", opt + 1);
read(a);
read(b);
if (opt[1] == 'C') {
if (Fa[a]) s[Fa[a]].erase(s[Fa[a]].lower_bound(val[a]));
val[a] = b;
if (Fa[a]) s[Fa[a]].insert(val[a]);
if (Fa[a]) val[Fa[a]] = *s[Fa[a]].begin();
add(1, 1, num, zcr[a], val[a]);
if (Fa[a]) add(1, 1, num, zcr[Fa[a]], val[Fa[a]]);
} else {
int lca = LCA(a, b);
int ans = query(a, b);
if (lca > n && Fa[lca]) {
ans = min(ans, val[Fa[lca]]);
}
printf("%d\n", ans);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int ans(string s) {}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<vector<int> > graph(n, vector<int>(n, 0));
vector<vector<int> > dist(n, vector<int>(n, 0));
string s;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < n; j++) {
graph[i][j] = (s[j] - '0');
}
}
int m;
cin >> m;
vector<int> p(m);
for (int i = 0; i < m; i++) {
cin >> p[i];
p[i]--;
}
for (int i = 0; i < n; i++) {
vector<int> visited(n, false);
queue<int> qu;
qu.push(i);
visited[i] = true;
dist[i][i] = 0;
while (!qu.empty()) {
int x = qu.front();
qu.pop();
for (int j = 0; j < n; j++) {
if (graph[x][j] == 1 && !visited[j]) {
visited[j] = true;
dist[i][j] = dist[i][x] + 1;
qu.push(j);
}
}
}
}
int ct = 1;
int i = 0;
vector<int> ans;
ans.push_back(p[0]);
while (i < m - 1) {
int j = i;
ct++;
while (i < m - 1 && dist[p[j]][p[i + 1]] == (i + 1 - j)) i++;
ans.push_back(p[i]);
}
cout << ct << '\n';
for (int l = 0; l < ct; l++) cout << ans[l] + 1 << ' ';
cout << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 15;
int p[N], s[N];
long long dp[N], c;
int main() {
int n, i, j;
cin >> n >> c;
for (i = 1; i <= n; ++i) scanf("%d", &p[i]);
for (i = 1; i <= n; ++i) scanf("%d", &s[i]);
dp[0] = 0;
for (i = 1; i <= n; ++i) {
dp[i] = 1e18;
for (j = i; j >= 1; --j)
dp[j] = min(dp[j] + c * j + p[i], dp[j - 1] + s[i]);
dp[0] += p[i];
}
long long ret = 1e18;
for (i = 0; i <= n; ++i) ret = min(ret, dp[i]);
cout << ret << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++) cin >> h[i];
sort(h, h + n);
cout << h[n - 1];
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int block = 320;
const int maxn = 11e4;
int n, m, q, dn[maxn], f[maxn][block], dp[maxn][block];
int prv[maxn];
vector<int> up[maxn];
inline void proc() {
memset((f), (0), sizeof(f));
for (register int(i) = (0); (i) < (maxn); ++(i)) {
for (register int(j) = (0); (j) < (up[i].size()); ++(j))
(f[i][(int)ceil((double)up[i][j] / block)]) =
max((f[i][(int)ceil((double)up[i][j] / block)]), (up[i][j]));
for (register int(j) = (1); (j) < (block); ++(j))
(f[i][j]) = max((f[i][j]), (f[i][j - 1]));
}
for (register int(i) = (block)-1; (i) >= (0); --(i)) {
stack<int> stk;
for (register int(j) = (i * block + 1) - 1; (j) >= (0); --(j)) {
dp[j][i] = f[j][i];
while (stk.size() && dp[j][i] >= stk.top())
(dp[j][i]) = max((dp[j][i]), (dp[stk.top()][i])), stk.pop();
stk.push(j);
}
}
}
int main() {
cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false);
cin >> n >> m;
for (register int(i) = (0); (i) < (maxn); ++(i))
dn[i] = i, up[i].push_back(i);
fill(prv, prv + n, 1ll << 25);
for (register int(i) = (0); (i) < (m); ++(i)) {
int l, r;
cin >> l >> r;
dn[r] = l, up[l].push_back(r);
prv[r - 1] = l - 1;
}
proc();
cin >> q;
while (q--) {
int x, y, res, po;
cin >> x >> y;
if (x / block != y / block)
res = dp[x][y / block], po = y / block * block;
else {
int l = x - 1, r = y, lm, pl;
lm = pl = l;
for (int j = pl + 1; j < r; ++j) {
if (prv[j] <= lm && prv[j] >= l) lm = max(lm, j);
}
cout << lm + 1 << '\n';
continue;
}
while (po++ < y)
if (x <= dn[po] && dn[po] <= res) res = po;
cout << res << '\n';
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
char s[2][110][110];
int st[2][2][100010], top[2];
int n, m;
void change(int x, int y, int op) {
top[op]++;
st[op][0][top[op]] = x;
st[op][1][top[op]] = y;
if (s[op][x][y] == 'U') {
s[op][x][y] = 'L';
s[op][x][y + 1] = 'R';
s[op][x + 1][y] = 'L';
s[op][x + 1][y + 1] = 'R';
} else {
s[op][x][y] = 'U';
s[op][x + 1][y] = 'D';
s[op][x][y + 1] = 'U';
s[op][x + 1][y + 1] = 'D';
}
}
void dfs(int x, int y, int op) {
if (s[op][x][y + 1] == 'U')
change(x, y, op);
else if (s[op][x + 1][y + 1] == 'L')
change(x, y + 1, op), change(x, y, op);
else
dfs(x + 1, y + 1, op), change(x, y + 1, op), change(x, y, op);
}
void solve(int op) {
bool flag = 0;
if (m & 1) {
flag = 1;
for (int i = 1; i <= max(n, m); i++)
for (int j = i; j <= max(n, m); j++) swap(s[op][i][j], s[op][j][i]);
swap(n, m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (s[op][i][j] == 'U')
s[op][i][j] = 'L';
else if (s[op][i][j] == 'D')
s[op][i][j] = 'R';
else if (s[op][i][j] == 'L')
s[op][i][j] = 'U';
else if (s[op][i][j] == 'R')
s[op][i][j] = 'D';
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[op][i][j] == 'U') dfs(i, j, op);
if (flag) {
for (int i = 1; i <= top[op]; i++) swap(st[op][0][i], st[op][1][i]);
swap(n, m);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int k = 0; k < 2; k++)
for (int i = 1; i <= n; i++) scanf("%s", s[k][i] + 1);
for (int k = 0; k < 2; k++) solve(k);
printf("%d\n", top[0] + top[1]);
for (int i = 1; i <= top[0]; i++) printf("%d %d\n", st[0][0][i], st[0][1][i]);
for (int i = top[1]; i >= 1; i--) printf("%d %d\n", st[1][0][i], st[1][1][i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int dy[4] = {-1, 0, 0, 1};
const int dx[4] = {0, -1, 1, 0};
struct Circle {
double x, y, r;
} c[3];
double ang[3];
double dis(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
double val(double x, double y) {
for (int i = 0; i < 3; i++) ang[i] = dis(x, y, c[i].x, c[i].y) / c[i].r;
double value = 0;
for (int i = 0; i < 3; i++)
value += (ang[i] - ang[(i + 1) % 3]) * (ang[i] - ang[(i + 1) % 3]);
return value;
}
int main() {
double x = 0, y = 0;
for (int i = 0; i < 3; i++) {
scanf("%lf %lf %lf", &c[i].x, &c[i].y, &c[i].r);
x += c[i].x / 3, y += c[i].y / 3;
}
double error = val(x, y), step = 1;
for (int times = 1; times < 1e5; times++) {
bool flag = false;
double X, Y;
for (int i = 0; i < 4; i++) {
double xx = x + dx[i] * step, yy = y + dy[i] * step;
double v = val(xx, yy);
if (v < error) {
error = v;
flag = true;
X = xx, Y = yy;
}
}
if (flag)
x = X, y = Y;
else
step /= 2;
}
if (error < 1e-6) printf("%.5f %.5f", x, y);
return 0;
}
| 9 |
//#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<iomanip>
#include<string>
#include<vector>
#include<algorithm>
#include<assert.h>
#include<cmath>
#include<unordered_set>
#include<numeric>
#include<set>
#include<memory>
#include<deque>
#include<array>
#include<map>
#include<queue>
using namespace std;
void solve() {
int k;
cin >> k;
vector<int> games(2<<k, 1);
string given;
cin >> given;
reverse(given.begin(), given.end());
given = " " + given;
for (int i = given.size() - 1; i > 0; --i) {
if (given[i] == '0') {
games[i] = games[2 * i + 1];
}
else if (given[i] == '1'){
games[i] = games[2 * i];
}
else {
games[i] = games[2 * i + 1] + games[2 * i];
}
}
int q;
cin >> q;
while (q--) {
int p;
char c;
cin >> p >> c;
p = given.size() - p;
given[p] = c;
while (p != 0) {
if (given[p] == '0') {
games[p] = games[2 * p + 1];
}
else if (given[p] == '1') {
games[p] = games[2 * p];
}
else {
games[p] = games[2 * p + 1] + games[2 * p];
}
p /= 2;
}
cout << games[1] << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
//cin >> t;
while (t--) solve();
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[1010];
int b[1010];
scanf("%d", &n);
a[0] = 10000017;
int num = 0;
int k = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] <= a[i - 1]) {
num++;
b[k++] = a[i - 1];
}
}
cout << num << endl;
for (int i = 1; i < k; i++) cout << b[i] << ' ';
cout << a[n] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1, c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 200000 + 5;
vector<int> V[MAXN], r, C[MAXN];
vector<pair<int, pair<int, int> > > res;
int n, st[MAXN], top, sz[MAXN], deep[MAXN], pre[MAXN];
void dfs(int u, int p) {
sz[u] = 1;
int flag = 1;
for (auto v : V[u]) {
if (v == p) continue;
dfs(v, u);
sz[u] += sz[v];
if (sz[v] > n >> 1) flag = 0;
}
if (n - sz[u] > n >> 1) flag = 0;
if (flag) r.push_back(u);
}
void dfs2(int u, int p) {
pre[st[top++] = u] = p;
if (deep[u] >= 3) C[st[1]].push_back(u);
for (auto v : V[u]) {
if (v == p) continue;
deep[v] = deep[u] + 1;
dfs2(v, u);
}
top--;
}
int main() {
n = read();
for (int i = 1, u, v; i < n; i++) {
u = read(), v = read();
V[u].push_back(v);
V[v].push_back(u);
}
dfs(1, 0);
if (r.size() == 1)
dfs2(r[0], 0);
else
dfs2(r[0], r[1]), dfs2(r[1], r[0]);
for (int i = 1; i <= n; i++) {
if (C[i].size()) {
int cur = i;
for (auto x : C[i]) {
res.push_back(make_pair(pre[i], make_pair(cur, x))),
res.push_back(make_pair(x, make_pair(pre[x], i))), cur = x;
}
res.push_back(make_pair(pre[i], make_pair(cur, i)));
}
}
printf("%d\n", res.size());
for (auto x : res) {
printf("%d %d %d\n", x.first, x.second.first, x.second.second);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> edges[1000001];
vector<int> edges_rev[1000001];
bool isv[1000001];
stack<int> s;
int n, m;
void read_data() {
cin >> n >> m;
int u, v;
for (int i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
edges[u].push_back(v);
edges_rev[v].push_back(u);
}
}
int main() {
read_data();
memset(isv, 0, sizeof(isv));
for (int u = 1; u <= n; u++)
if (!isv[u]) {
isv[u] = true;
s.push(u);
for (auto &v : edges[u]) isv[v] = true;
}
vector<int> ans;
memset(isv, 0, sizeof(isv));
while (!s.empty()) {
int u = s.top();
s.pop();
if (ans.size() == 0) {
isv[u] = true;
ans.push_back(u);
continue;
}
bool flag = false;
for (auto &v : edges_rev[u]) flag |= isv[v];
if (!flag) {
isv[u] = true;
ans.push_back(u);
}
}
cout << ans.size() << endl;
for (auto &u : ans) cout << u << ' ';
cout << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int b, p, f, h, c;
scanf("%d%d%d%d%d", &b, &p, &f, &h, &c);
int burgposm = min(p, b / 2);
int chickposmin = min(f, b / 2);
printf("%d\n",
max(h * burgposm + c * min((b - burgposm * 2) / 2, f),
c * chickposmin + h * min((b - chickposmin * 2) / 2, p)));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000;
const int NUML = 26;
const int INF = 0x7f7f7f7f;
const pair<int, int> END(INF, INF);
template <class Dis>
struct Record {
Dis arr[NUML];
inline Dis& operator[](int i) { return arr[i]; }
inline void operator=(const Record<Dis>& other) {
memcpy(arr, other.arr, sizeof(arr));
}
};
int n, m;
string base[MAXN];
int seq[MAXN];
char aim[MAXN + 1];
char line[1000001];
vector<Record<int> > baseNext[MAXN];
Record<pair<int, int> > seqNext[MAXN];
inline pair<int, int> getNext(pair<int, int> cur, char ch) {
int j = baseNext[seq[cur.first]][cur.second][ch - 'a'];
if (j == INF) {
if (cur.first == m - 1) {
return END;
} else {
return seqNext[cur.first + 1][ch - 'a'];
}
} else {
return pair<int, int>(cur.first, j);
}
}
pair<int, int> bestAns[MAXN + 1];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", line);
base[i] = line;
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &seq[i]);
seq[i]--;
}
scanf("%s", aim);
for (int i = 0; i < n; i++) {
baseNext[i].resize(base[i].size() + 1);
memset(baseNext[i][base[i].size()].arr, 0x7f,
sizeof(baseNext[i][base[i].size()].arr));
for (int j = (int)base[i].size() - 1; j >= 0; j--) {
baseNext[i][j] = baseNext[i][j + 1];
baseNext[i][j][base[i][j] - 'a'] = j + 1;
}
}
for (int i = m - 1; i >= 0; i--) {
if (i == m - 1) {
memset(seqNext[i].arr, 0x7f, sizeof(seqNext[i].arr));
} else {
seqNext[i] = seqNext[i + 1];
}
for (int j = 0; j < NUML; j++) {
if (baseNext[seq[i]][0][j] != INF) {
seqNext[i][j] = pair<int, int>(i, baseNext[seq[i]][0][j]);
}
}
}
int len = strlen(aim);
memset(bestAns, 0x7f, sizeof(pair<int, int>) * (len + 1));
bestAns[0] = pair<int, int>(0, 0);
for (int i = 0; i < len; i++) {
for (int j = i; j >= 0; j--) {
if (bestAns[j] != END) {
pair<int, int> cur = getNext(bestAns[j], aim[i]);
bestAns[j + 1] = min(bestAns[j + 1], cur);
}
}
}
int ans;
for (ans = len; bestAns[ans] == END; ans--)
;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
long long int x[n], y[n];
x[0] = 0;
for (int i = 1; i < s.size(); ++i) {
if (s[i - 1] == 'v' && s[i] == 'v')
x[i] = x[i - 1] + 1;
else
x[i] = x[i - 1];
}
y[n - 1] = 0;
for (int i = n - 2; i >= 0; --i) {
if (s[i + 1] == 'v' && s[i] == 'v')
y[i] = y[i + 1] + 1;
else
y[i] = y[i + 1];
}
long long int sum = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == 'o') sum += x[i] * y[i];
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, A[200000 + 8], power2 = 0, res = 1;
map<long long, long long> cnt;
int main() {
cin >> n;
for (int(i) = 0; (i) < (2 * n); (i)++) {
cin >> A[i];
cnt[A[i]]++;
if (i >= n && A[i] == A[i - n]) power2++;
}
cin >> m;
for (__typeof((cnt).begin()) it = (cnt).begin(); it != (cnt).end(); it++) {
for (int(i) = (1); (i) <= (it->second); (i)++) {
int tmp = i;
while (power2 > 0 && !(tmp & 1)) tmp /= 2, power2--;
res = (res * tmp) % m;
}
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[500050], f[500050];
set<int> s;
int res;
int find(int x) {
if (f[x] == -1) return x;
return f[x] = find(f[x]);
}
void makeset(int size) {
for (int i = 0; i <= size; i++) {
f[i] = -1;
}
}
void unionset(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (x < y) swap(x, y);
res++;
f[y] = x;
}
int main() {
int n, m;
cin >> n >> m;
makeset(n + 10);
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
unionset(x, y);
}
int cnt = 0, now = find(1);
for (int i = 2; i <= n; i++) {
if (i <= now) cnt++;
now = max(find(i), now);
}
cout << cnt - res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 5;
int x[maxn], y[maxn];
set<int> st;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
st.insert(x[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &y[i]);
st.insert(y[i]);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (st.find(x[i] ^ y[j]) != st.end()) {
cnt++;
}
}
}
if (cnt & 1)
cout << "Koyomi" << endl;
else
cout << "Karen" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int w, i;
bool operator<(const node &b) const { return w < b.w; }
};
int i, j, k, n, m, x, y, T, big, cas, ans[1005][2], step;
node a[1005];
bool flag;
int main() {
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
cin >> a[i].w;
a[i].i = i + 1;
}
sort(a, a + n);
while (1) {
if (a[n - 1].w - a[0].w <= 1) break;
a[n - 1].w--;
a[0].w++;
step++;
ans[step][0] = a[n - 1].i;
ans[step][1] = a[0].i;
sort(a, a + n);
if (step == k) break;
}
cout << a[n - 1].w - a[0].w << " " << step << endl;
for (i = 1; i <= step; i++) cout << ans[i][0] << " " << ans[i][1] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long nextPrime(long long N) {
if (N <= 1) return 2;
long long prime = N;
bool found = false;
while (!found) {
prime++;
if (isPrime(prime)) found = true;
}
return prime;
}
long long fact(long long n) {
if (n == 1) return 1;
return n * fact(n - 1);
}
long long cl(long long n, long long d) { return (n + d - 1) / d; }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / (gcd(a, b)); }
long long Pow(long long x, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans *= x;
x *= x;
n >>= 1;
}
return ans;
}
void solve() {
string a[2];
cin >> a[0] >> a[1];
long long i, ans = 0;
for (i = 0; i < a[0].size(); i++) {
if (a[0][i] == '0' && a[1][i] == 'X') {
if (i + 1 < a[0].size()) {
if (a[0][i + 1] == '0' && a[1][i + 1] == '0') {
ans++;
i++;
}
}
} else if (a[0][i] == 'X' && a[1][i] == '0') {
if (i + 1 < a[0].size()) {
if (a[0][i + 1] == '0' && a[1][i + 1] == '0') {
ans++;
i++;
}
}
} else if (a[0][i] == '0' && a[1][i] == '0') {
if (i + 1 < a[0].size()) {
if (i + 1 < a[0].size()) {
if (a[0][i + 1] == '0' || a[1][i + 1] == '0') {
ans++;
a[0][i] = 'X';
a[1][i] = 'X';
if (a[1][i + 1] == '0') {
a[1][i + 1] = 'X';
continue;
}
if (a[0][i + 1] == '0') {
a[0][i + 1] = 'X';
continue;
}
}
}
}
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 5 + 1e6;
struct SEG {
int t[MAX_N << 2];
void build(int p, int l, int r) {
t[p] = 2e9;
if (l == r) return;
int m = l + r >> 1;
build(p + p, l, m);
build(p + p + 1, m + 1, r);
}
void change(int p, int l, int r, int x, int y, int tag) {
if (l == x && r == y) {
t[p] = min(t[p], tag);
return;
}
int m = l + r >> 1;
if (y <= m)
change(p + p, l, m, x, y, tag);
else if (x > m)
change(p + p + 1, m + 1, r, x, y, tag);
else
change(p + p, l, m, x, m, tag),
change(p + p + 1, m + 1, r, m + 1, y, tag);
}
void dfs(int p, int l, int r, int key, vector<int>& g) {
key = min(key, t[p]);
if (l == r) return void(g[l] = key);
int m = l + r >> 1;
dfs(p + p, l, m, key, g);
dfs(p + p + 1, m + 1, r, key, g);
}
} seg;
vector<int> a;
set<int> s;
int ans = 0;
inline int get_key(int x, int std) { return x > std; }
bool check(set<int>::iterator it0, set<int>::iterator it1, int std) {
int pos0 = (*it0), pos1 = (*it1);
if (pos1 >= a.size()) return false;
if (get_key(a[pos1 - 1], std) != get_key(a[pos1], std)) {
s.erase(it1);
return true;
} else
return false;
}
void opera(int l, int r, int std) {
int cnt1 = (r - l + 1 + 1) / 2;
ans = max(ans, (r - l) / 2);
if (get_key(a[l], std) == get_key(a[r], std)) {
if (get_key(a[l], std) == 0) {
seg.change(1, 0, a.size() - 1, l, r, std);
}
} else if (get_key(a[l], std) == 0) {
if (l <= l + cnt1 - 1) {
seg.change(1, 0, a.size() - 1, l, l + cnt1 - 1, std);
}
} else {
if (l + cnt1 <= r) {
seg.change(1, 0, a.size() - 1, l + cnt1, r, std);
}
}
}
int gk(set<int>::iterator it) { return it == s.end() ? (int)a.size() : *it; }
void solve(int std, vector<int> pos) {
for (auto x : pos) {
s.insert(x);
if (x + 1 < a.size()) s.insert(x + 1);
}
for (auto x : pos) {
while (1) {
auto it = s.lower_bound(x);
if (it == s.end()) break;
auto it1 = next(it);
if (it1 == s.end()) break;
if (!check(it, it1, std)) break;
}
while (1) {
auto it = s.lower_bound(x);
if (it == s.begin() || it == s.end()) break;
auto it1 = prev(it);
if (!check(it1, it, std)) break;
}
}
for (auto x : pos) {
auto it = s.lower_bound(x);
if (it != s.end()) {
auto it1 = next(it);
opera((*it), gk(it1) - 1, std);
if (it1 != s.end()) {
auto it2 = next(it1);
opera(*it1, gk(it2) - 1, std);
}
}
if (it != s.begin()) {
auto it1 = prev(it);
opera((*it1), gk(it) - 1, std);
if (it1 != s.begin()) {
auto it2 = prev(it1);
opera(*it2, gk(it1) - 1, std);
}
}
}
}
map<int, vector<int> > k;
int main() {
int n;
scanf("%d", &n);
a.resize(n);
for (int i = 0; i < n; ++i) s.insert(i);
seg.build(1, 0, n - 1);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]), k[a[i]].push_back(i);
for (auto x : k) solve(x.first, x.second);
vector<int> ret;
ret.resize(n);
seg.dfs(1, 0, a.size() - 1, 2e9, ret);
printf("%d\n", ans);
for (auto x : ret) printf("%d ", x);
puts("");
return 0;
}
| 12 |
#include <bits/stdc++.h>
const int N = 110;
long long k, a[N], b[N], mat[N][N];
int n, m;
bool mk, mmk;
bool low, top;
long long L, T;
long long geta(int x, int y) {
mk = 1;
bool f1 = 0, f2 = 0, f3 = 0;
long long k1, k2;
for (int i = 1; i <= n; i++) {
long long d = mat[i][y] - mat[i][x];
if (d > 0) {
if (f1) {
if (k1 != d) return 0;
} else {
k1 = d;
f1 = 1;
}
} else if (d < 0) {
if (f2) {
if (k2 != d) return 0;
} else {
k2 = d;
f2 = 1;
}
} else {
f3 = 1;
}
}
if (f3) {
if (f1 || f2) {
mmk = 0;
return 0;
}
mk = 0;
return 0;
} else if (f1 && f2) {
return k1 - k2;
} else {
if (f1 && k1 > T) {
T = k1;
} else if (f2 && k2 < L) {
L = k2;
}
mk = 0;
return 0;
}
}
long long getb(int x, int y) {
mk = 1;
bool f1 = 0, f2 = 0, f3 = 0;
long long k1, k2;
for (int i = 1; i <= m; i++) {
long long d = mat[y][i] - mat[x][i];
if (d > 0) {
if (f1) {
if (k1 != d) return 0;
} else {
k1 = d;
f1 = 1;
}
} else if (d < 0) {
if (f2) {
if (k2 != d) return 0;
} else {
k2 = d;
f2 = 1;
}
} else {
f3 = 1;
}
}
if (f3) {
if (f1 || f2) {
mmk = 0;
return 0;
}
mk = 0;
return 0;
} else if (f1 && f2) {
return k1 - k2;
} else {
if (f1 && k1 > T) {
T = k1;
} else if (f2 && k2 < L) {
L = k2;
}
mk = 0;
return 0;
}
}
bool ok() {
L = 1;
T = -1;
mmk = 1;
bool flag = 0;
for (int i = 1; i <= m; i++) {
for (int j = i + 1; j <= m; j++) {
long long cur = geta(i, j);
if (!mmk) return 0;
if (!flag && mk) {
flag = 1;
k = cur;
} else if (mk && k != cur)
return 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
long long cur = getb(i, j);
if (!mmk) return 0;
if (!flag && mk) {
flag = 1;
k = cur;
} else if (mk && k != cur)
return 0;
}
}
if (!flag) {
k = (int)1e9 + 7;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (mat[i][j] >= k) return 0;
}
}
for (int i = 1; i <= m; i++) b[i] = mat[1][i];
for (int i = 1; i <= n; i++) {
a[i] = (mat[i][1] - b[1]) % k;
if (a[i] < 0) a[i] += k;
}
return 1;
}
int main() {
while (~scanf("%d %d", &n, &m)) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) scanf("%I64d", &mat[i][j]);
}
if (ok()) {
puts("YES");
printf("%I64d\n", k);
for (int i = 1; i <= n; i++) printf("%I64d%c", a[i], i == n ? '\n' : ' ');
for (int i = 1; i <= m; i++) printf("%I64d%c", b[i], i == m ? '\n' : ' ');
} else {
puts("NO");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int M = 5e5 + 15;
const unsigned long long P1 = 15260279, P2 = 8456593;
int a[M], cnt[M], pre[M][6];
unsigned long long h1[M], h2[M], p1[M], p2[M];
map<pair<unsigned long long, unsigned long long>, int> ma;
signed main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
p1[0] = p2[0] = 1;
for (int i = 1; i <= M - 5; i++) p1[i] = P1 * p1[i - 1];
for (int i = 1; i <= M - 5; i++) p2[i] = P2 * p2[i - 1];
unsigned long long nh1 = 0, nh2 = 0;
int l = 0;
ma[make_pair(0, 0)] = 1;
unsigned long long ans = 0;
for (int i = 1; i <= n; i++) {
int t = cnt[a[i]] % 3;
cnt[a[i]]++;
pre[a[i]][4] = pre[a[i]][3];
pre[a[i]][3] = pre[a[i]][2];
pre[a[i]][2] = pre[a[i]][1];
pre[a[i]][1] = i;
if (pre[a[i]][4]) {
while (l < pre[a[i]][4]) ma[make_pair(h1[l], h2[l])]--, l++;
}
nh1 = nh1 - p1[a[i]] * t + p1[a[i]] * ((t + 1) % 3);
nh2 = nh2 - p2[a[i]] * t + p2[a[i]] * ((t + 1) % 3);
ans += ma[make_pair(nh1, nh2)];
ma[make_pair(nh1, nh2)]++;
h1[i] = nh1;
h2[i] = nh2;
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char mass[101][101];
long res = 0;
for (int i = 0; i < n; i++) {
int cCount = 0;
cin >> mass[i];
for (int k = 0; k < n; k++) {
if (mass[i][k] == 'C') {
cCount++;
}
}
res += (cCount * (cCount - 1) / 2);
}
for (int i = 0; i < n; i++) {
int cCount = 0;
for (int k = 0; k < n; k++) {
if (mass[k][i] == 'C') {
cCount++;
}
}
res += (cCount * (cCount - 1) / 2);
}
printf("%d", res);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const double PI = acos(-1);
const int N = 1 << 16, L = 15, MASK = (1 << L) - 1;
complex<double> w[N];
void FFTInit() {
for (int i = 0; i < N; ++i) {
w[i] = complex<double>(cos(2 * i * PI / N), sin(2 * i * PI / N));
}
}
void FFT(complex<double> p[], int n) {
for (int i = 1, j = 0; i < n - 1; ++i) {
for (int s = n; j ^= s >>= 1, ~j & s;)
;
if (i < j) {
swap(p[i], p[j]);
}
}
for (int d = 0; (1 << d) < n; ++d) {
int m = 1 << d, m2 = m * 2, rm = n >> (d + 1);
for (int i = 0; i < n; i += m2) {
for (int j = 0; j < m; ++j) {
complex<double> &p1 = p[i + j + m], &p2 = p[i + j];
complex<double> t = w[rm * j] * p1;
p1 = p2 - t;
p2 = p2 + t;
}
}
}
}
complex<double> A[N], B[N], C[N], D[N];
void mul(int a[N], int b[N], int c[N], int same = false) {
for (int i = 0; i < N; ++i) {
if (i < N / 2) {
A[i] = complex<double>(a[i] >> L, a[i] & MASK);
B[i] = complex<double>(b[i] >> L, b[i] & MASK);
} else {
A[i] = 0;
B[i] = 0;
}
}
FFT(A, N);
if (!same)
FFT(B, N);
else {
for (int i = 0; i < N; ++i) B[i] = A[i];
}
for (int i = 0; i < N; ++i) {
int j = (N - i) % N;
complex<double> da = (A[i] - conj(A[j])) * complex<double>(0, -0.5),
db = (A[i] + conj(A[j])) * complex<double>(0.5, 0),
dc = (B[i] - conj(B[j])) * complex<double>(0, -0.5),
dd = (B[i] + conj(B[j])) * complex<double>(0.5, 0);
C[j] = da * dd + da * dc * complex<double>(0, 1);
D[j] = db * dd + db * dc * complex<double>(0, 1);
}
FFT(C, N), FFT(D, N);
for (int i = 0; i < N; ++i) {
long long da = (long long)(C[i].imag() / N + 0.5) % MOD,
db = (long long)(C[i].real() / N + 0.5) % MOD,
dc = (long long)(D[i].imag() / N + 0.5) % MOD,
dd = (long long)(D[i].real() / N + 0.5) % MOD;
c[i] = ((dd << (L * 2)) + ((db + dc) << L) + da) % MOD;
}
}
int n, m;
int ans[2][N];
int vec[2][2][N];
long long nc[2][N];
int tmp[N];
void update(int a[2][N], int b[2][N], int c[2][N], int same = 0) {
memset(nc, 0, sizeof nc);
mul(a[0], b[0], tmp, same);
for (int i = 0; i < N; ++i) nc[0][i] += tmp[i];
mul(a[1], b[1], tmp, same);
for (int i = 0; i < N; ++i) {
if (i + 1 < N) {
nc[0][i + 1] += tmp[i];
nc[1][i + 1] -= tmp[i];
}
nc[1][i] -= tmp[i];
}
mul(a[0], b[1], tmp);
for (int i = 0; i < N; ++i) nc[1][i] += tmp[i];
if (!same) mul(a[1], b[0], tmp);
for (int i = 0; i < N; ++i) nc[1][i] += tmp[i];
for (int i = 0; i < N; ++i) {
c[0][i] = nc[0][i];
while (c[0][i] < 0) c[0][i] += MOD;
while (c[0][i] >= MOD) c[0][i] -= MOD;
c[1][i] = nc[1][i];
while (c[1][i] < 0) c[1][i] += MOD;
while (c[1][i] >= MOD) c[1][i] -= MOD;
}
}
void solve() {
ios::sync_with_stdio(false);
FFTInit();
cin >> n >> m;
int cur = 0;
vec[cur][0][0] = vec[cur][0][1] = vec[cur][1][0] = 1;
ans[0][0] = 1;
for (int tm = n; tm; tm >>= 1) {
if (tm & 1) {
update(ans, vec[cur], ans);
}
update(vec[cur], vec[cur], vec[cur ^ 1], 1);
cur ^= 1;
}
for (int i = 1; i <= m; ++i) {
cout << ans[0][i] << ' ';
}
cout << endl;
}
int main() {
solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const long long INF = 1e18L + 7;
template <class n, class second>
ostream &operator<<(ostream &p, pair<n, second> x) {
return p << "<" << x.first << ", " << x.second << ">";
}
template <class n>
auto operator<<(ostream &p, n y) ->
typename enable_if<!is_same<n, string>::value,
decltype(y.begin(), p)>::type {
int o = 0;
p << "{";
for (auto c : y) {
if (o++) p << ", ";
p << c;
}
return p << "}";
}
void dor() { cerr << '\n'; }
template <class n, class... second>
void dor(n p, second... y) {
cerr << p << " ";
dor(y...);
}
template <class n, class second>
void mini(n &p, second y) {
if (p > y) p = y;
}
template <class n, class second>
void maxi(n &p, second y) {
if (p < y) p = y;
}
const int M = 1024 * 1024 * 2;
int n, m, T[M], dep[M];
long long sum;
vector<int> V;
int getdep(int v) {
if (T[2 * v] == 0 && T[2 * v + 1] == 0) {
return dep[v];
}
if (T[2 * v] > T[2 * v + 1]) {
return getdep(2 * v);
}
return getdep(2 * v + 1);
}
void wyjeb(int v) {
if (T[2 * v] == 0 && T[2 * v + 1] == 0) {
T[v] = 0;
return;
}
if (T[2 * v] > T[2 * v + 1]) {
T[v] = T[2 * v];
wyjeb(2 * v);
} else {
T[v] = T[2 * v + 1];
wyjeb(2 * v + 1);
}
}
void jebaj(int v) {
if (dep[v] > m) {
return;
}
int x = getdep(v);
while (x > m) {
sum -= T[v];
;
wyjeb(v);
V.push_back(v);
x = getdep(v);
}
jebaj(2 * v);
jebaj(2 * v + 1);
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = (0); i <= (int)((1 << (n + 1)) - 1); ++i) {
T[i] = 0;
}
sum = 0;
for (int i = (1); i <= (int)((1 << n) - 1); ++i) {
scanf("%d", T + i);
sum += T[i];
}
V.clear();
jebaj(1);
printf("%lld\n", sum);
for (auto x : V) {
printf("%d ", x);
}
printf("\n");
}
int32_t main() {
dep[1] = 1;
for (int i = (1); i <= (int)(M / 2 - 1); ++i) {
dep[2 * i] = dep[i] + 1;
dep[2 * i + 1] = dep[i] + 1;
}
int t;
scanf("%d", &t);
while (t--) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2, s3, s4;
cin >> s1;
string ans[10];
cin >> s2;
s3 = s1;
int flag = 0;
int count = 0;
while (flag == 0) {
if (s1[0] > s2[0]) {
if (s1[1] > s2[1]) {
s1[0]--;
s1[1]--;
count++;
} else if (s1[1] < s2[1]) {
s1[0]--;
s1[1]++;
count++;
} else if (s1[1] == s2[1]) {
s1[0]--;
count++;
}
} else if (s1[0] < s2[0]) {
if (s1[1] > s2[1]) {
s1[0]++;
s1[1]--;
count++;
} else if (s1[1] < s2[1]) {
s1[0]++;
s1[1]++;
count++;
;
} else if (s1[1] == s2[1]) {
s1[0]++;
count++;
}
} else if (s1[0] == s2[0]) {
if (s1[1] > s2[1]) {
s1[1]--;
count++;
} else if (s1[1] < s2[1]) {
count++;
s1[1]++;
} else if (s1[1] == s2[1]) {
flag = 1;
}
}
}
s1 = s3;
flag = 0;
cout << count << endl;
while (flag == 0) {
if (s1[0] > s2[0]) {
if (s1[1] == s2[1]) {
s1[0]--;
cout << "L" << endl;
} else if (s1[1] > s2[1]) {
s1[0]--;
s1[1]--;
cout << "LD" << endl;
} else if (s1[1] < s2[1]) {
s1[0]--;
s1[1]++;
cout << "LU" << endl;
}
} else if (s1[0] < s2[0]) {
if (s1[1] == s2[1]) {
s1[0]++;
cout << "R" << endl;
} else if (s1[1] > s2[1]) {
s1[0]++;
s1[1]--;
cout << "RD" << endl;
} else if (s1[1] < s2[1]) {
s1[0]++;
s1[1]++;
cout << "RU" << endl;
}
} else if (s1[0] == s2[0]) {
if (s1[1] > s2[1]) {
s1[1]--;
cout << "D" << endl;
} else if (s1[1] < s2[1]) {
s1[1]++;
cout << "U" << endl;
} else if (s1[1] == s2[1]) {
flag = 1;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1];
int b[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
cout << b[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 255;
const int MaxM = 1000005;
int x[MaxN], y[MaxN];
int ret[MaxM];
long long xmult(int x1, int y1, int x2, int y2, int x3, int y3) {
return (long long)(x2 - x1) * (y3 - y1) - (long long)(x3 - x1) * (y2 - y1);
}
int main() {
int N, M;
while (scanf("%d%d", &M, &N) == 2) {
fill(ret, ret + M + 1, 1);
for (int i = 0; i < N; i++) scanf("%d%d", &x[i], &y[i]);
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
int idx1 = i, idx2 = j;
if (y[idx1] > y[idx2]) swap(idx1, idx2);
if (y[idx1] == y[idx2]) continue;
int dy = y[idx2] - y[idx1];
int dx = x[idx2] - x[idx1];
if ((long long)dx * y[idx1] % dy == 0) {
long long tx = x[idx1] - (long long)dx * y[idx1] / dy;
if (tx >= 1 && tx <= M) {
int sum = 0;
for (int k = 0; k < N; k++) {
if (xmult(x[i], y[i], x[j], y[j], x[k], y[k]) == 0) sum++;
}
ret[tx] = max(ret[tx], sum);
}
}
}
}
int ans = 0;
for (int i = 1; i <= M; i++) ans += ret[i];
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, i, cou, j, k, val;
long long num, m, n2, m2;
char RE;
RE:
cin >> n;
long long A[n], B[n];
if (n < 2 && n > 100000) goto RE;
for (i = 0; i < n; i++) {
cin >> A[i];
}
m = A[0];
j = 0;
for (i = 1; i < n; i++) {
if (m > A[i]) {
m = min(m, A[i]);
j = i;
}
}
m2 = 0;
k = 0;
for (i = j; i < n; i++) {
if (A[i] == m) {
B[k] = i;
k++;
m2++;
}
}
k = k - 1;
cou = 1000000;
for (i = 0; i < k; i++) {
val = B[i + 1] - B[i];
if (val < cou) cou = val;
}
cout << cou << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
int mod = (int)1e9 + 7;
const int logN = 18;
const int inf = 1e9 + 9;
const int N = 2e5 + 6;
int root[N], size[N], m, n, x, y, sum[N], depth[N], lca[logN + 1][N], p;
long long cur, sk[N];
vector<int> v[N];
void init(int node, int root) {
sum[node] = 1;
lca[0][node] = root;
for (__typeof(v[node].begin()) it = v[node].begin(); it != v[node].end();
it++) {
if (*it == root) continue;
depth[*it] = depth[node] + 1;
init(*it, node);
sk[node] += sum[*it] * (long long)sum[*it];
sum[node] += sum[*it];
}
cur += (sum[node] - 1) * (long long)(n - sum[node]);
cur += ((sum[node] - 1) * (long long)(sum[node] - 1) - sk[node]) / 2;
}
int LCA(int x, int y) {
if (depth[x] < depth[y]) swap(x, y);
int diff = depth[x] - depth[y];
for (int i = 0; i <= logN; i++)
if (diff & (1 << i)) x = lca[i][x];
if (x == y) return x;
for (int i = logN; i >= 0; i--)
if (lca[i][x] != lca[i][y]) x = lca[i][x], y = lca[i][y];
return lca[0][x];
}
int findset(int x) { return root[x] = root[x] == x ? x : findset(root[x]); }
int up(int x) { return findset(lca[0][findset(x)]); }
int merge_up(int x) {
x = findset(x);
int y = up(x);
cur += (sum[x] * (long long)sum[x] - sk[x] - size[x]) / 2 * size[y];
cur += ((n - sum[x]) * (long long)(n - sum[x]) -
(sk[y] - sum[x] * (long long)sum[x] +
(n - sum[y]) * (long long)(n - sum[y])) -
size[y]) /
2 * size[x];
sk[y] = sk[y] - sum[x] * (long long)sum[x] + sk[x];
root[x] = y;
size[y] += size[x];
return y;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) root[i] = i, size[i] = 1;
init(1, 0);
for (int i = 1; i <= logN; i++) {
for (int j = 1; j <= n; j++) lca[i][j] = lca[i - 1][lca[i - 1][j]];
}
scanf("%d", &m);
cout << 2 * cur << '\n';
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
x = findset(x);
y = findset(y);
if (x == y) {
printf("%lld\n", 2 * cur);
continue;
}
int t = findset(LCA(x, y));
while (x != t) {
x = merge_up(x);
}
while (y != t) {
y = merge_up(y);
}
printf("%lld\n", 2 * cur);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void amax(X& x, const Y& y) {
if (x < y) x = y;
}
template <class X, class Y>
void amin(X& x, const Y& y) {
if (x > y) x = y;
}
const int INF = 1e9 + 10;
const long long INFL = 1e18 + 10;
const int MAX = 1e6 + 10;
int n, m[2], t, np;
int obs[2][MAX];
int pp[MAX * 2], dp[2][MAX * 2];
int mark[MAX * 2];
bool change[MAX * 2];
bool ison(int i, int ms) { return (ms >> i) & 1; }
void process() {
cin >> n >> m[0] >> m[1] >> t;
for (int i = 0; i < 2; i++)
for (int j = 0; j < m[i]; j++) cin >> obs[i][j];
for (int i = 0; i < 2; i++)
for (int j = 0; j < m[i]; j++) {
pp[++np] = obs[i][j];
pp[++np] = obs[i][j] + 1;
}
pp[++np] = 0;
pp[++np] = n + 1;
sort(pp + 1, pp + np + 1);
np = distance(pp + 1, unique(pp + 1, pp + np + 1));
for (int i = 0; i < 2; i++) {
for (int j = 0, k = 1; j < m[i] && k <= np; j++) {
while (k < np && pp[k] < obs[i][j]) k++;
if (pp[k] == obs[i][j]) {
mark[k++] |= (1 << i);
}
}
}
memset(dp, 255, sizeof(dp));
dp[0][1] = dp[1][1] = 0;
for (int i = 2; i <= np; i++) {
for (int j = 0; j < 2; j++)
if (dp[j][i - 1] != -1) {
if (ison(j, mark[i])) {
if (dp[j][i - 1] + pp[i] - 1 - pp[i - 1] >= t)
amax(dp[j][i], dp[j][i - 1] + pp[i] - pp[i - 1] - t);
} else {
amax(dp[j][i], dp[j][i - 1] + pp[i] - pp[i - 1]);
}
}
if (pp[i] == pp[i - 1] + 1) {
int vv[2];
vv[0] = dp[0][i];
vv[1] = dp[1][i];
for (int j = 0; j < 2; j++)
if (!ison(j, mark[i]) && ison(j, mark[i - 1]) && vv[j ^ 1] != -1) {
amax(dp[j][i], min(vv[j ^ 1], t));
}
}
}
int lane = (dp[0][np] == -1) ? 1 : 0;
if (dp[lane][np] == -1) {
cout << "No";
return;
}
for (int i = np; i > 1; i--) {
if (dp[lane][i - 1] != -1) {
if (ison(lane, mark[i])) {
if (dp[lane][i - 1] + pp[i] - 1 - pp[i - 1] >= t &&
dp[lane][i] == dp[lane][i - 1] + pp[i] - pp[i - 1] - t) {
continue;
}
} else {
if (dp[lane][i] == dp[lane][i - 1] + pp[i] - pp[i - 1]) {
continue;
}
}
}
change[i] = true;
lane ^= 1;
}
if (lane == 1) {
change[1] = true;
lane = 0;
}
vector<int> pchange;
vector<pair<int, int> > pshot;
if (change[1]) {
pchange.push_back(0);
lane ^= 1;
}
int start = 1;
while (start < np) {
int last = start + 1;
while (last < np && !change[last]) last++;
int cnt = 0;
for (int i = start; i <= last; i++)
if (ison(lane, mark[i])) cnt++;
for (int i = 1; i <= cnt; i++) {
pshot.push_back(
make_pair(lane, max(pp[start], pp[start] + i * t - dp[lane][start])));
}
if (change[last]) {
pchange.push_back(pp[last]);
lane ^= 1;
}
start = last;
}
cout << "Yes" << '\n';
cout << int(pchange.size()) << '\n';
for (auto x : pchange) cout << x << " ";
cout << '\n';
cout << int(pshot.size()) << '\n';
for (auto x : pshot) cout << x.second << " " << x.first + 1 << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
process();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const long long NLINF = 0xf7f7f7f7f7f7f7f7;
const int INF = 0x3f3f3f3f, NINF = 0xf7f7f7f7;
const int MOD1 = 1e9 + 7, MOD2 = 1e9 + 9;
const int N = 1e6;
int x, pf[N + 5], dp[N + 5][5];
int solve(int v, int k) {
if (dp[v][k] != -1) return dp[v][k];
if (pf[v] == v or !k) return v;
int v_orig = v, ret = INF;
while (v > 1) {
int x = (v_orig / pf[v] - 1);
for (int i = pf[v] * x; i < min(pf[v] * x + 100, pf[v] * (x + 1)); i++)
ret = min(ret, solve(i + 1, k - 1));
int curd = pf[v];
while (v % curd == 0) v /= curd;
}
return dp[v][k] = ret;
}
int main() {
scanf("%d", &x);
for (int i = 2; i <= N; i++) {
if (pf[i]) continue;
for (int j = i; j <= N; j += i) pf[j] = i;
}
memset(dp, -1, sizeof dp);
printf("%d\n", solve(x, 2));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
map<string, int> m;
vector<int> p(4);
int modpow(int a, int b) {
int c = 1;
while (b) {
if (b & 1) c = 1LL * c * a % 1000000007;
a = 1LL * a * a % 1000000007;
b >>= 1;
}
return c;
}
int main() {
cin >> n;
cin >> s;
m[""] = 0;
m["a"] = 1;
m["ab"] = 2;
m["abc"] = 3;
p[0] = 1;
p[1] = 0;
p[2] = 0;
p[3] = 0;
int q = 0;
for (int i = 0; i < n; i++) {
int t = modpow(3, q);
if (s[i] == 'a')
p[1] = (p[1] * 1LL + t) % 1000000007;
else if (s[i] == 'b')
p[2] = (p[2] * 1LL + p[1]) % 1000000007;
else if (s[i] == 'c')
p[3] = (p[3] * 1LL + p[2]) % 1000000007;
else {
int a = (3 * 1LL * p[1] + t) % 1000000007;
int b = (3 * 1LL * p[2] + p[1]) % 1000000007;
int c = (3 * 1LL * p[3] + p[2]) % 1000000007;
p[1] = a;
p[2] = b;
p[3] = c;
q += 1;
}
}
cout << p[3] << endl;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:258435456");
using namespace std;
int a[1000000];
bool was[10001][8][8];
long long c[10001][8][8];
char d[3][1000000];
int n;
int f(int k, int x, int y) {
if (k == n) return 1;
if (x == 7) return f(k + 1, y, a[k + 2]);
if (!was[k][x][y]) {
was[k][x][y] = true;
c[k][x][y] = 0;
int i = 0;
while (x & (1 << i)) i++;
if (!(y & (1 << i)) && !(d[i][k] == 'T' && d[i][k + 1] == 'T'))
c[k][x][y] += f(k, x + (1 << i), y + (1 << i));
if ((i < 2) && !(x & (1 << (i + 1))) &&
!(d[i][k] == 'T' && d[i + 1][k] == 'T'))
c[k][x][y] += f(k, x + (1 << i) + (1 << (i + 1)), y);
c[k][x][y] = c[k][x][y] % 1000000007;
}
return c[k][x][y];
}
int main() {
cin >> n;
char b[3][100000];
int x, y;
for (int i = 0; i < 1000000; i++) a[i] = 0;
for (int i = 0; i < 3; i++)
for (int j = 0; j < n; j++) {
cin >> b[i][j];
if (b[i][j] == 'O') x = i, y = j;
if (b[i][j] != '.') a[j] += (1 << i);
}
b[0][n] = b[1][n] = b[2][n] = 'X';
a[n] = 7;
memset(d, sizeof(d), '.');
long long ans = 0;
if ((y > 1) && (b[x][y - 1] == '.') && (b[x][y - 2] == '.')) {
for (int i = 0; i < 10001; i++)
for (int j = 0; j < 8; j++)
for (int k = 0; k < 8; k++) was[i][j][k] = false;
a[y - 1] += (1 << x);
a[y - 2] += (1 << x);
ans += f(0, a[0], a[1]);
a[y - 1] -= (1 << x);
a[y - 2] -= (1 << x);
d[x][y - 1] = d[x][y - 2] = 'T';
}
if ((y < n - 2) && (b[x][y + 1] == '.') && (b[x][y + 2] == '.')) {
for (int i = 0; i < 10001; i++)
for (int j = 0; j < 8; j++)
for (int k = 0; k < 8; k++) was[i][j][k] = false;
a[y + 1] += (1 << x);
a[y + 2] += (1 << x);
ans += f(0, a[0], a[1]);
a[y + 1] -= (1 << x);
a[y + 2] -= (1 << x);
d[x][y + 1] = d[x][y + 2] = 'T';
}
if ((x == 0) && (b[x + 1][y] == '.') && (b[x + 2][y] == '.')) {
for (int i = 0; i < 10001; i++)
for (int j = 0; j < 8; j++)
for (int k = 0; k < 8; k++) was[i][j][k] = false;
a[y] += 6;
ans += f(0, a[0], a[1]);
a[y] -= 6;
d[x + 1][y] = d[x + 2][y] = 'T';
}
if ((x == 2) && (b[x - 1][y] == '.') && (b[x - 2][y] == '.')) {
for (int i = 0; i < 10001; i++)
for (int j = 0; j < 8; j++)
for (int k = 0; k < 8; k++) was[i][j][k] = false;
a[y] += 3;
ans += f(0, a[0], a[1]);
a[y] -= 3;
d[x - 1][y] = d[x - 2][y] = 'T';
}
cout << ans % 1000000007;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100111;
vector<int> g[N], ans;
int p[N], h[N], par[N];
bool used[N], vis[N];
pair<int, int> l[N];
int root(int v) { return par[v] < 0 ? v : par[v] = root(par[v]); }
void check(int v, int an) {
for (int i = 0; i < g[v].size(); i++)
if (h[p[g[v][i]]] < h[v] && p[g[v][i]] != an) {
cout << -1 << endl;
exit(0);
}
}
void dfs(int v, int dep) {
vis[v] = true;
h[v] = dep;
l[v] = make_pair(-h[p[v]], v);
for (int i = 0; i < g[v].size(); i++) dfs(g[v][i], dep + 1);
}
int main() {
fill(par, par + N, -1);
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[--u].push_back(--v);
par[v] = u;
}
for (int i = 0; i < n; i++) cin >> p[i], p[i]--;
for (int i = 0; i < n; i++)
if (!vis[i]) dfs(root(i), 0);
sort(l, l + n);
for (int i = 0; i < n; i++) {
check(l[i].second, p[l[i].second]);
if (!used[p[l[i].second]]) ans.push_back(p[l[i].second]);
used[p[l[i].second]] = true;
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] + 1 << ' ';
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int a, b;
int d(int x, int y) { return x * x + y * y; }
int main() {
cin >> a >> b;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) {
int r = i * i + j * j;
if (r != a * a) continue;
if ((int)sqrt(r * 1.0) * (int)sqrt(r * 1.0) != r) continue;
r = (int)sqrt(r * 1.0);
int x = j * b;
int y = i * b;
if (x % r == 0 && y % r == 0)
if (x / r != i && (-y / r) != j) {
cout << "YES" << endl;
cout << "0 0" << endl;
cout << i << " " << j << endl;
cout << x / r << " " << -y / r << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int m, n;
cin >> m;
vector<long long> A(m);
for (int i = 0; i < m; ++i) {
cin >> A[i];
}
cin >> n;
vector<long long> B(n);
for (int j = 0; j < n; ++j) {
cin >> B[j];
}
int i = 0, j = 0;
int len = m;
bool f = true;
while (i < m && j < n) {
long long x = A[i];
long long y = B[j];
while (x != y) {
if (x < y) {
if (i + 1 < m) {
x += A[++i];
--len;
} else {
break;
}
} else {
if (j + 1 < n) {
y += B[++j];
} else {
break;
}
}
}
if (x != y) {
f = false;
break;
}
++i;
++j;
}
if (f && (i == m && j == n)) {
cout << len << "\n";
} else {
cout << -1 << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll tc,n;
ll a[210000];
bool compare(ll a, ll b){
return (a>b);
}
int main() {
cin>>tc;
for(int i=1;i<=tc;i++){
cin>>n;
for(int j=1;j<=n;j++){
cin>>a[j];
}
sort(a+1,a+n+1,compare);
ll ans=0;
for(int j=1;j<=n;j++){
if(j%2!=0){//alice even
if(a[j]%2==0)ans+=a[j];
}
else{//bob odd
if(a[j]%2!=0)ans-=a[j];
}
}
if(ans==0)cout<<"Tie"<<endl;
else if(ans>0)cout<<"Alice"<<endl;
else cout<<"Bob"<<endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, dp[4][5010], t[500010], d[500010], p = 0;
pair<int, int> A[500010];
bool b[500010];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
k = read(), n = read();
for (int i = 1; i <= n; ++i) t[i] = read();
sort(t + 1, t + n + 1);
for (int i = 1; i < n; ++i)
d[i] = A[i].first = t[i + 1] - t[i], A[i].second = i;
sort(A + 1, A + n);
for (int i = 1; i <= min(n, 3 * k); ++i) b[A[i].second] = 1;
memset(dp, 0x3f, sizeof(dp));
for (int i = 0; i < 4; dp[i++][0] = 0)
;
for (int i = 1; i < n; ++i) {
if (!b[i]) continue;
p++;
for (int j = 1; j <= k; ++j)
dp[p & 3][j] =
min(dp[(p - 1) & 3][j], dp[(p - 1 - b[i - 1]) & 3][j - 1] + d[i]);
}
printf("%d\n", dp[p & 3][k]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
const int N = 1e6 + 10, MOD = 1e9 + 7;
const long long INF = 1 << 30;
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
int b, p, f, h, c;
cin >> b >> p >> f >> h >> c;
int ans = 0;
for (int i = 0; i <= p; ++i)
for (int j = 0; j <= f; ++j) {
if (i * 2 + j * 2 > b) continue;
int res = h * i + c * j;
ans = std::max(ans, res);
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
long long a = 0, b = 0, c = 0;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'o')
b += a;
else if (i > 0 && s[i - 1] == 'v') {
a++;
c += b;
}
}
cout << c << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int sz = 1e9 + 7;
const long long int inf = 1e9;
const double pi = acos(-1);
int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool isPrime(long long int n) {
if (n == 1) return false;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
bool isPowerofTwo(long long int n) {
if (n == 0) return 0;
while (n != 1) {
if (n % 2 != 0) return 0;
n = n / 2;
}
return 1;
}
void solve() {
long long int n, m;
cin >> n >> m;
map<string, string> make_pair;
string a, b;
while (m--) {
cin >> a >> b;
if (a.size() > b.size()) {
make_pair[a] = b;
} else {
make_pair[a] = a;
}
}
while (n--) {
cin >> a;
cout << make_pair[a] << " ";
}
}
int main() {
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, y;
cin >> n >> m;
int a = n, b = 1;
while (m--) {
cin >> x >> y;
if (x < y) swap(x, y);
a = min(x, a), b = max(y, b);
}
cout << max(0, a - b);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string ans = "";
vector<string> v;
void die() {
cout << "NO" << endl;
exit(0);
}
string func(string s) {
int cnt = 0;
for (int i = (int)s.size() - 1; i >= 0; i--)
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u') {
++cnt;
if (cnt == k) return s.substr(i);
}
die();
return "ERROR";
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
v.clear();
for (int j = 0; j < 4; j++) {
string s;
cin >> s;
string x = func(s);
if (x == "ERROR") die();
v.push_back(x);
}
if (v[0] == v[1] && v[0] == v[2] && v[0] == v[3] && v[1] == v[2] &&
v[1] == v[3] && v[2] == v[3]) {
if (ans == "") ans = "aaaa";
} else if (v[0] == v[1] && v[2] == v[3]) {
if (ans != "" && ans != "aaaa" && ans != "aabb") die();
ans = "aabb";
} else if (v[0] == v[2] && v[1] == v[3]) {
if (ans != "" && ans != "aaaa" && ans != "abab") die();
ans = "abab";
} else if (v[0] == v[3] && v[1] == v[2]) {
if (ans != "" && ans != "aaaa" && ans != "abba") die();
ans = "abba";
} else
die();
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int x[3000], y[3000];
struct edge {
union {
struct {
unsigned int a : 16;
unsigned int b : 16;
unsigned int dist;
};
unsigned long long v;
};
edge() {}
edge(int dist, int a, int b) : dist(dist), a(a), b(b) {}
inline bool operator<(const edge& other) const { return v < other.v; }
} edges[(3000 * (3000 - 1) / 2)];
unsigned long long mask[3000][((3000 + 64 - 1) / 64)];
int main(int argc, char** argv) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d %d", &x[i], &y[i]);
int ne = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
edges[ne++] = edge(
(x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]), i, j);
sort(edges, edges + ne);
const int nmask = (n + 64 - 1) / 64;
int result = 0;
for (int e = ne - 1; e >= 0; e--) {
const edge ed = edges[e];
int k;
for (k = 0; k < nmask; k++)
if (mask[ed.a][k] & mask[ed.b][k]) break;
if (k < nmask) {
result = ed.dist;
break;
}
mask[ed.a][ed.b / 64] |= (1ULL << (ed.b % 64));
mask[ed.b][ed.a / 64] |= (1ULL << (ed.a % 64));
}
double radius = sqrt(result) / 2.0;
printf("%.20f\n", radius);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
unsigned long long int n, k, x;
scanf("%llu", &n);
for (int i = 0; i < n; i++) {
scanf("%llu %llu", &k, &x);
printf("%llu\n", (k - 1) * 9 + x);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream &operator>>(istream &in, vector<T> &a) {
for (int i = 0; i < a.size(); ++i) in >> a[i];
return in;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &a) {
for (int i = 0; i < a.size(); ++i) out << a[i] << " ";
return out;
}
int main() {
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
vector<int> a(n);
cin >> a;
sort(a.begin(), a.end());
long long idx = 1e8;
long long sum = 0;
vector<int> buffer;
for (long long i = 0; i < 7 * 1e7; ++i) {
buffer.push_back(rand() % 5);
if (buffer.size() > 1e4) buffer.clear();
}
cout << a << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x1, x2, y1, y2;
cin >> n >> m >> x1 >> y1 >> x2 >> y2;
int mx = max(((x1 - x2) > 0 ? (x1 - x2) : -(x1 - x2)),
((y1 - y2) > 0 ? (y1 - y2) : -(y1 - y2))) +
1,
mn = min(((x1 - x2) > 0 ? (x1 - x2) : -(x1 - x2)),
((y1 - y2) > 0 ? (y1 - y2) : -(y1 - y2))) +
1;
if (mx >= 6)
cout << "Second" << endl;
else if (mx <= 4)
cout << "First" << endl;
else {
if (mn < 4)
cout << "First" << endl;
else
cout << "Second" << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
const double EPS = 1e-6;
int a[455];
int b[455];
vector<int> G[455];
int boss[455];
void init() {
for (int i = 1; i < 455; i++) boss[i] = i;
}
int find_boss(int x) {
return boss[x] = (boss[x] == x ? x : find_boss(boss[x]));
}
bool unite(int x, int y) {
int bx = find_boss(x);
int by = find_boss(y);
if (bx == by) return false;
boss[bx] = by;
return true;
}
vector<pair<pair<int, int>, int> > res;
int pour(int from, int to, int d) {
int flow = min(d, max(a[to] - b[to], 0));
a[to] -= flow;
int pos = ((int)(res).size());
for (int i = 0; flow < d && i < ((int)(G[to]).size()); i++) {
int v = G[to][i];
if (v == from) continue;
flow += pour(to, v, d - flow);
}
if (from != -1) {
int po = min(a[to], flow);
if (po > 0)
res.insert(res.begin() + pos, make_pair(make_pair(to, from), po));
if (po < flow) res.push_back(make_pair(make_pair(to, from), flow - po));
}
return flow;
}
int main() {
int n, v, e;
scanf("%d %d %d", &n, &v, &e);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) scanf("%d", b + i);
init();
while (e--) {
int x, y;
scanf("%d %d", &x, &y);
if (unite(x, y)) {
G[x].push_back(y);
G[y].push_back(x);
}
}
for (int i = 1; i <= n; i++)
if (a[i] < b[i]) a[i] += pour(-1, i, b[i] - a[i]);
for (int i = 1; i <= n; i++)
if (a[i] != b[i]) return puts("NO"), 0;
printf("%d\n", ((int)(res).size()));
for (__typeof((res).begin()) itr = (res).begin(); itr != (res).end(); itr++)
printf("%d %d %d\n", itr->first.first, itr->first.second, itr->second);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
int n, m;
vector<vector<int> > V, H;
int X[100000 + 9], Y[100000 + 9];
map<pair<int, int>, int> mp;
struct CMP {
bool operator()(pair<int, int> l, pair<int, int> r) {
if (l.first != r.first) return l.first < r.first;
return l.second < r.second;
}
};
pair<int, int> cell(int i) { return make_pair(X[i], Y[i]); }
int main() {
read_file();
while (scanf("%d%d", &n, &m) != EOF) {
V.clear(), H.clear();
V.resize(n), H.resize(n);
mp.clear();
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
swap(x, y);
V[x].push_back(i);
H[y].push_back(i);
X[i] = x, Y[i] = y;
mp[make_pair(x, y)] = i;
}
vector<int> ans;
set<pair<int, int>, CMP> st;
for (int i = 0, j = n - 1; i < n; i++, j--) {
for (int k = 0; k < H[j].size(); k++) {
st.insert(cell(H[j][k]));
}
if (i != 0) {
for (int k = 0; k < V[i - 1].size(); k++) {
st.erase(cell(V[i - 1][k]));
}
}
if (st.empty()) continue;
ans.push_back(mp[*st.begin()]);
st.erase(st.begin());
}
int sz = ans.size();
printf("%d\n", sz);
for (int i = 0; i < sz; i++) printf("%d%c", ans[i] + 1, " \n"[i == sz - 1]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
pair<int, pair<int, int> > dance[100005];
pair<int, pair<int, int> > event[100005];
int finish[100005];
vector<pair<int, int> > x, y;
vector<int> ini;
int main() {
int n, w, h;
cin >> n >> w >> h;
for (int i = 1; i <= n; i++) {
int tipe, p, t;
cin >> tipe >> p >> t;
dance[i] = make_pair(tipe, make_pair(p, t));
event[i] = make_pair(p - t, make_pair(tipe, i));
finish[i] = i;
}
sort(event + 1, event + n + 1);
for (int i = 1; i <= n + 1; i++) {
if (i != n + 1 && (i == 1 || event[i].first == event[i - 1].first)) {
ini.push_back(event[i].second.second);
} else {
x.clear();
y.clear();
for (int j = 0; j < ini.size(); j++) {
int now = ini[j];
if (dance[now].first == 1) {
x.push_back(make_pair(dance[now].second.first, now));
} else {
y.push_back(make_pair(dance[now].second.first, now));
}
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
int mins = min(x.size(), y.size());
for (int j = 0; j < mins; j++) {
finish[y[y.size() - j - 1].second] = x[j].second;
finish[x[x.size() - j - 1].second] = y[j].second;
}
if (x.size() > y.size()) {
for (int j = 0; j < x.size() - mins; j++) {
finish[x[j].second] = x[mins + j].second;
}
} else {
for (int j = 0; j < y.size() - mins; j++) {
finish[y[j].second] = y[mins + j].second;
}
}
ini.clear();
ini.push_back(event[i].second.second);
}
}
for (int i = 1; i <= n; i++) {
int ini = finish[i];
if (dance[ini].first == 1) {
cout << dance[ini].second.first << " " << h << "\n";
} else {
cout << w << " " << dance[ini].second.first << "\n";
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int d[41][1001][1001];
int n, m;
int raq(int x) {
int res = 0;
while (x) {
res += x % 2;
x /= 2;
}
return res;
}
bool biti(int x, int i) {
if (i < 0) return 0;
return (x & (1 << i));
}
bool tek(int a, int b, int c) {
for (int i = 0; i < m; i++) {
if (!(biti(a, i) | biti(a, i - 1) | biti(a, i + 1) | biti(b, i) |
biti(c, i)))
return 0;
}
return 1;
}
int main() {
int avv, aavv, ozi, i, j;
cin >> n >> m;
if (n < m) swap(n, m);
for (i = 0; i <= n; i++) {
for (avv = 0; avv < (1 << m); avv++) {
for (ozi = 0; ozi < (1 << m); ozi++) {
d[i][ozi][avv] = 1e9;
}
}
}
for (ozi = 0; ozi < (1 << m); ozi++) d[0][ozi][0] = raq(ozi);
for (i = 1; i <= n; i++) {
for (ozi = 0; ozi < (1 << m); ozi++) {
for (avv = 0; avv < (1 << m); avv++) {
for (aavv = 0; aavv < (1 << m); aavv++) {
if (!tek(avv, ozi, aavv)) continue;
d[i][ozi][avv] = min(d[i][ozi][avv], d[i - 1][avv][aavv] + raq(ozi));
}
}
}
}
int res = 1e9;
for (i = 0; i < (1 << m); i++) {
res = min(res, d[n][0][i]);
}
cout << n * m - res;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const int inf = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long power(long long a, long long b, long long m = 1000000007) {
long long answer = 1;
while (b) {
if (b & 1) answer = (answer * a) % m;
b /= 2;
a = (a * a) % m;
}
return answer;
}
using namespace std;
void ctrl() { cout << "Control\n"; }
int main() {
string p;
cin >> p;
int n;
cin >> n;
map<char, char> mp;
for (register int i = 0; i < n; i += 1) {
string q;
cin >> q;
mp[q[0]] = q[1];
mp[q[1]] = q[0];
}
vector<pair<char, int> > v;
char temp = p[0];
int cnt = 1;
for (int i = 1; i < p.length(); i++) {
if (p[i] == temp) {
cnt++;
continue;
}
v.push_back(make_pair(temp, cnt));
temp = p[i];
cnt = 1;
}
v.push_back(make_pair(temp, cnt));
for (int i = 0; i < v.size(); i++) {
}
int ans = 0;
for (int i = 0; i < v.size() - 1; i++) {
int s1 = 0, s2 = 0;
while (mp[v[i].first] == v[i + 1].first) {
if (i % 2)
s1 += v[i].second;
else
s2 += v[i].second;
i++;
if (i == v.size() - 1) {
break;
}
}
if ((i) % 2)
s1 += v[i].second;
else
s2 += v[i].second;
ans += min(s1, s2);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
long long ans = 0;
for (int i = 1; i < n; i++) {
int j = 0;
for (j = 0; (1 << j) + i <= n; j++)
;
--j;
ans += a[i];
a[(1 << j) + i] += a[i];
printf("%I64d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
bool prime[1000001];
vector<int> v1;
void sieve() {
memset(prime, true, sizeof(prime));
for (int i = 2; i * i <= 1000000; i++)
if (prime[i])
for (int j = i * i; j <= 1000000; j += i) prime[j] = false;
prime[0] = prime[1] = false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> v1[m + 1];
for (int i = 0; i < n; i++) {
int a1, a2;
cin >> a1 >> a2;
v1[a1].push_back(a2);
}
for (int i = 1; i < m + 1; i++) {
sort((v1[i]).begin(), (v1[i]).end());
reverse((v1[i]).begin(), (v1[i]).end());
}
int mx = 0;
for (int i = 1; i < m + 1; i++) {
mx = max(mx, (int)v1[i].size());
for (int j = 1; j < v1[i].size(); j++) {
v1[i][j] = v1[i][j - 1] + v1[i][j];
}
}
vector<int> res(mx, 0);
int max1 = 0;
for (int i = 1; i < m + 1; i++) {
for (int j = 0; j < v1[i].size(); j++) {
if (v1[i][j] < 0) break;
res[j] += v1[i][j];
}
}
int ans = 0;
cout << max(ans, *max_element(res.begin(), res.end())) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double min, res, sum = 0;
int i, n, V;
cin >> n >> V;
double a[n], b[n], c[n];
for (i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
for (i = 0; i < n; i++) cin >> b[i];
for (i = 0; i < n; i++) c[i] = b[i] / a[i];
min = c[0];
for (i = 1; i < n; i++)
if (c[i] < min) min = c[i];
res = min * sum;
if (res > V)
cout << V;
else
printf("%f", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string ans[n];
int scores[m];
int deep = 0;
int x[5];
for (int i = 0; i < n; i++) {
cin >> ans[i];
}
for (int i = 0; i < 5; i++) x[i] = 0;
for (int i = 0; i < m; i++) cin >> scores[i];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
char tmp = char(ans[j][i]);
x[int(tmp) - 65]++;
}
int max = x[0];
for (int i = 1; i < 5; i++) {
if (x[i] > max) max = x[i];
}
deep += max * scores[i];
for (int i = 0; i < 5; i++) x[i] = 0;
}
cout << deep;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
double temp1, temp2;
temp1 = (double)log10(y * (double)(log10(x)));
temp2 = (double)log10(x * (double)(log10(y)));
if (temp1 == temp2)
cout << "=";
else if (temp1 > temp2)
cout << ">";
else
cout << "<";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, ans;
scanf("%d", &n);
ans = n / 2 + 1;
printf("%d", ans);
for (i = 1; i <= ans; ++i) printf("\n%d 1", i);
for (i = 2; i <= n - ans + 1; ++i) printf("\n%d %d", ans, i);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i, j, n;
scanf("%d", &n);
if (n % 2 == 0)
printf("NO\n");
else {
printf("YES\n");
int sum = 1;
for (i = 1; i < 2 * n; i = i + 1) {
if (i % 2 == 1) {
cout << sum % (2 * n) << " ";
sum = sum + 3;
} else {
cout << sum % (2 * n) << " ";
sum = sum + 1;
}
}
cout << 2 * n;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
long long cities[41];
long long dp[(1 << 21)];
long long fastpow(long long a, long long b) {
long long ret = 1;
while (b) {
if (b % 2) ret = (ret * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return ret;
}
string print(long long mask) {
string s;
for (int i = 20; i >= 0; i--) {
if (mask & (1 << i))
s += '1';
else
s += '0';
}
return s;
}
int main() {
int n, k;
cin >> n >> k;
if (n == 1) return puts("0");
for (int i = 0; i < n; i++) {
int a;
long long tot = 0;
for (int j = 0; j < n; j++) {
cin >> a;
if (a) tot |= (1LL << j);
}
tot |= (1LL << i);
cities[i] = tot;
}
int h = 20;
int h2 = n - h;
long long sz = 0;
long long tmpmask = (1 << h) - 1;
if (h2 > 0) {
for (long long i = 1; i < (1 << h2); i++) {
long long mask = i;
for (int j = 0; j < h2; j++) {
if ((i >> j) & 1) {
mask &= cities[j + h] >> h;
}
}
if (mask == i) dp[mask] = __builtin_popcount(i);
}
for (long long i = 1; i < (1 << h2); i++) {
for (int j = 0; j < h2; j++) {
if ((i >> j) & 1) {
dp[i] = max(dp[i], dp[i ^ (1 << j)]);
}
}
}
}
for (long long i = 1; i < (1 << min(h, n)); i++) {
long long mask = i;
long long mask2 = (1 << max(0, h2)) - 1;
for (int j = 0; j < h; j++) {
if ((i >> j) & 1) {
mask &= (cities[j] & tmpmask);
mask2 &= (cities[j] >> h);
}
}
if (mask == i) sz = max(sz, dp[mask2] + __builtin_popcount(i));
}
cout << fixed << setprecision(9) << k * k * (sz - 1) / (sz * (2.0)) << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
ostream &ra(ostream &stream) {
stream << " ------->";
return stream;
}
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long tc = 1;
cin >> tc;
while (tc--) {
long long n;
cin >> n;
if (n == 1)
cout << "FastestFinger";
else if (n == 2)
cout << "Ashishgup";
else if (n % 2 == 1)
cout << "Ashishgup";
else {
vector<long long> f;
f.clear();
long long t = n;
for (long long i = 2; i * i <= t; i++) {
if (t % i == 0) {
if (i % 2 == 1) f.push_back(i);
if ((t / i) % 2 == 1) f.push_back(t / i);
}
}
bool flag = false;
for (auto &x : f) {
if ((t / x) % 2 == 0 && (t / x) != 2) flag = true;
}
if (flag)
cout << "Ashishgup";
else
cout << "FastestFinger";
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename T1>
ostream &operator<<(ostream &out, pair<T, T1> obj) {
out << "(" << obj.first << ", " << obj.second << ")";
return out;
}
template <typename T, typename T1>
ostream &operator<<(ostream &out, map<T, T1> cont) {
typename map<T, T1>::const_iterator itr = cont.begin();
typename map<T, T1>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) {
out << *itr << " ";
}
out << endl;
return out;
}
template <typename T>
ostream &operator<<(ostream &out, set<T> cont) {
typename set<T>::const_iterator itr = cont.begin();
typename set<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) {
out << *itr << " ";
}
out << endl;
return out;
}
template <typename T>
ostream &operator<<(ostream &out, multiset<T> cont) {
typename multiset<T>::const_iterator itr = cont.begin();
typename multiset<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) {
out << *itr << " ";
}
out << endl;
return out;
}
template <typename T,
template <typename ELEM, typename ALLOC = allocator<ELEM>> class CONT>
ostream &operator<<(ostream &out, CONT<T> cont) {
typename CONT<T>::const_iterator itr = cont.begin();
typename CONT<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) {
out << *itr << " ";
}
out << endl;
return out;
}
template <typename T, unsigned int N, typename CTy, typename CTr>
typename enable_if<!is_same<T, char>::value, basic_ostream<CTy, CTr> &>::type
operator<<(basic_ostream<CTy, CTr> &out, const T (&arr)[N]) {
for (auto i = 0; i < N; ++i) {
out << arr[i] << " ";
}
out << endl;
return out;
}
template <typename T>
T GCD(T a, T b) {
T min_v = min(a, b);
T max_v = max(a, b);
while (min_v) {
T temp = max_v % min_v;
max_v = min_v;
min_v = temp;
}
return max_v;
}
template <typename T>
T LCM(T a, T b) {
return (a * b) / gcd(a, b);
}
template <typename T>
T fastExpPow(T base, T exp, T mod) {
T res = 1;
while (exp) {
if (exp & 1) {
res *= base;
res %= mod;
}
exp >>= 1;
base *= base;
base %= mod;
}
return res % mod;
}
int T, B, P, F, H, C;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d%d%d%d", &B, &P, &F, &H, &C);
int profit = 0;
if (H >= C) {
int many = min(B / 2, P);
B -= 2 * many;
profit += many * H;
many = min(B / 2, F);
profit += many * C;
} else {
int many = min(B / 2, F);
B -= 2 * many;
profit += many * C;
many = min(B / 2, P);
profit += many * H;
}
printf("%d\n", profit);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
while (b != 0) {
int t = b;
b = a % b;
a = t;
}
return a;
}
int const maxsize = 1000;
int arr[maxsize][maxsize];
void fillarr() {
for (int i = 0; i < maxsize; i++) {
for (int j = 0; j < maxsize; j++) arr[i][j] = 0;
}
}
bool prime(long long num) {
if (num <= 1) return false;
if (num == 2 || num == 3) return true;
if (num % 2 == 0 || num % 3 == 0) return false;
for (long long i = 3; i * i <= num; i += 2)
if (num % i == 0) return false;
return true;
}
string convert_number_to_bits(long long num) {
string str;
int i = 31;
str.resize(32, '0');
int re;
while (num != 0) {
re = num % 2;
if (re == 0)
str[i] = '0';
else
str[i] = '1';
i--;
num /= 2;
}
return str;
}
unsigned long long power2(int num) {
unsigned long long sum = 1;
for (int i = 0; i < num; i++) sum *= 2;
return sum;
}
long long convert_bits_to_number(string str) {
unsigned long long sum = 0;
reverse(str.begin(), str.end());
for (int i = 0; i < 32; i++) {
if (str[i] == '1') sum += power2(i);
}
return sum;
}
string XOR(string str1, string str2) {
string str3;
str3.resize(32, '0');
for (int i = 31; i >= 0; i--) {
if (str1[i] != str2[i]) str3[i] = '1';
}
return str3;
}
string convert_number_to_string(unsigned long long num) {
string str = "";
char ch;
int re;
while (num != 0) {
re = num % 10;
ch = re + 48;
str += ch;
num /= 10;
}
return str;
}
unsigned long long power(long long n, long long b) {
unsigned long long sum = 1;
for (int i = 0; i < b; i++) sum *= n;
return sum;
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
fast();
int n;
cin >> n;
vector<int> vec(n);
int z = 0;
string str = "";
for (int i = 0; i < n; i++) {
cin >> vec[i];
if (vec[i] != 0) z++;
}
int y = 0;
for (int i = 0; i < n && z; i++) {
if (vec[i] != 0) {
for (int j = 0; j < vec[i]; j++) {
str += 'P';
if (j != vec[i] - 1) {
if (i && y)
str += "LR";
else
str += "RL";
} else {
z--;
if (z) str += 'R', y = 1;
}
}
} else if (!vec[i] && z)
str += 'R', y = 1;
}
cout << str << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define vi vector<int>
#define mii map<int, int>
#define mod 10000000007
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define ps fixed<<setprecision(y)<<x
int main()
{
ll t;
cin>>t;
for(ll a=0; a<t; a++)
{
ll n;
cin>>n;
vi v;
for(int i=0; i<n; i++)
{
ll x;
cin>>x;
v.push_back(x);
}
ll ans=2;
if(is_sorted(v.begin(), v.end()))
{
ans=0;
}
else if(v[0]==1 || v[n-1]==n)
{
ans=1;
}
else if(v[0]==n && v[n-1]==1)
{
ans=3;
}
cout<<ans<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ele;
cin >> n;
int a[5] = {0}, b[5] = {0};
for (int i = 0; i < n; i++) {
cin >> ele;
a[ele - 1]++;
}
for (int i = 0; i < n; i++) {
cin >> ele;
b[ele - 1]++;
}
int res = 0, t;
bool f = 1;
for (int i = 0; i < 5; i++) {
t = abs(a[i] - b[i]);
if (t & 1) {
f = 0;
break;
}
res += t;
}
cout << ((f) ? res / 4 : -1);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t, n;
cin >> t;
while (t--) {
cin >> n;
char a[2 * n - 1], b[n];
long long i;
for (i = 0; i < 2 * n - 1; i++) {
cin >> a[i];
}
long long top = 0;
while (top < n) {
long long first = top;
cout << a[first + top];
top++;
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int num[1048576];
int f[1048576], b[1048576], last[1048576];
vector<int> ha;
struct BIT {
int v[1048576];
BIT() { fill(v, v + 1048576, 0); }
void add(int x) {
for (int i = x; i < 1048576; i += (i & -i)) v[i]++;
}
void sub(int x) {
for (int i = x; i < 1048576; i += (i & -i)) v[i]--;
}
int query(int x) {
long long sum = 0;
for (int i = x; i > 0; i -= (i & -i)) sum += v[i];
return sum;
}
};
BIT bit;
vector<int> fx[1048576], bx[1048576];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num[i];
ha.push_back(num[i]);
}
sort(ha.begin(), ha.end());
ha.resize(unique(ha.begin(), ha.end()) - ha.begin());
for (int i = 0; i < n; i++) {
int x = lower_bound(ha.begin(), ha.end(), num[i]) - ha.begin();
f[i] = ++last[x];
fx[f[i]].push_back(i + 1);
}
fill(last, last + 1048576, 0);
for (int i = n - 1; i >= 0; i--) {
int x = lower_bound(ha.begin(), ha.end(), num[i]) - ha.begin();
b[i] = ++last[x];
bx[b[i]].push_back(i + 1);
}
for (int i = 1; i <= n; i++) bit.add(i);
long long ans = 0;
for (int k = 1; bx[k].size(); k++) {
for (int i = 0; i < fx[k].size(); i++) bit.sub(fx[k][i]);
for (int i = 0; i < bx[k].size(); i++) ans += bit.query(bx[k][i] - 1);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,-ffloat-store")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
using namespace std;
const int mod = 998244353;
const int maxn = 3e5 + 5;
int x[maxn], l[maxn], r[maxn], u[25], v[25];
int dp[maxn][50], fct[maxn], inv[maxn], n, m;
bool ok[maxn];
void readf() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> l[i] >> r[i];
x[l[i]]++;
x[r[i] + 1]--;
}
for (int i = 0; i < m; ++i) {
cin >> u[i] >> v[i];
}
for (int i = 1; i <= n; ++i) x[i] += x[i - 1];
}
int pw(int A, int B) {
int tmp = 1;
for (; B; A = 1LL * A * A % mod, B >>= 1)
if (B & 1) tmp = 1LL * tmp * A % mod;
return tmp;
}
inline int C(int K, int N) {
if (N < 0 || K < 0) return 0;
if (K > N) return 0;
int TS = fct[N];
int MS = inv[N - K] * 1LL * inv[K] % mod;
return 1LL * TS * MS % mod;
}
inline int get(int L, int R, int T) {
if (R < L) return 0;
return (dp[R][T] - dp[L - 1][T] + mod) % mod;
}
void solve() {
fct[0] = 1;
for (int i = 1; i <= n; ++i) fct[i] = 1LL * fct[i - 1] * i % mod;
inv[n] = pw(fct[n], mod - 2);
for (int i = n - 1; i >= 0; --i) inv[i] = 1LL * (i + 1) * inv[i + 1] % mod;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= 2 * m; ++j)
dp[i][j] = (dp[i - 1][j] + C(i - j, x[i] - j)) % mod;
int ans = 0;
for (int mask = 0; mask < (1 << m); ++mask) {
int L = 1, R = n;
for (int i = 0; i < m; ++i) ok[u[i]] = ok[v[i]] = 0;
int sl = 0;
for (int i = 0; i < m; ++i)
if ((((mask) >> (i)) & 1)) {
if (ok[u[i]] == 0) {
L = max(L, l[u[i]]);
R = min(R, r[u[i]]);
sl++;
}
if (ok[v[i]] == 0) {
L = max(L, l[v[i]]);
R = min(R, r[v[i]]);
sl++;
}
ok[u[i]] = ok[v[i]] = 1;
}
if (__builtin_popcount((mask)) & 1)
ans = (ans - get(L, R, sl)) % mod;
else
ans = (ans + get(L, R, sl)) % mod;
}
cout << (ans + mod) % mod << '\n';
}
int main() {
srand(time(NULL));
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
readf();
solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[100005], T, c;
int main() {
cin >> T;
for (long long j = 1; j <= T; j++) {
cin >> n;
long long op;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
if (a[n] >= a[1] + a[2])
cout << "1 2 " << n << endl;
else
cout << "-1\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, pos, k;
int t;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> a >> b >> k;
if (k % 2 == 0)
pos = (k / 2) * a - (k / 2) * b;
else
pos = ((k + 1) / 2) * a - (k / 2) * b;
cout << pos << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int change(string s) {
if (s == "S")
return 0;
else if (s == "M")
return 1;
else if (s == "L")
return 2;
else if (s == "XL")
return 3;
return 4;
}
string rev(int n) {
if (n == 0)
return "S";
else if (n == 1)
return "M";
else if (n == 2)
return "L";
else if (n == 3)
return "XL";
return "XXL";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
vector<int> size(5);
for (auto &i : size) cin >> i;
int k;
cin >> k;
while (k--) {
string temp;
cin >> temp;
int n = change(temp);
for (int i = 0; i < 5; ++i) {
if (n + i < 5 && size[n + i]) {
cout << rev(n + i) << '\n';
size[n + i]--;
break;
}
if (n - i >= 0 && size[n - i]) {
cout << rev(n - i) << '\n';
size[n - i]--;
break;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n;
long int x;
cin >> n >> x;
long int a[n], b[n];
long long sum = 0;
for (long int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
sum += b[i] - a[i] + 1;
}
sum += (a[0] - 1) % x;
for (int i = 1; i < n; i++) sum += (a[i] - b[i - 1] - 1) % x;
cout << sum;
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.