solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000100;
const double EPS = 1e-9;
int dp[N][10];
int cnt(int l, int r, int val) { return dp[r][val] - dp[l - 1][val]; }
long long a;
int main() {
dp[0][0] = dp[1][0] = 1;
for (int i = 2; i < N; ++i) {
long long l = pow(i, 0.25);
while (l * l * l * l < i) l++;
long long r = pow(i, 0.5) + EPS;
while (r * r > i) r--;
int g = 0;
if (r >= l)
while (cnt(l, r, g)) g++;
for (int j = 0; j < 10; j++) dp[i][j] = dp[i - 1][j];
dp[i][g]++;
}
int n;
cin >> n;
int ans = 0;
for (int i = 0; i < n; ++i) {
scanf("%lld", &a);
long long l = pow(a, 0.25);
while (l * l * l * l < a) l++;
long long r = pow(a, 0.5) + EPS;
while (r * r > a) r--;
int g = 0;
if (r >= l)
while (cnt(l, r, g)) g++;
ans ^= g;
}
if (!ans)
cout << "Rublo";
else
cout << "Furlo";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
const long long mod = 1e9 + 7;
const long long INF = 1000000000;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
bool compare(const pair<long long, long long>& i,
const pair<long long, long long>& j) {
return i.second < j.second;
}
long long fact[N];
vector<bool> is_prime(100000, true);
vector<int> prime;
void pre() {
fact[0] = 1;
for (long long i = 1; i < N; i++) {
fact[i] = i * fact[i - 1];
fact[i] %= mod;
}
}
long long modexp(long long x, long long n) {
long long r = 1;
while (n) {
if (n & 1) r = (r * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return r;
}
long long modinv(long long x) { return modexp(x, mod - 2); }
long long ncr(long long n, long long r) {
if (n < r) return 0;
long long ans =
(fact[n] % mod * modinv(fact[r]) % mod * modinv(fact[n - r]) % mod) % mod;
return ans;
}
void solve() {
string s;
cin >> s;
int n = s.size();
map<char, int> make_pair;
for (int i = 0; i < n; i++) {
make_pair[s[i]]++;
}
if (make_pair['x'] - make_pair['y'] > 0) {
int t = make_pair['x'] - make_pair['y'];
while (t--) cout << 'x';
cout << "\n";
} else {
int t = make_pair['y'] - make_pair['x'];
while (t--) cout << 'y';
cout << "\n";
}
return;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int n = 1e7;
int main() {
long long a, b, c, ans = 0;
cin >> a >> b >> c;
long long mx = max(a, max(b, c));
long long sum = (a + b + c) - mx;
if (sum * 2 <= mx)
cout << sum << endl;
else
cout << (a + b + c) / 3 << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, K, y;
set<int> s;
set<pair<int, int> > a;
vector<int> ans[500005];
inline void dfs(int nod) {
set<int>::iterator it;
for (it = s.begin(); it != s.end();) {
if (!a.count(make_pair(min(*it, nod), max(*it, nod)))) {
int x = *it;
s.erase(x);
dfs(x);
it = s.lower_bound(x);
} else
it++;
}
ans[K].push_back(nod);
}
int main() {
ios::sync_with_stdio(false);
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d %d", &x, &y);
if (x > y) swap(x, y);
a.insert({x, y});
}
for (int i = 1; i <= n; ++i) s.insert(i);
while (!s.empty()) {
x = *s.begin();
s.erase(x);
K++;
dfs(x);
}
printf("%d\n", K);
for (int i = 1; i <= K; ++i) {
printf("%d ", ans[i].size());
for (auto it : ans[i]) printf("%d ", it);
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int n, dp[5001][5001][2];
char s[5001];
int calc(int i, int indentationLevel, bool open) {
if (i == n) {
return !open;
}
int& ret = dp[i][indentationLevel][open];
if (ret != -1) {
return ret;
}
ret = 0;
if (open) {
ret = calc(i + 1, indentationLevel + (s[i] == 'f'), s[i] == 'f');
} else {
if (indentationLevel) {
ret = calc(i, indentationLevel - 1, false);
}
ret += calc(i + 1, indentationLevel + (s[i] == 'f'), s[i] == 'f');
ret %= MOD;
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf(" %c", &s[i]);
}
memset(dp, -1, sizeof dp);
printf("%d\n", calc(0, 0, false));
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int a, b, x;
double c;
int counter = 0;
a = 1;
b = 1;
for (a = 1; a <= n; a++) {
for (b = a; b <= n; b++) {
x = (a * a) + (b * b);
c = sqrt(x);
if (c == (int)c && c <= n) {
counter++;
}
}
}
printf("%d\n", counter);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
int n, cnt = 0, tk;
cin >> n;
vector<int> vc, s;
for (int i = 1; i <= n; i++) cin >> tk, vc.push_back(tk), s.push_back(tk);
sort(s.begin(), s.end());
for (int i = 0; i < n; i++) {
if (vc[i] != s[i]) cnt++;
}
if (cnt > 2)
puts("NO");
else
puts("YES");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s1;
cin >> s1;
for (int i = 0; i < n; i++) {
if (s1[i] == 'o' && s1[i + 1] == 'g' && s1[i + 2] == 'o') {
s1.erase(i, 3);
s1.insert(i, "***");
}
if (s1[i] == '*' && s1[i + 1] == 'g' && s1[i + 2] == 'o') {
s1.erase(i + 1, 2);
i -= 2;
}
}
cout << s1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
string x;
string ans;
vector<int> pos;
int main() {
cin >> n >> p >> x;
for (int i = 0; i < x.size(); i++) {
if (x[i] == '.') pos.push_back(i);
ans += x[i];
}
for (int i = 0; i < 1000; i++) {
for (int j = 0; j < pos.size(); j++) ans[pos[j]] = (rand() & 1 ? '1' : '0');
int bad = 1;
for (int j = 0; j + p < ans.size(); j++)
if (ans[j] != ans[j + p]) bad = 0;
if (!bad) {
cout << ans;
return 0;
}
}
cout << "No";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
int p[k];
int max = -1;
for (int i = 0; i < k; ++i) {
cin >> p[i];
if (p[i] > max) {
max = p[i];
}
}
if (max - 25 <= 0) {
cout << 0 << endl;
} else {
cout << max - 25 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn], f[maxn];
void solve() {
int n, k;
cin >> n >> k;
if (k % (n - 1) == 0) {
cout << k / (n - 1) * n - 1 << endl;
} else {
cout << k / (n - 1) * n + k % (n - 1) << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int a[501][501], n, m;
char b[501][501];
int check(int i_a, int j_a) {
return (i_a >= 0 && j_a >= 0 && i_a < n && j_a < m && b[i_a][j_a] == '.' &&
a[i_a][j_a] == 0);
}
void dfs(int i, int j, int k) {
int prev = 0, x, y;
stack<pair<int, int> > s;
s.push(make_pair(i, j));
a[i][j] = 1;
while (!s.empty()) {
if (k == 0) break;
i = s.top().first;
j = s.top().second;
prev = s.size();
if (check(i, j + 1)) {
a[i][j + 1] = 1;
s.push(make_pair(i, j + 1));
}
if (check(i + 1, j)) {
a[i + 1][j] = 1;
s.push(make_pair(i + 1, j));
}
if (check(i - 1, j)) {
a[i - 1][j] = 1;
s.push(make_pair(i - 1, j));
}
if (check(i, j - 1)) {
a[i][j - 1] = 1;
s.push(make_pair(i, j - 1));
}
if (prev == s.size()) {
b[i][j] = 'X';
k--;
s.pop();
}
}
return;
}
int main() {
int k, flag = 0, x, y;
char c;
cin >> n >> m >> k;
for (int i = (0), _n = (n); i < _n; i++) {
for (int j = (0), _n = (m); j < _n; j++) {
cin >> b[i][j];
if (b[i][j] == '.' && flag == 0) {
x = i;
y = j;
flag = 1;
}
a[i][j] = 0;
}
}
dfs(x, y, k);
for (int i = (0), _n = (n); i < _n; i++) {
for (int j = (0), _n = (m); j < _n; j++) {
cout << b[i][j];
}
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> list;
int price[101];
int highp[101];
int listn[101];
typedef struct _data {
string s;
int n;
} data;
data dat[101];
int cmp1(int i, int j) { return i > j; }
int cmp3(data i, data j) { return i.n > j.n; }
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &price[i]);
highp[i] = price[i];
}
int num = 0, listnum = 0;
for (int j = 0; j < m; j++) {
dat[j].n = 0;
dat[j].s = "";
}
for (int i = 0; i < m; i++) {
string tmp;
cin >> tmp;
int j = 0;
for (; j < listnum; j++) {
if (dat[j].s == tmp) {
dat[j].n++;
break;
}
}
if (j == listnum) dat[listnum].n = 1, dat[listnum++].s = tmp;
}
sort(dat, dat + listnum, cmp3);
sort(price, price + n);
sort(highp, highp + n, cmp1);
int h = 0, l = 0;
for (int i = 0; i < listnum; i++) {
int tmpl = dat[i].n * price[i];
l += tmpl;
int tmph = dat[i].n * highp[i];
h += tmph;
}
printf("%d %d\n", l, h);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t-- > 0) {
int n, m;
cin >> n >> m;
vector<pair<int, int> > out;
int x, y;
vector<vector<pair<int, bool> > > g(n + 2);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &x, &y);
g[x].push_back({y, 0});
g[y].push_back({x, 0});
}
int ans = 0;
vector<bool> used(n + 2);
for (int it = 1; it <= n; ++it) {
if (used[it]) continue;
vector<int> conn;
set<pair<int, int> > check;
queue<int> q;
q.push(it);
used[it] = 1;
while (!q.empty()) {
int v = q.front();
q.pop();
if (g[v].size() % 2 == 0)
ans++;
else
conn.push_back(v);
for (int i = 0; i < g[v].size(); ++i)
if (!used[g[v][i].first]) {
used[g[v][i].first] = 1;
q.push(g[v][i].first);
}
}
for (int i = 0; i < conn.size(); i += 2) {
g[conn[i]].push_back({conn[i + 1], 0});
g[conn[i + 1]].push_back({conn[i], 0});
check.insert({conn[i], conn[i + 1]});
check.insert({conn[i + 1], conn[i]});
}
stack<int> st;
st.push(it);
vector<int> res;
while (!st.empty()) {
int v = st.top();
int x = -1;
for (int i = 0; i < g[v].size(); ++i)
if (!g[v][i].second) x = i;
if (x == -1) {
res.push_back(v);
st.pop();
} else {
g[v][x].second = 1;
int to = g[v][x].first;
for (int i = 0; i < g[to].size(); ++i)
if (g[to][i].first == v) {
g[to][i].second = 1;
break;
}
st.push(to);
}
}
if (res.size() < 2) continue;
for (int i = 0; i < res.size() - 1; ++i) {
if (check.find({res[i], res[i + 1]}) == check.end())
out.push_back({res[i], res[i + 1]});
else {
check.erase({res[i], res[i + 1]});
check.erase({res[i + 1], res[i]});
}
}
}
cout << ans << endl;
for (int i = 0; i < out.size(); ++i)
printf("%d %d\n", out[i].first, out[i].second);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a[200009];
priority_queue<int> q[26];
char s[200009];
int main() {
long long n, k, ans = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> s[i];
q[s[0] - 'a'].push(a[0]);
for (int i = 1; i < n; i++) {
q[s[i] - 'a'].push(a[i]);
if (s[i] != s[i - 1]) {
int num = 1;
while (!q[s[i - 1] - 'a'].empty() && num <= k) {
ans += q[s[i - 1] - 'a'].top();
q[s[i - 1] - 'a'].pop();
num++;
}
while (!q[s[i - 1] - 'a'].empty()) {
q[s[i - 1] - 'a'].pop();
}
}
}
int num = 1;
while (!q[s[n - 1] - 'a'].empty() && num <= k) {
ans += q[s[n - 1] - 'a'].top();
q[s[n - 1] - 'a'].pop();
num++;
}
while (!q[s[n - 1] - 'a'].empty()) {
q[s[n - 1] - 'a'].pop();
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int num[102];
int t[5005];
struct node {
int ti;
int c;
} q[5005];
bool cmp(node a, node b) { return a.ti > b.ti; }
struct Res {
int l, r;
} res[5005];
int main() {
while (scanf("%d %d", &n, &m) != EOF) {
memset(num, 0, sizeof(num));
int p;
for (int i = 0; i < n; i++) {
scanf("%d", &p);
num[p]++;
}
int tp = 0;
for (int i = 1; i <= m; i++) {
if (num[i]) {
q[tp].ti = num[i];
q[tp++].c = i;
}
}
sort(q, q + tp, cmp);
int top = 0;
for (int i = 0; i < tp; i++) {
for (int j = 0; j < q[i].ti; j++) {
t[top++] = q[i].c;
}
}
top = 0;
for (int i = 0; i < n; i++) {
if (t[i] != t[(q[0].ti + i) % n]) {
top++;
}
}
printf("%d\n", top);
for (int i = 0; i < n; i++) {
printf("%d %d\n", t[i], t[(q[0].ti + i) % n]);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int last = -1, ans = 0, ps;
for (int i = 0; i < n; i++) {
if (s[i] - '0' == 1) {
if (last == -1) {
ps = max(0, i - k);
} else {
ps = max(0, i - last - 1 - 2 * k);
}
if (ps > 0) {
ans++;
ps--;
ans += ps / (k + 1);
}
last = i;
}
}
if (last != -1) {
ps = max(0, n - last - 1 - k);
if (ps > 0) {
ans++;
ps--;
ans += ps / (k + 1);
}
} else {
ps = n;
if (ps > 0) {
ans++;
ps--;
ans += ps / (k + 1);
}
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
int epos;
int d, b;
deque<char> ans;
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'e') epos = i;
}
for (int i = epos - 1; i > 1; i--) {
d += int(s[i] - '0') * pow(10.0, epos - 1 - i);
}
for (int i = s.size() - 1; i > epos; i--) {
b += int(s[i] - '0') * pow(10.0, int(s.size()) - i - 1);
}
int index = -2;
for (int i = 0; i < epos; i++) {
if (s[i] == '.') {
index++;
continue;
}
if (index == b) {
ans.push_back('.');
}
ans.push_back(s[i]);
index++;
}
while (index < b) {
ans.push_back('0');
index++;
}
if (ans.front() == '0' && b == 0 && d == 0) {
cout << '0';
return 0;
}
if (b == 0 && d == 0) {
cout << ans.front();
return 0;
}
while (!ans.empty()) {
cout << ans.front();
ans.pop_front();
}
cin >> s;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << n - max(a + 1, n - b) + 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
int t;
cin >> t;
while(t--)
{
string s;
cin >> s;
bool IND = false;
for(int m = 0; m <= s.size(); m++)
{
bool ind = true;
int tr = -2;
for(int i = 0; i < m; i++)
{
if(s[i] == '1')
{
if(tr == i - 1)
{
ind = false;
break;
}
else
{
tr = i;
}
}
}
for(int i = m; i < s.size(); i++)
{
if(s[i] == '0')
{
if(tr == i - 1)
{
ind = false;
break;
}
else
{
tr = i;
}
}
}
if(ind)
{
IND = true;
break;
}
}
if(IND)
{
cout << "YES" << endl;
}
else
{
cout << "NO" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 2e6 + 5;
char a[maxn], b[maxn];
int n;
int cnta, cntb, ansa, ansb;
int main() {
while (~scanf("%d", &n)) {
cnta = cntb = ansa = ansb = 0;
scanf("%s", &a);
scanf("%s", &b);
int both = 0;
for (int i = 0; i < 2 * n; ++i) {
if (a[i] == '1' && b[i] == '1') both++;
if (a[i] == '1') cnta++;
if (b[i] == '1') cntb++;
}
cntb -= both;
cnta -= both;
ansa = (both + 1) / 2;
ansb = both - ansa;
int t = min(cnta, cntb);
if (ansa > ansb) {
if (cnta > cntb) {
ansb += cntb;
ansa += cntb;
cnta -= cntb;
ansa += (cnta / 2);
} else {
ansb += cnta;
ansa += cnta;
cntb -= cnta;
ansb += ((cntb + 1) / 2);
}
} else {
if (cnta > cntb) {
ansb += cntb;
ansa += cntb;
cnta -= cntb;
ansa += ((cnta + 1) / 2);
} else {
ansb += cnta;
ansa += cnta;
cntb -= cnta;
ansb += (cntb / 2);
}
}
if (ansa == ansb)
puts("Draw");
else if (ansa > ansb)
puts("First");
else
puts("Second");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k = 0, i;
int n;
cin >> n;
int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
for (i = 1; i < n - 1; i++) {
if (arr[i - 1] == 1 && arr[i] == 0 && arr[i + 1] == 1) {
k++;
i = i + 2;
}
}
cout << k;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, ans;
cin >> n >> k;
int r = (n - 1) / k;
if ((n - 1) % k == 0)
ans = 2 * r;
else if ((n - 1) % k == 1)
ans = 2 * r + 1;
else
ans = 2 * r + 2;
cout << ans << endl;
for (int i = 2; i < 2 + k; i++) printf("1 %d\n", i);
for (int i = 2 + k; i <= n; i++) printf("%d %d\n", i, i - k);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC target("popcnt")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native"
using namespace std;
template <typename T, typename K>
inline bool smax(T &x, const K &y) {
return x < y ? x = y, true : false;
}
template <typename T, typename K>
inline bool smin(T &x, const K &y) {
return x > y ? x = y, true : false;
}
const int mod = 1e9 + 7;
int add(int x, int y) {
int z = x + y;
if (z >= mod) {
z -= mod;
}
return z;
}
int sub(int x, int y) {
int z = x - y;
if (z < 0) {
z += mod;
}
return z;
}
int mul(int x, int y) {
long long z = 1ll * x * y;
if (z >= mod) {
z %= mod;
}
return z;
}
int binpow(int a, long long p) {
int r = 1;
while (p) {
if (p & 1) r = mul(r, a);
a = mul(a, a), p >>= 1;
}
return r;
}
vector<vector<int>> g;
vector<int> in;
set<int> alive;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
g = vector<vector<int>>(n + 1);
in = vector<int>(n + 1);
for (int i = 1; i <= n; ++i) {
int k;
cin >> k;
for (int j = 1; j <= k; ++j) {
int x;
cin >> x;
g[x].push_back(i);
in[i] += 1;
}
}
alive.clear();
int done = 0, cnt = 0;
for (int i = 1; i <= n; ++i) {
if (in[i] == 0) {
alive.insert(i);
}
}
while (done != n) {
if (alive.empty()) {
cnt = 1e9;
break;
}
++cnt;
int chapter = 0;
auto it = alive.begin();
while (!alive.empty() &&
(it = alive.lower_bound(chapter)) != alive.end() &&
*it > chapter) {
int cur = *it;
alive.erase(it);
++done;
for (auto v : g[cur]) {
in[v] -= 1;
if (in[v] == 0) {
alive.insert(v);
}
}
chapter = cur;
}
}
cout << (cnt < 1e9 ? cnt : -1) << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 20;
int e[N][N];
int n, m;
void init() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) e[i][j] = i == j ? 0 : 0x3f3f3f3f;
}
struct Dijkstra {
int vis[N], dis[N];
void dijkstra(int st) {
for (int i = 1; i <= n; i++) {
dis[i] = 0x3f3f3f3f;
vis[i] = 0;
}
dis[st] = 0;
for (int i = 1; i <= n; i++) {
int minn = 0x3f3f3f3f, k;
for (int j = 1; j <= n; j++)
if (!vis[j] && dis[j] < minn) {
minn = dis[j];
k = j;
}
vis[k] = 1;
for (int j = 1; j <= n; j++)
if (!vis[j] && dis[k] + e[k][j] < dis[j]) dis[j] = dis[k] + e[k][j];
}
}
} ac1, ac2;
int main() {
int u, v, st, ed;
scanf("%d%d%d%d", &n, &m, &st, &ed);
init();
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
e[u][v] = e[v][u] = 1;
}
ac1.dijkstra(st);
ac2.dijkstra(ed);
int ans = 0;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (e[i][j] == 0x3f3f3f3f)
if (ac1.dis[i] + 1 + ac2.dis[j] >= ac1.dis[ed] &&
ac2.dis[i] + 1 + ac1.dis[j] >= ac2.dis[st])
ans++;
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > tb;
int dpsolve(string str) {
int n = str.length();
tb.assign(2, vector<int>(n, 0));
tb[0][0] = (str[0] == '1');
tb[1][0] = (str[0] == '0');
int cnt1 = (str[0] == '1');
for (int i = int(1); i <= int(n - 1); i++) {
tb[0][i] = min(tb[0][i - 1], tb[1][i - 1]) + (str[i] == '1');
tb[1][i] = min(tb[1][i - 1], cnt1) + (str[i] == '0');
cnt1 += (str[i] == '1');
}
return min(tb[0][n - 1], tb[1][n - 1]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<string> pstrs(k);
vector<int> cnt1(k, 0);
int total1 = 0;
for (int i = int(0); i <= int(n - 1); i++) {
pstrs[i % k].push_back(s[i]);
if (s[i] == '1') {
cnt1[i % k]++;
total1++;
}
}
int ans = 1e9;
for (int i = int(0); i <= int(k - 1); i++) {
ans = min(ans, dpsolve(pstrs[i]) + total1 - cnt1[i]);
}
cout << ans << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long n, t;
long long dx[7] = {2, 1, -1, -2, -1, 1, 2}, dy[7] = {0, 2, 2, 0, -2, -2, 0},
k, x, y;
cin >> n;
if (n == 0) {
cout << "0 0";
return 0;
} else {
t = sqrt((double)n / 3);
while (3 * t * (t + 1) < n) t++;
}
k = n - (3 * (t * t - t));
x = t * dx[k / t] + (k % t) * (dx[k / t + 1] - dx[k / t]);
y = t * dy[k / t] + (k % t) * (dy[k / t + 1] - dy[k / t]);
cout << x << " " << y;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline _T sqr(const _T& x) {
return x * x;
}
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 1e-11;
char TEMPORARY_CHAR;
const int INF = 1e9;
const int N = 1 << 16;
inline void input(int& a) {
a = 0;
while ((TEMPORARY_CHAR = getchar()) > '9' || TEMPORARY_CHAR < '0') {
}
while (TEMPORARY_CHAR <= '9' && TEMPORARY_CHAR >= '0') {
a = (a << 3) + (a << 1) + TEMPORARY_CHAR - '0';
TEMPORARY_CHAR = getchar();
}
}
inline int nxt() {
int(ret);
input((ret));
;
return ret;
}
pair<int, int> a[1000];
bool cmp(int i, int j) {
return a[i].second < a[j].second ||
(a[j].second == a[i].second && a[i].first > a[j].first);
}
int main() {
int(n);
input((n));
;
int(k);
input((k));
;
int o[1000];
int tab = 0;
for (int i = 0; i < (int)(n); i++) {
a[i].first = 2 * nxt();
a[i].second = nxt();
if (a[i].second == 1) tab++;
o[i] = i;
}
int r = min(k - 1, tab);
sort(o, o + n, cmp);
long long ans = 0;
vector<vector<int> > q(k);
int p = 0;
for (int i = 0; i < (int)(r); i++) {
ans += a[o[i]].first / 2;
q[p++].push_back(o[i] + 1);
}
int mi = a[r].first;
for (int i = (r); i <= (int)(n - 1); i++) {
mi = min(mi, a[o[i]].first);
ans += a[o[i]].first;
if (p < k - 1)
q[p++].push_back(o[i] + 1);
else
q[p].push_back(o[i] + 1);
}
if (tab > k - 1) ans -= mi / 2;
if (ans & 1)
cout << ans / 2 << ".5\n";
else
cout << ans / 2 << ".0\n";
for (int i = 0; i < (int)(k); i++) {
cout << (int)q[i].size() << " ";
for (__typeof((q[i]).begin()) it = (q[i]).begin(); it != (q[i]).end(); it++)
cout << *it << " ";
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1000010;
int n, m, r, h = 1;
char mp[1010][1010];
bool vis[2020];
int pre[2020], deg[2020], q[2020], val[1000010];
int head[2020], tot = 0;
struct node {
int v, next, w;
node(int _v = 0, int _next = 0, int _w = 0) : v(_v), next(_next), w(_w) {}
} edge[maxn];
inline void add(int u, int v) {
edge[++tot].v = v;
edge[tot].next = head[u];
head[u] = tot;
deg[v]++;
}
int Find(int x) { return x == pre[x] ? x : pre[x] = Find(pre[x]); }
void join(int x, int y) { pre[Find(x)] = Find(y); }
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) scanf("%s", mp[i] + 1);
for (int i = 1; i < 2005; ++i) pre[i] = i;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (mp[i][j] == '=') join(i, j + n);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (mp[i][j] == '<') add(Find(i), Find(j + n));
if (mp[i][j] == '>') add(Find(j + n), Find(i));
}
}
for (int i = 1; i <= n + m; ++i)
if (i == Find(i) && !deg[i]) q[++r] = i, val[i] = 1, vis[i] = 1;
while (h <= r) {
int u = q[h++];
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].v;
if (vis[v]) continue;
deg[v]--;
if (!deg[v]) {
vis[v] = 1;
val[v] = val[u] + 1;
q[++r] = v;
}
}
}
for (int i = 1; i <= n + m; ++i) {
if (i == Find(i) && !vis[i]) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
for (int i = 1; i <= n; i++) cout << val[Find(i)] << " ";
cout << endl;
for (int i = 1; i <= m; i++) cout << val[Find(i + n)] << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = sqrt(n); i >= 1; i--) {
if (n % i == 0) {
cout << i << " " << n / i;
return 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long l, r, ans;
cin >> l >> r;
if (l == r)
cout << l;
else
cout << 2;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, F = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') F = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * F;
}
int ans;
int T, n, m, siz[1200000 + 5], num[1200000 + 5];
vector<long long> P;
vector<int> G[1200000 + 5];
int add(int a, int b) {
return (a + b >= 1000000007) ? a + b - 1000000007 : a + b;
}
int dec(int a, int b) { return (a - b < 0) ? a - b + 1000000007 : a - b; }
int mul(int a, int b) { return (1LL * a * b) % 1000000007; }
void dfs(int x, int fa) {
siz[x] = 1;
for (int i = 0; i < G[x].size(); i++) {
int v = G[x][i];
if (v == fa) continue;
dfs(v, x);
P.push_back(1LL * siz[v] * (n - siz[v]));
siz[x] += siz[v];
}
}
int main() {
T = read();
while (T--) {
P.clear(), ans = 0;
n = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, 0);
sort(P.begin(), P.end());
m = read();
for (int i = 1; i <= m; i++) num[i] = read();
sort(num + 1, num + m + 1);
for (int i = m; i > n - 1; i--)
num[i - 1] = mul(num[i - 1], num[i]), num[i] = 0;
m = min(m, n - 1);
reverse(num + 1, num + m + 1);
for (int i = n - 1; i >= 1; i--)
ans = add(ans, mul(num[n - i] ? num[n - i] : 1, P[i - 1] % 1000000007));
printf("%d\n", ans);
for (int i = 1; i <= n; i++) G[i].clear();
for (int i = 1; i <= m; i++) num[i] = 0;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
const int M = 1000000007;
const double PI = atan(1) * 4;
const int oo = 1000000000;
int n, v[N], fr[N];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> v[i];
for (int i = n - 1; i >= 0; --i) v[i] += v[i + 1];
int mx = v[0];
for (int i = 0, ct = 0; i < n; ++i) {
ct += v[i] == v[i + 1];
mx = max(mx, ct + v[i]);
}
cout << mx << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e18 + 7;
long long n, a[300005], suff[300005], IT[1200005], l[300005], r[300005];
pair<pair<long long, long long>, long long> ques[600005];
stack<long long> stk;
unordered_map<long long, long long> uomp;
void upd(long long id, long long l, long long r, long long pos) {
if (l > pos || r < pos) return;
if (l == r) {
IT[id]++;
return;
}
long long mid = (l + r) >> 1;
upd(id << 1, l, mid, pos);
upd(id << 1 | 1, mid + 1, r, pos);
IT[id] = IT[id << 1] + IT[id << 1 | 1];
}
long long get(long long id, long long l, long long r, long long L,
long long R) {
if (l > R || r < L) return 0;
if (L <= l && r <= R) {
return IT[id];
}
long long mid = (l + r) >> 1;
return get(id << 1, l, mid, L, R) + get(id << 1 | 1, mid + 1, r, L, R);
}
bool cmp1(pair<pair<long long, long long>, long long> a,
pair<pair<long long, long long>, long long> b) {
return a.first.second < b.first.second;
}
signed main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
long long itr = 0;
for (long long i = 1; i <= n; i++) {
uomp[a[i]]++;
while (uomp.size() != (i - itr)) {
itr++;
uomp[a[itr]]--;
if (!uomp[a[itr]]) uomp.erase(a[itr]);
}
suff[i] = i - itr;
}
stk.push(0);
for (long long i = 1; i <= n; i++) {
while (stk.size() >= 2 && a[stk.top()] < a[i]) stk.pop();
l[i] = stk.top() + 1;
stk.push(i);
}
while (!stk.empty()) stk.pop();
stk.push(n + 1);
for (long long i = n; i >= 1; i--) {
while (stk.size() >= 2 && a[stk.top()] < a[i]) stk.pop();
r[i] = stk.top() - 1;
stk.push(i);
}
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
if (r[i] >= (l[i] + a[i] - 1)) {
cnt++;
ques[cnt] = {{0, l[i] + a[i] - 2}, a[i]};
cnt++;
ques[cnt] = {{1, min(r[i], i + a[i] - 1)}, a[i]};
}
}
if (!cnt) {
cout << 0;
return 0;
}
sort(ques + 1, ques + cnt + 1, cmp1);
long long ans = 0;
for (long long i = 1; i <= cnt; i++) {
for (long long j = ques[i - 1].first.second + 1; j <= ques[i].first.second;
j++) {
upd(1, 1, n, suff[j]);
}
long long tmp = get(1, 1, n, ques[i].second, n);
if (ques[i].first.first)
ans += tmp;
else
ans -= tmp;
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[66], b[66];
int main() {
int n;
scanf("%d", &n);
while (n--) {
long long l, r;
cin >> l >> r;
int ac = 0, bc = 0;
while (l) {
a[ac++] = l % 2;
l /= 2;
}
while (r) {
b[bc++] = r % 2;
r /= 2;
}
reverse(a, a + ac);
reverse(b, b + bc);
bool ao = true;
for (int i = 0; i < bc; ++i) {
if (b[i] == 0) ao = false;
}
if (ao) {
long long ans = 0;
for (int i = 0; i < bc; ++i) ans = ans * 2 + 1;
cout << ans << endl;
continue;
}
if (bc > ac) {
long long ans = 0;
for (int i = 1; i < bc; ++i) {
ans = ans * 2 + 1;
}
cout << ans << endl;
continue;
}
long long ans = 0;
for (int i = 0; i < ac; ++i) {
if (a[i] < b[i]) {
ao = true;
for (int j = i; j < ac; ++j)
if (!b[j]) ao = false;
ans = ans * 2;
if (ao) ans++;
for (int j = i + 1; j < ac; ++j) ans = ans * 2 + 1;
break;
}
ans = ans * 2 + a[i];
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
inline void get(complex<double> &a) {
double x, y;
cin >> x >> y;
a = complex<double>(x, y);
}
bool intersect(complex<double> a, double ra, complex<double> b, double rb,
complex<double> c, double rc) {
if (abs(a - b) > ra + rb + eps) return false;
if (abs(a - c) < ra - eps && abs(b - c) < rb - eps) return true;
if (abs(a - b) < abs(ra - rb) - eps) return false;
b -= a, c -= a;
complex<double> i = complex<double>(b.real() / abs(b), b.imag() / abs(b));
b /= i, c /= i;
double x = (ra * ra + abs(b) * abs(b) - rb * rb) / (2 * abs(b));
double h = sqrt(max(ra * ra - x * x, 0.0));
complex<double> p = complex<double>(x, h), q = complex<double>(x, -h);
if (min(abs(p - c), abs(q - c)) < rc + eps) return true;
return false;
}
bool eval(complex<double> a, double ra, complex<double> b, double rb,
complex<double> c, double rc) {
if (ra < eps || rb < eps || rc < eps) return false;
if (intersect(a, ra, b, rb, c, rc)) return true;
if (intersect(a, ra, c, rc, b, rb)) return true;
if (intersect(b, rb, c, rc, a, ra)) return true;
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
double t1, t2;
complex<double> a, b, c;
cin >> t1 >> t2;
get(a), get(b), get(c);
double ab = abs(a - b), ac = abs(a - c), bc = abs(b - c);
if (ab + t2 > ac + bc - eps) {
cout << fixed << setprecision(5) << min(ab + t2, ac + bc + t1) << '\n';
return 0;
}
double l = 0, r = min(ab + t2, ac + t1);
while (fabs(r - l) > eps) {
double m = (l + r) * 0.5;
if (eval(a, m, b, ab + t2 - m, c, ac + t1 - m))
l = m;
else
r = m;
}
cout << fixed << setprecision(5) << (l + r) * 0.5 << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N, K, ans;
int p[205];
int main() {
int i;
scanf("%d", &N);
for (i = 1; i <= 2 * N - 1; i++) {
scanf("%d", &p[i]);
if (p[i] >= 0)
K++;
else
p[i] = -p[i];
ans += p[i];
}
sort(p + 1, p + 2 * N);
if ((2 * N - 1 - K) % 2 == 1)
if (N % 2 == 0) ans -= p[1] * 2;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int maxn = 5005;
const int maxm = 200005;
int Read() {
int x = 0, t = 1;
char c = getchar();
if (c == '-') {
t = -1;
c = getchar();
}
while (c > '9' || c < '0') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return t * x;
}
int n;
vector<int> v;
int main() {
ios_base::sync_with_stdio(false);
int i, j, x;
string t;
cin >> n;
for (i = 0; i < n; i++) {
cin >> t;
if (t == "add") {
cin >> x;
v.insert(lower_bound(v.begin(), v.end(), x), x);
} else if (t == "del") {
cin >> x;
v.erase(lower_bound(v.begin(), v.end(), x));
} else if (t == "sum") {
long long ans = 0;
for (j = 2; j < v.size(); j += 5) ans += v[j];
cout << ans << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2048;
const int M = 8192;
struct data {
int s[N];
int p[N];
int l, r;
void clear() {
l = 1;
r = 0;
}
void insert(int d, int k) {
while (l <= r && s[r] > d) r--;
r++;
s[r] = d;
p[r] = k;
}
int pos() { return p[l]; }
int height() { return s[l]; }
int pop() { l++; }
};
bool a[N][N];
int p[M][N], q[M][N];
data x, y;
int ans[M];
char ch[N];
int n, m, i, j, k, t, u, v, w;
int solve(int cur, int l, int r) {
int mid, i, j, k, ans, last;
mid = (l + r) >> 1;
x.clear();
y.clear();
last = ans = 0;
for (i = 1; i <= m; i++) {
if (a[mid][i]) {
x.clear();
y.clear();
last = i;
continue;
}
x.insert(p[cur][i], i);
y.insert(q[cur][i], i);
while (x.height() + y.height() - 1 < i - last) {
last = min(x.pos(), y.pos());
if (x.pos() == y.pos()) {
x.pop();
y.pop();
} else if (x.pos() < y.pos())
x.pop();
else
y.pop();
}
ans = max(ans, min(x.height() + y.height() - 1, i - last));
}
return ans;
}
void up(int cur) {
ans[cur] = max(ans[cur], ans[cur << 1]);
ans[cur] = max(ans[cur], ans[cur << 1 | 1]);
}
void build(int cur, int l, int r) {
int mid, i;
mid = (l + r) >> 1;
for (i = 1; i <= m; i++) {
for (p[cur][i] = 0; mid - p[cur][i] >= l && !a[mid - p[cur][i]][i];
p[cur][i]++)
;
for (q[cur][i] = 0; mid + q[cur][i] <= r && !a[mid + q[cur][i]][i];
q[cur][i]++)
;
}
ans[cur] = solve(cur, l, r);
if (l == r) return;
build(cur << 1, l, mid);
build(cur << 1 | 1, mid + 1, r);
up(cur);
}
void update(int cur, int l, int r, int u, int v) {
int mid;
mid = (l + r) >> 1;
for (p[cur][v] = 0; mid - p[cur][v] >= l && !a[mid - p[cur][v]][v];
p[cur][v]++)
;
for (q[cur][v] = 0; mid + q[cur][v] <= r && !a[mid + q[cur][v]][v];
q[cur][v]++)
;
ans[cur] = solve(cur, l, r);
if (l == r) return;
if (u <= mid)
update(cur << 1, l, mid, u, v);
else
update(cur << 1 | 1, mid + 1, r, u, v);
up(cur);
}
int main() {
scanf("%d%d%d", &n, &m, &t);
for (i = 1; i <= n; i++) {
scanf("%s", ch + 1);
for (j = 1; j <= m; j++) a[i][j] = ch[j] == 'X';
}
build(1, 1, n);
for (i = 1; i <= t; i++) {
scanf("%d%d", &u, &v);
a[u][v] = true;
update(1, 1, n, u, v);
printf("%d\n", ans[1]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 15;
int n;
int a[maxn];
int b[maxn];
int main() {
cin >> n;
for (int(i) = (1); (i) != (n + 1); (i)++) {
scanf("%d", &a[i]);
b[i] = b[i - 1] + a[i];
}
int max_inc = -1;
for (int(i) = (1); (i) != (n + 1); (i)++) {
for (int(j) = (i); (j) != (n + 1); (j)++) {
int ones = b[j] - b[i - 1];
int zeroes = j - i + 1 - ones;
max_inc = max(max_inc, zeroes - ones);
}
}
cout << b[n] + max_inc << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int MaxN = 3e5;
vector<int> adj[MaxN];
vector<int> prec[MaxN];
void dfs(const int u, const int p) {
prec[u] = {1, n};
adj[u].erase(remove(adj[u].begin(), adj[u].end(), p), adj[u].end());
for (auto &&v : adj[u]) {
dfs(v, u);
prec[u][0] = max(prec[u][0], 1 + prec[v][0]);
}
for (int i = 2;; ++i) {
int lo = 1;
int hi = adj[u].size();
while (lo < hi) {
int mid = (lo + hi + 1) >> 1;
int count = 0;
for (auto &&v : adj[u])
count += i <= prec[v].size() && prec[v][i - 1] >= mid;
if (count >= mid)
lo = mid;
else
hi = mid - 1;
}
if (lo <= 1) break;
prec[u].push_back(lo);
}
}
void dfs2(const int u, long long &ans) {
for (auto &&v : adj[u]) {
dfs2(v, ans);
if (prec[u].size() < prec[v].size()) prec[u].resize(prec[v].size(), 0);
for (int i = 2; i < prec[v].size(); ++i)
prec[u][i] = max(prec[u][i], prec[v][i]);
}
ans -= prec[u].size() - 1;
for (auto &&x : prec[u]) ans += x;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(0, -1);
long long ans = 0;
dfs2(0, ans);
cout << ans;
return 0;
}
| 9 |
//#pragma GCC target ("avx2")
//#pragma GCC optimization ("O3")
//#pragma GCC optimization ("unroll-loops")
#include<bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
#define eps 1e-8
#define eq(x,y) (fabs((x)-(y)) < eps)
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int>pii;
const ll mod= 998244353;
long double PI = acosl(-1);
const ll infl = 1e17+100;
const int inf = 1e9+100;
const int nmax = 3e5+5;
//const int MAXLG = log2(nmax)+1;
//mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
//typedef tree< int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ost;
bool vis[nmax];
vector<int>g[nmax];
void dfs(int u){
vis[u] = true;
for(int v : g[u]) if(!vis[v])
dfs(v);
}
int main(){
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
int tc;
cin>>tc;
while(tc--){
int n,m;
cin>>n>>m;
for(int i=0; i<m; i++){
int u,v;
cin>>u>>v;
g[u].push_back(v);
g[v].push_back(u);
}
bool hoise = false;
bool unposibol = false;
for(int i=1; i<=n; i++){
if(!vis[i]){
if(!hoise){
dfs(i);
hoise = true;
}
else unposibol = true;
}
}
if(unposibol) cout<<"NO\n";
else{
cout<<"YES\n";
for(int i=1; i<=n; i++) vis[i] = false;
vector<int>ans;
set<int>st; st.insert(1);
while(st.size()){
int u = *st.begin();
st.erase(u);
if(vis[u]) continue;
vis[u] = true;
ans.push_back(u);
vector<int>tmp;
for(int v : g[u]) if(!vis[v]){
vis[v] = true;
tmp.push_back(v);
}
for(int v : tmp){
for(int z : g[v]) if(!vis[z]){
st.insert(z);
}
}
}
cout<<ans.size()<<"\n";
for(int x : ans) cout<<x<<" ";
cout<<"\n";
}
for(int i=1; i<=n; i++) vis[i] = false, g[i].clear();
}
}
/*
*/
| 7 |
#include <bits/stdc++.h>
using namespace std;
int data[100005], n;
long long g[2][100005], h[2][100005];
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) scanf("%d", &data[i]);
g[0][1] = g[1][1] = 0;
for (int i = 2; i <= n; i++) {
if (data[i - 1] == 0)
g[1][i] = 0;
else
g[1][i] = max(g[1][i - 1], g[0][i - 1]) + (data[i - 1] - 1) / 2 * 2 + 1;
if (data[i - 1] <= 1)
g[0][i] = 0;
else
g[0][i] = g[0][i - 1] + data[i - 1] / 2 * 2;
}
h[0][n] = h[1][n] = 0;
for (int i = n - 1; i >= 1; i--) {
if (data[i] == 0)
h[1][i] = 0;
else
h[1][i] = max(h[1][i + 1], h[0][i + 1]) + (data[i] - 1) / 2 * 2 + 1;
if (data[i] <= 1)
h[0][i] = 0;
else
h[0][i] = h[0][i + 1] + data[i] / 2 * 2;
}
long long ans = -1;
for (int i = 1; i <= n; i++) {
ans = max(ans, g[0][i] + h[0][i]);
ans = max(ans, g[1][i] + h[0][i]);
ans = max(ans, g[0][i] + h[1][i]);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int LIM = 1e5 + 5, MOD = 1e9 + 7;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long fastpowMOD(long long a, long long p, long long MOD) {
if (p == 0) return 1;
long long z = fastpowMOD(a, p / 2, MOD);
z = (z * z) % MOD;
if (p % 2) z = (z * a) % MOD;
return z;
}
bool seive[2005];
void SieveOfEratosthenes(long long n) {
memset(seive, true, sizeof(seive));
for (long long p = 2; p * p <= n; p++)
if (seive[p] == true)
for (long long i = p * p; i <= n; i += p) seive[i] = false;
}
long long fastpow(long long a, long long p) {
if (p == 0) return 1;
long long z = fastpow(a, p / 2);
z = (z * z);
if (p % 2) z = (z * a);
return z;
}
long long n, i, ans = 0;
vector<long long> v[200005];
long long ver[200005] = {0}, val[200005] = {0}, odd = 0, even = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, i, j;
cin >> n >> m;
pair<long long, long long> a[n + 5], b[n + 5];
for (i = 1; i <= n; i++) {
long long x, y;
cin >> x >> y;
b[i].first = x;
b[i].second = y;
a[i].first = (x - y);
a[i].second = i;
}
sort(a + 1, a + n + 1);
long long my[n + 5];
for (i = 1; i <= n; i++) {
my[a[i].second] = i;
}
long long ans[n + 5];
long long pre = 0;
long long suf = 0;
for (i = 1; i <= n; i++) {
pre += b[a[i].second].second;
}
for (i = 1; i <= n; i++) {
ans[i] = (n - i) * b[a[i].second].first + (i - 1) * (b[a[i].second].second);
ans[i] += suf;
pre -= b[a[i].second].second;
suf += b[a[i].second].first;
ans[i] += pre;
}
for (i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
long long x1 = my[x];
long long y1 = my[y];
ans[x1] -= min(b[x].first + b[y].second, b[y].first + b[x].second);
ans[y1] -= min(b[x].first + b[y].second, b[y].first + b[x].second);
}
for (i = 1; i <= n; i++) {
cout << ans[my[i]] << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b) {
long long int res = 1;
a = a % 1000000007;
while (b > 0) {
if (b & 1) {
res = (res * a) % 1000000007;
b--;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long int gcd(long long int a, long long int b) {
return (b == 0) ? a : gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m;
cin >> n >> m;
vector<long long int> a(n);
for (auto &i : a) cin >> i;
long long int sum = 0;
vector<long long int> freq(101, 0);
vector<long long int> ans(n);
for (long long int i = 0; i < n; i++) {
long long int cur = sum + a[i];
long long int j = 100;
long long int c = 0;
while (cur > m) {
if (freq[j] == 0) {
j--;
continue;
}
long long int tak = (cur - m + j - 1) / j;
tak = min(tak, freq[j]);
c += tak;
cur -= tak * j;
j--;
}
ans[i] = c;
freq[a[i]]++;
sum += a[i];
}
for (auto i : ans) cout << i << " ";
cout << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ '0'), c = getchar();
return x * f;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 1e5 + 5;
struct node {
int l, r, id;
} t[N];
int n, m, a[N], pre[N], last[N], fail[N], sum1[N], sum2[N], s1, s2, ans[N];
inline bool cmp(node a, node b) { return a.r < b.r; }
int main() {
n = read();
for (register int i = 1; i <= n; ++i) {
a[i] = read();
pre[i] = last[a[i]];
last[a[i]] = i;
if (i - pre[i] == pre[i] - pre[pre[i]])
fail[i] = fail[pre[i]];
else
fail[i] = pre[pre[i]];
}
m = read();
for (register int i = 1; i <= m; ++i) {
t[i].l = read();
t[i].r = read();
t[i].id = i;
}
sort(t + 1, t + m + 1, cmp);
int k = 1;
for (register int i = 1; i <= n; ++i) {
for (int j = i; j; j -= j & -j) ++sum1[j];
for (int j = pre[i]; j; j -= j & -j) --sum1[j];
for (int j = fail[i]; j; j -= j & (-j)) ++sum2[j];
for (int j = fail[pre[i]]; j; j -= j & -j) --sum2[j];
for (; k <= m && t[k].r == i; ++k) {
s1 = s2 = 0;
for (int j = t[k].l; j <= n; j += j & (-j)) s1 += sum1[j], s2 += sum2[j];
ans[t[k].id] = s1 + (s1 == s2);
}
}
for (register int i = 1; i <= m; ++i) write(ans[i]), puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100009;
struct E {
int u, v;
long long val;
} edges[maxn];
vector<int> neigh[maxn];
long long val[maxn];
int be = -1;
int depth[maxn];
long long cur_val[maxn];
void dfs(int v, int p) {
int bck;
for (int i : neigh[v]) {
int u = (edges[i].v == v ? edges[i].u : edges[i].v);
if (u == p) {
bck = i;
} else if (depth[u] == -1) {
depth[u] = depth[v] + 1;
dfs(u, v);
} else if (depth[u] < depth[v]) {
if ((depth[u] + depth[v]) % 2 == 0) {
be = i;
}
}
}
if (v != 1) {
edges[bck].val = cur_val[v];
cur_val[p] -= cur_val[v];
}
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> val[i];
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
edges[i].u = u;
edges[i].v = v;
neigh[u].push_back(i);
neigh[v].push_back(i);
}
memset(depth, -1, sizeof depth);
memcpy(cur_val, val, sizeof val);
depth[1] = 0;
dfs(1, 0);
if (cur_val[1] != 0) {
if (be == -1 || cur_val[1] % 2 != 0) {
cout << "NO";
return 0;
}
for (int i = 0; i < m; i++) edges[i].val = 0;
if (depth[edges[be].u] % 2 == 0)
edges[be].val = cur_val[1] / 2;
else
edges[be].val = -cur_val[1] / 2;
val[edges[be].u] -= edges[be].val;
val[edges[be].v] -= edges[be].val;
memset(depth, -1, sizeof depth);
memcpy(cur_val, val, sizeof val);
depth[1] = 0;
dfs(1, 0);
}
cout << "YES\n";
for (int i = 0; i < m; i++) cout << edges[i].val << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 5;
vector<int> graph[N];
unordered_map<int, string> name;
unordered_map<string, int> id;
bitset<N> adj[N];
int getId(string &x) {
if (id.count(x)) return id[x];
int t = int(id.size());
name[t] = x;
return id[x] = t;
}
int go(int x) {
int n = int(id.size()), best = -1, ans = 0;
for (int u = 0; u < n; ++u)
if (u != x && !adj[u][x]) {
int now = 0;
for (int v : graph[u]) {
now += adj[x][v];
}
if (now > best) best = now, ans = 0;
if (now == best) ans++;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int m;
cin >> m;
string a, b;
for (int i = int(0); i < int(N); ++i) adj[i].reset();
for (int i = 0; i < m; ++i) {
cin >> a >> b;
int x = getId(a), y = getId(b);
adj[x][y] = adj[y][x] = true;
graph[x].push_back(y);
graph[y].push_back(x);
}
int n = int(id.size());
cout << n << '\n';
for (int i = 0; i < n; ++i) {
cout << name[i] << ' ' << go(i) << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
const long long int N = 5e5 + 30, mod = 1e9 + 7, inf = 1e12;
const long double eps = 0.0001;
int n, m;
bool visited[N];
set<pair<int, int> > st;
set<int> ve;
vector<int> g[N];
void bfs(int v, int t) {
g[t].push_back(v);
queue<int> q;
q.push(v);
visited[v] = 1;
ve.erase(v);
while (!q.empty()) {
int u = q.front();
q.pop();
bool f = 0;
if (ve.empty()) break;
for (auto it = ve.begin(); it != ve.end(); it) {
if (ve.empty()) return;
if (f) it = ve.begin();
f = 0;
int i = *it;
if (!visited[i] and st.find({min(i, u), max(i, u)}) == st.end()) {
q.push(i);
visited[i] = 1;
g[t].push_back(i);
it = ve.erase(it);
} else
it++;
if (ve.empty()) return;
}
}
}
int main() {
ios ::sync_with_stdio(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
if (x > y) swap(x, y);
st.insert({x, y});
}
if (m < n - 1) {
cout << 1 << '\n' << n << ' ';
for (int i = 1; i < n + 1; i++) cout << i << ' ';
return 0;
}
for (int i = 1; i < n + 1; i++) ve.insert(i);
int t = 0;
for (int i = 1; i < n + 1; i++) {
if (!visited[i]) {
t++;
bfs(i, t);
}
}
cout << t << '\n';
for (int i = 1; i < t + 1; i++) {
cout << g[i].size() << ' ';
for (int u : g[i]) cout << u << ' ';
cout << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void cetak(T t) {
cout << t << ')' << endl;
}
template <typename T, typename... V>
void cetak(T t, V... v) {
cout << t;
if (sizeof...(v)) cout << ", ";
cetak(v...);
}
typedef int (*func)(int, int);
const int MOD = 1e9 + 7;
int add(int x, int y) {
int ret = x + y;
if (ret >= MOD) ret -= MOD;
return ret;
}
int sub(int x, int y) {
int ret = x - y;
if (ret < 0) ret += MOD;
return ret;
}
int mul(int x, int y) { return (long long)x * y % MOD; }
const int mx = 1e5 + 10;
int p[mx];
vector<int> prima;
vector<int> a, b;
void cari(int bil, int now, set<int> &res) {
if (now == (int)(a.size())) {
if (bil > 1) res.insert(bil);
return;
}
int kali = 1;
cari(bil, now + 1, res);
for (int i = 1; i <= b[now]; i++) {
kali *= a[now];
cari(bil * kali, now + 1, res);
}
}
void solve(int tc) {
a.clear();
b.clear();
int n;
cin >> n;
for (int i : prima) {
if (n % i) continue;
int tot = 0;
while (n % i == 0) {
n /= i;
tot += 1;
}
a.push_back(i);
b.push_back(tot);
}
if (n > 1) {
a.push_back(n);
b.push_back(1);
}
int N = (int)(a.size());
set<int> faktor;
cari(1, 0, faktor);
if (N == 1) {
for (int i : faktor) cout << i << ' ';
cout << '\n';
cout << 0 << '\n';
return;
}
if (N == 2) {
int ada = max(b[0], b[1]);
if (ada == 1) {
for (int i : faktor) cout << i << ' ';
cout << '\n';
cout << 1 << '\n';
return;
}
vector<int> aa, bb, ab;
for (int i : faktor) {
if (i % a[0] == 0 && i % a[1] == 0)
ab.push_back(i);
else if (i % a[0] == 0)
aa.push_back(i);
else
bb.push_back(i);
}
for (int i : aa) cout << i << ' ';
cout << ab[0] << ' ';
for (int i : bb) cout << i << ' ';
for (int i = 1; i < (int)(ab.size()); i++) cout << ab[i] << ' ';
cout << '\n';
cout << 0 << '\n';
return;
}
for (int i = 0; i < N; i++) {
int kali = 1;
for (int j = 0; j < b[i]; j++) {
kali *= a[i];
cout << kali << ' ';
faktor.erase(kali);
}
vector<int> buang, hapus;
for (int x : faktor) {
if (x % a[i] == 0 && x % a[(i + 1) % N] == 0) {
buang.push_back(x);
}
}
for (int x : buang) faktor.erase(x);
for (int x : faktor) {
if (x % a[i] == 0 && x % a[(i - 1 + N) % N] > 0) {
cout << x << ' ';
hapus.push_back(x);
}
}
for (int x : hapus) faktor.erase(x);
for (int x : buang) {
cout << x << ' ';
}
}
assert(faktor.empty());
cout << '\n';
cout << 0 << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
for (int i = 2; i < mx; i++) {
if (!p[i]) {
prima.push_back(i);
for (int j = i; j < mx; j += i) p[j] = i;
}
}
int t = 1;
cin >> t;
int tc = 0;
while (t--) {
solve(++tc);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
void fsint(int& inp) {
register char c = getchar_unlocked(), prev = '+';
for (; !isdigit(c); c = getchar_unlocked()) prev = c;
inp = 0;
for (; isdigit(c); c = getchar_unlocked()) {
inp = (inp << 3) + (inp << 1) + (c - '0');
}
if (prev == '-') inp = -inp;
}
void fsll(long long& inp) {
register char c = getchar_unlocked(), prev = '+';
for (; !isdigit(c); c = getchar_unlocked()) prev = c;
inp = 0;
for (; isdigit(c); c = getchar_unlocked()) {
inp = (inp << 3) + (inp << 1) + (c - '0');
}
if (prev == '-') inp = -inp;
}
int main() {
long long m;
fsll(m);
vector<long long> pow3(100000 + 5, 0);
for (int idx = 1; idx <= 100000 + 2; ++idx) {
long long val = idx;
pow3[idx] = val * val * val;
}
long long vol_used = 0;
vector<long long> blocks;
bool reach_end = false;
for (int idx = 1; (not reach_end); ++idx) {
long long next_reach;
if (pow3[idx + 1] - 1 < m) {
next_reach = pow3[idx + 1] - 1;
} else {
next_reach = m;
reach_end = true;
}
long long nblock_use = (next_reach - vol_used) / pow3[idx];
long long vol_use = pow3[idx] * nblock_use;
vol_used += vol_use;
for (int it = 0; it < nblock_use; ++it) {
blocks.push_back(pow3[idx]);
}
}
vector<long long> pref_sum;
for (int idx = 0; idx < (int)blocks.size(); ++idx) {
pref_sum.push_back((pref_sum.size() ? pref_sum.back() : 0) + blocks[idx]);
}
int j = blocks.size() - 1;
long long max_add = LLONG_MAX;
for (int i = 100000 - 1; j >= 0;) {
vol_used -= blocks[j];
bool has_used = false;
if ((vol_used + pow3[i] <= m) and
(pow3[i] + (j ? pref_sum[j - 1] : 0) < max_add)) {
max_add = min(max_add - pow3[i], pow3[i + 1] - pow3[i]);
blocks[j] = pow3[i];
has_used = true;
}
vol_used += blocks[j];
if (has_used)
--j;
else
--i;
}
printf("%d %I64d\n", (int)blocks.size(), vol_used);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ok = 1;
int a, b, c, n;
cin >> a >> b >> c >> n;
a -= c;
b -= c;
if (a < 0 || b < 0) ok = 0;
if (a + b + c >= n) ok = 0;
if (!ok) {
cout << "-1\n";
return 0;
}
cout << n - (a + b + c) << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int niza[17];
niza[1] = 1;
niza[2] = 0;
niza[3] = 0;
niza[4] = 1;
niza[5] = 0;
niza[6] = 1;
niza[7] = 0;
niza[8] = 1;
niza[9] = 1;
niza[10] = 1;
niza[11] = 0;
niza[12] = 0;
niza[13] = 1;
niza[14] = 0;
niza[15] = 1;
niza[16] = 0;
int n;
cin >> n;
cout << niza[n];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[] = {0, 4, 10, 20, 35, 56, 83, 116, 155, 198, 244, 292};
int main() {
long long n;
cin >> n;
if (n <= 11)
cout << a[n];
else
cout << 292 + (n - 11) * 49;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 10;
int n, m, a[maxN], b[maxN];
double chia;
void init() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
chia = 1;
for (int i = 0; i < n; i++) chia = chia * (b[i] - a[i] + 1);
}
double cal(double l, double r, double x) {
if (x < l) return 0;
if (x > r) return r - l + 1;
return x - l + 1;
}
void xuly() {
double res = 0;
for (int i = 0; i < n; i++)
for (int gia0 = 1; gia0 < b[i]; gia0++) {
double ans = b[i] - max(gia0 + 1, a[i]) + 1;
if (ans == 0) break;
double ans1 = 0;
for (int j = 1; j < 1 << n; j++)
if ((j >> i) % 2 != 1) {
double tam = 1;
for (int t = 0; t < n; t++)
if (t != i)
if ((j >> t) % 2 == 0)
tam = tam * cal(a[t], b[t], gia0 - 1);
else {
if (a[t] > gia0 || b[t] < gia0) tam = 0;
}
ans1 += tam;
}
res += gia0 * ans1 * ans;
}
for (int i = 1; i < 1 << n; i++) {
for (int gia0 = 1; gia0 < 10001; gia0++) {
double ans = 0, ans1 = 1;
int dem = 0;
for (int j = 0; j < n; j++)
if ((i >> j) % 2 == 0)
ans1 = ans1 * cal(a[j], b[j], gia0 - 1);
else {
++dem;
if (a[j] > gia0 || b[j] < gia0) dem = -1000;
}
if (dem == 1) continue;
if (dem < 0) continue;
res += gia0 * ans1;
}
}
printf("%.15lf", res / chia);
}
int main() {
init();
xuly();
fclose(stdin);
fclose(stdout);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int size(const T &x) {
return x.size();
}
const int INF = ~(1 << 31);
const double pi = acos(-1);
const double EPS = 1e-9;
vector<int> lis(vector<int> a) {
int n = a.size(), l = 0, lo, hi, mid;
vector<int> dp(n + 1, INF), rtn;
dp[0] = -1;
for (const auto &i : a) {
lo = 0, hi = l;
while (lo < hi) {
mid = (lo + hi + 1) / 2;
if (dp[mid] > i)
hi = mid - 1;
else
lo = mid;
}
l = max(l, ++lo);
dp[lo] = i;
rtn.push_back(lo);
}
return rtn;
}
int main() {
cin.sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> P(m + 1, 0);
for (int i = (0); i < (n); i++) {
int a, b;
cin >> a >> b;
a--;
P[b]--;
P[a]++;
}
for (int i = (0); i < (m); i++) P[i + 1] += P[i];
P.pop_back();
vector<int> L1 = lis(P);
reverse(P.begin(), P.end());
vector<int> L2 = lis(P);
reverse(L2.begin(), L2.end());
int mx = 0;
for (int i = (0); i < (m); i++) {
mx = max(L1[i] + L2[i] - 1, mx);
}
cout << mx << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long x, b = 2;
cin >> x;
int cnt = 0;
while (true) {
long long c = (b - 1) * (b) / 2;
if (c > x) break;
x -= c;
cnt++;
b *= 2;
}
cout << cnt << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define ld long double
#define endl "\n"
#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define pb push_back
#define mp(a,b) make_pair(a,b)
#define ms(v,x) memset(v,x,sizeof(v))
#define all(v) v.begin(),v.end()
#define ff first
#define ss second
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define per(i, a, b) for(int i = b-1; i>=a ; i--)
#define trav(a, x) for(auto& a : x)
#define allin(a , x) for(auto a : x)
#define Unique(v) sort(all(v));v.erase(unique(all(v)),v.end());
#define sz(v) ((int)v.size())
#define int long long
using namespace std;
typedef vector<int> vi;
#define y1 abacaba
//#define left oooooopss
#define db(x) cerr << #x <<" == "<<x << endl;
#define db2(x,y) cerr<<#x <<" == "<<x<<", "<<#y<<" == "<<y<<endl;
#define db3(x,y,z) cerr << #x<<" == "<<x<<", "<<#y<<" == "<<y<<", "<<#z<<" == "<<z<<endl;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
std::mt19937 rng((int) std::chrono::steady_clock::now().time_since_epoch().count());
inline ll mod(ll n, ll m ){ ll ret = n%m; if(ret < 0) ret += m; return ret; }
ll gcd(ll a, ll b){return (b == 0LL ? a : gcd(b, a%b));}
ll exp(ll b,ll e,ll m){
b%=m;
ll ans = 1;
for (; e; b = b * b % m, e /= 2)
if (e & 1) ans = ans * b % m;
return ans;
}
string add(string s){ // s + 1
int n = sz(s);
for(int i=n-1;i>=0;i--){
if(s[i]=='1'){
s[i]='0';
}else{
s[i]='1';
break;
}
}
return s;
}
int32_t main(){
fastio;
int n;
cin >> n;
string l,r;
cin >> l >> r;
if(l[0]!=r[0]){
rep(i,0,n)cout<<1;
cout<<endl;
return 0;
}
if(r[n-1]=='1'){
// odd
cout << r << endl;
return 0;
}
if(l==r || add(l)==r){
cout << r << endl;
}else{
r[n-1] = '1';
cout << r << endl;
}
// math -> gcd it all
// Did u check N=1? Did you switch N,M?
} | 9 |
#include <bits/stdc++.h>
using namespace std;
int N, H;
long double p, q;
long double dp[4][2005][2005];
int pos[2005];
double solve(int msk, int l, int r) {
if (l > r) {
return 0;
}
if (dp[msk][l][r] + 1) {
return dp[msk][l][r];
}
int cstll, cstlr, cstrl, cstrr;
dp[msk][l][r] = 0;
if (msk & 1) {
cstll = min(pos[l] - (pos[l - 1] + H), H);
cstrl = min(pos[r] - (pos[l - 1] + H), H);
} else {
cstll = min(pos[l] - pos[l - 1], H);
cstrl = min(pos[r] - pos[l - 1], H);
}
if ((msk | 2) != msk) {
cstlr = min(pos[r + 1] - H - pos[l], H);
cstrr = min(pos[r + 1] - H - pos[r], H);
} else {
cstlr = min(pos[r + 1] - pos[l], H);
cstrr = min(pos[r + 1] - pos[r], H);
}
if (msk & 1 && pos[l - 1] + H > pos[l]) {
dp[msk][l][r] =
solve(msk, l + 1, r) + max(0, -(pos[l - 1] + H - pos[l]) + cstlr);
} else if ((msk | 2) != msk && pos[r + 1] - H < pos[r]) {
dp[msk][l][r] =
solve(msk, l, r - 1) + max(0, -(pos[r] - pos[r + 1] + H) + cstrl);
} else {
dp[msk][l][r] += 0.5 * p * (solve(msk & 2, l + 1, r) + cstll);
dp[msk][l][r] += 0.5 * p * (solve(msk & 1, l, r - 1) + cstrl);
dp[msk][l][r] += 0.5 * q * (solve(msk | 1, l + 1, r) + cstlr);
dp[msk][l][r] += 0.5 * q * (solve(msk | 2, l, r - 1) + cstrr);
}
return dp[msk][l][r];
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> H >> p;
q = 1 - p;
for (int i = 1; i <= N; i++) {
cin >> pos[i];
}
sort(pos + 1, pos + 1 + N);
pos[0] = -300000010;
pos[N + 1] = -pos[0];
for (int k = 0; k < 4; k++) {
for (int i = 1; i <= N; i++) {
for (int j = i; j <= N; j++) {
dp[k][i][j] = -1;
}
}
}
cout << setprecision(8) << solve(0, 1, N) << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<ld, ld>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<ld>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
str tout[4] = {"No", "Yes", "NO", "YES"};
const ll M18 = 1e18;
const int M9 = 1e9;
const int N = 1e5;
int main() {
int n;
cin >> n;
cout << 6 - n << "\n";
map<str, str> m;
m["purple"] = "Power";
m["green"] = "Time";
m["blue"] = "Space";
m["orange"] = "Soul";
m["red"] = "Reality";
m["yellow"] = "Mind";
for (int i = (0); i < (n); i++) {
str s;
cin >> s;
m[s] = "";
}
cout << m["purple"] << "\n";
cout << m["green"] << "\n";
cout << m["blue"] << "\n";
cout << m["orange"] << "\n";
cout << m["red"] << "\n";
cout << m["yellow"];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d;
long i, n, x, y, r1, r, coun;
cin >> r >> d;
cin >> n;
coun = 0;
for (i = 0; i < n; i++) {
cin >> x >> y >> r1;
if (x * x + y * y >= (r - d + r1) * (r - d + r1) &&
x * x + y * y <= (r - r1) * (r - r1) && 2 * r1 <= d)
coun++;
}
cout << coun << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
struct node {
int l, r, m, tg, s;
} t[N << 2];
inline void upd(int x) { t[x].s = t[x].tg ? 0 : t[x << 1].s + t[x << 1 | 1].s; }
inline void build(int i, int l, int r) {
t[i] = node{l, r, l + r >> 1, 0, r - l + 1};
if (l == r) return;
build(i << 1, l, t[i].m);
build(i << 1 | 1, t[i].m + 1, r);
}
void mdy(int i, int l, int r, int v) {
if (l <= t[i].l && t[i].r <= r) {
t[i].tg += v;
t[i].s = t[i].tg ? 0 : t[i].l == t[i].r ? 1 : t[i << 1].s + t[i << 1 | 1].s;
return;
}
if (l <= t[i].m) mdy(i << 1, l, r, v);
if (t[i].m < r) mdy(i << 1 | 1, l, r, v);
upd(i);
}
int n, a[N], i, p[N];
long long ans;
vector<int> ve[N];
inline void mdy(int x, int i, int v) {
if (p[x] < ve[x].size()) {
if (p[x] + 2 < ve[x].size()) {
int i1 = ve[x][p[x]], i2 = ve[x][p[x] + 2],
i3 = p[x] + 3 < ve[x].size() ? ve[x][p[x] + 3] : n + 1;
mdy(1, i1, i2 - 1, v);
if (i3 <= n) mdy(1, i3, n, v);
} else
mdy(1, ve[x][p[x]], n, v);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (i = 1; i <= n; ++i) cin >> a[i], ve[a[i]].push_back(i);
build(1, 1, n);
for (i = 1; i <= n; ++i) mdy(i, 1, 1);
for (i = 1; i <= n; ++i) {
ans += t[1].s, i < n ? mdy(a[i], i, -1), ++p[a[i]], mdy(a[i], i + 1, 1),
mdy(1, i, i, 1), 0 : 0;
cerr << i << ' ' << ans << endl;
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
namespace modular {
const int mod = 1000000007;
inline int add(int x, int y) { return x + y >= mod ? x + y - mod : x + y; }
inline int dec(int x, int y) { return x - y < 0 ? x - y + mod : x - y; }
inline int mul(int x, int y) { return 1ll * x * y % mod; }
} // namespace modular
using namespace modular;
inline int poww(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = mul(ans, a);
a = mul(a, a);
b >>= 1;
}
return ans;
}
const int inv2 = poww(2, mod - 2);
const int inv3 = poww(3, mod - 2);
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 << 1) + (x << 3) + (ch ^ '0');
ch = getchar();
}
return x * f;
}
int T;
int f(int a, int b, int c, int n) {
return add(add(mul(a, mul(n, n)), mul(b, n)), c);
}
int s(int n) { return (n / 3) + (n % 3); }
int t(int n) {
int nn = n / 3;
int res = f(mul(3, inv2), mul(5, inv2), 0, nn);
for (int i = nn * 3 + 1; i <= n; i++) res = add(res, s(i));
return res;
}
int a(int n) {
int nn = n / 3;
int res = mul(nn, f(mul(3, inv2), mul(9, inv2), 2, nn));
for (int i = nn * 3 + 1; i <= n; i++) res = add(res, t(i));
return res;
}
int b(int n) { return mul(n, f(inv2, 2, mul(3, inv2), n)); }
int c(int n) {
int nn = n / 2;
int res = mul(nn, f(1, mul(5, inv2), inv2, nn));
if (n & 1) res = add(res, t((3ll * n - 1) / 2));
return res;
}
int C1(int X, int Y) {
X = min(X, 2 * Y), Y = min(Y, 2 * X);
int mid = Y / 2;
if (mid < 3) mid = 2;
if (mid > X) mid = X;
return dec(add(dec(b(mid), b(2)), dec(a(X + Y), a(mid + Y))),
dec(c(X), c(2)));
}
int S1(int n) {
int opt = n % 4;
if (!opt) return mul(f(1, mod - 3, mod - 4, n), mul(inv2, inv2));
if (opt == 1) return mul(f(1, mod - 1, mod - 8, n), mul(inv2, inv2));
if (opt == 2) return mul(f(1, mod - 3, mod - 2, n), mul(inv2, inv2));
return mul(f(1, mod - 1, mod - 6, n), mul(inv2, inv2));
}
int d(int n) {
int nn = n / 4;
int res = mul(nn, f(mul(16, inv3), mod - 2, dec(0, mul(19, inv3)), nn));
for (int i = nn * 4 + 1; i <= n; i++) res = add(res, S1(i));
return res;
}
int S2(int n, int Y) {
int opt = n % 4;
if (!opt) return dec(add(mul(n / 2, Y - 1), (Y + 1) / 2), 1);
if (opt == 1) return dec(add(mul((n + 1) / 2, Y - 1), (Y + 1) / 2), 1);
if (opt == 2) return add(mul(n / 2, Y - 1), Y / 2);
return add(mul((n + 1) / 2, Y - 1), Y / 2);
}
int e(int n, int Y) {
int nn = n / 4;
int res = mul(dec(mul(4, Y), 4), add(mul(nn, nn), nn));
for (int i = nn * 4 + 1; i <= n; i++) res = add(res, S2(i, Y));
return res;
}
int C2(int X, int Y) {
if (2 * Y + 2 >= X) return dec(d(X), d(4));
return add(dec(d(2 * Y + 2), d(4)), dec(e(X, Y), e(2 * Y + 2, Y)));
}
int P(int X, int Y) {
if (X < 2 || Y < 2) return 0;
int ans = 0;
for (int i = 2; i <= min(4, Y); i++) ans += 6 - i;
ans = add(ans, C1(X, Y));
ans = add(ans, C2(X, Y));
ans = add(ans, C2(Y, X));
return ans;
}
int main() {
T = read();
while (T--) {
int x = read() - 1, y = read() - 1, n = read() - 1, m = read() - 1;
printf("%d\n",
dec(add(P(n, m), P(x - 1, y - 1)), add(P(x - 1, m), P(n, y - 1))));
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<int, int>, char> > A[4];
bool check(char x, int indx) {
if (x == 'Q') return 1;
if (x == 'R' && (indx == 0 || indx == 1)) return 1;
if (x == 'B' && (indx == 2 || indx == 3)) return 1;
return 0;
}
int main() {
int n;
cin >> n;
int x0, y0;
cin >> x0 >> y0;
for (int i = 0; i < n; i++) {
pair<pair<int, int>, char> cur;
cin >> cur.second >> cur.first.first >> cur.first.second;
if (cur.first.first == x0) A[0].push_back(cur);
if (cur.first.second == y0) A[1].push_back(cur);
if (cur.first.first - cur.first.second == x0 - y0) A[2].push_back(cur);
if (cur.first.first + cur.first.second == y0 + x0) A[3].push_back(cur);
}
for (int i = 0; i < 4; i++) {
A[i].push_back({{x0, y0}, 'Z'});
sort(A[i].begin(), A[i].end());
}
for (int j = 0; j < 4; j++) {
for (int i = 0; i < (int)A[j].size(); i++) {
if (A[j][i].second == 'Z') {
if (i - 1 >= 0 && check(A[j][i - 1].second, j)) {
cout << "YES" << endl;
return 0;
} else if (i + 1 < (int)A[j].size() && check(A[j][i + 1].second, j)) {
cout << "YES" << endl;
return 0;
}
}
}
}
cout << "NO" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dp[5010][5010];
int A[300010];
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> A[i];
sort(A, A + n);
dp[0][0] = 0;
int lsize = (n + k - 1) / k;
int ssize = lsize - 1;
int llim = n % k;
if (llim == 0) llim += k;
for (int l = 1; l <= llim; l++)
dp[l][0] =
dp[l - 1][0] + A[(l - 1) * lsize + lsize - 1] - A[(l - 1) * lsize];
for (int s = 1; s <= k - 1; s++)
dp[0][s] =
dp[0][s - 1] + A[(s - 1) * ssize + ssize - 1] - A[(s - 1) * ssize];
for (int l = 1; l <= llim; l++)
for (int s = 1; s <= k - 1; s++) {
int proc_l = (l - 1) * lsize + s * ssize;
int proc_s = l * lsize + (s - 1) * ssize;
dp[l][s] = min(dp[l - 1][s] + A[proc_l + lsize - 1] - A[proc_l],
dp[l][s - 1] + A[proc_s + ssize - 1] - A[proc_s]);
}
cout << dp[llim][(k - n % k) % k];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, gn1 = 0, gj1 = 0, gn2 = 0, gj2 = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x % 2 == 0)
gn1++;
else
gj1++;
}
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (x % 2 == 0)
gn2++;
else
gj2++;
}
cout << min(gj1, gn2) + min(gj2, gn1) << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<long long, long long> a[200007];
long long cnt[200007];
long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long gg[200007];
vector<vector<long long> > t;
vector<int> mod = {1000066153, 1000025129, 1000074059, 1000156673, 1000049989,
1000009573, 1000014761, 1000077497, 1000003577, 1000164709,
1000080127, 1000089919, 1000007479, 1000128629, 1000186501,
1000069099, 1000029619, 1000180079, 1000104887, 1000162081};
bool check(long long x1, long long y1, long long x2, long long y2) {
for (int i = 0; i < 5; i++) {
long long xx1 = x1 % mod[i];
long long xx2 = x2 % mod[i];
long long yy1 = y1 % mod[i];
long long yy2 = y2 % mod[i];
if (xx1 * (long long)yy2 % mod[i] != xx2 * (long long)yy1 % mod[i])
return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
set<long long> xx, yy;
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second >> cnt[i];
set<pair<long long, long long> > se;
for (int i = 0; i < n; i++) {
xx.insert(a[i].first);
yy.insert(a[i].second);
se.insert(a[i]);
}
if ((long long)xx.size() * (long long)yy.size() != n) cout << 0, exit(0);
for (long long first : xx)
for (long long second : yy)
if (se.find(make_pair(first, second)) == se.end()) cout << 0, exit(0);
if (xx.size() > yy.size()) {
for (int i = 0; i < n; i++) swap(a[i].first, a[i].second);
swap(xx, yy);
}
vector<long long> fy, fx;
for (long long second : yy) fy.push_back(second);
for (long long first : xx) fx.push_back(first);
t.resize(xx.size());
for (int i = 0; i < xx.size(); i++) t[i].resize(yy.size());
for (int i = 0; i < n; i++) {
int posy = lower_bound(fy.begin(), fy.end(), a[i].second) - fy.begin();
int posx = lower_bound(fx.begin(), fx.end(), a[i].first) - fx.begin();
t[posx][posy] = cnt[i];
}
long long tmp = t[0][0];
for (int j = 0; j < yy.size(); j++) tmp = gcd(tmp, t[0][j]);
for (int j = 0; j < yy.size(); j++) {
gg[j] = t[0][j];
for (int i = 0; i < xx.size(); i++) gg[j] = gcd(gg[j], t[i][j]);
}
for (int i = 1; i < xx.size(); i++) {
for (int j = 1; j < yy.size(); j++) {
if (!check(t[0][0], t[i][0], t[0][j], t[i][j])) cout << 0, exit(0);
}
}
int ans = 0;
for (long long i = 1; i * (long long)i <= tmp; i++)
if (tmp % i == 0) {
long long val = i;
int ok = 1;
for (int j = 0; j < yy.size(); j++) {
long long now = t[0][j] / val;
if (gg[j] % now != 0) {
ok = 0;
break;
}
}
ans += ok;
if (i * (long long)i != tmp) {
val = tmp / i;
int ok = 1;
for (int j = 0; j < yy.size(); j++) {
long long now = t[0][j] / val;
if (gg[j] % now != 0) {
ok = 0;
break;
}
}
ans += ok;
}
}
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, l;
int main() {
for (std::cin >> n >> k; n; n--) {
std::cin >> a;
b = 0;
while (a) {
if (a % 10 <= k) b |= 1 << a % 10;
a /= 10;
}
if (b + 1 == 2 << k) l++;
}
std::cout << l;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<int, int>, int> > aq;
bool aquecido(pair<int, int> coord, pair<pair<int, int>, int> ac) {
int xg = coord.first;
int yg = coord.second;
int xa = ac.first.first;
int ya = ac.first.second;
int r = ac.second;
if ((pow((xa - xg), 2) + (pow((ya - yg), 2))) <= pow(r, 2)) {
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int xa, ya, xb, yb;
cin >> xa >> ya >> xb >> yb;
int n, x, y, r;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y >> r;
aq.push_back(pair<pair<int, int>, int>(pair<int, int>(x, y), r));
}
pair<int, int> sd = pair<int, int>(max(xa, xb), max(ya, yb));
pair<int, int> se = pair<int, int>(min(xa, xb), max(ya, yb));
pair<int, int> id = pair<int, int>(max(xa, xb), min(ya, yb));
pair<int, int> ie = pair<int, int>(min(xa, xb), min(ya, yb));
vector<pair<int, int> > generais;
pair<int, int> atual = se;
while (true) {
generais.push_back(atual);
atual.first++;
if (atual.first == sd.first) {
break;
}
}
atual = sd;
while (true) {
generais.push_back(atual);
atual.second--;
if (atual.second == id.second) {
break;
}
}
atual = id;
while (true) {
generais.push_back(atual);
atual.first--;
if (atual.first == ie.first) {
break;
}
}
atual = ie;
while (true) {
generais.push_back(atual);
atual.second++;
if (atual.second == se.second) {
break;
}
}
int cont = 0;
for (pair<int, int> g : generais) {
bool ok = false;
for (pair<pair<int, int>, int> a : aq) {
if (aquecido(g, a)) {
ok = true;
break;
}
}
if (!ok) {
cont++;
}
}
cout << cont << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int m;
int x, y, ans;
int dx[5] = {0, 0, 1, -1};
int dy[5] = {1, -1, 0, 0};
int b[4][100005], dp[100005][(1 << 3)], nxt[100005];
char a[4][10005];
bool vis[1 << 4];
bool inside(int x, int y) {
if (0 <= x && x <= 2 && 1 <= y && y <= m) return 1;
return 0;
}
int init(int s) {
memset(nxt, 0, sizeof(nxt));
for (int i = 0; i <= 2; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == '.')
b[i][j] = 0;
else
b[i][j] = 1;
}
}
for (int i = 0; i < 4; i++) {
if (s & (1 << i)) {
int tx = x + dx[i] * 2;
int ty = y + dy[i] * 2;
if (inside(tx, ty) == 0)
s = s - (1 << i);
else if (b[x + dx[i]][y + dy[i]] == 1 ||
b[x + dx[i] * 2][y + dy[i] * 2] == 1)
s = s - (1 << i);
else {
for (int j = 1; j <= 2; j++) b[x + dx[i] * j][y + dy[i] * j] = 1;
}
}
}
for (int i = 1; i <= m; i++)
for (int j = 0; j <= 2; j++)
if (b[j][i]) nxt[i] = nxt[i] | (1 << j);
return s;
}
int solve() {
memset(dp, 0, sizeof(dp));
dp[1][nxt[1]] = 1;
if ((nxt[1] & (1 << 0)) == 0 && (nxt[1] & (1 << 1)) == 0)
dp[1][nxt[1] | (1 << 0) | (1 << 1)] = 1;
if ((nxt[1] & (1 << 1)) == 0 && (nxt[1] & (1 << 2)) == 0)
dp[1][nxt[1] | (1 << 1) | (1 << 2)] = 1;
for (int i = 2; i <= m; i++) {
for (int j = nxt[i - 1]; j < (1 << 3); j = (j + 1) | nxt[i - 1]) {
if ((j ^ 7) & nxt[i]) continue;
dp[i][(j ^ 7) | nxt[i]] = (dp[i][(j ^ 7) | nxt[i]] + dp[i - 1][j]) % mod;
}
if ((nxt[i] & (1 << 0)) == 0 && (nxt[i] & (1 << 1)) == 0) {
dp[i][3] = (dp[i][3] + dp[i][0]) % mod;
dp[i][7] = (dp[i][7] + dp[i][4]) % mod;
}
if ((nxt[i] & (1 << 1)) == 0 && (nxt[i] & (1 << 2)) == 0) {
dp[i][6] = (dp[i][6] + dp[i][0]) % mod;
dp[i][7] = (dp[i][7] + dp[i][1]) % mod;
}
}
return dp[m][7];
}
int count_two(int val) {
int ret = 0;
while (val) {
ret = ret + (val & 1);
val >>= 1;
}
return ret;
}
int main() {
cin >> m;
for (int i = 0; i <= 2; i++)
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == 'O') {
x = i;
y = j;
}
}
for (int i = 1; i < (1 << 4); i++) {
int now = init(i);
if (vis[now] || now == 0) continue;
ans = (ans + solve() * (count_two(now) % 2 ? 1 : -1)) % mod;
vis[now] = 1;
}
cout << (ans + mod) % mod;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int f[N], mem[N], sv[N];
int h[N];
inline int get(int p) {
if (f[p] == p) return p;
return get(f[p]);
}
inline void join(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return;
if (h[a] < h[b])
f[a] = b;
else
f[b] = a;
if (h[a] == h[b]) h[a]++;
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<bool> cur(m, 0);
vector<vector<int> > clr(2, vector<int>(m, 0));
int answer = 0;
int q = 1;
for (int i = 0; i < n; i++) {
string l;
cin >> l;
for (int j = 0; j < (m >> 2); j++) {
int x;
if ('0' <= l[j] && l[j] <= '9') {
x = l[j] - '0';
} else {
x = l[j] - 'A' + 10;
}
cur[(j << 2) | 0] = (x >> 3) & 1;
cur[(j << 2) | 1] = (x >> 2) & 1;
cur[(j << 2) | 2] = (x >> 1) & 1;
cur[(j << 2) | 3] = (x >> 0) & 1;
}
int cnt = 0;
for (int j = 0; j < m; j++) {
clr[q][j] = 0;
cnt = max(cnt, clr[q ^ 1][j]);
}
answer -= cnt;
for (int j = 0; j < m; j++) {
if (cur[j]) clr[q][j] = ++cnt;
mem[sv[j]] = 0;
}
for (int j = 1; j <= cnt; j++) {
f[j] = j;
h[j] = 1;
}
for (int j = 0; j < m; j++) {
if (clr[q][j]) {
if (j && clr[q][j - 1]) {
join(clr[q][j - 1], clr[q][j]);
}
if (j + 1 < m && clr[q][j + 1]) {
join(clr[q][j + 1], clr[q][j]);
}
if (clr[q ^ 1][j]) {
join(clr[q][j], clr[q ^ 1][j]);
}
}
if (clr[q ^ 1][j]) {
if (j && clr[q ^ 1][j - 1]) {
join(clr[q ^ 1][j - 1], clr[q ^ 1][j]);
}
if (j + 1 < m && clr[q ^ 1][j + 1]) {
join(clr[q ^ 1][j + 1], clr[q ^ 1][j]);
}
}
}
for (int j = 1; j <= cnt; j++) {
if (f[j] == j) answer++;
}
cnt = 0;
for (int j = 0; j < m; j++) {
if (clr[q][j]) clr[q][j] = get(clr[q][j]);
}
for (int j = 0; j < m; j++) {
if (!clr[q][j]) continue;
if (!mem[clr[q][j]]) mem[clr[q][j]] = ++cnt;
sv[j] = clr[q][j];
clr[q][j] = mem[clr[q][j]];
}
for (int j = 0; j < m; j++) {
mem[sv[j]] = 0;
}
q ^= 1;
}
cout << answer << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int n, sum = 0;
scanf("%d", &n);
sum += n / 100;
n %= 100;
sum += n / 20;
n %= 20;
sum += n / 10;
n %= 10;
sum += n / 5;
n %= 5;
sum += n / 1;
printf("%d\n", sum);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<long long, long long> p[100010];
bool used[100010];
inline pair<long long, long long> operator-(
const pair<long long, long long> &a, const pair<long long, long long> &b) {
return {a.first - b.first, a.second - b.second};
}
inline long long cross(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.first * 1ll * b.second - a.second * 1ll * b.first;
}
bool ok(pair<long long, long long> a, pair<long long, long long> b) {
memset(used, false, sizeof(used));
for (int i = 0; i < n; i++) {
if (cross(b - a, p[i] - a) == 0) {
used[i] = true;
}
}
int p1 = -1, p2 = -1;
for (int i = 0; i < n; i++) {
if (used[i]) continue;
if (p1 == -1) {
p1 = i;
} else if (p2 == -1) {
p2 = i;
}
}
if (p2 == -1) {
return true;
}
for (int i = 0; i < n; i++) {
if (used[i]) continue;
if (cross(p[p2] - p[p1], p[i] - p[p1]) != 0) {
return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << setprecision(3) << fixed;
if (fopen("ArturoTextD.txt", "r")) freopen("ArturoTextD.txt", "r", stdin);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i].first >> p[i].second;
}
if (n < 3) {
cout << "YES" << '\n';
return 0;
}
if (ok(p[0], p[1]) || ok(p[0], p[2]) || ok(p[1], p[2])) {
cout << "YES" << '\n';
return 0;
}
cout << "NO" << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
long long ans = LONG_LONG_MAX, x = 0;
for (int i = 0; i < n; i++) {
x = (b[i] - a[0]);
if (x < 0) x += m;
int j;
for (j = 1; j < n; j++)
if ((a[j] + x - b[(i + j) % n] + m) % m != 0) break;
if (j == n) ans = min(ans, x);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
int a[N], sum[N];
int main() {
int n, w;
scanf("%d%d", &n, &w);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
sort(sum + 1, sum + n + 1);
int x = sum[1], y = sum[n];
int minn = max(0, -x), maxx = min(w, w - y);
printf("%d\n", minn <= maxx ? maxx - minn + 1 : 0);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int pow1(long long int first, long long int n, long long int m) {
long long int result = 1;
while (n > 0) {
first %= m;
if (n % 2 == 1) result = (result * first) % m;
first = (first * first) % m;
n = n / 2;
}
return result;
}
long long int pow2(long long int first, long long int n) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * first);
first = (first * first);
n = n / 2;
}
return result;
}
long long int modInverse(long long int A, long long int M) {
return pow1(A, M - 2, M);
}
long long int f[1000001];
void fact() {
f[0] = f[1] = 1;
for (int i = 2; i <= 1e6; i++) f[i] = (f[i - 1] * i) % mod;
}
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
const int size = 1e6 + 1;
int minPrime[size + 1];
void pre() {
int n = size;
for (int i = 2; i * i <= n; ++i) {
if (minPrime[i] == 0) {
for (int j = i * i; j <= n; j += i) {
if (minPrime[j] == 0) {
minPrime[j] = i;
}
}
}
}
for (int i = 2; i <= n; ++i) {
if (minPrime[i] == 0) {
minPrime[i] = i;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
vector<long long int> ac;
for (int i = int(0); i < int(n); i++) {
cin >> a[i];
ac.push_back(a[i]);
}
sort(a, a + n);
long long int first = a[n - 1] * a[0];
long long int ans = first;
long long int d = 0;
vector<long long int> dc;
for (long long int i = 1; i * i <= first; i++) {
if (first % i == 0) d += 2;
if (i * i == first) d--;
if (i == 1 or first % i != 0)
continue;
else if (i * i == first)
dc.push_back(i);
else {
dc.push_back(i);
dc.push_back(first / i);
}
}
sort(ac.begin(), ac.end());
sort(dc.begin(), dc.end());
bool m = false;
if (ac == dc) m = true;
if (n != d - 2 or !m)
cout << "-1";
else
cout << ans;
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dp[400 + 5][400 + 5];
void init() {
memset(dp, 0, sizeof(dp));
dp[1][1] = dp[1][0] = 1;
for (int i = 2; i <= 400; i++)
for (int j = 0; j <= 400; j++)
for (int k = 0; k + j <= 400; k++) {
long long temp = (dp[i - 1][j] * dp[i - 1][k]) % 1000000007;
dp[i][j + k] = (dp[i][j + k] + temp) % 1000000007;
dp[i][j + k - 1] =
(dp[i][j + k - 1] + temp * (k + j) * (k + j - 1)) % 1000000007;
dp[i][j + k + 1] = (dp[i][j + k + 1] + temp) % 1000000007;
dp[i][j + k] = (dp[i][j + k] + (temp * (k + j) * 2)) % 1000000007;
}
}
int main() {
init();
int n;
while (~scanf("%d", &n)) {
printf("%lld\n", dp[n][1]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x, y;
cin >> n >> x >> y;
long long int a[n + 1];
a[1] = x;
for (int i = 2; i <= n; i++) {
if (i % 2 == 0) {
a[i] = min(a[i - 1] + x, a[i / 2] + y);
} else {
a[i] = min(a[i - 1] + x, a[(i + 1) / 2] + y + x);
}
}
cout << a[n] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
long long int n, m;
cin >> n >> m;
int arr[m][3];
for (int i = 0; i < m; i++) {
long long int a, b, c;
cin >> a >> b >> c;
arr[i][0] = a;
arr[i][1] = b;
arr[i][2] = c;
}
map<int, int> mp;
for (int i = 0; i < m; i++) {
int tc = 1, ta = 1, tb = 1;
;
long long int a = arr[i][0];
long long int b = arr[i][1];
long long int c = arr[i][2];
map<int, int> val;
val[1]++, val[2]++, val[3]++;
if (mp.find(a) != mp.end()) val.erase(mp[a]);
if (mp.find(b) != mp.end()) val.erase(mp[b]);
if (mp.find(c) != mp.end())
val.erase(mp[c]);
else {
}
if (mp.find(a) == mp.end()) {
auto it = val.begin();
mp[a] = it->first;
val.erase(it->first);
}
if (mp.find(b) == mp.end()) {
auto it = val.begin();
mp[b] = it->first;
val.erase(it->first);
}
if (mp.find(c) == mp.end()) {
auto it = val.begin();
mp[c] = it->first;
val.erase(it->first);
}
}
for (auto it : mp) cout << it.second << " ";
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int main() {
int n;
cin >> n;
vector<int> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
int max = 0;
if (n < 3) {
cout << n;
return 0;
}
for (long long j = 2; j < n; j++) {
int curr = 0;
while ((v[j] == v[j - 1] + v[j - 2]) && j < n) {
++j;
++curr;
}
max = (max > curr ? max : curr);
}
cout << max + 2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, c[9][9], a[9][9], ans = 0;
bool flag = 0;
int w[4][5][2] = {{{0, 0}, {0, 1}, {0, 2}, {1, 1}, {2, 1}},
{{0, 2}, {1, 0}, {1, 1}, {1, 2}, {2, 2}},
{{0, 1}, {1, 1}, {2, 0}, {2, 1}, {2, 2}},
{{0, 0}, {1, 0}, {1, 1}, {1, 2}, {2, 0}}};
bool ok(int x, int y, int i) {
for (int p = 0; p < 5; p++)
if (a[x + w[i][p][0]][y + w[i][p][1]]) return 0;
return 1;
}
void dfs(int x, int y, int num, int last) {
if ((n - x) * m - y <= (ans - num) * 6.9) return;
if (last <= x - 3) return;
if (y + 2 >= m) {
dfs(x + 1, 0, num, last);
return;
}
if (x + 2 >= n) {
if (num > ans) {
ans = num;
memcpy(c, a, sizeof(a));
}
return;
}
for (int i = 0; i < 4; i++)
if (ok(x, y, i)) {
num++;
for (int j = 0; j < 5; j++) a[x + w[i][j][0]][y + w[i][j][1]] = num;
dfs(x, y + 1, num, x);
num--;
for (int j = 0; j < 5; j++) a[x + w[i][j][0]][y + w[i][j][1]] = 0;
}
dfs(x, y + 1, num, last);
}
void print() {
cout << ans << endl;
if (!flag)
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
cout << (c[i][j] ? (char)(c[i][j] + 'A' - 1) : '.');
cout << endl;
}
else
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++)
cout << (c[j][i] ? (char)(c[j][i] + 'A' - 1) : '.');
cout << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
if (n < m) {
flag = 1;
swap(n, m);
}
dfs(0, 0, 0, 0);
print();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
static int a[23];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
static int dp[1 << 23];
dp[0] = 0;
dp[1] = 1;
vector<pair<int, int> > p[23];
for (int i = 0; i < n; ++i) {
for (int x = 0; x < i; ++x) {
for (int y = x; y < i; ++y) {
if (a[x] + a[y] == a[i]) {
p[i].push_back({x, y});
}
}
}
}
for (int mask = 1; mask < (1 << (n - 1)); ++mask) {
int x = -1;
for (int i = 0; i < n; ++i) {
if ((mask & (1 << i)) > 0) x = i;
}
x++;
for (auto pp : p[x]) {
int i = pp.first, j = pp.second;
if ((mask & (1 << i)) > 0 && (mask & (1 << j)) > 0) {
dp[mask | (1 << x)] = dp[mask] + 1;
for (int k = 0; k < x; ++k) {
if ((mask & (1 << k)) > 0) {
dp[(mask | (1 << x)) ^ (1 << k)] = dp[mask];
}
}
}
}
}
int ans = 100;
for (int i = (1 << (n - 1)); i < (1 << n); ++i) {
if (dp[i]) {
ans = min(ans, dp[i]);
}
}
if (ans == 100) ans = -1;
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 22;
int n, a, b, c, d, t0, t1, cnt;
char res[MAXN];
int f(int x) {
for (__typeof(1e5) i = (0) - ((0) > (1e5)); i != (1e5) - ((0) > (1e5));
i += 1 - 2 * ((0) > (1e5))) {
if (i * (i - 1) > 2 * x) {
cout << "Impossible";
exit(0);
}
if (i * (i - 1) == 2 * x) return i;
}
}
int main() {
cin >> a >> b >> c >> d;
t0 = f(a), t1 = f(d);
n = t0 + t1;
if (n == 0 && b == 0 && c == 0) return cout << "0" << endl, 0;
if (t0 == 0 || t1 == 0) {
if (c == 0 && b == 0)
22;
else
t0 += (t0 == 0), t1 += (t1 == 0);
}
n = t0 + t1;
if (t0 * t1 != b + c) return cout << "Impossible", 0;
while (c >= t0 && c > 0) {
c -= t0;
res[cnt++] = '1';
t1--;
}
if (c > 0) {
int r = t0 - c;
while (r--) res[cnt++] = '0', t0--;
res[cnt++] = '1';
t1--;
}
while (t0 > 0) {
res[cnt++] = '0';
t0--;
}
while (t1 > 0) {
res[cnt++] = '1';
t1--;
}
if (t1 == 0 && t0 == 0 && cnt == n) {
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
cout << res[i];
} else {
cout << "Impossible";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, sum = 0;
cin >> n;
long long int A[n][n], i, j;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) cin >> A[i][j];
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (i == j || i + j == n - 1) sum += A[i][j];
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (i == n / 2 || j == n / 2) sum += A[i][j];
sum -= A[n / 2][n / 2];
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
int t;
cin >> t;
while (t--) {
long long a, b, n, c = 0, d;
cin >> a >> b >> n;
if (a < b) swap(a, b);
while (a <= n) {
b += a;
c++;
swap(a, b);
}
cout << c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, b, w, x, y;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &b, &w);
x = 3;
y = 2;
if (b > w) {
swap(b, w);
x--;
}
if (w <= 3 * b + 1) {
printf("YES\n");
while (b >= 1) {
printf("%d %d\n", x, y);
printf("%d %d\n", x, y + 1);
y += 2;
b--;
w--;
}
if (w >= 1) {
printf("%d 1\n", x);
w--;
}
y = 2;
while (w >= 2) {
printf("%d %d\n", x - 1, y);
printf("%d %d\n", x + 1, y);
y += 2;
w -= 2;
}
if (w == 1) {
printf("%d %d\n", x - 1, y);
}
} else {
printf("NO\n");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc = 1;
cin >> tc;
while (tc--) {
string st;
cin >> st;
int r = 0, s = 0, p = 0, mx = 0;
for (int i = 0; i < st.size(); i++) {
if (st[i] == 'S') s++;
if (st[i] == 'P') p++;
if (st[i] == 'R') r++;
}
mx = max(max(s, p), r);
if (mx == s) {
for (int i = 0; i < st.size(); i++) cout << "R";
cout << endl;
continue;
}
if (mx == p) {
for (int i = 0; i < st.size(); i++) cout << "S";
cout << endl;
continue;
}
if (mx == r) {
for (int i = 0; i < st.size(); i++) cout << "P";
cout << endl;
continue;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int lsb(int val) { return val & ((val ^ (val - 1))); }
pair<int, pair<int, int> > a[600666];
int Arb[600666], SEG[600666], result[600666];
bool comp(pair<int, pair<int, int> > i1, pair<int, pair<int, int> > i2) {
return i1.second.second < i2.second.second;
}
int query(int pos) {
if (pos) return Arb[pos] + query(pos - lsb(pos));
return 0;
}
void update(int pos, int n) {
if (pos > n) return;
Arb[pos]++;
update(pos + lsb(pos), n);
}
int bs(int value, int n, int A[]) {
int left = 1, right = n + 1;
while (left < right - 1) {
int mid = (right + left) / 2;
if (A[mid] <= value)
left = mid;
else
right = mid;
}
return left;
}
int main() {
cin.sync_with_stdio(false);
int n, i, nr_seg = 0;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> a[i].second.first >> a[i].second.second;
a[i].first = i;
SEG[++nr_seg] = a[i].second.first;
SEG[++nr_seg] = a[i].second.second;
}
sort(SEG + 1, SEG + nr_seg + 1);
sort(a + 1, a + n + 1, comp);
for (i = 1; i <= n; ++i) {
a[i].second.first = bs(a[i].second.first, nr_seg, SEG);
a[i].second.second = bs(a[i].second.second, nr_seg, SEG);
}
for (i = 1; i <= n; ++i) {
result[a[i].first] = query(a[i].second.second) - query(a[i].second.first);
update(a[i].second.first, n * 2);
}
for (i = 1; i <= n; ++i) cout << result[i] << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 6;
vector<pair<int, int> > g[MAX], g1[MAX];
int p[MAX];
vector<int> calc[MAX];
vector<long long> pref[MAX];
void dfs(int v, int pr) {
p[v] = pr;
for (auto u : g[v])
if (u.first != pr) {
dfs(u.first, v);
g1[v].push_back(u);
}
}
int getW(int v, int u) {
for (auto z : g1[v])
if (z.first == u) return z.second;
}
long long get(int v, int h) {
int pos =
upper_bound((calc[v]).begin(), (calc[v]).end(), h) - calc[v].begin();
--pos;
if (pos == -1)
return 0;
else
return (long long)h * (pos + 1) - pref[v][pos];
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int(i) = (1); (i) < (n); ++i) {
int a = (i + 1) / 2;
int b = i + 1;
--a, --b;
int w;
cin >> w;
g[a].push_back(make_pair(b, w));
g[b].push_back(make_pair(a, w));
}
dfs(0, -1);
for (int(i) = (0); (i) < (n); ++i) {
int v = i, sum = 0;
calc[v].push_back(sum);
while (v != 0) {
sum += getW(p[v], v);
v = p[v];
calc[v].push_back(sum);
}
}
for (int(i) = (0); (i) < (n); ++i) {
sort((calc[i]).begin(), (calc[i]).end());
for (int(j) = (0); (j) < (((int)(calc[i]).size())); ++j)
if (j)
pref[i].push_back(pref[i].back() + calc[i][j]);
else
pref[i].push_back(calc[i][j]);
}
for (int(z) = (0); (z) < (m); ++z) {
int a, h;
cin >> a >> h;
--a;
long long ans = get(a, h);
int A = a, B = p[a];
while (B != -1) {
int cur = -1;
for (auto u : g1[B])
if (u.first != A) cur = u.first;
h -= getW(B, A);
if (h >= 0)
ans += h;
else
break;
if (cur != -1) ans += get(cur, h - getW(B, cur));
A = p[A];
B = p[B];
}
cout << ans << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int pc[1 << 10];
for (size_t i = 0; i < (1 << 10); i++) {
int buf = 0;
for (int j = 0; j < 10; j++) {
if ((1 << j) & i) buf++;
}
pc[i] = buf;
}
int n, m;
cin >> n >> m;
map<int, pair<unsigned long long, unsigned long long>> ans;
vector<int> v1(n);
vector<int> v2(m);
for (size_t i = 0; i < n; i++) {
cin >> v1[i];
v1[i] *= 2;
}
for (size_t i = 0; i < m; i++) {
cin >> v2[i];
v2[i] *= 2;
}
for (size_t i = 0; i < n; i++) {
for (size_t j = 0; j < m; j++) {
int buf = (v1[i] + v2[j]) / 2;
ans[buf].first |= (1ULL << i);
ans[buf].second |= (1ULL << j);
}
}
int ansv = 0;
for (auto i = ans.begin(); i != ans.end(); i++) {
for (auto j = i; j != ans.end(); j++) {
long long a1 = i->second.first;
long long a2 = j->second.first;
long long b1 = i->second.second;
long long b2 = j->second.second;
long long buf1 = a1 | a2;
long long buf2 = b1 | b2;
int buf = 0;
while (buf1) {
int buff = buf1 & 1023;
buf1 >>= 10;
buf += pc[buff];
}
while (buf2) {
int buff = buf2 & 1023;
buf2 >>= 10;
buf += pc[buff];
}
ansv = max(ansv, buf);
}
}
cout << ansv;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<string> depth[1500000];
int w, k = 0;
int a = 0;
struct Test {
string in;
int child;
} P[1500000];
void compute(int dep) {
w = max(w, dep);
while (a != k) {
int sz = 0;
depth[dep].push_back(P[a].in);
int ws = a;
while (P[ws].child != sz) {
a++;
sz++;
compute(dep + 1);
}
if (dep != 1) return;
a++;
}
return;
}
int main() {
string temp;
int n;
while (1) {
char t;
int num;
getline(cin, temp, ',');
scanf("%d", &num);
scanf("%c", &t);
P[k].in = temp;
P[k].child = num;
k++;
if (t == '\n') break;
}
compute(1);
printf("%d\n", w);
for (int a = 1; a <= w; a++) {
int sz = depth[a].size();
for (int b = 0; b < sz; b++) {
if (b != 0) printf(" ");
cout << depth[a][b];
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e15;
const long long MX = 500;
const long long INF2 = 1e9;
struct Hungarian {
long long matchRow[MX];
long long matchCol[MX];
long long assign(vector<vector<long long>> A) {
long long n = A.size();
long long m = A[0].size();
vector<long long> colAdd(m, 0);
vector<long long> rowAdd(n, 0);
fill(matchRow, matchRow + n, -1);
fill(matchCol, matchCol + m, -1);
for (long long i = 0; i < n; i++) {
vector<bool> forbidden(m, false);
vector<long long> parent(n, -1);
vector<long long> minVal(m, INF);
vector<long long> minPos(m, -1);
long long cur = i;
while (true) {
long long minCol = -1;
for (long long j = 0; j < m; j++) {
if (!forbidden[j]) {
long long val = A[cur][j] + rowAdd[cur] + colAdd[j];
if (val < minVal[j]) {
minVal[j] = val;
minPos[j] = cur;
}
if (minCol == -1 || minVal[j] < minVal[minCol]) {
minCol = j;
}
}
}
long long x = minVal[minCol];
for (long long j = 0; j < m; j++) {
if (forbidden[j]) {
colAdd[j] += x;
rowAdd[matchCol[j]] -= x;
} else {
minVal[j] -= x;
}
}
rowAdd[i] -= x;
if (matchCol[minCol] == -1) {
long long curRow = minPos[minCol];
long long oldMatch = matchRow[curRow];
matchCol[minCol] = curRow;
matchRow[curRow] = minCol;
while (curRow != i) {
curRow = parent[curRow];
long long assigned = oldMatch;
oldMatch = matchRow[curRow];
matchCol[assigned] = curRow;
matchRow[curRow] = assigned;
}
break;
} else {
forbidden[minCol] = true;
cur = matchCol[minCol];
parent[cur] = minPos[minCol];
}
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long j = matchRow[i];
if (j != -1) {
ans += A[i][j];
}
}
return ans;
}
} hg;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
string s;
cin >> s;
vector<long long> c(n);
long long ans = 0;
for (long long i = 0; i < (long long)n; i++) {
cin >> c[i];
ans += c[i];
}
vector<long long> problems;
vector<vector<long long>> noProblem;
for (int i = 0; i < n / 2; i++) {
if (s[i] == s[n - i - 1]) {
ans -= min(c[i], c[n - i - 1]);
problems.push_back(s[i] - 'a');
} else {
noProblem.push_back(
{min(c[i], c[n - i - 1]), s[i] - 'a', s[n - i - 1] - 'a'});
}
}
if (problems.empty()) {
cout << ans << "\n";
return 0;
}
sort(noProblem.begin(), noProblem.end());
long long best = INF;
for (int let = 0; let < 26; let++) {
vector<vector<long long>> A = vector<vector<long long>>(
2 * problems.size(), vector<long long>(2 * problems.size(), 0));
for (int i = 0; i < problems.size(); i++) {
for (long long j = 0; j < problems.size(); j++) {
if (problems[i] != let) {
A[i][j + problems.size()] = INF2;
} else {
A[i][j + problems.size()] = 1;
}
}
}
for (int i = 0; i < problems.size(); i++) {
for (long long j = 0; j < problems.size(); j++) {
if (i == j) {
A[i][j] = INF2;
continue;
}
if (problems[i] != problems[j]) {
A[i][j] = 0;
} else {
A[i][j] = INF2;
}
}
}
long long cnt = hg.assign(A);
if (cnt >= INF2) continue;
long long curCost = 0;
for (int i = 0; i < noProblem.size(); i++) {
if (cnt == 0) break;
if (noProblem[i][1] != let && noProblem[i][2] != let) {
cnt--;
curCost += noProblem[i][0];
}
}
if (cnt == 0) {
best = min(best, curCost);
}
}
ans -= best;
cout << ans << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:256000000")
long long qs(long long n) {
long long s = 0;
for (long long i = (n / 4) * 4; i <= n; i++) s ^= i;
return s;
}
long long f(long long i, long long n) {
long long q = n / i, p = n % i, s = 0;
if (q % 2 != 0) s = qs(i - 1);
s ^= qs(p);
return s;
}
int main() {
long long n, a, i, q = 0;
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d", &a);
q ^= a ^ f(i, n);
}
cout << q;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
int d[1 << 13];
int pv[1 << 13];
queue<int> q;
void bfs(int k, bool tp) {
memset(d, 0x3f, sizeof d);
if (tp) {
for (int i = 0; i < (signed)(1 << 5); i++) {
d[i] = 0;
q.push(i);
}
} else {
d[0] = 0;
q.push(0);
}
int mxd = 0;
while (!q.empty()) {
int cn = q.front();
q.pop();
for (int i = 0; i < (signed)(k); i++) {
for (int j = (1); j <= (signed)(k); j++) {
int a = i - j, b = i, c = i + j;
if (a < 0 || c >= k) continue;
int nn = cn;
nn ^= ((1 << a) + (1 << b) + (1 << c));
if (d[nn] == 0x3f3f3f3f) {
pv[nn] = cn;
d[nn] = d[cn] + 1;
mxd = d[nn];
q.push(nn);
}
}
}
}
}
vector<int> ree;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < (signed)(n); i++) {
cin >> a[i];
}
bfs(11, true);
int cur = n;
while (cur >= 11) {
int st = cur - 11;
int sm = 0;
for (int i = 0; i < (signed)(11); i++) {
if (a[st + i]) sm += (1 << i);
}
while (d[sm] != 0) {
int dif = sm ^ pv[sm];
for (int i = 0; i < (signed)(11); i++) {
if (dif & (1 << i)) {
ree.push_back(st + i + 1);
a[st + i] = 1 - a[st + i];
}
}
sm = pv[sm];
}
cur -= 6;
}
n = min(10, n);
bfs(n, false);
int sm = 0;
for (int i = 0; i < (signed)(n); i++) {
if (a[i]) sm += (1 << i);
}
if (d[sm] == 0x3f3f3f3f) {
cout << "NO\n";
} else {
cout << "YES\n";
while (sm != 0) {
int dif = sm ^ pv[sm];
for (int i = 0; i < (signed)(n); i++) {
if (dif & (1 << i)) {
ree.push_back(i + 1);
}
}
sm = pv[sm];
}
cout << ree.size() / 3 << "\n";
for (int i = 0; i < (signed)(ree.size()); i++) {
cout << ree[i] << " ";
if (i % 3 == 2) cout << "\n";
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300 + 5;
const int MBIT = 15 + 5;
const int INF = 0x3f3f3f3f;
int n, m, MT, dp[MBIT][MAXN][MAXN];
int ans[2][MAXN][MAXN];
inline void umax(int& a, const int& b) { a = max(a, b); }
void init() {
MT = (int)floor(log2((long double)n));
for (int s = 0; s <= MT; s++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[s][i][j] = -INF;
}
dp[s][i][i] = 0;
}
}
}
void clr(int z) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
ans[z][i][j] = -INF;
}
ans[z][i][i] = 0;
}
}
bool check(int step) {
int z = 0;
clr(z);
for (int s = 0; s <= MT; s++) {
if (((step >> s) & 1) == 0) continue;
z ^= 1;
clr(z);
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
umax(ans[z][i][j], ans[z ^ 1][i][k] + dp[s][k][j]);
}
}
}
}
for (int i = 1; i <= n; i++) {
if (ans[z][i][i] > 0) return true;
}
return false;
}
int main() {
int u, v, a, b;
while (~scanf("%d %d", &n, &m)) {
init();
for (int i = 1; i <= m; i++) {
scanf("%d %d %d %d", &u, &v, &a, &b);
dp[0][u][v] = a, dp[0][v][u] = b;
}
for (int s = 1; s <= MT; s++) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
if (dp[s - 1][i][k] == -INF) continue;
for (int j = 1; j <= n; j++) {
umax(dp[s][i][j], dp[s - 1][i][k] + dp[s - 1][k][j]);
}
}
}
}
int lb = 2, ub = n + 1, mid;
while (lb <= ub) {
mid = (lb + ub) >> 1;
if (check(mid))
ub = mid - 1;
else
lb = mid + 1;
}
if (lb >= n + 1) lb = 0;
printf("%d\n", lb);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long t;
int a[1000000], i, j, k, n, m, x, y, z;
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) scanf("%d", a + i);
int l = 1;
int r = 2 * 2e9;
while (l < r) {
int mid = ((long long)l + r) / 2;
if (l == mid) mid++;
t = 0;
for (i = 1; i <= n; i++) t += max(0, mid - a[i]);
if (t <= k)
l = mid;
else
r = mid - 1;
}
t = k;
for (i = 1; i <= n; i++) {
t -= max(0, l - a[i]);
a[i] = max(a[i], l);
}
for (i = 1; i <= n; i++)
if (a[i] == l and t) {
t--;
a[i]++;
}
l = 1, r = 2 * 2e9;
while (l < r) {
int mid = ((long long)l + r) / 2;
t = 0;
for (i = 1; i <= n; i++) t += max(0, a[i] - mid);
if (t <= k)
r = mid;
else
l = mid + 1;
}
t = k;
for (i = 1; i <= n; i++) {
t -= max(0, a[i] - l);
a[i] = min(a[i], l);
}
for (i = 1; i <= n; i++)
if (a[i] == l and t) {
t--;
a[i]--;
}
cout << *max_element(a + 1, a + 1 + n) - *min_element(a + 1, a + 1 + n)
<< endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
pair<long long int, long long int> s4[4] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
pair<long long int, long long int> s8[8] = {
{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, 1}, {1, 0}, {1, -1}};
void judge() {}
void solve() {
long long int t;
cin >> t;
while (t--) {
long long int a, b;
cin >> a >> b;
string s;
cin >> s;
long long int ans = a;
int n = s.size();
int x = -1, y = -1;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
x = i;
break;
}
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '1') {
y = i;
break;
}
}
if (x == y && x == -1) {
cout << 0 << '\n';
continue;
}
for (int i = x; i <= y; i++) {
int zero = 0;
while (s[i] == '0') {
zero++;
i++;
}
ans += min(a, b * zero);
}
cout << ans << '\n';
}
}
signed main() {
judge();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, cnt = 0;
scanf("%d %d", &n, &m);
int a[n];
int b[m];
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
for (int i = 0, j = 0; i < n; i++) {
while (b[j] < a[i] && j < m) {
j++;
}
if (j >= m) cnt++;
j++;
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<long long int, int> trains[3 * 100005];
bool used[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m, h, k;
cin >> n >> h >> m >> k;
for (int i = 0; i < n; i++) {
int temp;
long long int val;
cin >> temp >> val;
trains[3 * i].second = i;
trains[3 * i + 1].second = i;
trains[3 * i + 2].second = i;
val %= m / 2;
trains[3 * i].first = val;
trains[3 * i + 1].first = val - (m / 2);
trains[3 * i + 2].first = val + (m / 2);
}
sort(trains, trains + 3 * n);
int debut = 0;
while (trains[debut].first < -k) debut++;
int fin = debut;
int best = INT_MAX;
set<int> compte;
for (; trains[debut].first < (m / 2) - k; debut++) {
while (trains[fin].first - trains[debut].first < k) {
compte.insert(trains[fin].second);
fin++;
}
compte.erase(trains[debut].second);
best = min<int>(best, compte.size());
}
cout << best << ' ';
debut = 0;
while (trains[debut].first < -k) debut++;
fin = debut;
compte.clear();
for (; trains[debut].first < (m / 2) - k; debut++) {
while (trains[fin].first - trains[debut].first < k) {
compte.insert(trains[fin].second);
fin++;
}
compte.erase(trains[debut].second);
if (compte.size() == best) {
cout << (trains[debut].first + k) << '\n';
for (int val : compte) {
cout << (val + 1) << ' ';
}
cout << '\n';
return 0;
}
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.