solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
string Input;
bool judgeResult[8][5];
void solve() {
int j, k, len;
string tmp;
len = Input.size();
tmp = "";
for (int i = 0; i < 5 - len; i++) {
tmp += "0";
}
Input = tmp + Input;
len = Input.size();
//cout << Input << endl;
for (int i = len - 1; i > -1; i--) {
//cout << Input[i] << endl;
if (Input[i] > '4') {
judgeResult[1][i] = true;
k = Input[i] - '0' - 5;
}
else {
judgeResult[0][i] = true;
k = Input[i] - '0';
}
for (j = 0; j < k; j++) {
judgeResult[3+j][i] = true;
}
for (int t = 4 + j; t < 8; t++) {
judgeResult[t][i] = true;
}
}
}
int main() {
bool flag = false;
while (cin >> Input) {
if (flag) {
cout << endl;
}
flag = true;
memset(judgeResult, false, sizeof(judgeResult));
solve();
for (int i = 0; i < 8; i++) {
if (i == 2) {
cout << "=====" << endl;
continue;
}
for (int j = 0; j < 5; j++) {
cout << (judgeResult[i][j] ? "*" : " ");
}
cout << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void Add(string &s, int i) {
string tmp1 = "";
string tmp2 = "";
for (int k = 0; k <= i + 1; k++) tmp1 += s[k];
if (i == s.length() - 2)
s = tmp1;
else {
for (int k = i + 2; k < s.length(); k++) tmp2 += s[k];
s = tmp1 + ',' + tmp2;
}
}
void Sub(string &s) {
string tmp1 = "";
string tmp2 = "";
for (int i = s.length() - 1; i >= 0; i--) {
if (s[i] == ',') {
for (int j = 0; j < i; j++) tmp1 += s[j];
for (int j = i + 1; j < s.length(); j++) tmp2 += s[j];
s = tmp1 + tmp2;
break;
}
}
}
int main() {
string s;
while (cin >> s) {
int length = s.length();
int dem(0), count(0);
if (s[0] == '@' || s[length - 1] == '@')
cout << "No solution" << endl;
else {
for (int i = 0; i < length; i++) {
if (s[i] == '@') {
if (s[i + 1] == '@') {
dem = 1;
break;
}
Add(s, i);
length = s.length();
count = 1;
}
}
int count1(0), count2(0);
length = s.length();
for (int i = 0; i < length; i++) {
if (s[i] == ',') {
if (s[i + 1] == '@') {
count1 = -1;
dem = 1;
break;
} else
count1++;
}
if (s[i] == '@') count2++;
}
if (count1 == count2) Sub(s);
if (dem || !count)
cout << "No solution" << endl;
else
cout << s << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void FIO() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
inline int D() {
int t;
scanf("%d", &t);
return t;
}
inline long long LLD() {
long long t;
scanf("%lld", &t);
return t;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long power(long long x, long long p, long long m) {
long long res = 1;
while (p) {
if (p & 1) res = (res * x) % m;
x = ((x % m) * (x % m)) % m;
p >>= 1ll;
}
return res;
}
long double ModLog(long double base, long double x) {
return (logl(x) / logl(base));
}
const int N = 1e6 + 5;
int main() {
int t = D();
while (t--) {
int n0 = D(), n1 = D(), n2 = D();
if (!n1) {
printf("%s\n", string(n0 ? n0 + 1 : n2 + 1, n0 ? '0' : '1').c_str());
continue;
}
string s = "";
for (int i = 0; i < n1; ++i) s.push_back(!(i & 1) ? '1' : '0');
if (n1 & 1) {
for (int i = 0; i < n2; ++i) s.push_back('1');
for (int i = 0; i < n0 + 1; ++i) s.push_back('0');
} else {
for (int i = 0; i < n0; ++i) s.push_back('0');
for (int i = 0; i < n2 + 1; ++i) s.push_back('1');
}
puts(s.c_str());
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long b, long long p, long long md) {
if (p == 0) return 1;
if (p % 2 == 1) {
return ((b % md) * bigmod(b, p - 1, md)) % md;
} else {
long long y = bigmod(b, p / 2, md);
return (y * y) % md;
}
}
int main() {
long long k, a, b;
cin >> k >> a >> b;
if (a + b < k) {
cout << "-1" << endl;
return 0;
}
long long aa = max(a, b);
long long bb = min(a, b);
long long p = aa / k;
long long q = bb / k;
long long rem1 = aa % k;
if (rem1 > (q * (k - 1))) {
cout << "-1" << endl;
return 0;
}
long long rem2 = bb % k;
if (rem2 > (p * (k - 1))) {
cout << "-1" << endl;
return 0;
}
cout << p + q << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> count_white(long long int n,
long long int m) {
return {(long long int)(ceil((n * m) / 2.)),
(long long int)(floor((n * m) / 2.))};
}
pair<long long int, long long int> count_black(long long int n,
long long int m) {
return {(long long int)(floor((n * m) / 2.)),
(long long int)(ceil((n * m) / 2.))};
}
pair<pair<long long int, long long int>, pair<long long int, long long int>>
intersec(long long int ax, long long int ay, long long int bx, long long int by,
long long int cx, long long int cy, long long int dx,
long long int dy) {
long long int x = min(bx, dx) - max(ax, cx);
long long int y = min(by, dy) - max(ay, cy);
if (x < 0 || y < 0)
return {{-1, -1}, {-1, -1}};
else
return {{max(ax, cx), max(ay, cy)}, {min(bx, dx), min(by, dy)}};
}
int main() {
long long int q;
cin >> q;
for (long long int i = 0; i < q; ++i) {
long long int n, m;
cin >> n >> m;
long long int ax, ay, bx, by, cx, cy, dx, dy;
cin >> ax >> ay >> bx >> by >> cx >> cy >> dx >> dy;
long long int w = count_white(n, m).first;
long long int b = count_white(n, m).second;
if ((ax % 2 + ay % 2) % 2) {
b -= count_black(by - ay + 1, bx - ax + 1).second;
w += count_black(by - ay + 1, bx - ax + 1).second;
} else {
b -= count_white(by - ay + 1, bx - ax + 1).second;
w += count_white(by - ay + 1, bx - ax + 1).second;
}
pair<pair<long long int, long long int>, pair<long long int, long long int>>
itr = intersec(ax, ay, bx, by, cx, cy, dx, dy);
if (itr.first.first != -1) {
if ((itr.first.first % 2 + itr.first.second % 2) % 2) {
w -= count_black(itr.second.second - itr.first.second + 1,
itr.second.first - itr.first.first + 1)
.second;
b += count_black(itr.second.second - itr.first.second + 1,
itr.second.first - itr.first.first + 1)
.second;
} else {
w -= count_white(itr.second.second - itr.first.second + 1,
itr.second.first - itr.first.first + 1)
.second;
b += count_white(itr.second.second - itr.first.second + 1,
itr.second.first - itr.first.first + 1)
.second;
}
}
if ((cx % 2 + cy % 2) % 2) {
w -= count_black(dy - cy + 1, dx - cx + 1).first;
b += count_black(dy - cy + 1, dx - cx + 1).first;
} else {
w -= count_white(dy - cy + 1, dx - cx + 1).first;
b += count_white(dy - cy + 1, dx - cx + 1).first;
}
cout << w << " " << b << endl;
}
}
| 3 |
#include<cstdio>
#include<algorithm>
using namespace std;
int n;
long long c,ans,sum[1000005],val[1000005],v[1000005],id[1000005];
void calc(){
for (int i=n; i>=1; i--){
sum[i]=sum[i+1]+v[i];
val[i]=sum[i]-(c-id[i]);
}
for (int i=n; i>=1; i--)
val[i]=max(val[i],val[i+1]);
long long ss=0;
for (int i=1; i<=n; i++){
ss+=v[i];
ans=max(ans,ss-id[i]);
ans=max(ans,ss-id[i]*2+val[i+1]);
}
}
int main(){
scanf("%d%lld",&n,&c);
for (int i=1; i<=n; i++)
scanf("%lld%lld",&id[i],&v[i]);
calc();
for (int i=1; i<=n; i++) id[i]=c-id[i];
for (int i=1; i<=n/2; i++){
swap(id[i],id[n-i+1]);
swap(v[i],v[n-i+1]);
}
calc();
printf("%lld\n",ans);
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
bool judge(string s, bool head)
{
if (s.empty()) return true;
char c = s[0];
bool ff = true, fff = true, ffff = true;
string ss = s, sss = s, ssss = s;
for (int i = 0; i < 3; i++){
if (ss.find(c) == -1){ ff = false; break; }
ss.erase(ss.find(c), 1);
}
if (ff) ff = judge(ss, head);
for (int i = 0; i < 3; i++){
if (sss.find(c+i) == -1){ fff = false; break; }
sss.erase(sss.find(c+i), 1);
}
if (fff) fff = judge(sss, head);
if (!head){
for (int i = 0; i < 2; i++){
if (ssss.find(c) == -1){ ffff = false; break; }
ssss.erase(ssss.find(c), 1);
}
if (ffff) ffff = judge(ssss, true);
}
else ffff = false;
return ff || fff || ffff;
}
int main(void)
{
string s;
while (cin >> s){
bool flag = false;
vector <int> v;
for (char c = '1'; c <= '9'; c++){
string ss = s;
ss += c;
if (static_cast <int> (count(ss.begin(), ss.end(), c)) > 4) continue;
sort(ss.begin(), ss.end());
if (judge(ss, false))
{
v.push_back(c - '0');
flag = true;
}
}
if (!flag) cout << "0" << endl;
else {
for (int i = 0; i < v.size(); i++){
cout << v[i];
if (i+1==v.size()) puts("");
else cout << " ";
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 4000000 + 10;
int N, M, nxt[N_MAX], pre[N_MAX];
long long a[N_MAX];
namespace Ninit {
void init() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; ++i) scanf("%I64d", &a[i]);
}
} // namespace Ninit
namespace Nwork {
long long A[N_MAX];
int tmp, num, used[N_MAX], vis[N_MAX];
void prepare() {
num = 0;
memset(nxt, 0, sizeof(nxt));
memset(pre, 0, sizeof(pre));
for (int i = 2; i <= N; ++i)
if (a[i] != a[i - 1]) {
A[++num] = a[i] - a[i - 1];
if (num > 1 && ((A[num] > 0) == (A[num - 1] > 0))) {
--num;
A[num] += A[num + 1];
}
if (num < 2 && A[num] <= 0) --num;
}
while (num > 0 && A[num] < 0) --num;
for (int i = 1; i <= num; ++i) {
nxt[i - 1] = i;
pre[i] = i - 1;
}
nxt[num] = 0;
pre[0] = num;
A[0] = 0;
}
pair<long long, int> t[N_MAX], val;
queue<int> Q;
void add(int x) {
if (!vis[x] && pair<long long, int>(abs(A[x]), x) <= val) {
vis[x] = 1;
Q.push(x);
}
}
long long abs(long long x) { return x < 0 ? -x : x; }
void merge(int x) {
if (used[x]) return;
int L = pre[x], R = nxt[x];
if (L > 0 && abs(A[x]) > abs(A[L])) return;
if (R > 0 && abs(A[x]) > abs(A[R])) return;
if (L > 0)
pre[x] = pre[L];
else
pre[x] = 0;
if (R > 0)
nxt[x] = nxt[R];
else
nxt[x] = 0;
nxt[pre[x]] = x;
pre[nxt[x]] = x;
used[L] = 1;
used[R] = 1;
A[x] += A[L] + A[R];
if (L == 0) {
nxt[0] = nxt[R];
pre[nxt[R]] = 0;
used[x] = 1;
}
if (R == 0) {
pre[0] = pre[L];
nxt[pre[L]] = 0;
used[x] = 1;
}
if (pre[x] > 0) add(pre[x]);
if (nxt[x] > 0) add(nxt[x]);
add(x);
}
void solve() {
memset(used, 0, sizeof(used));
memset(vis, 0, sizeof(vis));
for (;;) {
tmp = 0;
for (int i = nxt[0]; i; i = nxt[i])
if (!used[i]) t[++tmp] = pair<long long, int>(abs(A[i]), i);
if (tmp <= M * 2) break;
int del = (tmp - M * 2 + 1) / 2;
nth_element(t + 1, t + del, t + tmp + 1);
val = t[del];
while (!Q.empty()) Q.pop();
for (int i = nxt[0]; i; i = nxt[i]) add(i);
while (!Q.empty()) {
int top = Q.front();
Q.pop();
vis[top] = 0;
merge(top);
}
}
long long ret = 0LL;
for (int i = nxt[0]; i; i = nxt[i])
if (A[i] > 0) ret += A[i];
printf("%I64d\n", ret);
}
void main() {
prepare();
solve();
}
} // namespace Nwork
int main() {
Ninit::init();
Nwork::main();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 200;
int n, a[maxn], l[maxn], r[maxn];
vector<int> ans;
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = (1); i <= (n); ++i) scanf("%d", &a[i]);
for (int i = (1); i <= (n); ++i) {
int cur = i;
while (cur > 1 && a[cur - 1] % a[i] == 0) cur = l[cur - 1];
l[i] = cur;
}
for (int i = (n); i >= (1); --i) {
int cur = i;
while (cur < n && a[cur + 1] % a[i] == 0) cur = r[cur + 1];
r[i] = cur;
}
int Ans = 0;
ans.clear();
for (int i = (1); i <= (n); ++i) Ans = max(Ans, r[i] - l[i]);
for (int i = (1); i <= (n); ++i)
if (Ans == r[i] - l[i]) ans.push_back(l[i]);
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
printf("%d %d\n", ans.size(), Ans);
for (int i = (0); i <= (ans.size() - 1); ++i) printf("%d ", ans[i]);
putchar('\n');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long int, vector<long long int>, greater<long long int> >
ti;
vector<long long int> p[200005], y[300005], f(2000005, 0);
long long int vis[100005], b[100005];
map<pair<long long int, long long int>, long long int> mp;
set<pair<long long int, long long int> > s;
set<long long int> st;
map<long long int, long long int> np, v;
queue<long long int> qy;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int bpow(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % 998244353;
a = (a * a) % 998244353;
b >>= 1;
}
return res % 998244353;
}
void fact(long long int i) {
f[0] = 1;
for (long long int k = 1; k <= i; k++) {
(f[k] = f[k - 1] * k) %= 998244353;
}
}
long long int isprime(long long int n) {
if (n == 1) return 0;
for (long long int i = 2; i <= sqrt(n); i++)
if (n % i == 0) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int x, y;
fact(n);
for (long long int i = 0; i < n - 1; i++) {
cin >> x >> y;
p[x].push_back(y);
p[y].push_back(x);
}
long long int root = 1;
long long int ans = 1;
for (long long int i = 1; i <= n; i++) {
(ans *= f[p[i].size()]) %= 998244353;
}
(ans *= n) %= 998244353;
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, c;
string s;
string ss = "ogo";
cin >> n;
cin >> s;
c = 0;
for (i = 0; i < n; i++) {
if (s.substr(i, 3) == ss) {
c++;
i++;
} else {
if (c > 0) {
cout << "***";
c = 0;
} else {
cout << s[i];
}
}
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <int m>
struct modint {
unsigned x;
modint() : x(0) {}
modint(long long arg) {
arg %= m;
if (arg < 0) {
x = arg + m;
} else {
x = arg;
}
}
modint& operator+=(const modint& other) {
x += other.x;
if (x >= m) {
x -= m;
}
return *this;
}
modint& operator*=(const modint& other) {
x = (x * 1ull * other.x) % m;
return *this;
}
modint& operator-=(const modint& other) {
x += m - other.x;
if (x >= m) {
x -= m;
}
return *this;
}
modint operator+(const modint& other) const {
modint tmp = *this;
tmp += other;
return tmp;
}
modint operator-(const modint& other) const {
modint tmp = *this;
tmp -= other;
return tmp;
}
modint operator*(const modint& other) const {
modint tmp = *this;
tmp *= other;
return tmp;
}
explicit operator int() const { return x; }
modint& operator++() {
++x;
if (x == m) {
x = 0;
}
return *this;
}
modint& operator--() {
if (x == 0) {
x = m - 1;
} else {
--x;
}
return *this;
}
modint operator++(int) {
modint tmp = *this;
++*this;
return tmp;
}
modint operator--(int) {
modint tmp = *this;
--*this;
return tmp;
}
bool operator==(const modint& other) const { return x == other.x; }
bool operator!=(const modint& other) const { return x != other.x; }
template <class T>
modint operator^(T arg) const {
if (arg == 0) {
return 1;
}
if (arg == 1) {
return x;
}
auto t = *this ^ (arg >> 1);
t *= t;
if (arg & 1) {
t *= *this;
}
return t;
}
template <class T>
modint operator^=(T arg) {
return *this = *this ^ arg;
}
modint inv() const { return *this ^ (m - 2); }
};
const int MOD = 1985561387;
const int B = 543751;
int n;
string s;
modint<MOD> h[200005], p[200005];
int z[200005], f[200005];
modint<MOD> hg(int x, int y) { return h[y] - h[x] * p[z[y] - z[x]]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n >> s;
p[0] = 1;
for (int i = 0; i < n; i++) p[i + 1] = p[i] * B;
int last = -1;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
z[i + 1] = z[i] + 1;
h[i + 1] = h[i] * B + ((i - last) % 2 ? 1 : -1);
last = i;
} else {
z[i + 1] = z[i];
h[i + 1] = h[i];
}
}
for (int i = n - 1; i >= 0; i--) f[i] = s[i] == '0' ? 0 : f[i + 1] + 1;
int q;
cin >> q;
while (q--) {
int a, b, l;
cin >> a >> b >> l;
a--, b--;
bool ok = false;
int d0 = f[a];
int d1 = f[b];
if (z[a + l] == z[a] && z[b + l] == z[b]) {
ok = true;
} else if (z[a + l] - z[a] == z[b + l] - z[b] && d0 % 2 == d1 % 2) {
modint<MOD> h1 = hg(a + f[a] + 1, a + l);
modint<MOD> h2 = hg(b + f[b] + 1, b + l);
ok = h1 == h2;
}
cout << (ok ? "Yes\n" : "No\n");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
scanf("%lld", &n);
scanf("%lld", &k);
long long ans[n];
vector<pair<long long, pair<long long, long long>>> v(n);
for (long long i = 0; i < n; i++) {
long long x;
scanf("%lld", &x);
v[i].first = x;
}
for (long long i = 0; i < n; i++) {
long long x;
scanf("%lld", &x);
v[i].second.first = x;
v[i].second.second = i;
}
if (k == 0) {
for (long long i = 0; i < n; i++) printf("%lld ", v[i].second.first);
puts("");
exit(0);
}
sort(v.begin(), v.end());
long long sum = 0;
priority_queue<long long, vector<long long>, greater<long long>> pq;
for (long long i = 0; i < n; i++) {
if ((long long)pq.size() == k) {
long long val = pq.top();
if (v[i].second.first > val) {
ans[v[i].second.second] = sum + v[i].second.first;
pq.pop();
sum -= val;
sum += v[i].second.first;
pq.push(v[i].second.first);
} else {
ans[v[i].second.second] = sum + v[i].second.first;
}
} else {
ans[v[i].second.second] = sum + v[i].second.first;
sum += v[i].second.first;
pq.push(v[i].second.first);
}
}
for (long long i = 0; i < n; i++) printf("%lld ", ans[i]);
puts("");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100;
const int mod = 1e9 + 7;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int n, m, D[maxn][maxn], DD[maxn][maxn];
pair<int, int> st, e;
vector<string> grid;
bool valid(int first, int second) {
return first >= 0 && first < n && second >= 0 && second < m &&
grid[first][second] != 'T';
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
grid.push_back(s);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (grid[i][j] == 'S') st = pair<int, int>(i, j);
if (grid[i][j] == 'E') e = pair<int, int>(i, j);
}
queue<pair<int, int> > Q;
Q.push(st);
memset(D, 127, sizeof D);
D[st.first][st.second] = 0;
while ((int)Q.size()) {
pair<int, int> v = Q.front();
Q.pop();
for (int i = 0; i < 4; i++) {
int nx = v.first + dx[i], ny = v.second + dy[i];
if (!valid(nx, ny)) continue;
if (D[nx][ny] > D[v.first][v.second] + 1)
D[nx][ny] = D[v.first][v.second] + 1, Q.push(pair<int, int>(nx, ny));
}
}
int dist = D[e.first][e.second];
memset(DD, 127, sizeof DD);
Q.push(e);
DD[e.first][e.second] = 0;
while ((int)Q.size()) {
pair<int, int> v = Q.front();
Q.pop();
for (int i = 0; i < 4; i++) {
int nx = v.first + dx[i], ny = v.second + dy[i];
if (!valid(nx, ny)) continue;
if (DD[nx][ny] > DD[v.first][v.second] + 1 &&
DD[v.first][v.second] < dist)
DD[nx][ny] = DD[v.first][v.second] + 1, Q.push(pair<int, int>(nx, ny));
}
}
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (grid[i][j] >= '0' && grid[i][j] <= '9' && DD[i][j] < mod)
ans += grid[i][j] - '0';
}
cout << ans << "\n";
return 0;
}
| 2 |
#include<cstdio>
#include<vector>
#include<queue>
#include<string>
#include<algorithm>
#include<functional>
#include<map>
#include<cstring>
#include<iostream>
using namespace std;
typedef pair<int,int> P;
typedef pair<int,P> PP;
int fie[21][21];
int dp[21][21][1<<10];
int w,h;
int rx,ry;
int sx[4]={1,0,-1,0};
int sy[4]={0,1,0,-1};
int dcnt;
int bfs(){
queue<PP> que;
memset(dp,-1,sizeof(dp));
dp[rx][ry][0]=0;
que.push(PP(0,P(rx,ry)));
while(que.size()){
PP q=que.front();
que.pop();
int x=q.second.first,y=q.second.second,bit=q.first;
if(bit==(1<<dcnt)-1)return dp[x][y][bit];
for(int i=0;i<4;i++){
int nx=x+sx[i],ny=y+sy[i];
if(nx>=0 && nx<w && ny>=0 && ny<h){
if(fie[nx][ny]==0 && dp[nx][ny][bit]==-1){
dp[nx][ny][bit]=dp[x][y][bit]+1;
que.push(PP(bit,P(nx,ny)));
}
if(fie[nx][ny]>0){
int nbit=bit|(1<<(fie[nx][ny]-1));
if(dp[nx][ny][nbit]==-1){
dp[nx][ny][nbit]=dp[x][y][bit]+1;
que.push(PP(nbit,P(nx,ny)));
}
}
}
}
}
return -1;
}
int main(void){
while(1){
scanf("%d %d",&w,&h);
if(w+h==0)break;
dcnt=0;
for(int i=0;i<h;i++){
string str;
cin >> str;
for(int j=0;j<w;j++){
if(str[j]=='o'){
fie[j][i]=0;
rx=j,ry=i;
}
if(str[j]=='.'){
fie[j][i]=0;
}
if(str[j]=='*'){
dcnt++;
fie[j][i]=dcnt;
}
if(str[j]=='x'){
fie[j][i]=-1;
}
}
}
printf("%d\n",bfs());
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x;
vector<int> adj[100010];
long long dp[100005][12][3];
void dfs(int src, int prv) {
dp[src][0][0] = (k - 1);
dp[src][1][1] = 1;
dp[src][0][2] = (m - k);
for (int i = 0; i < adj[src].size(); i++) {
if (adj[src][i] == prv) continue;
int tmp = adj[src][i];
dfs(tmp, src);
for (int j = x; j >= 0; j--) {
long long a1 = 0, a2 = 0, a3 = 0;
for (int k = j; k >= 0; k--) {
a1 = (a1 +
(dp[src][j - k][0] *
(dp[tmp][k][1] + dp[tmp][k][0] + dp[tmp][k][2]) % 1000000007) %
1000000007) %
1000000007;
a2 = (a2 +
(dp[src][j - k][1] * (dp[tmp][k][0]) % 1000000007) % 1000000007) %
1000000007;
a3 = (a3 + (dp[src][j - k][2] * (dp[tmp][k][0] + dp[tmp][k][2]) %
1000000007) %
1000000007) %
1000000007;
}
dp[src][j][0] = a1;
dp[src][j][1] = a2;
dp[src][j][2] = a3;
}
}
}
int main() {
std::ios::sync_with_stdio(false);
;
std::cin >> n >> m;
for (int i = 1; i <= n - 1; i++) {
int x, y;
std::cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
std::cin >> k >> x;
dfs(1, -1);
long long ans = 0;
for (int i = 0; i <= x; i++) {
for (int j = 0; j <= 2; j++) {
ans = (ans + dp[1][i][j]) % 1000000007;
}
}
std::cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a;
int main() {
scanf("%d %d", &n, &a);
if (a % 2 == 1) {
printf("%d", (a - 1) / 2 + 1);
return 0;
}
if (a % 2 == 0) {
printf("%d", n / 2 + 1 - a / 2);
return 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1205;
struct P {
int l, r;
};
int n;
int dp[N][N];
int st[N][N];
int lb[N], rb[N];
char res[N];
int solve(int l, int r) {
if (l > r) return 1;
if (dp[l][r] != -1) return dp[l][r];
for (int md = lb[l] / 2; md <= min((rb[l] - 1) / 2, r - l); md++) {
int res = 1;
if (md != 0) res &= solve(l + 1, l + md);
if (l + md + 1 <= r) res &= solve(l + md + 1, r);
if (res == 1) {
st[l][r] = md;
return dp[l][r] = 1;
}
}
return dp[l][r] = 0;
}
void fill_ans(int l, int r, int off) {
res[off] = '(';
int md = st[l][r];
res[off + 2 * md + 1] = ')';
if (md != 0) fill_ans(l + 1, l + md, off + 1);
if (l + md + 1 <= r) fill_ans(l + md + 1, r, off + 2 + 2 * md);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> lb[i] >> rb[i];
memset(dp, -1, sizeof(dp));
if (solve(0, n - 1)) {
fill_ans(0, n - 1, 0);
for (int i = 0; i < 2 * n; i++) cout << res[i];
cout << endl;
} else
cout << "IMPOSSIBLE" << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void Do(int a, int b, int &x, int &y) {
if (b == 0) {
x = 1;
y = 0;
} else {
int dx, dy;
Do(b, a % b, dx, dy);
x = dy;
y = dx - a / b * dy;
}
}
int main() {
int N;
scanf("%d", &N);
map<int, int> Mx;
int tn = N;
for (int i = 2; i * i <= tn; i++)
while (tn % i == 0) Mx[i]++, tn /= i;
if (tn > 1) Mx[tn]++;
if ((int)Mx.size() == 1) {
puts("NO");
return 0;
}
vector<pair<int, int> > vx;
for (pair<int, int> e : Mx) vx.push_back(e);
int p = vx[0].first, q = vx[1].first;
int x, y;
Do(p, q, x, y);
x = -x, y = -y;
if (x < 0)
x += N / p;
else
y += N / q;
while (x < 0) x += q, y -= p;
while (y < 0) x -= q, y += p;
puts("YES\n2");
printf("%d %d\n", x, N / p);
printf("%d %d\n", y, N / q);
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int MOD = 998244353;
const int N = 2e5 + 5;
int t, n, a[N], f[N];
vector<int> p;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i <= n; ++i) f[i] = 0;
p.clear();
for (int i = 1; i <= n; ++i) {
cin >> a[i];
f[a[i]]++;
}
long long res = 0;
int pos = n;
for (int i = 0; i <= n; ++i) {
int ans = f[i];
cout << ans + res << ' ';
if (f[i] == 0) {
if (p.empty()) {
pos = i;
break;
} else {
res += i - p.back();
p.pop_back();
}
}
for (int j = 1; j <= f[i] - 1; ++j) p.push_back(i);
}
for (int i = pos + 1; i <= n; ++i) cout << -1 << ' ';
cout << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, d, b, i, j, k, t1, t2, x1, x2;
long long a[100005], s[100005];
int main() {
scanf("%I64d%I64d%I64d", &n, &d, &b);
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
s[i] = s[i - 1] + a[i];
}
for (i = 1; i <= n / 2; i++) {
x1 = s[min(n, i + d * (i))] - s[max(1ll, i - d * (i)) - 1];
x2 = s[min(n, n - i + 1 + d * (i))] - s[max(1ll, n - i + 1 - d * (i)) - 1];
if ((t1 + 1) * b <= x1) {
t1++;
}
if ((t2 + 1) * b <= x2) {
t2++;
}
}
printf("%I64d", n / 2 - min(t1, t2));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e3 + 3, mod = 1e9 + 7;
int dp[MN], i, j, x, n, tot, ans;
int main() {
for (scanf("%d", &n), i = 1; i <= n; i++) {
scanf("%d", &x);
tot = 0;
dp[i] = 1;
for (j = i; j >= x; j--) tot = (tot + dp[j]) % mod;
dp[i] = (dp[i] + tot) % mod;
ans = (ans + dp[i]) % mod;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include<bits/stdc++.h>
const int N = 200010;
typedef long long ll;
typedef std::pair <ll, ll> pii;
struct jewel{
ll value, id;
bool ispair;
bool operator < (const jewel &j)const{
if (value != j.value){
return value > j.value;
}
return ispair > j.ispair;
}
};
std::vector <int> vec[N];
int main(){
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0, c, v; i < n; ++ i){
scanf("%d%d", &c, &v);
vec[c].push_back(v);
}
std::vector <jewel> jewels;
std::multiset <pii> singin, singout, doubin, doubout, tripout;
for (int i = 1; i <= k; ++ i){
std::sort(vec[i].begin(), vec[i].end(), std::greater <int>());
ll x = vec[i][0] + vec[i][1];
jewels.push_back({x, i, true});
doubout.insert({x << 1, i});
if ((int) vec[i].size() >= 3){
tripout.insert({(x + vec[i][2]) << 1, i});
}
for (int j = 2, sz = vec[i].size(); j < sz; ++ j){
jewels.push_back({vec[i][j] << 1, i, false});
}
}
std::sort(jewels.begin(), jewels.end());
puts("-1");
long long ans = 0;
for (int i = 2, j = 0, cnt = 0; i <= n; ++ i){
ll value = jewels[j].value, id = jewels[j].id;
int num = jewels[j].ispair ? 2 : 1;
if (cnt + num <= i){
cnt += num;
ans += num * value;
if (num == 1){
auto u = singout.find({value, id});
singin.insert(*u);
singout.erase(u);
}
else{
auto u = doubout.find({value << 1, id});
doubin.insert(*u);
doubout.erase(u);
if ((int) vec[id].size() >= 3){
u = tripout.find({((ll) vec[id][0] + vec[id][1] + vec[id][2]) * 2, id});
tripout.erase(u);
}
for (int j = 2, sz = vec[id].size(); j < sz; ++ j){
singout.insert({vec[id][j] << 1, id});
}
}
++ j;
}
if (cnt == i){
printf("%lld\n", ans >> 1);
continue;
}
ll max = LLONG_MIN;
if (!singout.empty()){
max = std::max(max, (-- singout.end()) -> first);
}
if (!singin.empty() && !doubout.empty()){
ll x = singin.begin() -> first;
ll y = (-- doubout.end()) -> first;
max = std::max(max, y - x);
}
if (!doubin.empty() && !tripout.empty()){
ll x = doubin.begin() -> first;
ll y = (-- tripout.end()) -> first;
max = std::max(max, y - x);
}
if (max == LLONG_MIN){
puts("-1");
continue;
}
printf("%lld\n", (ans + max) >> 1);
}
return 0;
} | 0 |
#include<stdio.h>
int main(void)
{
int n,m,A[100001],B,C[100001],sum=1,sum1=0,i;
scanf("%d%d",&n,&m);
for(i=1;i<n;i++){
C[i]=0;
}
for(i=1;i<n;i++){
scanf("%d",&A[i]);
C[i+1]=C[i]+A[i];
}
for(i=1;i<=m;i++){
scanf("%d",&B);
if(sum<sum+B){
sum1+=C[sum+B]-C[sum];
}
else{
sum1+=C[sum]-C[sum+B];
}
sum+=B;
sum1%=100000;
}
printf("%d\n",sum1);
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cstdio>
#include <math.h>
#include <map>
#include <queue>
#include <string>
using namespace std;
int n[100000],s[100000],m;
int main(){
int c=0;
while(scanf("%d,%d",&n[c],&s[c])){
if(n[c]+s[c]==0)break;
c++;
}
int p=1;
for(int i=30;i>=0;i--){
int flag=0;
for(int j=0;j<c;j++){
if(s[j]==i){s[j]=p+100;flag=1;}
}
if(flag==1)p++;
}
while(scanf("%d",&m)!=EOF){
for(int i=0;i<c;i++)if(n[i]==m){
cout<<s[i]-100<<endl;
break;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int sum = 0;
string s;
while (n--) {
int x, y;
cin >> x >> y;
if (sum + x <= 500) {
sum += x;
s += 'A';
} else {
sum -= y;
s += 'G';
}
}
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n;
while (~scanf("%d", &n)) {
if (n <= 10 || n > 21)
printf("0\n");
else if (n == 20)
printf("15\n");
else
printf("4\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, res[111];
pair<int, int> a[111];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a[i] = make_pair(x, i);
}
sort(a, a + n);
for (int i = 0; i < n; i++) res[a[i].second] = i % 2;
for (int i = 0; i < n; i++) cout << res[i] << " ";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int a[N], b[N];
int main() {
int n, m;
scanf("%d", &n);
unsigned long long sum1 = 0, sum2 = 0;
for (int i = 0; i < n; i++) scanf("%d", a + i), sum1 += a[i];
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", b + i), sum2 += b[i];
if (sum1 != sum2) {
puts("-1");
return 0;
}
int aa = 0, bb = 0;
unsigned long long sum_a = a[0], sum_b = b[0];
int ans = 0;
while (aa < n && bb < m) {
while (sum_a != sum_b) {
if (aa < n - 1 && sum_a < sum_b)
sum_a += a[++aa];
else if (bb < m - 1 && sum_a > sum_b)
sum_b += b[++bb];
else
break;
}
aa++, bb++;
if (sum_a == sum_b) {
ans++;
if (aa < n && bb < m) sum_a = a[aa], sum_b = b[bb];
}
}
if (!ans || sum_a != sum_b)
puts("-1");
else
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, i;
int a[111][2];
scanf("%d", &n);
scanf("%d", &t);
for (i = 0; i < n; i++) scanf("%d %d", &a[i][0], &a[i][1]);
t = 7 - t;
for (i = 1; i <= n - 1; i++) {
if (t == a[i][0] or t == a[i][1] or t == 7 - a[i][0] or t == 7 - a[i][1])
break;
}
if (i == n)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin >> n;
set<int> st;
for(int i = 0;i < n;i++)
{
int x;
cin >> x;
st.insert(x);
}
if(st.size() % 2 == 0)
{
cout << st.size() - 1;
}
else
{
cout << st.size();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long pw(long long x, long long y) {
long long ret = 1;
while (y) {
if (y % 2) ret = (ret * x) % 1000000007;
x = (x * x) % 1000000007;
y /= 2;
}
return ret;
}
long long s[100005] = {0}, e[100005] = {0}, cur = 0;
vector<pair<long long, long long> > rng[100005];
vector<long long> v[100005];
void dfs(long long r, long long p) {
s[r] = ++cur;
for (long long i : v[r]) {
if (i == p) continue;
dfs(i, r);
}
e[r] = cur;
}
long long SGT[4 * 100005] = {0}, LZY[4 * 100005] = {0}, ans[100005] = {0};
void upd(long long id, long long s, long long e, long long l, long long r,
long long val) {
if (s > r || l > e) return;
if (l <= s && e <= r) {
LZY[id] += val;
if (LZY[id] > 0)
SGT[id] = (e - s + 1);
else {
if (s != e)
SGT[id] = SGT[id + id] + SGT[id + id + 1];
else {
SGT[id] = 0;
}
}
return;
}
long long mid = (s + e) / 2;
upd(id + id, s, mid, l, r, val);
upd(id + id + 1, mid + 1, e, l, r, val);
if (LZY[id])
SGT[id] = (e - s + 1);
else
SGT[id] = SGT[id + id] + SGT[id + id + 1];
}
void dfs1(long long r, long long p) {
for (auto it : rng[r]) {
upd(1, 1, 100005 - 1, it.first, it.second, 1);
}
ans[r] = SGT[1];
for (long long i : v[r]) {
if (i == p) continue;
dfs1(i, r);
}
for (auto it : rng[r]) {
upd(1, 1, 100005 - 1, it.first, it.second, -1);
}
}
int main() {
long long n, m;
cin >> n >> m;
for (long long i = 1; i < n; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, 0);
for (long long i = 1; i <= m; i++) {
long long a, b;
cin >> a >> b;
rng[a].push_back({s[a], e[a]});
rng[a].push_back({s[b], e[b]});
rng[b].push_back({s[a], e[a]});
rng[b].push_back({s[b], e[b]});
}
dfs1(1, 0);
for (long long i = 1; i <= n; i++) {
cout << max(ans[i] - 1, 0ll) << " ";
}
cout << endl;
return 0;
}
| 5 |
#include<map>
#include<string>
#include<iostream>
using namespace std;
int main()
{
map<char,string> en;
en[' ']="101"; en['\'']="000000"; en[',']="000011";
en['-']="10010001"; en['.']="010001"; en['?']="000001";
en['A']="100101"; en['B']="10011010"; en['C']="0101";
en['D']="0001"; en['E']="110"; en['F']="01001";
en['G']="10011011"; en['H']="010000"; en['I']="0111";
en['J']="10011000"; en['K']="0110"; en['L']="00100";
en['M']="10011001"; en['N']="10011110"; en['O']="00101";
en['P']="111"; en['Q']="10011111"; en['R']="1000";
en['S']="00110"; en['T']="00111"; en['U']="10011100";
en['V']="10011101"; en['W']="000010"; en['X']="10010010";
en['Y']="10010011"; en['Z']="10010000";
map<string,char> de;
de["00000"]='A'; de["00001"]='B'; de["00010"]='C';
de["00011"]='D'; de["00100"]='E'; de["00101"]='F';
de["00110"]='G'; de["00111"]='H'; de["01000"]='I';
de["01001"]='J'; de["01010"]='K'; de["01011"]='L';
de["01100"]='M'; de["01101"]='N'; de["01110"]='O';
de["01111"]='P'; de["10000"]='Q'; de["10001"]='R';
de["10010"]='S'; de["10011"]='T'; de["10100"]='U';
de["10101"]='V'; de["10110"]='W'; de["10111"]='X';
de["11000"]='Y'; de["11001"]='Z'; de["11010"]=' ';
de["11011"]='.'; de["11100"]=','; de["11101"]='-';
de["11110"]='\''; de["11111"]='?';
string s,z[5];
for(int i=1;i<5;i++) z[i]+=z[i-1]+'0';
while(getline(cin,s)){
string code;
for(int i=0;i<s.length();i++) code+=en[s[i]];
if(code.length()%5!=0) code+=z[5-code.length()%5];
for(int i=0;i<code.length();i+=5) cout<<de[code.substr(i,5)];
cout<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int t;
cin >> t;
int n;
n = s.size();
if (n % t == 0) {
char a[1001];
for (int i = 1; i <= n; i++) {
a[i] = s[i - 1];
}
bool flag;
flag = true;
int j;
int k;
for (int i = 1; i < n; i = i + n / t) {
j = i;
k = i + n / t - 1;
while (j < k) {
if (a[j] != a[k]) {
flag = false;
break;
}
j++;
k--;
}
if (flag == false) {
break;
}
}
if (flag == true) {
cout << "YES";
} else {
cout << "NO";
}
} else {
cout << "NO";
}
return 0;
}
| 1 |
#include<iostream>
using namespace std;
class Dice{
public:
int f[6];
Dice(){}
void roll_x(){roll(1,4,6,3);} // to E
void roll_y(){roll(1,2,6,5);} // to N
void roll_z(){roll(2,3,5,4);} // 上から見て時計回り
void roll(int i,int j,int k,int l){
int t=f[i]; f[i]=f[j]; f[j]=f[k]; f[k]=f[l]; f[l]=t;
}
void move(char ch){
if(ch == 'E') roll_x();
if(ch == 'S') for(int i=0;i<3;i++) roll_y();
if(ch == 'W') for(int i=0;i<3;i++) roll_x();
if(ch == 'N') roll_y();
}
};
int main(){
Dice d;
string name;
for(int i=1;i<=6;i++) cin >> d.f[i];
cin >> name;
for(int i=0;i<name.size();i++) d.move(name[i]);
cout << d.f[1] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long flag;
char s, s1, s2, s3, s4, s5, x, x1, x2, x3, x4, x5;
int main() {
cin >> x >> s;
cin >> x1 >> s1 >> x2 >> s2 >> x3 >> s3 >> x4 >> s4 >> x5 >> s5;
flag = 0;
if (x1 == x || x2 == x || x3 == x || x4 == x || x5 == x) flag++;
if (s1 == s || s2 == s || s3 == s || s4 == s || s5 == s) flag++;
if (flag == 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1000 * 100 + 9;
double mas[N], sum[N];
int main() {
ios::sync_with_stdio(false);
int n, m, T;
double c;
int a;
cin >> n >> T >> c;
for (int i = 1; i <= n; ++i) {
cin >> a;
mas[i] = (mas[i - 1] + a * 1.0 / T) / c;
sum[i] = sum[i - 1] + a;
}
cin >> m;
double real, x;
int p;
std::cout.sync_with_stdio(false);
cout.precision(9);
cout.fixed;
for (int i = 1; i <= m; ++i) {
cin >> p;
real = (sum[p] - sum[p - T]) / T;
x = abs(mas[p] - real);
cout << real << " " << mas[p] << " " << x / real << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using nagai = long long;
#define sz(x) int((x).size())
const int mod=1e6+3;
int su(int a,int b){
if((a+=b)>=mod)a-=mod;
return a;
}
int mu(int a,int b){
return (nagai)a*b%mod;
}
int pw(int a,int b,int c=1){
for(;b;b>>=1,a=mu(a,a))if(b&1)c=mu(c,a);
return c;
}
int dv(int a,int b){
return mu(a,pw(b,mod-2));
}
int q;
const int N=2*mod+5;
int pref[N];
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
pref[0]=1;
for(int i=0;i+1<N;++i){
if(i%mod==0)
pref[i+1]=pref[i];
else
pref[i+1]=mu(pref[i],i%mod);
}
cin>>q;
while(q--){
int x,d,n;
cin>>x>>d>>n;
if(d==0){
cout<<pw(x,n)<<'\n';
continue;
}
if(x==0||n>=mod){
cout<<0<<'\n';
continue;
}
int k=dv(mod-x,d);
if(k<n){
cout<<0<<'\n';
continue;
}
x=dv(x,d);
cout<<mu(pw(d,n),dv(pref[x+n],pref[x]))<<'\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
struct node {
long long a;
int b;
bool operator<(const node &y) const { return a < y.a; }
} f[maxn];
long long a[maxn];
int n;
int judge1() {
if (a[1] + a[3] != a[2] * 2) return -1;
int c = a[2] - a[1], t = 0, ind = 1, i;
for (i = 4; i <= n; i++)
if (a[i] != a[1] + (i - 1 - t) * c) t++, ind = i;
if (t <= 1) return ind;
return -1;
}
int judge2() {
if (a[2] + a[4] != a[3] * 2) return -1;
int c = a[3] - a[2], t = 0, i;
for (i = 5; i <= n; i++)
if (a[i] != a[4] + (i - 4 - t) * c) t++;
if (t == 0) return 1;
return -1;
}
int judge3() {
if (a[1] + a[4] != a[3] * 2) return -1;
int c = a[3] - a[1], t = 0, i;
for (i = 5; i <= n; i++)
if (a[i] != a[4] + (i - 4 - t) * c) t++;
if (t == 0) return 2;
return -1;
}
int judge4() {
if (a[1] + a[4] != a[2] * 2) return -1;
int c = a[2] - a[1], t = 0, i;
for (i = 5; i <= n; i++)
if (a[i] != a[4] + (i - 4 - t) * c) t++;
if (t == 0) return 3;
return -1;
}
int main() {
int x = -1, y = -1, z = -1, r = -1, i;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%lld", &f[i].a);
f[i].b = i;
}
sort(f + 1, f + n + 1);
for (i = 1; i <= n; i++) a[i] = f[i].a;
if (n <= 3) {
printf("%d", 1);
return 0;
}
x = judge1();
if (n >= 4) y = judge2();
if (n >= 4) z = judge3();
if (n >= 4) r = judge4();
x = max(max(x, y), max(z, r));
if (x != -1) x = f[x].b;
printf("%d", x);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acosl(-1.0);
bool isSubsetSum(vector<int> set, int n, int sum) {
bool subset[n + 1][sum + 1];
for (int i = 0; i <= n; i++) subset[i][0] = true;
for (int i = 1; i <= sum; i++) subset[0][i] = false;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= sum; j++) {
if (j < set[i - 1]) subset[i][j] = subset[i - 1][j];
if (j >= set[i - 1])
subset[i][j] = subset[i - 1][j] || subset[i - 1][j - set[i - 1]];
}
}
return subset[n][sum];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, x, t;
cin >> n >> x;
vector<pair<int, int> > v(n);
vector<int> s;
for (int i = 0; i < n; i++) v[i].second = -1;
for (int i = 0; i < n; i++) {
cin >> v[i].first;
v[i].first--;
if (v[i].first != -1) v[v[i].first].second = i;
}
int cnt, par;
for (int i = 0; i < n; i++) {
if (i == x - 1) continue;
if (v[i].second == -1) {
bool kp = false;
cnt = 1;
par = v[i].first;
while (par != -1) {
if (par == x - 1) kp = 1;
cnt++;
par = v[par].first;
}
if (!kp) s.push_back(cnt);
}
}
sort(s.begin(), s.end());
int p = 0;
par = x - 1;
while (par != -1) {
p++;
par = v[par].first;
}
vector<int> ans;
ans.push_back(p);
for (int i = p + 1; i <= n; i++) {
if (isSubsetSum(s, s.size(), i - p)) ans.push_back(i);
}
for (int i = 0; i < ans.size(); i++) cout << ans[i] << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
int n, k;
char ch[N], m;
bool ok[N][N];
queue<pair<int, int> > q;
int main() {
int i, j, l, o, t;
scanf("%s", ch + 1);
ch[0] = '_';
n = strlen(ch) - 1;
i = 2;
while (i <= n) {
k++;
i <<= 1;
}
l = n - (1 << k) + 1;
ok[0][0] = 1;
for (o = 0; o < l; o = o + 1) {
m = 'z' + 1;
for (i = o; i + (l - o) <= n; i = i + 1) {
j = i - o;
if (ok[i][j]) {
m = min(m, ch[i + 1]);
for (t = 0; t < k; t = t + 1) {
if (j & (1 << t)) continue;
ok[i + (1 << t)][j | (1 << t)] = 1;
}
}
}
cout << m;
for (i = o; i + (l - o) <= n; i = i + 1) {
j = i - o;
if (ok[i][j]) {
if (ch[i + 1] == m) ok[i + 1][j] = 1;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long INV2 = 500000004;
long long INV6 = 166666668;
long long power(long long a, long long b, long long c) {
long long x = 1, y = a;
while (b > 0) {
if (b & 1) x = (x * y) % c;
y = (y * y) % c;
b /= 2;
}
return x % c;
}
int dx[] = {0, -1, 0, 1};
int dy[] = {-1, 0, 1, 0};
const int MAX = 1179858 + 5;
int dp[MAX], v[MAX], dp1[MAX];
void seive() {
for (long long i = 2; i <= 1179858; i++) {
if (!v[i]) {
dp[i] = dp[i - 1] + 1;
for (long long j = i * i; j <= 1179858; j += i) {
v[j] = 1;
}
} else {
dp[i] = dp[i - 1];
}
}
}
bool check(int num) {
char ch[25];
sprintf(ch, "%d", num);
int len = strlen(ch), fl = 1;
for (int i = 0; i < len; ++i) {
if (ch[i] != ch[len - i - 1]) {
return 0;
}
}
return 1;
}
int main() {
seive();
dp1[0] = 0;
for (int i = 1; i <= 1179858; ++i) {
if (check(i)) {
dp1[i] = dp1[i - 1] + 1;
} else {
dp1[i] = dp1[i - 1];
}
}
double p, q;
scanf("%lf%lf", &p, &q);
double a = p / q;
int fl = 1, mx = 0;
for (int i = 0; i < 1179859; ++i) {
double rub = a * dp1[i];
double pi = dp[i];
if (pi <= rub) {
fl = 0;
mx = max(mx, i);
}
}
if (fl) {
printf("Palindromic tree is better than splay tree\n");
} else {
printf("%d\n", mx);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int MAXN = 2e5 + 5;
using namespace std;
struct info {
int coord;
bool taxi;
} v[MAXN];
int n, m, dist[MAXN], man[MAXN], fr[MAXN];
int main() {
cin >> n >> m;
for (int i = 1; i <= n + m; i++) {
cin >> v[i].coord;
dist[i] = 2e9;
}
for (int i = 1; i <= n + m; i++) cin >> v[i].taxi;
int cur = -1;
for (int i = 1; i <= n + m; i++) {
if (v[i].taxi) cur = i;
if (!v[i].taxi && cur != -1) {
dist[i] = v[i].coord - v[cur].coord;
man[i] = cur;
}
}
cur = -1;
for (int i = n + m; i >= 1; i--) {
if (v[i].taxi) cur = i;
if (!v[i].taxi && cur != -1) {
if (v[cur].coord - v[i].coord < dist[i]) {
dist[i] = v[cur].coord - v[i].coord;
man[i] = cur;
}
}
}
for (int i = 1; i <= n + m; i++)
if (!v[i].taxi) fr[man[i]]++;
for (int i = 1; i <= n + m; i++) {
if (v[i].taxi) cout << fr[i] << " ";
}
return 0;
}
| 2 |
#include<iostream>
#include<map>
#include<queue>
using namespace std;
map<int,int> m1;
priority_queue<int> q1;
int t[200005];
int check(int a){
for(int i=0;;i++){
if((1<<i)>a)return ((1<<i)-a);
}
}
int main(){
int n;
int i,j,k;
int a,b,c;
int s=0;
cin>>n;
for(i=0;i<n;i++){
cin>>t[i];
m1[t[i]]++;
q1.push(t[i]);
}
while(!q1.empty()){
a=q1.top(),q1.pop();
if(m1[a]==0)continue;
m1[a]--;
b=check(a);
if(m1[b]>0)m1[b]--,s++;
}
cout<<s<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int x[510][510], row[510][510], col[510][510];
int n, m, ans;
void calc_ans(int sx, int sy) {
int up = sx - 1, down = sx + 1, left = sy - 1, right = sy + 1;
int t = x[sx][sy], sum = x[sx][sy];
while (up >= 1 && down <= n && left >= 1 && right <= m) {
int add = row[up][right] - row[up][left] + col[right][down] -
col[right][up] + row[down][right - 1] - row[down][left - 1] +
col[left][down - 1] - col[left][up - 1];
t = sum - t + add - x[up + 1][left];
sum += add;
ans = max(ans, t);
up--;
down++;
left--;
right++;
}
}
void init() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> x[i][j];
row[i][j] = row[i][j - 1] + x[i][j];
col[j][i] = col[j][i - 1] + x[i][j];
}
}
void solve() {
ans = -250000000;
for (int i = 2; i <= n - 1; i++)
for (int j = 2; j <= m - 1; j++) calc_ans(i, j);
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
init();
solve();
return 0;
}
| 3 |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n+1);
a[n] = 1000000001;
vector<int> b(n+1);
b[n] = 1000000001;
vector<int> c(2 * n);
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a[i] = x;
b[i] = y;
c[2 * i] = x; c[2 * i + 1] = y;
}
int ca = 0; int cb = 0;
int ans = 0;
int ba = 0;
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
for (int i = 0; i < 2*n; i++) {
int da = 0;
if (i != 0) {
if (c[i] == c[i - 1]) {
da == 1;
}
}
if (da == 0) {
int si = c[i];
while (a[ca] <= si) {
ca++;
ba++;
}
while (b[cb] < si) {
cb++;
ba--;
}
ans = max(ans, ba);
}
}
cout << ans << endl;
}
| 0 |
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <queue>
#include <vector>
#include <map>
#include <set>
using namespace std;
typedef pair<int , int> P2;
typedef pair<pair<int , int> , int> P3;
typedef pair<pair<int , int> , pair<int , int> > P4;
#define Fst first
#define Snd second
#define PB(a) push_back(a)
#define MP(a , b) make_pair((a) , (b))
#define M3P(a , b , c) make_pair(make_pair((a) , (b)) , (c))
#define M4P(a , b , c , d) make_pair(make_pair((a) , (b)) , make_pair((c) , (d)))
#define repp(i,a,b) for(int i = (int)(a) ; i < (int)(b) ; ++i)
#define repm(i,a,b) for(int i = (int)(a) ; i > (int)(b) ; --i)
#define repv(t,it,v) for(vector<t>::iterator it = v.begin() ; it != v.end() ; ++it)
int N,Q;
int b[100010];
int main(){
scanf("%d%d" , &N, &Q);
b[1] = 1;
b[2] = 1;
int x = 1;
repp(i,0,Q){
int A,B;
scanf("%d%d" , &A , &B);
swap(b[A] , b[B]);
if(A == x){
x = B;
} else if(B == x){
x = A;
}
b[x-1] = b[x+1] = 1;
}
int ans = 0;
repp(i,1,N+1){
if(b[i] > 0) ++ans;
}
printf("%d\n" , ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(make_pair(x, i + 1));
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int cost = 1;
for (int i = 1; i < n; i++) {
cost += 1 + (i * v[i].first);
}
cout << cost << endl;
for (int i = 0; i < n; i++) cout << v[i].second << " ";
cout << endl;
return 0;
}
| 2 |
#include <iostream>
#include <set>
using namespace std;
int main() {
int n;
set<string> st;
cin >> n;
bool flg=true;
for (int i=0; i<n; i++) {
char t;
string s;
cin >> s;
if (i>0 && s.front()!=t) flg=false;
t=s.back();
st.insert(s);
}
if (st.size()!=n) flg=false;
if (flg) cout << "Yes";
else cout << "No";
} | 0 |
#include <bits//stdc++.h>
using namespace std;
#define int long long
signed main(){
int a,b,c,k;
cin>>a>>b>>c>>k;
if(b>a){
swap(a,b);
}
if(c>a){
swap(a,c);
}
cout<<(1<<k)*a+b+c<<endl;
}
| 0 |
#include<stdio.h>
int main()
{
int a[4][3][10]={0},b,f,r,v,n;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d %d %d %d",&b,&f,&r,&v);
a[b-1][f-1][r-1]=a[b-1][f-1][r-1]+v;
}
for(int x=0;x<4;x++)
{
for(int y=0;y<3;y++)
{
for(int z=0;z<10;z++)
{
printf(" %d",a[x][y][z]);
}
printf("\n");
}
if(x!=3) printf("####################\n");
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(void){
int n; cin>>n;
string s; cin>>s;
vector<int> e(n+1,0),w(n+1,0);
for(int i=1; i<n+1; ++i){
e[i]=e[i-1]; w[i]=w[i-1];
if(s[i-1]=='E') ++e[i]; else ++w[i];
}
int res=2147483647;
for(int i=1; i<n+1; ++i) res=min(res,w[i-1]+e[n]-e[i]);
cout<<res;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, i, j;
cin >> n >> m;
char img[55][55];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> img[i][j];
}
}
int cnt = 0;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < m - 1; j++) {
vector<char> v;
v.push_back(img[i][j]);
v.push_back(img[i][j + 1]);
v.push_back(img[i + 1][j]);
v.push_back(img[i + 1][j + 1]);
sort(v.begin(), v.end());
if (v[0] == 'a' && v[1] == 'c' && v[2] == 'e' && v[3] == 'f') cnt++;
}
}
cout << cnt << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 29;
const int mod = (int)1e9 + 7;
const double eps = 1e-8;
const double pi = acos(-1.0);
int n, m, k;
char a[2000010], b[1000010];
int nxt[2000010];
int main() {
scanf("%d", &n);
scanf("%s%s", a, b);
n--;
for (int i = 0; i < n; i++) {
if (b[i] == 'N')
b[i] = 'S';
else if (b[i] == 'S')
b[i] = 'N';
else if (b[i] == 'W')
b[i] = 'E';
else
b[i] = 'W';
}
reverse(a, a + n);
strcat(a, b);
k = 0;
for (int i = 1; i < 2 * n; i++) {
while (k && a[i] != a[k]) k = nxt[k - 1];
if (a[i] == a[k]) k++;
nxt[i] = k;
}
puts(nxt[2 * n - 1] ? "NO" : "YES");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1, r, n, a, d, c, b, x, y, sum, cnt, i, j, k, m, l, q, maxx,
minn, temp, ans, flag, g, ts;
char ch, chh;
double dans;
string str, ttr;
cin >> t;
for (ts = 1; ts <= t; ts++) {
flag = 0;
sum = 0;
cnt = 0;
ans = 0;
k = 0;
maxx = 0;
minn = 0;
a = 0;
b = 0;
temp = 0;
cin >> n >> k;
x = (k / n);
temp = x;
k += x;
while (x != 0) {
x = (k / n);
x = (x - temp);
temp = (k / n);
k += x;
}
cout << k;
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e18;
struct LiChao_min {
struct line {
int64_t a, b;
line() {
a = 0;
b = 0;
}
line(int64_t _a, int64_t _b) {
a = _a;
b = _b;
}
int64_t eval(int x) { return a * x + b; }
};
struct node {
node *l, *r;
line f;
node() {
f = line();
l = nullptr;
r = nullptr;
}
node(int64_t a, int64_t b) {
f = line(a, b);
l = nullptr;
r = nullptr;
}
node(line v) {
f = v;
l = nullptr;
r = nullptr;
}
};
typedef node *pnode;
pnode root;
int sz;
void init(int _sz) {
sz = _sz + 1;
root = nullptr;
}
void add_line(int64_t a, int64_t b) {
line v = line(a, b);
insert(v, -sz, sz, root);
}
int64_t query(int x) { return query(x, -sz, sz, root); }
void insert(line &v, int l, int r, pnode &nd) {
if (!nd) {
nd = new node(v);
return;
}
int64_t trl = nd->f.eval(l), trr = nd->f.eval(r);
int64_t vl = v.eval(l), vr = v.eval(r);
if (trl <= vl && trr <= vr) return;
if (trl > vl && trr > vr) {
nd->f = v;
return;
}
int mid = (l + r) >> 1;
if (trl > vl) swap(nd->f, v);
if (nd->f.eval(mid) < v.eval(mid))
insert(v, mid + 1, r, nd->r);
else
swap(nd->f, v), insert(v, l, mid, nd->l);
}
int64_t query(int x, int l, int r, pnode &nd) {
if (!nd) return inf;
if (l == r) return nd->f.eval(x);
int mid = (l + r) >> 1;
if (mid >= x) return min(nd->f.eval(x), query(x, l, mid, nd->l));
return min(nd->f.eval(x), query(x, mid + 1, r, nd->r));
}
};
LiChao_min tree;
int main() {
int n;
scanf("%d", &n);
long long a[n], b[n], dp[n];
for (int i = 0; i < n; ++i) scanf("%I64d", &a[i]);
for (int i = 0; i < n; ++i) scanf("%I64d", &b[i]);
tree.init(1e9);
dp[0] = 0;
tree.add_line(b[0], dp[0]);
for (int i = 1; i < n; ++i) {
dp[i] = tree.query(a[i]);
tree.add_line(b[i], dp[i]);
}
return printf("%I64d", dp[n - 1]), 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[10][10];
int main() {
int r, c, n, k, x, y, m = 0;
cin >> r >> c >> n >> k;
long long count = 0;
for (int i = 0; i < n; i++) {
cin >> x >> y;
a[x - 1][y - 1] = 1;
}
for (int x1 = 0; x1 < r; x1++)
for (int y1 = 0; y1 < c; y1++)
for (int x2 = x1; x2 < r; x2++)
for (int y2 = y1; y2 < c; y2++) {
m = 0;
for (int i = x1; i <= x2; i++)
for (int j = y1; j <= y2; j++) {
if (a[i][j] == 1) m++;
}
if (m >= k) count++;
}
cout << count;
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main() {
int a;
int ans;
ans = 0;
for (int i = 1; i <= 5; i++) {
cin >> a;
if (a <= 40) {
a = 40;
}
ans = ans + a;
}
cout << ans / 5 << endl;
}
| 0 |
#include <iostream>
#define REP(i, a, n) for(int i = (a); i <= (n); i++)
using namespace std;
typedef pair<int, int> pii;
int P, Q, A, N;
int dfs(int p, int q, int n, int t) {
if(P * q == p * Q) return 1;
if(P * q < p * Q) return 0;
if(N == n) return 0;
int ans = 0;
REP(i, t, A / q) ans += dfs(p * i + q, q * i, n + 1, i);
return ans;
}
int main(void) {
while(cin >> P >> Q >> A >> N, P != 0) {
cout << dfs(0, 1, 0, 1) << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void chmin(T &a, T b) {
if (a > b) a = b;
}
constexpr long long INF = 1000000000000000000;
constexpr long long mod = 1000000007;
constexpr double eps = 1e-8;
long long dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
bool prime(long long a) {
if (a == 1) return false;
for (long long i = 2; i * i <= a; i++) {
if (a % i == 0) return false;
}
return true;
}
long long modpow(long long a, long long b) {
if (b == 0) return 1;
if (b % 2) return modpow(a, b - 1) * a % mod;
long long memo = modpow(a, b / 2);
return memo * memo % mod;
}
vector<long long> kaijo, invkaijo;
void init_fact(long long n) {
kaijo.resize(n + 1);
invkaijo.resize(n + 1);
kaijo[0] = 1;
for (long long i = 1; i <= n; i++) {
kaijo[i] = kaijo[i - 1] * i;
kaijo[i] %= mod;
}
for (long long i = 0; i < n + 1; i++) invkaijo[i] = modpow(kaijo[i], mod - 2);
}
long long comb(long long a, long long b) {
if (a < b) return 0;
if (a < 0 || b < 0) return 0;
return kaijo[a] * modpow(kaijo[a - b], mod - 2) % mod *
modpow(kaijo[b], mod - 2) % mod;
}
long long inv(long long x) {
x = modpow(x, mod - 2);
return x;
}
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
long long pos = 0, ans = 0;
while (pos < n) {
long long siz = 0;
while (pos < n) {
siz++;
if (a[pos] <= siz) {
pos++;
goto ok;
}
pos++;
}
break;
ok:;
ans++;
}
cout << ans << endl;
}
signed main() {
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m, a[111111];
void fileOpen() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
ios ::sync_with_stdio(false);
}
int main() {
scanf("%d", &(n));
for (int i = (int)(1); i <= (int)(n); ++i) scanf("%d", &(a[i]));
sort(a + 1, a + n + 1);
int sum = 10;
for (int i = (int)(1); i <= (int)(n); ++i) {
sum += a[i];
if (sum > 720) {
n = i - 1;
break;
}
}
printf("%d ", n);
int ans = 0;
sum = 0;
sum = 10;
for (int i = (int)(1); i <= (int)(n); ++i) {
sum += a[i];
if (sum > 360) ans += sum - 360;
}
printf("%d\n", (ans));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > conections;
vector<int> selected;
vector<bool> visited;
vector<int> init;
vector<int> goal;
void visit(int index, int level, int count0, int count1) {
if (visited[index]) return;
visited[index] = true;
if (level % 2 == 0) {
if ((init[index] + count0) % 2 == goal[index]) {
for (int i = 0, size = conections[index].size(); i < size; i++) {
if (!visited[conections[index][i]])
visit(conections[index][i], level + 1, count0, count1);
}
} else {
selected.push_back(index);
for (int i = 0, size = conections[index].size(); i < size; i++) {
if (!visited[conections[index][i]])
visit(conections[index][i], level + 1, count0 + 1, count1);
}
}
} else {
if ((init[index] + count1) % 2 == goal[index]) {
for (int i = 0, size = conections[index].size(); i < size; i++) {
if (!visited[conections[index][i]])
visit(conections[index][i], level + 1, count0, count1);
}
} else {
selected.push_back(index);
for (int i = 0, size = conections[index].size(); i < size; i++) {
if (!visited[conections[index][i]])
visit(conections[index][i], level + 1, count0, count1 + 1);
}
}
}
}
int main() {
int n, a, b;
cin >> n;
conections.assign(n + 1, vector<int>());
visited.assign(n + 1, false);
init.assign(n + 1, 0);
goal.assign(n + 1, 0);
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
conections[a].push_back(b);
conections[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
cin >> a;
init[i] = a;
}
for (int i = 1; i <= n; i++) {
cin >> a;
goal[i] = a;
}
visit(1, 0, 0, 0);
cout << selected.size() << endl;
for (int i = 0; i < selected.size(); i++) {
cout << selected[i] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
long long a, b, c, d[4];
for (long long i = 0; i < 4; i++) {
cin >> d[i];
}
sort(d, d + 4);
a = d[0] + d[1] - d[3];
b = d[1] + d[2] - d[3];
c = d[0] + d[2] - d[3];
cout << a << " " << b << " " << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
bool adj[N][N];
long long dp[1 << N][N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a][b] = adj[b][a] = true;
}
for (int i = 0; i < n; i++) dp[1 << i][i] = 1;
long long ans = 0;
for (int mask = 0; mask < (1 << n); mask++) {
int t = __builtin_popcount(mask);
if (t <= 1) continue;
int x = mask, first = -1;
for (int j = 0; j < n; j++, x /= 2)
if (x % 2) {
first = j;
break;
}
for (int i = first + 1; i < n; i++) {
for (int j = 0; j < n; j++)
if (adj[i][j]) dp[mask][i] += dp[mask ^ (1 << i)][j];
if (t >= 3 && adj[first][i]) ans += dp[mask][i];
}
}
cout << ans / 2 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> k;
while (cin >> n) cout << (n < 4 ? 4 - n : n % 2) << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll n, m, r; cin >> n >> m >> r;
ll dp[n][n];
for(ll i = 0; i < n; ++i)
for(ll j = 0; j < n; ++j)dp[i][j] = (i == j ? 0 : 1145141919);
vector<ll> rr;
for(ll i = 0; i < r; ++i){
ll a; cin >> a;
rr.push_back(--a);
}
sort(rr.begin(), rr.end());
for(ll i = 0; i < m; ++i){
ll a, b; cin >> a >> b;
cin >> dp[--a][--b];
dp[b][a] = dp[a][b];
}
for(ll i = 0; i < n; ++i)
for(ll j = 0; j < n; ++j)
for(ll k = 0; k < n; ++k) dp[j][k] = min(dp[j][k], dp[j][i] + dp[i][k]);
ll ans = 1145141919;
do{
ll dist = 0;
for(ll i = 0; i < rr.size() - 1; ++i) dist += dp[rr[i]][rr[i + 1]];
ans = min(dist, ans);
}while(next_permutation(rr.begin(), rr.end()));
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30) - 1;
const long long linf = (1ll << 62) - 1;
int q;
map<int, long long> parent, value;
inline int getLevel(long long x) {
int ans = 0;
while (x > 1) {
x >>= 1;
ans++;
}
return ans;
}
int main() {
cin >> q;
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 1 || t == 2) {
long long v, k;
scanf("%lld%lld", &v, &k);
int level = getLevel(v);
if (t == 1) {
value[level] = (value[level] + k + (1ll << level)) % (1ll << level);
} else {
parent[level] = (parent[level] + k + (1ll << level)) % (1ll << level);
}
} else {
long long v;
scanf("%lld", &v);
int level = getLevel(v);
long long start = (1ll << level);
v = (v - start + value[level] + (2ll << level)) % (1ll << level) + start;
for (int j = level; j >= 0; j--) {
long long start = (1ll << j);
printf("%lld ",
(v - start - value[j] + (2ll << j)) % (1ll << j) + start);
v = (v - start + parent[j] + (2ll << j)) % (1ll << j) + start;
v >>= 1;
}
puts("");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long A, B;
cin >> A >> B;
long long hb = (floor(log10(B + 1)) == log10(B + 1)) ? (floor(log10(B)) + 1)
: floor(log10(B));
cout << hb * A << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[6];
const long long maxn = 1e5;
long long b[6][maxn];
long long n;
long long get(long long T, long long val) {
auto it = lower_bound(b[T], b[T] + n, val);
return it - b[T];
}
long long calc(long long pos, long long v) {
long long last = pos;
long long mx = b[v][pos];
for (long long i = 0; i < 6; ++i) {
long long id = get(i, b[v][pos]);
if (id >= last) {
continue;
}
mx = max(mx, b[i][last - 1]);
last = id;
}
if (last != 0) return 1e18;
last = n;
for (long long i = 0; i <= v; ++i) {
long long id = get(i, b[v][pos]);
if (id >= last) {
continue;
}
mx = max(mx, b[i][last - 1]);
last = id;
}
if (last > pos) return 1e18;
return mx;
}
signed main() {
cin.tie();
cout.tie();
ios_base::sync_with_stdio(false);
for (long long i = 0; i < 6; ++i) {
cin >> a[i];
}
sort(a, a + 6);
reverse(a, a + 6);
cin >> n;
long long y[n];
for (long long j = 0; j < n; ++j) {
cin >> y[j];
}
sort(y, y + n);
for (long long l = 0; l < 6; ++l) {
for (long long i = 0; i < n; ++i) {
b[l][i] = y[i] - a[l];
}
}
long long ans = 1e18;
for (long long k = 0; k < 6; ++k) {
for (long long i = 0; i < n; ++i) {
ans = min(ans, calc(i, k) - b[k][i]);
}
}
cout << ans;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int n,t[2],a[5][100010],to[100010];
char buffer[10000010],*hed;
inline char Getchar(){
return *hed++;
}
inline int rd(){
register int x=0;
char c;
do c=Getchar();
while(!isdigit(c));
do{
x=(x<<1)+(x<<3)+(c^48);
c=Getchar();
}while(isdigit(c));
return x;
}
inline int abs(int x){
return x>=0?x:-x;
}
int main(){
int len=fread(buffer,1,10000000,stdin);
hed=buffer;
n=rd();
for(int i=1;i<=3;i++)
for(int j=1;j<=n;j++)
a[i][j]=rd();
for(register int i=1;i<=n;i++){
to[i]=a[2][i]/3+1;
if(!((a[1][i]-a[2][i]==-1&&a[2][i]-a[3][i]==-1&&a[1][i]%3==1)||(a[1][i]-a[2][i]==1&&a[2][i]-a[3][i]==1&&!(a[1][i]%3)))||(abs(i-to[i])&1)){
puts("No");
return 0;
}
t[i&1]^=(a[1][i]>a[2][i]);
}
for(register int i=1;i<=n;i++){
while(to[i]!=i){
t[i&1^1]^=1;
swap(to[i],to[to[i]]);
}
}
puts(t[0]||t[1]?"No":"Yes");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
const long long SZ = 1e5 + 4;
const double EPS = 1e-7;
const long long mod = 1e9 + 7;
const long long hashpow = 2;
const long long inf = 2e9;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
long long n;
long long a[SZ];
inline void read() {
cin >> n;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
}
map<long long, long long> get(long long k) {
if (k == 1) return {};
map<long long, long long> ans;
long long x = 2;
while (x * x <= k) {
if (k % x == 0) {
++ans[x];
k /= x;
} else {
++x;
}
}
++ans[k];
return ans;
}
inline void solve() {
map<long long, vector<long long>> s;
for (long long i = 0; i < n; ++i) {
map<long long, long long> x = get(a[i]);
for (auto [u, v] : x) {
s[u].push_back(v);
}
}
long long ans = 1;
for (auto& it : s) {
sort(it.second.begin(), it.second.end());
if (it.second.size() == n - 1) {
for (long long i = 0; i < it.second[0]; ++i) {
ans *= it.first;
}
} else if (it.second.size() == n) {
for (long long i = 0; i < it.second[1]; ++i) {
ans *= it.first;
}
}
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
read();
solve();
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
double cost[22][22];
double ans;
cin>>n>>m;
double l[22],a[22],b[22];
for(int i=0;i<n;i++)
cin>>l[i]>>a[i]>>b[i];
for(int i=0;i<n;i++)
for(int j=i+1;j<n;j++){
double x=l[i]-l[j];
double y=a[i]-a[j];
double z=b[i]-b[j];
cost[i][j]=cost[j][i]=x*x+y*y+z*z;
}
for(int i=0;i<(1<<n);i++){
int sum=0;
double tmp=0;
for(int j=0;j<n;j++)
if(i>>j&1)sum++;
if(sum!=m)continue;
for(int j=0;j<n;j++){
for(int k=j+1;k<n;k++){
if(i>>k&1&&i>>j&1)tmp+=cost[j][k];
}
}
ans=max(ans,tmp);
}
printf("%.10lf\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void doin() {
cin.tie();
cout.tie();
ios::sync_with_stdio(0);
}
template <typename X, typename Y>
istream& operator>>(istream& in, pair<X, Y>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T>
void getv(T& i) {
cin >> i;
}
template <typename T, typename... Ns>
void getv(vector<T>& v, int n, Ns... ns) {
v.resize(n);
for (auto& i : v) getv(i, ns...);
}
template <typename T>
void getv1(T& i) {
cin >> i;
}
template <typename T, typename... Ns>
void getv1(vector<T>& v, int n, Ns... ns) {
v.resize(n + 1);
for (int i = 1; i <= n; i++) getv1(v[i], ns...);
}
inline void getch(char& x) {
while (x = getchar_unlocked(), x < 33) {
;
}
}
inline void getstr(string& str) {
str.clear();
char cur;
while (cur = getchar_unlocked(), cur < 33) {
;
}
while (cur > 32) {
str += cur;
cur = getchar_unlocked();
}
}
template <typename T>
inline bool sc(T& num) {
bool neg = 0;
int c;
num = 0;
while (c = getchar_unlocked(), c < 33) {
if (c == EOF) return false;
}
if (c == '-') {
neg = 1;
c = getchar_unlocked();
}
for (; c > 47; c = getchar_unlocked()) num = num * 10 + c - 48;
if (neg) num *= -1;
return true;
}
template <typename a, typename b>
void minq(a& x, b y) {
if (x > y) x = y;
}
template <typename a, typename b>
void maxq(a& x, b y) {
if (x < y) x = y;
}
using AntonTsypko = void;
using arsijo = AntonTsypko;
using god = arsijo;
uniform_real_distribution<double> double_dist(0, 1);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, x, y;
vector<long long> a;
bool chk(int i) {
int l = max(0, i - x), r = min(i + y, (int)a.size() - 1);
int m = INT_MAX;
for (; l < i; l++) minq(m, a[l]);
for (; r > i; r--) minq(m, a[r]);
return m > a[i];
}
int main() {
doin();
cin >> n >> x >> y;
getv(a, n);
for (int i = 0; i < n; i++)
if (chk(i)) return cout << i + 1, 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr ll TEN(int n) { return (n==0) ? 1 : 10*TEN(n-1); }
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;
using D = double;
const D PI = acos(D(-1)), EPS = 1e-10;
int sgn(D a) { return (abs(a) <= EPS) ? 0 : (a < 0 ? -1 : 1); }
int sgn(D a, D b) { return sgn(a-b); }
//relative sign
// int rsgn(D a, D f) {
// if (abs(a) <= f*EPS) return 0;
// return (a < 0) ? -1 : 1;
// }
struct Pt2 {
D x, y;
Pt2() {}
Pt2(D _x, D _y) : x(_x), y(_y) {}
Pt2 operator+(const Pt2 &r) const { return Pt2(x+r.x, y+r.y); }
Pt2 operator-(const Pt2 &r) const { return Pt2(x-r.x, y-r.y); }
Pt2 operator*(const Pt2 &r) const { return Pt2(x*r.x-y*r.y, x*r.y+y*r.x); }
Pt2 operator*(const D &r) const { return Pt2(x*r, y*r); }
Pt2 operator/(const D &r) const { return Pt2(x/r, y/r); }
Pt2& operator+=(const Pt2 &r) { return *this=*this+r; }
Pt2& operator-=(const Pt2 &r) { return *this=*this-r; }
Pt2& operator*=(const Pt2 &r) { return *this=*this*r; }
Pt2& operator*=(const D &r) { return *this=*this*r; }
Pt2& operator/=(const D &r) { return *this=*this/r; }
Pt2 operator-() const { return Pt2(-x, -y); }
bool operator<(const Pt2 &r) const { return 2*sgn(x, r.x)+sgn(y, r.y)<0; }
bool operator==(const Pt2 &r) const { return sgn((*this-r).rabs()) == 0; }
D abs() const { return sqrt(x*x + y*y); }
D rabs() const { return max(std::abs(x), std::abs(y)); } // robust abs
D arg() const { return atan2(y, x); }
pair<D, D> to_pair() const { return make_pair(x, y); }
static Pt2 polar(D le, D th) { return Pt2(le*cos(th), le*sin(th)); }
};
ostream& operator<<(ostream& os, const Pt2 &p) {
os << "(" << p.x << ", " << p.y << ")";
return os;
}
using P = Pt2;
struct L {
P s, t;
L() {}
L(P _s, P _t) : s(_s), t(_t) {}
P vec() const { return t-s; }
D abs() const { return vec().abs(); }
D arg() const { return vec().arg(); }
};
D cross(P a, P b) { return a.x*b.y - a.y*b.x; }
D dot(P a, P b) { return a.x*b.x + a.y*b.y; }
// cross(a, b) is too small?
int sgncrs(P a, P b) {
D cr = cross(a, b);
if (abs(cr) <= (a.rabs() + b.rabs()) * EPS) return 0;
return (cr < 0) ? -1 : 1;
}
// -2, -1, 0, 1, 2 : front, clock, on, cclock, back
int ccw(P b, P c) {
int s = sgncrs(b, c);
if (s) return s;
if (c == P(0, 0) || c == b) return 0;
if (dot(b, c) < 0) return 2;
if (dot(-b, c-b) < 0) return -2;
return 0;
}
int ccw(P a, P b, P c) { return ccw(b-a, c-a); }
int ccw(L l, P p) { return ccw(l.s, l.t, p); }
int crossLL(const L &l, const L &m, P &r) {
D cr1 = cross(l.vec(), m.vec()), cr2 = cross(l.vec(), l.t - m.s);
if (sgncrs(l.vec(), m.vec()) == 0) {
r = l.s;
if (sgncrs(l.vec(), l.t - m.s)) return 0;
return -1;
}
r = m.s + m.vec() * (cr2 / cr1);
return 1;
}
int crossSS(L l, L m, P &r) {
int u = crossLL(l, m, r);
if (u == 0) return 0;
if (u == -1) {
r = max(min(l.s, l.t), min(m.s, m.t));
P q = min(max(l.s, l.t), max(m.s, m.t));
return (r == q) ? 1 : (q < r ? 0 : -1);
}
if (ccw(l, r) == 0 && ccw(m, r) == 0) return 1;
return 0;
}
struct C {
P p; D r;
C() {}
C(P p, D r) : p(p), r(r) {}
};
// pからcに接線を引く，交点はp1, p2
int tangent(const C &c, const P &p, P &p1, P &p2) {
D di = (c.p - p).abs();
int si = sgn(c.r, di);
if (si == 1) return 0;
D th = acos(min(D(1), c.r / di));
D ar = (p - c.p).arg();
p1 = c.p + P::polar(c.r, ar-th);
p2 = c.p + P::polar(c.r, ar+th);
if (si == 0) return 1;
return 2;
}
//共通接線
int tangent(const C &c, const C &d, L &l, L &r, bool inter) {
D di = (d.p - c.p).abs(), ar = (d.p - c.p).arg();
if (sgn(di) == 0) {
assert(sgn(c.r - d.r)); // prohibit same circles
return 0;
}
D costh = (c.r + (inter ? d.r : -d.r)) / di;
int si = sgn(abs(costh), 1);
if (si == 1) return 0;
D th = acos(min(D(1), max(D(-1), costh)));
P base;
base = P::polar(1, ar-th);
l = L(c.p + base * c.r, d.p + base * d.r * (inter ? -1 : 1));
base = P::polar(1, ar+th);
r = L(c.p + base * c.r, d.p + base * d.r * (inter ? -1 : 1));
if (si == 0) return 1;
return 2;
}
P project(const L &l, const P &p) {
P v = l.vec();
return l.s + v * (dot(v, p-l.s) / (v.x*v.x + v.y*v.y));
}
D distLP(const L &l, const P &p) {
return abs(cross(l.vec(), p-l.s)) / l.abs();
}
//need Intersect/distLP
int crossCL(const C &c, const L &l, L &r) {
D u = distLP(l, c.p);
int si = sgn(u, c.r);
if (si == 1) return 0;
P v = project(l, c.p);
P di = (si == 0) ? P(0, 0) : l.vec() * (sqrt(c.r*c.r - u*u) / l.abs());
r = L(v+di, v-di);
if (si == 0) return 1;
return 2;
}
bool solve() {
int n;
D x, y, r, R;
P s, t;
cin >> n >> r >> R;
if (!n) return false;
cin >> x >> y;
s = P(x, y);
cin >> x >> y;
t = P(x, y);
D th = PI / n;
D z = 2 * (r / sin(th)) * cos(th / 2);
if (z + r > R) {
cout << "-1" << endl;
return true;
}
V<C> poles(4);
poles[0] = C(P::polar(R, th/2), r);
poles[1] = C(P::polar(R, -th/2), r);
poles[2] = C(P::polar(R, th/2+PI), r);
poles[3] = C(P::polar(R, -th/2+PI), r);
auto can = [&](P p) {
D pd = p.abs();
if (sgn(pd, z) == -1) return false;
if (sgn(abs(p.x), r) == -1) {
if (sgn(abs(p.y), R) == 1) return false;
}
for (auto c: poles) {
if (sgn((c.p-p).abs(), c.r) == -1) return false;
}
if (sgn(pd, R-r) == 1 && sgn(pd, R+r) == -1) {
D ar = p.arg();
if (sgn(ar, th/2) == 1 && sgn(ar, PI-th/2) == -1) return false;
if (sgn(ar, -th/2) == -1 && sgn(ar, -PI+th/2) == 1) return false;
}
return true;
};
V<C> circles = poles;
circles.push_back(C(P(0, 0), R-r));
circles.push_back(C(P(0, 0), R+r));
circles.push_back(C(P(0, 0), z));
V<P> pred;
auto canl = [&](L s) {
V<P> v = {s.s, s.t};
for (auto c: circles) {
L l;
if (crossCL(c, s, l)) {
if (ccw(s, l.s) == 0) v.push_back(l.s);
if (ccw(s, l.t) == 0) v.push_back(l.t);
}
}
P p;
if (crossLL(s, L(P(-r, 0), P(-r, 1)), p)) {
if (ccw(s, p) == 0) v.push_back(p);
}
if (crossLL(s, L(P(r, 0), P(r, 1)), p)) {
if (ccw(s, p) == 0) v.push_back(p);
}
sort(begin(v), end(v));
int n = int(v.size());
for (int i = 0; i < n-1; i++) {
P p = (v[i]+v[i+1])/2;
if (!can(p)) return false;
}
for (int i = 0; i < n; i++) assert(can(v[i]));
return true;
};
for (auto c: circles) {
P p1, p2;
if (tangent(c, s, p1, p2)) {
pred.push_back(p1);
pred.push_back(p2);
}
if (tangent(c, t, p1, p2)) {
pred.push_back(p1);
pred.push_back(p2);
}
for (auto d: circles) {
if (c.p == d.p && sgn(c.r, d.r) == 0) continue;
L l1, l2;
for (int f = 0; f <= 1; f++) {
if (tangent(c, d, l1, l2, f)) {
pred.insert(end(pred), {l1.s, l1.t, l2.s, l2.t});
}
}
}
}
sort(begin(pred), end(pred));
pred.erase(unique(begin(pred), end(pred)), end(pred));
pred.erase(remove_if(begin(pred), end(pred), [&](P p){
return !can(p);
}), end(pred));
pred.push_back(s);
pred.push_back(t);
int gn = int(pred.size());
VV<D> di(gn, V<D>(gn, 1e30));
for (int i = 0; i < gn; i++) {
di[i][i] = 0;
for (int j = i+1; j < gn; j++) {
D ans = 1e100;
P pi = pred[i], pj = pred[j];
if (canl(L(pi, pj))) {
ans = min(ans, (pi - pj).abs());
}
for (auto c: poles) {
if (sgn((c.p - pi).abs(), c.r) == 0 && sgn((c.p - pj).abs(), c.r) == 0) {
D ar = fmod((pi - c.p).arg() - (pj - c.p).arg() + 4*PI, 2*PI);
ar = min(ar, 2*PI - ar);
ans = min(ans, c.r * ar);
}
}
{
C c = C(P(0, 0), z);
if (sgn((c.p - pi).abs(), c.r) == 0 && sgn((c.p - pj).abs(), c.r) == 0) {
D ar = fmod((pi - c.p).arg() - (pj - c.p).arg() + 4*PI, 2*PI);
ar = min(ar, 2*PI - ar);
ans = min(ans, c.r * ar);
}
}
{
C c = C(P(0, 0), R-r);
if (sgn((c.p - pi).abs(), c.r) == 0 && sgn((c.p - pj).abs(), c.r) == 0) {
D ar = fmod((pi - c.p).arg() - (pj - c.p).arg() + 4*PI, 2*PI);
ar = min(ar, 2*PI - ar);
ans = min(ans, c.r * ar);
}
}
{
C c = C(P(0, 0), R+r);
if (sgn((c.p - pi).abs(), c.r) == 0 && sgn((c.p - pj).abs(), c.r) == 0
&& sgn(pi.x) == sgn(pj.x)) {
assert(sgn(abs(pi.x), r) != -1);
assert(sgn(abs(pj.x), r) != -1);
D ar = fmod((pi - c.p).arg() - (pj - c.p).arg() + 4*PI, 2*PI);
ar = min(ar, 2*PI - ar);
ans = min(ans, c.r * ar);
}
}
di[i][j] = di[j][i] = ans;
}
}
for (int k = 0; k < gn; k++) {
for (int i = 0; i < gn; i++) {
for (int j = 0; j < gn; j++) {
di[i][j] = min(di[i][j], di[i][k] + di[k][j]);
}
}
}
cout << di[gn-2][gn-1] << endl;
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20);
while (solve()) {}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int setBit(int N, int pos) { return N = N | (1 << pos); }
inline int resetBit(int N, int pos) { return N = N & ~(1 << pos); }
inline bool checkBit(int N, int pos) { return (bool)(N & (1 << pos)); }
long long n, m;
string s, t;
int hour_dig, min_dig;
void gen() {
s = t = "";
int cnt = 0;
while (n) {
s += (n % 7) + '0';
n /= 7;
cnt++;
}
cnt = 0;
while (m) {
t += (m % 7) + '0';
m /= 7;
cnt++;
}
reverse(s.begin(), s.end());
reverse(t.begin(), t.end());
if (s.size() == 0) s = "0";
if (t.size() == 0) t = "0";
hour_dig = s.size();
min_dig = t.size();
}
long long dp[10][3][(1 << 7) + 5], gp[10][3][(1 << 7) + 5];
long long go(int pos, bool sml, int mask) {
if (pos == min_dig) {
return 1;
}
if (mask == ((1 << 7) - 1)) return 0;
long long &ret = gp[pos][sml][mask];
if (ret != -1) return ret;
ret = 0;
if (sml) {
for (int i = 0; i <= 6; i++) {
if (checkBit(mask, i) == 0) ret += go(pos + 1, sml, setBit(mask, i));
}
} else {
for (int i = 0; i <= (t[pos] - '0'); i++) {
if (checkBit(mask, i) == 0) {
if (i == t[pos] - '0')
ret += go(pos + 1, 0, setBit(mask, i));
else
ret += go(pos + 1, 1, setBit(mask, i));
}
}
}
return ret;
}
long long call(int pos, bool sml, int mask) {
if (pos == hour_dig) {
return go(0, 0, mask);
}
if (mask == ((1 << 7) - 1)) return 0;
long long &ret = dp[pos][sml][mask];
if (ret != -1) return ret;
ret = 0;
if (sml) {
for (int i = 0; i <= 6; i++) {
if (checkBit(mask, i) == 0) ret += call(pos + 1, sml, setBit(mask, i));
}
} else {
for (int i = 0; i <= (s[pos] - '0'); i++) {
if (checkBit(mask, i) == 0) {
if (i == s[pos] - '0')
ret += call(pos + 1, 0, setBit(mask, i));
else
ret += call(pos + 1, 1, setBit(mask, i));
}
}
}
return ret;
}
int main() {
int i, j, k, cs;
memset(dp, -1, sizeof(dp));
;
memset(gp, -1, sizeof(gp));
;
scanf("%lld %lld", &n, &m);
n--;
m--;
gen();
printf("%lld\n", call(0, 0, 0));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int N;
cin >> N;
int A[N], i, j, tot = 0, max = 0;
for (i = 0; i < N; ++i) {
cin >> A[i];
}
sort(A, A + N, greater<int>());
int l, b;
for (i = 0; i < N; ++i) {
l = A[i];
b = i + 1;
if ((b <= l) && max < b) {
max = b;
}
}
cout << max << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ans = 0;
int deg[1013], ged[1013];
pair<int, int> has[2][1013][1013];
int color[100013];
int c[2];
void dfs(int x, int p) {
auto i = has[p][x][c[p ^ 1]];
if (has[p ^ 1][i.first][c[p]].second)
dfs(i.first, p ^ 1);
else
has[p ^ 1][i.first][c[p ^ 1]] = make_pair(0, 0);
has[p][x][c[p]] = i;
has[p ^ 1][i.first][c[p]] = make_pair(x, i.second);
color[i.second] = c[p];
}
int main() {
scanf("%*d%*d%d", &m);
n = 1000;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
deg[x] += 1;
ged[y] += 1;
ans = max(ans, deg[x]);
ans = max(ans, ged[y]);
for (c[0] = 1; has[0][x][c[0]].second; c[0]++)
;
for (c[1] = 1; has[1][y][c[1]].second; c[1]++)
;
if (c[0] != c[1]) dfs(y, 1);
has[0][x][c[0]] = make_pair(y, i);
has[1][y][c[0]] = make_pair(x, i);
color[i] = c[0];
}
printf("%d\n", ans);
for (int i = 1; i <= m; i++) printf("%d ", color[i]);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0;
bool f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
const int N = 3e6 + 10;
const int mod = 1e9 + 7;
const int inv3 = (mod + 1) / 3;
int fac[N], ifac[N], n, q, f[N][3];
long long qp(long long x, int t) {
long long res = 1;
for (; t; t >>= 1, x = x * x % mod)
if (t & 1) res = res * x % mod;
return res;
}
int upd(int x) { return x + (x >> 31 & mod); }
long long C(int x, int y) {
return x < y || x < 0 || y < 0
? 0
: (long long)fac[x] * ifac[y] % mod * ifac[x - y] % mod;
}
int main() {
n = read(), q = read();
for (int i = (fac[0] = 1); i <= 3 * n + 1; i++)
fac[i] = (long long)fac[i - 1] * i % mod;
ifac[3 * n + 1] = qp(fac[3 * n + 1], mod - 2);
for (int i = 3 * n; i >= 0; i--)
ifac[i] = (long long)ifac[i + 1] * (i + 1) % mod;
f[0][0] = f[0][1] = f[0][2] = n;
for (int i = 1; i <= 3 * n; i++) {
f[i][0] = upd(C(3 * n, i + 1) - 2ll * f[i - 1][0] % mod);
f[i][0] = upd(f[i][0] - f[i - 1][1] % mod);
f[i][0] = (long long)f[i][0] * inv3 % mod;
f[i][1] = upd(f[i - 1][0] + f[i][0] - mod);
f[i][2] = upd(f[i - 1][1] + f[i][1] - mod);
}
while (q--) {
int x = read();
if (x == 3 * n) {
printf("%d\n", 1);
continue;
}
long long ans = f[x][0] + C(3 * n, x);
ans %= mod;
printf("%lld\n", ans);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
string s;
int main() {
cin >> N >> K >> s;
for (int i = 0; i < N; i++) {
if (K == 0) break;
if ((i + 1) % 2 != 0) {
if (i < N - 1 && s[i] == '4' && s[i + 1] == '7') {
s[i] = s[i + 1] = '4';
K--;
}
} else {
if (i < N - 1 && s[i] == '4' && s[i + 1] == '7') {
if (i > 0 && s[i - 1] == '4') {
if (K % 2 != 0) s[i] = s[i + 1] = '7';
break;
} else {
s[i] = s[i + 1] = '7';
K--;
}
}
}
}
cout << s << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (int)1e9 + 7;
const int mod = (int)1e9 + 7;
const int N = (int)1e5 + 2;
int n, degree[N];
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d %d", &x, &y);
degree[x]++, degree[y]++;
}
for (int i = 1; i <= n; ++i) {
if (degree[i] == 2) return !printf("NO\n");
}
printf("YES\n");
return 0;
}
| 1 |
#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
int g[16][16],n,x,y,now;
void func2(void);
void func1(void){
if(x>=n)x=0;
if(x<0)x=n-1;
if(y>=n)y=0;
if(g[y][x]>0)func2();
}
void func2(void){
if(g[y][x]>0) x--,y++;
if(x>=n || x<0 || y>=n)func1();
}
int main(void){
while(cin >> n,n){
for(int i=0;i<16;i++)
for(int j=0;j<16;j++)
g[i][j]=0;
x=n/2;
y=n/2+1;
g[y][x]=1;
now=2;
for(int i=1;i<n*n;i++,now++){
x++;
y++;
if(x>=n || x<0 || y>=n)func1();
if(g[y][x]>0)func2();
g[y][x]=now;
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
printf("%4d",g[i][j]);
}
cout << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, c, n;
char b;
cin >> r >> c;
vector<vector<int> > v(101);
bool wrong = 0;
for (int i = 0; i < r; i++) {
bool at_least_once = 0;
for (int j = 0; j < c; j++) {
cin >> b;
n = b - '0';
if (n == 1) {
at_least_once = 1;
v[i].push_back(j);
}
}
if (!at_least_once) {
wrong = 1;
}
}
if (wrong) {
cout << -1;
return 0;
}
int ans = 1e9;
for (int i = 0; i < c; i++) {
int anss = 0, one, two;
for (int j = 0; j < r; j++) {
if (!(binary_search(v[j].begin(), v[j].end(), i))) {
int pos = upper_bound(v[j].begin(), v[j].end(), i) - v[j].begin();
if (pos >= v[j].size()) {
one = abs(i - v[j][(int)v[j].size() - 1]);
two = v[j][0] + c - i;
if (v[j].size() == 1) two = c - one;
anss += min(one, two);
} else if (pos <= v[j].size() - 1 && pos > 0) {
one = abs(v[j][pos] - i);
two = abs(i - v[j][pos - 1]);
anss += min(one, two);
} else {
one = abs(v[j][pos] - i);
two = abs(c - v[j][(int)v[j].size() - 1] + i);
anss += min(one, two);
}
}
}
if (anss < ans) ans = anss;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const int mod = 998244353;
void inc(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int qpow(int a, int b) {
int tmp = 1;
while (b) {
if (b & 1) tmp = 1ll * tmp * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return tmp;
}
int n, ni, q, hd[N], cnt, siz[N], fa[N], dep[N], son[N], top[N], dfn[N], dfc,
w[N];
struct Edge {
int to, nxt;
} e[N << 1];
void adde(int u, int v) {
e[++cnt].to = v;
e[cnt].nxt = hd[u];
hd[u] = cnt;
e[++cnt].to = u;
e[cnt].nxt = hd[v];
hd[v] = cnt;
}
void dfs1(int u) {
siz[u] = 1;
for (int i = hd[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa[u]) continue;
fa[v] = u;
dep[v] = dep[u] + 1;
dfs1(v);
siz[u] += siz[v];
if (siz[v] > siz[son[u]]) son[u] = v;
}
}
void dfs2(int u, int topf) {
top[u] = topf;
dfn[u] = ++dfc;
if (!son[u]) return;
dfs2(son[u], topf);
for (int i = hd[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa[u] || v == son[u]) continue;
dfs2(v, v);
}
}
namespace BIT {
int c[N];
void modify(int x, int v) {
for (int i = x; i <= n; i += (i & -i)) {
inc(c[i], v);
}
}
int query(int x) {
long long sum = 0;
for (int i = x; i >= 1; i ^= (i & -i)) {
sum += c[i];
}
return sum % mod;
}
} // namespace BIT
void add(int l, int r, int v) {
BIT::modify(l, v);
BIT::modify(r + 1, mod - v);
}
void modifysubtree(int x, int d) { add(dfn[x], dfn[x] + siz[x] - 1, d); }
void modify(int x, int d) {
inc(w[x], d);
if (son[x]) modifysubtree(son[x], 1ll * (n - siz[son[x]]) * d % mod);
if (!fa[x]) return;
modifysubtree(1, 1ll * siz[x] * d % mod);
modifysubtree(x, 1ll * siz[x] * (mod - d) % mod);
}
void query(int x) {
int sum = BIT::query(dfn[x]);
sum = (sum + 1ll * n * w[x]) % mod;
while (x) {
sum = (sum + 1ll * w[fa[top[x]]] * (n - siz[top[x]])) % mod;
x = fa[top[x]];
}
printf("%d\n", 1ll * sum * ni % mod);
}
int main() {
scanf("%d%d", &n, &q);
ni = qpow(n, mod - 2);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
adde(u, v);
}
dfs1(1);
dfs2(1, 1);
for (int i = 1; i <= q; ++i) {
int op, x, d;
scanf("%d%d", &op, &x);
if (op == 1) {
scanf("%d", &d);
modify(x, d);
} else
query(x);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 5e5 + 100;
int t[MN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> t[i];
}
int b = 0;
int ma = 0;
for (; b < n; ++b) {
if (b == n - 1 || t[b] != t[b + 1]) break;
}
while (b < n - 1) {
int x = 0;
for (x = b + 1; x < n; ++x) {
if (x == n - 1 || t[x] == t[x + 1]) break;
}
if (x == b + 1) {
++b;
for (; b < n; ++b) {
if (b == n - 1 || t[b] != t[b + 1]) break;
}
}
if (t[b] != t[x]) {
ma = max(ma, (x - b) / 2);
for (int i = 0; i < (x - b) / 2; ++i) {
t[b + i + 1] = t[b];
t[x - i - 1] = t[x];
}
for (; b < n; ++b) {
if (b == n - 1 || t[b] != t[b + 1]) break;
}
} else {
ma = max(ma, (x - b) / 2);
for (int i = b; i < x; ++i) {
t[i] = t[b];
}
for (; b < n; ++b) {
if (b == n - 1 || t[b] != t[b + 1]) break;
}
}
}
cout << ma << '\n';
for (int i = 0; i < n; ++i) {
cout << t[i] << ' ';
}
cout << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
for (int i = 0; i < str.length(); i++) {
if (i == 0 && str[i] == '9') continue;
if (str[i] >= '5') str[i] = '9' - str[i] + '0';
}
cout << str << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long nax = 100005, mod = 1e9 + 7;
vector<long long> g[nax];
long long c[nax], dp[nax][2] = {{0}};
long long mod_expo(long long a, long long b) {
long long tans = 1;
a = a % mod;
while (b != 0) {
if (b & 1) tans = (1LL * tans * a) % mod;
a = (1LL * a * a) % mod;
b /= 2;
}
return tans;
}
long long mod_inv(long long a) { return mod_expo(a, mod - 2); }
long long sum(long long a, long long b) { return (a + b) % mod; }
long long mul(long long a, long long b) { return (a * b) % mod; }
long long divm(long long a, long long b) { return (a * mod_inv(b)) % mod; }
void dfs(long long u, long long p) {
for (auto &k : g[u])
if (k != p) dfs(k, u);
if (c[u] == 0) {
dp[u][0] = 1;
for (auto &k : g[u])
if (k != p) dp[u][0] = (dp[u][0] * (dp[k][0] + dp[k][1])) % mod;
dp[u][1] = 0;
long long zpi = 1;
for (auto &k : g[u])
if (k != p) zpi = (zpi * (dp[k][0] + dp[k][1])) % mod;
for (auto &k : g[u])
if (k != p)
dp[u][1] =
sum(dp[u][1], mul(divm(zpi, (dp[k][0] + dp[k][1])), dp[k][1]));
} else {
dp[u][0] = 0;
dp[u][1] = 1;
for (auto &k : g[u])
if (k != p) dp[u][1] = (dp[u][1] * (dp[k][0] + dp[k][1])) % mod;
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long x;
cin >> x;
g[i + 1].push_back(x);
g[x].push_back(i + 1);
}
for (long long i = 0; i < n; i++) cin >> c[i];
dfs(0, 0);
cout << dp[0][1] << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void online_judge() {}
void ISO() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
ISO();
online_judge();
int t;
cin >> t;
while (t--) {
long long int n;
long long y;
cin >> n >> y;
long long ans = 0;
long long int a[n];
for (int i = 0; i < n; ++i) {
long long int k;
cin >> k;
a[i] = k;
}
sort(a, a + n);
for (int i = 1; i < n; ++i) {
if (a[i] > y) {
break;
} else {
ans += (y - a[i]) / a[0];
}
}
cout << ans << "\n";
}
cerr << "Time elapsed: " << clock() / 1000 << " ms" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5 * 1e5 + 10;
char str[N];
bool st[N];
char s[2][10] = {"Ann", "Mike"};
int main() {
scanf("%s", str + 1);
int len = strlen(str + 1);
char min_ch;
for (int i = 1; i <= len; i++) {
if (i == 1) {
min_ch = str[i];
st[i] = true;
} else {
if (str[i] <= min_ch) {
st[i] = true;
min_ch = str[i];
} else {
st[i] = false;
}
}
}
for (int i = 1; i <= len; i++) {
cout << s[st[i]] << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
vector<int> vec;
int count = 0;
int N;
cin >> N;
int arr[N - 1][2];
for (int i = 0; i < (N - 1); i++) {
for (int j = 0; j < 2; j++) {
cin >> arr[i][j];
}
}
for (int search_item = 1; search_item <= N; search_item++) {
for (int p = 0; p < (N - 1); p++) {
for (int q = 0; q < 2; q++) {
if (arr[p][q] == search_item) {
count++;
break;
}
}
}
if (count == 1) {
vec.push_back(search_item);
count -= count;
} else {
count -= count;
}
}
cout << vec.size() << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T& t) {
cin >> t;
}
template <typename T, typename... U>
void read(T& t, U&... u) {
read(t);
read(u...);
}
template <typename T>
void write(T t) {
cout << t;
}
template <typename T, typename... U>
void write(T t, U... u) {
write(t);
write(u...);
}
const vector<pair<int, int>> dxy = {pair<int, int>(0, -1), pair<int, int>(0, 1),
pair<int, int>(-1, 0),
pair<int, int>(1, 0)};
const long double EPS = 1e-9L, PI = acos(-1.0L);
const long long INFLL = 4e18L;
const int INF = 2e9, MOD = 1e9 + 7, LOGN = 16 + 1;
const int N = 2e5 + 3, N2 = +3;
struct DSU {
vector<int> rep, size, nbe;
DSU() {}
DSU(int n) {
rep.assign(n + 1, 0);
size.assign(n + 1, 1);
nbe.assign(n + 1, 0);
for (int i = 1; i <= n; ++i) rep[i] = i;
}
int find(int x) { return (rep[x] == x) ? x : rep[x] = find(rep[x]); }
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x != y) size[x] += size[y], rep[y] = x, nbe[x] += nbe[y];
}
};
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
write(fixed, setprecision(12));
int n, m;
read(n, m);
vector<pair<int, pair<int, int>>> in;
for (int i = 1; i <= m; ++i) {
int a, b, cost;
read(a, b, cost);
in.push_back({cost, {a, b}});
}
sort(in.begin(), in.end());
reverse(in.begin(), in.end());
int ans = 0;
DSU dsu(n);
for (auto el : in) {
int a = el.second.first;
int b = el.second.second;
int cost = el.first;
int rep_a = dsu.find(a);
int rep_b = dsu.find(b);
if (rep_a == rep_b && dsu.size[rep_a] >= 1 + dsu.nbe[rep_a]) {
ans += cost;
++dsu.nbe[rep_a];
}
if (rep_a != rep_b && dsu.size[rep_a] + dsu.size[rep_b] >=
1 + dsu.nbe[rep_a] + dsu.nbe[rep_b]) {
ans += cost;
dsu.unite(rep_a, rep_b);
++dsu.nbe[dsu.find(rep_a)];
}
}
write(ans, "\n");
}
| 6 |
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define PI acos(-1)
#define Mod (int)1000000007
#define INFTY (int)INT_MAX
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
#define BitRep(i, n) for (int i = 0; i < (int)(1 << n); i++)
#define All(vec) vec.begin(), vec.end()
#define Part(vec, b, e) vec.begin() + b, vec.begin() + e
#define Sum(vec) accumulate(vec.begin(), vec.end(), 0)
#define Sort(vec) sort(vec.begin(), vec.end())
#define Reverse(vec) reverse(vec.begin(), vec.end())
#define Count(vec, x) count(vec.begin(), vec.end(), x)
#define Next_permutation(vec) next_permutation(vec.begin(), vec.end())
#define Find(S, s) S.find(s) != string::npos
int main() {
set<int> S;
int q;
cin >> q;
Rep(i, q) {
int n, x;
cin >> n >> x;
if (n == 0) {
S.insert(x);
cout << S.size() << endl;
}
else if (n == 1) {
if (S.find(x) != S.end()) cout << 1 << endl;
else cout << 0 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct state {
short int len, link;
map<char, int> next;
};
state st[12000];
short int vis[12000][5001];
int dp[5005];
int sz, last;
void sa_init() {
sz = last = 0;
st[0].len = 0;
st[0].link = -1;
++sz;
}
char str[5005];
void sa_extend(char c) {
int cur = sz++;
st[cur].len = st[last].len + 1;
int p;
for (p = last; p != -1 && !st[p].next.count(c); p = st[p].link)
st[p].next[c] = cur;
if (p == -1)
st[cur].link = 0;
else {
int q = st[p].next[c];
if (st[p].len + 1 == st[q].len)
st[cur].link = q;
else {
int clone = sz++;
st[clone].len = st[p].len + 1;
st[clone].next = st[q].next;
st[clone].link = st[q].link;
for (; p != -1 && st[p].next[c] == q; p = st[p].link)
st[p].next[c] = clone;
st[q].link = st[cur].link = clone;
}
}
last = cur;
}
int big = 100000000;
int main() {
int i, j, k, l, m, n, a, b;
cin >> n >> a >> b;
scanf("%s", &str);
sa_init();
for (int i = n - 1; i >= 0; i--) {
sa_extend(str[i]);
}
for (int i = 0; str[i]; i++) {
int cur = 0;
dp[i] = big;
for (int j = i, ln = 1; j >= 0; j--, ln++) {
char c = str[j];
cur = st[cur].next[c];
int f = 0;
if (j) f = dp[j - 1];
if (ln == 1) {
dp[i] = min(dp[i], f + a);
}
if (vis[cur][ln] == 0) {
vis[cur][ln] = i + 1;
continue;
}
int g = vis[cur][ln] - 1;
if (g < j) dp[i] = min(dp[i], f + b);
}
}
cout << dp[n - 1] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
int n, m, t, q;
vector<long long> G;
map<int, int> M;
set<int> S;
struct node {
long long x, y;
} a[N];
bool cmp(node aa, node bb) { return aa.x < bb.x; }
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); i++) scanf("%lld", &a[i].x);
for (int i = (1); i <= (n); i++) scanf("%lld", &a[i].y);
sort(a + 1, a + n + 1, cmp);
for (int i = (1); i <= (n - 1); i++)
if (a[i].x == a[i + 1].x) G.push_back(a[i].x);
int sz = G.size();
long long ans = 0;
for (int i = (1); i <= (n); i++) {
for (int j = (0); j <= (sz - 1); j++) {
if ((G[j] | a[i].x) == G[j]) {
ans += a[i].y;
break;
}
}
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y,
long long int p = 1e9 + 7) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) {
res = (res * x) % p;
}
x = (x * x) % p;
y = y >> 1;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
cin >> t;
while (t--) {
long long int i, j, k, n, l;
vector<long long int> v;
cin >> n;
for (i = 0; i < n; i++) {
cin >> k;
v.push_back(k);
}
if (n == 1) {
cout << 1 << " " << v[0] << " " << 0 << endl;
continue;
}
i = 0;
j = n;
long long int c = 1;
long long int sum = v[0];
long long int u = 1;
long long int p = 0;
while (i != j) {
if (u) {
c++;
j--;
if (i == j) {
j++;
p = 1;
c--;
break;
}
long long int temp = v[j];
while (temp <= sum) {
j--;
if (i == j) {
p = 1;
j++;
break;
}
temp += v[j];
}
sum = temp;
if (p) break;
u = 0;
} else {
c++;
i++;
if (i == j) {
p = 1;
c--;
i--;
break;
}
if (p) break;
long long int temp = v[i];
while (temp <= sum) {
i++;
if (i == j) {
p = 1;
i--;
break;
}
temp += v[i];
}
if (p) break;
sum = temp;
u = 1;
}
}
long long int sum1 = 0, sum2 = 0;
for (l = 0; l < i + 1; l++) sum1 += v[l];
for (l = n - 1; l >= j; l--) sum2 += v[l];
cout << c << " " << sum1 << " " << sum2 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void show(const T& v) {
cerr << v << ' ';
}
template <typename T1, typename... T2>
void show(const T1& first, const T2&... rest) {
show(first);
show(rest...);
}
template <typename F, typename S>
ostream& operator<<(ostream& os, const pair<F, S>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
typename vector<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[";
typename set<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream& operator<<(ostream& os, const map<F, S>& v) {
os << "[";
typename map<F, S>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
const double eps = 1e-9;
const long long lim = 1e5 + 5;
long long n, m;
long long arr[lim], brr[lim];
long long f(long long x) {
long long ans = 0;
for (int i = 0; i < n; i++) {
if (arr[i] < x) ans += (x - arr[i]);
}
for (int i = 0; i < m; i++) {
if (brr[i] > x) ans += (brr[i] - x);
}
return ans;
}
void solve() {
long long lo = INT_MAX, hi = INT_MIN;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> arr[i], lo = min(lo, arr[i]);
for (int i = 0; i < m; i++) cin >> brr[i], hi = max(hi, brr[i]);
if (lo >= hi) {
cout << "0\n";
return;
}
while (hi - lo >= 3) {
long long m1 = lo + (hi - lo) / 3;
long long m2 = hi - (hi - lo) / 3;
if (f(m1) > f(m2))
lo = m1;
else
hi = m2;
}
long long ans = 1e18;
for (int i = lo; i <= hi; i++) {
long long temp = f(i);
ans = min(ans, temp);
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int t = 1, cs = 0;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 20;
const long long inf = 2e15;
long long d[N], inq[N];
queue<int> q;
long long n, m, k;
struct node {
long long x, y;
} p[N];
long long SPFA() {
for (int i = 1; i <= k; i++) d[i] = inf, inq[i] = 0;
while (!q.empty()) q.pop();
q.push(1), inq[1] = 1, d[1] = 0;
while (!q.empty()) {
int u = q.front();
q.pop(), inq[u] = 0;
for (int i = 1; i <= k; i++) {
if (i == u) continue;
long long val = inf;
int dx = abs(p[u].x - p[i].x), dy = abs(p[u].y - p[i].y);
if (dx + dy == 1)
val = 0;
else if (dx <= 2 || dy <= 2)
val = 1;
if (d[i] > d[u] + val) {
d[i] = d[u] + val;
if (!inq[i]) inq[i] = 1, q.push(i);
}
}
}
if (d[k] == inf) d[k] = -1;
return d[k];
}
int main() {
while (cin >> n >> m >> k) {
bool flag = false;
for (int i = 1; i <= k; i++) {
scanf("%I64d%I64d", &p[i].x, &p[i].y);
if (p[i].x == n && p[i].y == m) flag = true;
}
if (flag == false) p[++k].x = n + 1, p[k].y = m + 1;
cout << SPFA() << endl;
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
map<pair<int, int> , int> ans;
int gcd(int a, int b)
{
return (!b) ? a : gcd(b, a % b);
}
void solve()
{
int n;
scanf("%d", &n);
int D = 0, K = 0;
for(int i = 1; i <= n; i++)
{
char cur;
scanf(" %c", &cur);
if(cur == 'D') D++;
else K++;
int div = gcd(D, K);
ans[{D / div, K / div}]++;
printf("%d ", ans[{D / div, K / div}]);
}
printf("\n");
ans.clear();
}
int main ()
{
int t;
scanf("%d", &t);
while(t--) solve();
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double pii = 2 * pi;
const double eps = 1e-6;
const long long MOD = 1e9 + 7;
void solve() {
int n, t;
cin >> n >> t;
string x, y;
cin >> x >> y;
int ctr = 0;
for (int i = 0; i < n; i++)
if (x[i] != y[i]) ctr++;
if (t > ctr) {
t -= ctr;
string ans = x;
for (int i = 0; i < n; i++) {
if (x[i] != y[i]) {
char xx = 'a';
while (xx == x[i] || xx == y[i]) xx++;
ans[i] = xx;
} else {
if (t > 0) {
char xx = 'a';
while (xx == x[i]) xx++;
ans[i] = xx;
t--;
} else {
ans[i] = x[i];
}
}
}
cout << ans << "\n";
return;
} else {
int a = 0;
for (a = 0; a < ctr; a++) {
if (2 * a <= ctr && ctr - a == t) {
break;
}
}
if (!(2 * a <= ctr && ctr - a == t)) {
cout << "-1\n";
return;
}
a *= 2;
string ans = x;
for (int i = 0; i < n; i++) {
if (x[i] == y[i])
ans[i] = x[i];
else {
if (a > 0) {
if (a % 2 == 0) {
ans[i] = x[i];
a--;
} else {
ans[i] = y[i];
a--;
}
} else {
char xx = 'a';
while (x[i] == xx || y[i] == xx) xx++;
ans[i] = xx;
}
}
}
cout << ans << "\n";
return;
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, sum = 0;
cin >> t;
while (t--) {
string s;
cin >> s;
if (s == "Tetrahedron") {
sum += 4;
}
if (s == "Cube") {
sum += 6;
}
if (s == "Octahedron") {
sum += 8;
}
if (s == "Dodecahedron") {
sum += 12;
}
if (s == "Icosahedron") {
sum += 20;
}
}
cout << sum << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, vis[2001], Color[2001], par[2001], d[2001];
vector<vector<int> > G(2001), G1(2001);
queue<int> q;
void make_orientation(int);
void set_color(int, int);
void find_bridge(int);
void print_colors();
void print_graph();
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
G1[x].push_back(y);
G1[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
sort(G[i].begin(), G[i].end());
sort(G1[i].begin(), G1[i].end());
}
make_orientation(1);
int color = 1;
while (!q.empty()) {
if (vis[q.front()] != 2) {
set_color(q.front(), color);
color++;
}
q.pop();
}
int k, s, f;
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d%d", &s, &f);
int cnt = 0;
while (!q.empty()) q.pop();
for (int j = 1; j <= n; j++) vis[j] = 0;
q.push(s);
while (!vis[f]) {
int v = q.front();
q.pop();
vis[v] = 2;
for (int j = 0; j < G1[v].size(); j++) {
if (!vis[G1[v][j]]) {
q.push(G1[v][j]);
vis[G1[v][j]] = 1;
par[G1[v][j]] = v;
}
}
}
int v = f;
while (v != s) {
cnt += (Color[v] != Color[par[v]]);
v = par[v];
}
d[i] = cnt;
}
for (int i = 1; i <= k; i++) printf("%d\n", d[i]);
return 0;
}
void make_orientation(int v) {
vis[v] = 1;
q.push(v);
for (int i = 0; i < G[v].size(); i++)
if (!vis[G[v][i]]) {
int t = G[v][i];
G[v].erase(G[v].begin() + i);
make_orientation(t);
i--;
}
}
void set_color(int v, int color) {
vis[v] = 2;
Color[v] = color;
for (int i = 0; i < G[v].size(); i++)
if (vis[G[v][i]] != 2) set_color(G[v][i], color);
}
void find_bridge(int v) {
vis[v] = 3;
for (int i = 0; i < G1[v].size(); i++)
if (vis[G1[v][i]] != 3) {
if (Color[v] != Color[G1[v][i]]) printf("%d %d\n", v, G1[v][i]);
find_bridge(G1[v][i]);
}
}
void print_graph() {
printf("\n\n");
for (int i = 1; i <= n; i++) {
for (int j = 0; j < G[i].size(); j++) printf("%d ", G[i][j]);
printf("\n");
}
printf("\n\n");
}
void print_colors() {
printf("\n\n");
for (int i = 1; i <= n; i++) printf("%d ", Color[i]);
printf("\n\n");
}
| 2 |
Subsets and Splits