solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int N = 2e5 + 10;
bool check(vector<int> v, int x = 0, int y = 0) {
if (x) v.push_back(x);
if (y) v.push_back(y);
sort(v.begin(), v.end());
int q1 = (v[0] + v[1] + v[2] + v[3]);
int q2 = (v[1] + v[2]) * 2;
int q3 = (v[3] - v[0]) * 4;
if (q1 == q2 && q2 == q3) {
cout << "YES" << endl;
if (x) cout << x << endl;
if (y) cout << y << endl;
return true;
}
return false;
}
int main() {
int n;
cin >> n;
vector<int> v(n);
for (auto &x : v) cin >> x;
if (n == 0) {
cout << "YES" << endl;
cout << 1 << endl;
cout << 1 << endl;
cout << 3 << endl;
cout << 3 << endl;
return 0;
}
if (n == 1) {
cin >> v[0];
int x = v[0];
cout << "YES" << endl;
cout << x << endl;
cout << 3 * x << endl;
cout << 3 * x << endl;
return 0;
}
if (n == 4) {
if (!check(v)) cout << "NO" << endl;
return 0;
}
if (n == 2) {
for (int i = 1; i <= 2000; i++) {
for (int j = i; j <= 2000; j++) {
if (check(v, i, j)) return 0;
}
}
cout << "NO" << endl;
return 0;
}
if (n == 3) {
for (int i = 1; i <= 2000; i++) {
if (check(v, i)) return 0;
}
cout << "NO" << endl;
return 0;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<char> v;
int main() {
int t;
scanf("%d", &t);
while (t--) {
v.clear();
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (i == s.size() - 1 || s[i] != s[i + 1]) {
v.push_back(s[i]);
} else
i++;
}
sort(v.begin(), v.end());
int len = unique(v.begin(), v.end()) - v.begin();
for (int i = 0; i < len; i++) {
cout << v[i];
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, i, c = 0, c1 = 0;
cin >> n;
if (n == 1) {
string s;
cin >> s;
cout << s << endl;
return 0;
} else {
vector<string> v;
for (i = 0; i < n; ++i) {
string s;
cin >> s;
v.push_back(s);
}
string a, b;
a = v[0];
for (i = 1; i < n; ++i) {
if (v[i] != v[0]) {
b = v[i];
break;
}
}
for (i = 0; i < n; i++) {
if (a == v[i])
c++;
else if (b == v[i])
c1++;
}
if (c > c1)
cout << a << endl;
else
cout << b << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long LINF = 1e18;
vector<vector<int>> gr;
vector<int> order;
vector<bool> used;
void dfs(int x) {
order.push_back(x);
used[x] = 1;
for (auto i : gr[x]) {
if (!used[i]) {
dfs(i);
order.push_back(x);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
used.resize(n + 1);
gr.resize(n + 1);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
gr[a].push_back(b);
gr[b].push_back(a);
}
dfs(1);
int mxn = ceil(2. * n / k);
int c = k;
for (int i = 0; i < order.size(); i++) {
if (i % mxn == 0 && i != 0) cout << "\n";
if (i % mxn == 0) {
cout << min(mxn, (int)order.size() - i) << " ";
c--;
}
cout << order[i] << " ";
}
while (c--) {
cout << 1 << " " << 1 << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > mul(vector<vector<long long> > a,
vector<vector<long long> > b) {
vector<vector<long long> > c;
c.resize(a.size());
for (int i = 0; i < c.size(); i++) c[i].resize(b[0].size(), 0);
for (int i = 0; i < c.size(); i++)
for (int j = 0; j < c[i].size(); j++)
for (int k = 0; k < b.size(); k++)
c[i][j] = (c[i][j] + a[i][k] * b[k][j]);
return c;
}
vector<vector<long long> > Def;
vector<vector<long long> > bpow(vector<vector<long long> > a, long long st) {
if (st == 0) return Def;
if (st == 1) return a;
vector<vector<long long> > b = bpow(a, st >> 1);
b = mul(b, b);
if (st & 1) b = mul(a, b);
return b;
}
long long AR = 19, BR = 13, CR = 23, XR = 228, YR = 322, MOD = 1e9 + 993;
long long myrand() {
long long ZR = (XR * AR + YR * BR + CR) % MOD;
XR = YR;
YR = ZR;
return ZR;
}
long long sqr(long long x) { return x * x; }
const long long llinf = 2e18;
const long double EPS = 1e-9;
const long double PI = atan2(0, -1);
const int maxn = 2e5 + 100, inf = 1e9 + 100, mod = 1e9 + 7;
int n, W, H;
vector<int> g[maxn];
queue<int> w[maxn];
queue<int> def[maxn];
int answer[maxn];
pair<int, pair<int, int> > danc[maxn];
vector<pair<pair<int, int>, int> > q;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> W >> H;
for (int i = 0; i < n; i++) {
cin >> danc[i].first >> danc[i].second.first >> danc[i].second.second;
if (danc[i].first == 1)
q.push_back(make_pair(danc[i].second, i));
else
g[danc[i].second.second - danc[i].second.first + H].push_back(i);
answer[i] = i;
}
for (int i = 0; i < maxn; i++)
if (!g[i].empty()) {
vector<pair<int, int> > s(g[i].size());
for (int j = 0; j < g[i].size(); j++)
s[j] = make_pair(danc[g[i][j]].second.first, g[i][j]);
sort(s.begin(), s.end());
reverse(s.begin(), s.end());
for (int j = 0; j < s.size(); j++)
w[i].push(s[j].second), def[i].push(s[j].second);
}
sort(q.begin(), q.end());
for (int i = 0; i < q.size(); i++) {
int id = q[i].first.second - q[i].first.first + H;
if (id < 0 || g[id].empty()) continue;
answer[w[id].front()] = q[i].second;
w[id].pop();
w[id].push(q[i].second);
}
for (int i = 0; i < maxn; i++)
if (!g[i].empty())
for (int j = 0; j < g[i].size(); j++)
answer[w[i].front()] = def[i].front(), def[i].pop(), w[i].pop();
for (int i = 0; i < n; i++) {
int x = answer[i];
if (danc[x].first == 1)
cout << danc[x].second.first << ' ' << H << '\n';
else
cout << W << ' ' << danc[x].second.first << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[5005], f[5005];
int main() {
double gar;
scanf(" %d %d ", &n, &m);
for (int i = 0, _n = (n); i < _n; i++) scanf(" %d %lf ", &a[i], &gar);
int res = 0;
for (int i = 0, _n = (n); i < _n; i++) {
f[i] = 1;
for (int j = 0, _n = (i); j < _n; j++)
if (a[j] <= a[i]) f[i] = max(f[i], f[j] + 1);
res = max(res, f[i]);
}
printf("%d\n", n - res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[109][109];
int main() {
int n, m, flag = 1;
scanf("%d%d", &n, &m);
int i, j;
for (i = 0; i < n; i++) {
scanf("%s", &s[i]);
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
int cnt = 0;
if (s[i][j] != '*') {
if (s[i][j - 1] == '*' && (j - 1) >= 0) cnt++;
if (s[i][j + 1] == '*' && (j + 1) < m) cnt++;
if (s[i - 1][j] == '*' && (i - 1) >= 0) cnt++;
if (s[i - 1][j - 1] == '*' && (i - 1) >= 0 && (j - 1) >= 0) cnt++;
if (s[i - 1][j + 1] == '*' && (i - 1) >= 0 && (j + 1) < m) cnt++;
if (s[i + 1][j - 1] == '*' && (j - 1) >= 0 && (i + 1) < n) cnt++;
if (s[i + 1][j + 1] == '*' && (j + 1) < m && (i + 1) < n) cnt++;
if (s[i + 1][j] == '*' && (i + 1) < n) cnt++;
}
if (s[i][j] == '.' && cnt > 0) {
flag = 0;
break;
}
if (s[i][j] >= '0' && s[i][j] <= '9') {
if (s[i][j] != '0' + cnt) {
flag = 0;
break;
}
}
}
if (!flag) break;
}
if (flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline string tostr(const T &x) {
stringstream ss;
ss << x;
return ss.str();
}
const double EPS = 1e-6;
const int INF = 1000 * 1000 * 1000;
const char CINF = 102;
const long long LINF = INF * 1ll * INF;
const double PI = 3.1415926535897932384626433832795;
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
unsigned int gcd(unsigned int a, unsigned int b) {
return a ? gcd(b % a, a) : b;
}
int n, m;
const int B = 50;
struct image {
bool a[1700][1700];
};
struct comps {
int a[1700][1700];
};
void filter(const image &src, image &dst, int W, bool grow) {
if (grow) {
memset(dst.a, 0, sizeof(dst.a));
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m); ++j) {
if (!src.a[i][j]) continue;
for (int di = -W; di <= W; ++di) {
int ii = i + di;
int t = (int)sqrt((double)(W * W - di * di));
for (int dj = -t; dj <= t; ++dj) {
int jj = j + dj;
dst.a[ii + B][jj + B] = true;
}
}
}
}
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m); ++j) {
dst.a[i][j] = dst.a[i + B][j + B];
}
}
} else {
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m); ++j) {
bool b = true;
for (int di = -W; di <= W; ++di) {
int ii = i + di;
int t = (int)sqrt((double)(W * W - di * di));
for (int dj = -t; dj <= t; ++dj) {
int jj = j + dj;
bool v = src.a[ii][jj];
b &= v;
if (!b) break;
}
if (!b) break;
}
dst.a[i][j] = b;
}
}
}
}
void subtract(const image &a, const image &b, image &dst) {
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m); ++j) {
dst.a[i][j] = a.a[i][j] && !b.a[i][j];
}
}
}
void fill(image &a, comps &c, int x, int i, int j) {
if (i < 0 || j < 0 || i >= n || j >= m || !a.a[i][j]) return;
a.a[i][j] = false;
c.a[i][j] = x;
fill(a, c, x, i, j - 1);
fill(a, c, x, i, j + 1);
fill(a, c, x, i - 1, j);
fill(a, c, x, i + 1, j);
}
int getcomps(image &a, comps &c) {
int k = 0;
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m); ++j) {
if (!a.a[i][j]) continue;
fill(a, c, ++k, i, j);
}
}
return k;
}
void save(const image &a, string file) {
ofstream f(file.c_str());
f << "P2\n" << m << ' ' << n << " 1\n";
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m); ++j) {
f << a.a[i][j] << '\n';
}
}
}
int main() {
static image src, tmp;
cin >> n >> m;
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m); ++j) {
int a;
scanf("%d", &a);
src.a[i][j] = !!a;
}
}
tmp = src;
filter(tmp, src, 1, false);
static image core, big, rays;
filter(src, core, 4, false);
filter(core, big, 8, true);
subtract(src, big, rays);
static comps sunid, rayid;
int k = getcomps(src, sunid);
getcomps(rays, rayid);
vector<set<int> > res(k);
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m); ++j) {
int r = rayid.a[i][j];
int s = sunid.a[i][j] - 1;
if (s != -1 && r != 0) {
res[s].insert(r);
}
}
}
vector<int> ans(k);
for (int i = 0; i < (k); ++i) {
ans[i] = ((int)(res[i]).size());
}
sort((ans).begin(), (ans).end());
cout << k << '\n';
for (int i = 0; i < (k); ++i) {
printf("%d ", ans[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
string s;
cin >> n >> k;
vector<long long> a(n);
for (long long& i : a) cin >> i;
cin >> s;
long long i = 0, res = 0;
while (i < n) {
long long j = i;
while (j + 1 < n && s[j + 1] == s[j]) j++;
vector<long long> cur;
for (long long l = i; l <= j; l++) cur.push_back(a[l]);
sort((cur).rbegin(), (cur).rend());
for (long long l = 0; l < min(k, (long long)((cur).size())); l++)
res += cur[l];
i = j + 1;
}
cout << res << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
const int N = 2, K = 2e5;
int n, k_total;
int32_t k[N], a[N], x[N], y[N], m[N], p[N];
bool greater_by_a(int i, int j) { return a[i] > a[j]; }
priority_queue<int32_t, vector<int32_t>, decltype(&greater_by_a)> q(
greater_by_a);
vector<int32_t> q2;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout << fixed;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k[i] >> a[i] >> x[i] >> y[i] >> m[i];
k_total += k[i];
q.push(i);
}
int ans = 0, a0 = 0;
vector<pii> ans2;
for (;;) {
while (!q.empty()) {
int i = q.top();
q.pop();
;
if (a[i] >= a0) {
if (k_total <= 2e5) ans2.emplace_back(a[i], i + 1);
a0 = a[i];
if (++p[i] < k[i]) {
a[i] = ((int64_t)a[i] * x[i] + y[i]) % m[i];
q.push(i);
}
} else {
q2.push_back(i);
}
}
if (q2.empty()) break;
for (int i : q2) q.push(i);
q2.clear();
ans++, a0 = 0;
}
cout << ans << endl;
if (k_total <= 2e5) {
for (auto ai : ans2) {
cout << ai.first << ' ' << ai.second << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MAXN = 200000;
int S[MAXN + 5], a[MAXN + 5], p[MAXN + 5];
char s[MAXN + 5];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
p[a[i]] = i;
}
scanf("%s", s);
for (int i = 1; i < n; i++) S[i] = S[i - 1] + s[i - 1] - '0';
for (int i = 1; i <= n; i++) {
if (a[i] != i) {
if (a[i] > i) {
int p = S[a[i] - 1] - S[i - 1];
if (p != a[i] - i) {
printf("NO\n");
return 0;
}
} else if (a[i] < i) {
int p = S[i - 1] - S[a[i] - 1];
if (p != i - a[i]) {
printf("NO\n");
return 0;
}
}
}
}
printf("YES\n");
}
| 3 |
#include <bits/stdc++.h>
int main(int argc, char const *argv[]) {
int t, n, n1, n2, j, p, e;
int i;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &p);
for (i = 5; i * (i - 1) <= 4 * i + 2 * p; ++i)
;
n1 = --i;
e = 2 * (i + 1) + p;
n2 = e - (i - 1) * i / 2;
for (i = 2; i < n + (n2 > 0); ++i) printf("1 %d\n", i);
n2--;
for (i = 3; i < n + (n2 > 0); ++i) printf("2 %d\n", i);
n2--;
for (i = 3; i < n1; ++i, --n2)
for (j = i + 1; j <= n1 + (n2 > 0); ++j) printf("%d %d\n", i, j);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int OO = 1e9;
const long long INF = 1e18;
const int irand(int lo, int hi) {
return ((double)rand() / (RAND_MAX + 1.0)) * (hi - lo + 1) + lo;
}
const long long lrand(long long lo, long long hi) {
return ((double)rand() / (RAND_MAX + 1.0)) * (hi - lo + 1) + lo;
}
template <typename T>
T getnum() {
int sign = 1;
T ret = 0;
char c;
do {
c = getchar();
} while (c == ' ' || c == '\n');
if (c == '-')
sign = -1;
else
ret = c - '0';
while (1) {
c = getchar();
if (c < '0' || c > '9') break;
ret = 10 * ret + c - '0';
}
return sign * ret;
}
inline void ini(int& x) { x = getnum<int>(); }
inline void scani(int& x) { scanf("%d", &x); }
const int N = 2e5 + 5;
int n;
map<int, int> mep;
vector<pair<int, int> > vec;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(10);
cin >> n;
for (int i = 1; i <= n; i += 1) {
int x;
cin >> x;
mep[x]++;
}
for (map<int, int>::iterator it = mep.begin(); it != mep.end(); it++) {
vec.push_back(make_pair(-it->second, it->first));
}
sort(vec.begin(), vec.end());
int ans = 0;
int mul = 1;
int curr = OO;
for (int i = 0; i < vec.size(); i++) {
curr = min(curr / 2, -vec[i].first);
ans = max(ans, curr * mul);
mul = mul * 2 + 1;
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct P {
int x, y, z, id;
bool operator<(const P &a) const {
if (x != a.x) return x < a.x;
if (y != a.y) return y < a.y;
return z < a.z;
}
} a[50005];
vector<pair<int, int> > ans;
int main() {
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(n); i++)
scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].z), a[i].id = i;
sort(a + 1, a + n + 1);
int top = 0;
for (int i = (int)(1); i <= (int)(n); i++)
if (top && a[i].x == a[top].x && a[i].y == a[top].y)
ans.push_back(pair<int, int>(a[i].id, a[top--].id));
else
a[++top] = a[i];
n = top;
top = 0;
for (int i = (int)(1); i <= (int)(n); i++)
if (top && a[i].x == a[top].x)
ans.push_back(pair<int, int>(a[i].id, a[top--].id));
else
a[++top] = a[i];
n = top;
top = 0;
for (int i = (int)(1); i <= (int)(n); i++)
if (top)
ans.push_back(pair<int, int>(a[i].id, a[top--].id));
else
a[++top] = a[i];
for (int i = (int)(0); i <= (int)(ans.size() - 1); i++)
printf("%d %d\n", ans[i].first, ans[i].second);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k = 3, n;
scanf("%d", &n);
while (k * (k + 1) / 2 <= n) k++;
vector<int> ans[k];
int num = 1;
printf("%d\n", k);
for (int i = 0; i < k; i++)
for (int l = i + 1; l < k; l++) {
ans[i].push_back(num);
ans[l].push_back(num++);
}
for (int i = 0; i < k; i++) {
if (i) printf("\n");
for (int l = 0; l < ans[i].size(); l++) printf("%d ", ans[i][l]);
}
}
| 4 |
#include <bits/stdc++.h>
const double pi = acos(-1.0);
using namespace std;
int fact(int n) { return (n == 0) || (n == 1) ? 1 : n * fact(n - 1); }
void sieve(long long n) {
bool check[n + 1];
memset(check, true, sizeof(check));
for (long long i = 2; i * i <= n; i++)
if (check[i] == true)
for (long long j = i * i; j <= n; j += i) check[j] = false;
for (long long i = 2; i <= n; i++) {
if (check[i] == true) {
cout << i << " ";
}
}
}
bool isprime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n + 2];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = n - 1; i >= 0; i--) {
cout << a[i] << " ";
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void print_arr(long long int arr[], long long int n) {
cout << '\n';
for (long long int i = 0; i < n; i++) {
cout << arr[i] << ' ';
}
cout << '\n';
}
void input_arr(long long int arr[], long long int n) {
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
}
bool primes[1000001];
vector<long long int> v;
void seive() {
memset(primes, true, sizeof(primes));
primes[0] = false;
primes[1] = false;
for (long long int i = 2; i * i <= 1000001; i++) {
if (primes[i]) {
for (long long int j = 2 * i; j < 1000001; j += i) {
primes[j] = false;
}
}
}
for (long long int i = 2; i <= 1000000; i++) {
if (primes[i]) {
long long int temp = i * i;
v.push_back(temp);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
seive();
cin >> t;
while (t--) {
long long int n;
cin >> n;
if (binary_search(v.begin(), v.end(), n)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const int M = 3e5 + 10;
int a[M], b[M];
int main() {
int n;
cin >> n;
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
for (int i = 0; i < n; i++) {
cin >> a[i];
int x = i;
int y = n - i - 1;
x = max(x, y);
if (x != 0) b[i] = a[i] / x;
}
sort(b, b + n);
cout << b[0] << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
long long int power(long long int a, long long int b) {
long long int res = 1;
a %= mod;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
int main() {
long long int n;
cin >> n;
long long int ans =
2 * (power(3, n * n) - power(power(3, n) - 3, n) + mod) % mod;
long long int choose = 1;
for (int i = 1; i <= n; i++) {
choose = choose * (n - i + 1) % mod * power(i, mod - 2) % mod;
long long int term =
3 * (power(3, n * (n - i)) - power(power(3, n - i) - 1, n) + mod) % mod;
if (i & 1)
ans = ((ans - choose * term) % mod + mod) % mod;
else
ans = (ans + choose * term) % mod;
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N, arr[100005], a, b, c;
int R, C, K;
int mat[15][15];
int u, v;
int main() {
int res = 0;
memset(mat, 0, sizeof(mat));
scanf("%d %d %d %d", &R, &C, &N, &K);
for (int i = 0; i < N; i++) {
scanf("%d %d", &u, &v);
mat[u][v] = 1;
}
for (int i = 1; i <= R; i++) {
for (int j = 1; j <= C; j++) {
for (int k = 1; k <= R; k++) {
for (int l = 1; l <= C; l++) {
int cnt = 0;
for (int x = i; x <= k; x++) {
for (int y = j; y <= l; y++) {
cnt += mat[x][y];
}
}
if (cnt >= K) {
res++;
}
}
}
}
}
printf("%d\n", res);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 150010;
const int INF = 0x7fffffff;
bool t[maxn];
long long q[maxn + 1];
queue<int> qu;
int main() {
int n, m;
while (scanf("%d%d", &n, &m) == 2) {
for (int i = 0; i < maxn; i++) {
q[i] = 0;
}
memset(t, false, sizeof(t));
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
if (a < maxn) {
t[a] = true;
q[a] -= a;
}
}
for (int i = 1; i < maxn; i++) {
q[i] += q[i - 1] + i;
}
q[maxn] = INF;
for (int i = 1; i < maxn; i++) {
if (q[i] <= m && q[i + 1] > m) {
for (int j = 1; j <= i; j++) {
if (!t[j]) qu.push(j);
}
break;
}
}
printf("%d\n", qu.size());
if (!qu.empty()) {
printf("%d", qu.front());
qu.pop();
}
while (!qu.empty()) {
printf(" %d", qu.front());
qu.pop();
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define Mp make_pair
#define pb push_back
typedef long long ll;
typedef double db;
typedef pair<int, int> pii;
typedef vector<int> vi;
mt19937 mrand(time(0));
#define debug(...) fprintf(stderr, __VA_ARGS__)
ll get(ll r) { return ((ll)mrand() * mrand() % r + r) % r; }
ll get(ll l, ll r) { return get(r - l + 1) + l; }
void solve() {
ll n; cin >> n;
while(n % 2 == 0) n /= 2;
puts(n == 1 ? "NO" : "YES");
}
signed main() {
int _; for(scanf("%d", &_); _; _--) solve();
debug("time=%.4f\n", (db)clock()/CLOCKS_PER_SEC);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const long long INF_LL = 1000000000000000000LL;
class tree {
int n;
vector<int> t;
public:
tree(int n) : n(n), t(n) {}
int len() { return n; }
void inc(int i, int v) {
for (; i < n; i |= i + 1) t[i] += v;
}
int sum(int r) {
int res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) res += t[r];
return res;
}
int ye(int l, int r) {
if (r > n) r = n;
return (r - l) - (sum(r - 1) - sum(l - 1));
}
};
const int h = 200022;
int n, m, k;
pair<int, int> u[h];
bool y[h];
vector<tree> t;
map<int, pair<int, int> > ui;
int main() {
scanf("%d%d%d", &n, &m, &k);
memset(y, 0, sizeof y);
for (int i(0), _b(n); i < _b; ++i)
if (!y[i]) {
int j = i;
int k = 0;
while (!y[j]) {
y[j] = true;
u[j] = pair<int, int>(int((t).size()), k);
j += m;
if (j >= n) j -= n;
++k;
}
t.push_back(tree(k));
}
long long ans = 0;
char c;
int id, hs;
for (int i(0), _b(k); i < _b; ++i) {
c = 0;
while (c != '-' && c != '+') scanf("%c", &c);
scanf("%d", &id);
if (c == '+') {
scanf("%d", &hs);
int v = u[hs].first, p = u[hs].second;
if (!t[v].ye(p, t[v].len())) {
ans += t[v].len() - p;
p = 0;
}
int a = 1;
while ((a << 1) <= t[v].len()) a <<= 1;
while (a > 0) {
if (!t[v].ye(p, p + a)) {
ans += a;
p += a;
}
a >>= 1;
}
ui[id] = pair<int, int>(v, p);
t[v].inc(p, 1);
} else {
pair<int, int> uid = ui[id];
int v = uid.first, p = uid.second;
t[v].inc(p, -1);
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long a = 0;
char c = getchar();
while (c > '9' || c < '0') c = getchar();
while ('0' <= c && c <= '9') {
a = a * 10 + c - 48;
c = getchar();
}
return a;
}
struct data {
long long x, y, c;
data(long long X = 0, long long Y = 0, long long C = 0) {
x = X;
y = Y;
c = C;
}
} w[2005], e[2005];
long long n, k, L;
bool cmp(data a, data b) { return a.x < b.x; };
bool cmp2(data a, data b) { return a.y < b.y; }
long long nxt[2005], f[2005];
multiset<long long> Set[2005];
long long sum[2005 << 2], Max[2005 << 2], tag[2005 << 2];
void pushup(long long x) {
sum[x] = (sum[(x << 1)] + sum[(x << 1 | 1)]) % 1000000007;
assert(Max[(x << 1)] <= Max[(x << 1 | 1)]);
Max[x] = Max[(x << 1 | 1)];
}
void build(long long x, long long l, long long r) {
tag[x] = 0;
if (l == r) {
sum[x] = f[l] * (e[l].y - e[l - 1].y) % 1000000007;
Max[x] = f[l];
return;
}
build((x << 1), l, ((l + r) >> 1));
build((x << 1 | 1), ((l + r) >> 1) + 1, r);
pushup(x);
}
void ptag(long long x, long long l, long long r, long long v) {
assert(Max[x] <= v);
sum[x] = v * (e[r].y - e[l - 1].y) % 1000000007;
tag[x] = Max[x] = v;
}
void pushdown(long long x, long long l, long long r) {
if (tag[x]) {
ptag((x << 1), l, ((l + r) >> 1), tag[x]);
ptag((x << 1 | 1), ((l + r) >> 1) + 1, r, tag[x]);
tag[x] = 0;
}
}
void chkmax(long long x, long long l, long long r, long long b, long long e,
long long v) {
if (r < b || l > e) return;
if (l == r && Max[x] > v) return;
if (Max[x] <= v && b <= l && r <= e) {
ptag(x, l, r, v);
return;
}
bool flag = (v > Max[(x << 1)]);
pushdown(x, l, r);
chkmax((x << 1), l, ((l + r) >> 1), b, e, v);
if (flag) chkmax((x << 1 | 1), ((l + r) >> 1) + 1, r, b, e, v);
pushup(x);
}
signed main() {
n = read();
k = read();
L = read();
for (long long i = 1; i <= n; ++i) {
w[i].x = read() + 1;
w[i].y = read() + 1;
w[i].c = read();
e[i] = w[i];
}
sort(w + 1, w + 1 + n, cmp);
sort(e + 1, e + 1 + n, cmp2);
e[n + 1].y = L + 1;
w[n + 1].x = w[n + 2].x = L + 1;
w[n + 1].y = L + 1;
long long ans = 0;
for (long long i = n; i; --i) {
long long tmp = (w[i].x - w[i - 1].x);
if (!tmp) continue;
multiset<long long> S;
S.clear();
for (long long i = 1; i <= k; ++i) {
S.insert(L + 1), nxt[i] = L + 1;
Set[i].clear();
Set[i].insert(L + 1);
Set[i].insert(0);
}
for (long long j = n; j; --j) {
if (e[j].x >= w[i].x) {
S.erase(S.find(nxt[e[j].c]));
nxt[e[j].c] = e[j].y;
S.insert(nxt[e[j].c]);
Set[e[j].c].insert(e[j].y);
}
f[j] = (*(--S.end()));
}
build(1, 1, n);
for (long long j = n + 1; j > i; --j) {
if (w[j].c) {
assert(Set[w[j].c].find(w[j].y) != Set[w[j].c].end());
Set[w[j].c].erase(Set[w[j].c].find(w[j].y));
multiset<long long>::iterator it = --Set[w[j].c].upper_bound(w[j].y),
ir = it;
++ir;
long long ll = lower_bound(e, e + 1 + n, data(0, *it, 0), cmp2) - e;
if (ll) assert(e[ll].y != e[ll - 1].y);
chkmax(1, 1, n, ll + 1, n, *ir);
}
long long res = ((L + 1) * e[n].y - sum[1] + 1000000007) % 1000000007;
ans =
(ans + (res * tmp % 1000000007 * (w[j].x - w[j - 1].x))) % 1000000007;
}
}
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int N = 1e9;
int n, m;
long long X[maxn], T[maxn];
long long P[maxn], B[maxn];
int eat[maxn];
unordered_map<long long, int> M;
typedef struct node* pnode;
struct node {
long long ans;
pnode L, R;
node() {
ans = 0;
L = R = NULL;
}
};
pnode root;
long long getNode(pnode Node) {
if (!Node) return 0;
return Node->ans;
}
void update(pnode Node, int i, int j, int pos, long long val) {
if (i == j) {
Node->ans = max(Node->ans, pos + val);
return;
}
int mid = (i + j) >> 1;
if (pos <= mid) {
if (!Node->L) Node->L = new node();
update(Node->L, i, mid, pos, val);
} else {
if (!Node->R) Node->R = new node();
update(Node->R, mid + 1, j, pos, val);
}
Node->ans = max(getNode(Node->L), getNode(Node->R));
}
int query(pnode Node, int i, int j, int x) {
if (!Node || Node->ans < x || x < i) return -1;
if (i == j) return i;
int mid = (i + j) >> 1;
int pos = query(Node->L, i, mid, x);
if (pos != -1) return pos;
return query(Node->R, mid + 1, j, x);
}
multiset<pair<long long, long long> > mosq;
multiset<pair<long long, long long> >::iterator it;
void solve() {
root = new node();
for (int i = 1; i <= n; ++i) {
M[X[i]] = i;
update(root, 0, N, X[i], T[i]);
}
for (int i = 1; i <= m; ++i) {
int x = query(root, 0, N, P[i]);
if (x == -1)
mosq.insert({P[i], B[i]});
else {
int id = M[x];
++eat[id];
T[id] += B[i];
it = mosq.lower_bound({X[id], -1});
vector<pair<long long, long long> > del;
while (it != mosq.end() && T[id] + X[id] >= it->first) {
T[id] += it->second;
++eat[id];
del.push_back({it->first, it->second});
++it;
}
for (auto k : del) mosq.erase(mosq.find({k.first, k.second}));
update(root, 0, N, X[id], T[id]);
}
}
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> X[i] >> T[i];
for (int i = 1; i <= m; ++i) cin >> P[i] >> B[i];
solve();
for (int i = 1; i <= n; ++i) cout << eat[i] << " " << T[i] << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m;
cin >> n >> m;
if (m > n)
cout << -1;
else if (m == n)
cout << n;
else {
long long int x, y;
for (y = (n / 2); y >= 0; y--) {
if (n - y >= 0) {
x = n - 2 * y;
if ((x + y) % m == 0) {
cout << x + y;
break;
}
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<pair<long long, long long> > v;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
v.push_back(make_pair(x, y));
}
int f = 0, c = 0;
for (int i = 0; i < n; i++) {
if (v[i].first >= v[i].second) {
for (int j = 0; j < i; j++) {
if (v[j].second <= v[i].second && v[j].first <= v[i].first &&
v[i].first - v[j].first >= v[i].second - v[j].second) {
c++;
} else
f = 1;
}
if (f == 1) break;
} else {
f = 1;
break;
}
}
if (f == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
const int N = 1100;
using namespace std;
long long ans;
int n, m;
long long cnt[N];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
int val;
cin >> val;
cnt[val]++;
}
ans = 1ll * n * (n - 1) / 2;
for (int i = 1; i <= m; i++) {
long long val = cnt[i];
ans -= val * (val - 1) / 2;
}
cout << ans << endl;
cin.get();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[1505];
int main() {
int f = 0;
int n;
cin >> n;
cout << n << endl;
for (int i = 1; i <= n; i++) cout << 1 << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int dp[N];
int pdp[2 * N];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int c, n;
cin >> c >> n;
++n;
pair<pair<int, int>, int> a[n];
a[0] = {{1, 1}, 0};
for (int i = 1; i < n; i++)
cin >> a[i].second >> a[i].first.first >> a[i].first.second;
memset(dp, 0, sizeof dp);
memset(pdp, 0, sizeof pdp);
dp[n - 1] = 1;
pdp[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
dp[i] = i != 0;
for (int j = i + 1; j < min(n, i + 1005); j++) {
int taken = abs(a[i].first.first - a[j].first.first) +
abs(a[i].first.second - a[j].first.second);
int can = a[j].second - a[i].second;
if (taken <= can) {
dp[i] = max(dp[i], dp[j] + (i != 0));
}
}
dp[i] = max(dp[i], pdp[i + 1004] + (i != 0));
pdp[i] = max(dp[i], pdp[i + 1]);
}
cout << dp[0] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dcmp(double a, double b) {
return fabs(a - b) <= 0.00000000000001 ? 0 : (a > b) ? 1 : -1;
}
vector<int> vis(300000 + 9);
int main() {
int n, m, p, cnt = 0, i;
char c;
string s;
cin >> n >> m >> s;
for (i = 0; i < ((int)(s).size()); i++) {
if (s[i] == '.' && s[i + 1] == '.') {
cnt++;
}
if (s[i] == '.') vis[i] = 1;
}
while (m--) {
cin >> p >> c;
if (c != '.' && s[p - 1] == '.') {
if (((p < n && vis[p] == 1) && (p - 2 < 0 || vis[p - 2] == 0)) ||
((p >= n || vis[p] != 1) && (p - 2 >= 0 && vis[p - 2] == 1))) {
cnt--;
} else if ((p < n && vis[p] == 1) && (p - 2 >= 0 && vis[p - 2] == 1)) {
cnt -= 2;
}
vis[p - 1] = 0;
} else if (c == '.' && s[p - 1] != '.') {
if (((p < n && vis[p] == 1) && (p - 2 < 0 || vis[p - 2] == 0)) ||
((p >= n || vis[p] != 1) && (p - 2 >= 0 && vis[p - 2] == 1))) {
cnt++;
} else if ((p < n && vis[p] == 1) && (p - 2 >= 0 && vis[p - 2] == 1)) {
cnt += 2;
}
vis[p - 1] = 1;
}
s[p - 1] = c;
cout << cnt << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, kk;
vector<int> a;
vector<int> bad, mod;
const int sz = 1000002;
inline bool check(int m) {
int c = kk;
for (int mm = m; mm < sz; mm += m)
if ((c -= bad[mm]) < 0) return false;
c = k;
for (int i = (int)(0); i < (int)(n); ++i) {
if (++mod[a[i] % m] > 1) {
if (--c < 0) {
for (int j = (int)(0); j < (int)(i + 1); ++j) mod[a[j] % m] = 0;
return false;
}
}
}
return true;
}
int main() {
cin >> n >> k;
a.resize(n);
for (int i = (int)(0); i < (int)(n); ++i) cin >> a[i];
sort(a.begin(), a.end());
bad.resize(sz);
for (int i = (int)(0); i < (int)(n); ++i)
for (int j = (int)(i + 1); j < (int)(n); ++j) ++bad[a[j] - a[i]];
kk = k * (k + 1) / 2;
mod.resize(sz);
for (int i = (int)(1); i < (int)(sz); ++i) {
if (check(i)) {
cout << i << endl;
break;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e9 + 7;
const int Maxn = 100 + 3;
long long dp[Maxn][Maxn], dp2[Maxn][Maxn], dp3[Maxn][Maxn], dp4[Maxn][Maxn];
vector<pair<int, int> > ord;
long long mul(long long a, long long b) { return (a * b) % Mod; }
long long bin_pow(long long b, long long p) {
long long res = 1;
for (long long j = 1, pw = b; j <= p; j <<= 1, pw = mul(pw, pw))
if (p & j) res = mul(res, pw);
return res;
}
long long inv(long long x) { return bin_pow(x, Mod - 2); }
long long f[Maxn], iv[Maxn];
long long nCr(long long n, long long r) {
n += Mod;
n %= Mod;
if ((n < r) || (r < 0)) return 0;
long long res = iv[r];
for (int i = 0; i < r; i++) res = mul(res, n - i);
return res;
}
long long solve(long long cn, long long sm) {
if (cn == 0 && sm == 0) return 1;
return nCr(cn - 1 + sm, sm);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
f[0] = 1;
for (int i = 1; i < Maxn; i++) f[i] = mul(f[i - 1], i);
for (int i = 0; i < Maxn; i++) iv[i] = inv(f[i]);
long long N = 60;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) ord.push_back({i, j});
dp3[0][0] = 1;
for (auto st : ord) {
int i = st.first, j = st.second;
memset(dp4, 0, sizeof dp4);
for (int cnt = 0; cnt <= N; cnt++) {
long long nw = solve(dp2[i][j], cnt);
if (nw == 0) continue;
for (int n = 0; n + cnt * (i - 2) <= N; n++) {
for (int m = 0; m + cnt * j <= N; m++) {
dp4[n + cnt * (i - 2)][m + cnt * j] += mul(nw, dp3[n][m]);
}
}
}
for (int n = 0; n <= N; n++)
for (int m = 0; m <= N; m++) dp3[n][m] = dp4[n][m] % Mod;
if (i < 2 || j < 1)
dp[i][j] = 0;
else
dp[i][j] = dp3[i - 2][j - 1];
for (auto st2 : ord) {
if (st2.first == i && st2.second == j) break;
if (N < i + st2.first - 1) continue;
(dp2[i + st2.first - 1][min(j, st2.second)] +=
2ll * dp[i][j] * dp[st2.first][st2.second]) %= Mod;
}
if (i + i - 1 <= N) (dp2[i + i - 1][j] += dp[i][j] * dp[i][j]) %= Mod;
}
long long n, m;
cin >> n >> m;
cout << dp[n + 2][m] << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
int id;
double rad;
point(int xx, int yy, int idd) {
x = xx;
y = yy;
id = idd;
}
bool operator<(const point &o) const { return rad < o.rad; }
void calRad(int xx, int yy) { rad = atan2(y - yy, x - xx); }
};
vector<int> e[2000];
vector<point> p;
int totalChild[3000];
int pass[3000];
int ans[3000];
int par[3000];
pair<int, int> findRef(vector<point> p) {
int ymax = 1000000001;
int xmax = 1000000001;
for (int i = 0; i < p.size(); i++) {
if (p[i].y < ymax) {
ymax = p[i].y;
xmax = p[i].x;
} else if (p[i].y == ymax && p[i].x < xmax) {
xmax = min(p[i].x, xmax);
}
}
return make_pair(xmax, ymax);
}
int dfs(int now) {
totalChild[now] = 0;
pass[now] = 1;
for (int i = 0; i < e[now].size(); i++) {
if (pass[e[now][i]] == 0) {
par[e[now][i]] = now;
totalChild[now] += dfs(e[now][i]) + 1;
}
}
return totalChild[now];
}
void doit(int now, vector<point> p) {
pair<int, int> ref = findRef(p);
for (int i = 0; i < p.size(); i++) {
if (p[i].x == ref.first && p[i].y == ref.second) {
p[i].rad = -10;
continue;
}
p[i].calRad(ref.first, ref.second);
}
sort(p.begin(), p.end());
ans[p[0].id] = now;
int idx = 1;
for (int i = 0; i < e[now].size(); i++) {
if (e[now][i] == par[now]) continue;
vector<point> pp;
for (int j = idx; j < idx + totalChild[e[now][i]] + 1; j++)
pp.push_back(p[j]);
idx = idx + totalChild[e[now][i]] + 1;
doit(e[now][i], pp);
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
e[a].push_back(b);
e[b].push_back(a);
}
par[1] = -1;
dfs(1);
int ymax = -1000000001;
int xmax = -1000000001;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
p.push_back(point(a, b, i));
}
doit(1, p);
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double Pi = acos(-1.0);
const int MAXN = 1e6 + 5;
int n, m, t;
int flag;
struct NODE {
int a, b, c;
} q[MAXN];
vector<int> to[MAXN];
int ans[MAXN];
int cmp(NODE a, NODE b) { return a.c > b.c; }
int ma[5005][5005];
int dfs(int u, int f, int ed, int x, int index) {
if (u == ed) {
if (f == 0) return 1;
if (!ans[ma[u][f]] || ans[ma[u][f]] == x)
flag = 1, ans[ma[u][f]] = x;
else if (flag == 0 && ans[ma[u][f]] > x)
flag = -1;
return 1;
}
int tmp = 0;
for (int i = 0; i < to[u].size(); i++) {
int v = to[u][i];
if (v == f) continue;
tmp |= dfs(v, u, ed, x, index);
if (tmp == 1) {
if (f == 0) return 1;
if (!ans[ma[u][f]] || ans[ma[u][f]] == x)
flag = 1, ans[ma[u][f]] = x;
else if (flag == 0 && ans[ma[u][f]] > x)
flag = -1;
}
}
return tmp;
}
int main() {
cin >> n;
for (int i = 1; i <= n - 1; i++) {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
to[a].push_back(b);
to[b].push_back(a);
ma[a][b] = ma[b][a] = i;
}
cin >> m;
for (int i = 1; i <= m; i++) {
int a, b, c;
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &c);
q[i] = {a, b, c};
}
sort(q + 1, q + 1 + m, cmp);
for (int i = 1; i <= m; i++) {
flag = 0;
dfs(q[i].a, 0, q[i].b, q[i].c, i);
if (flag == -1) {
cout << -1;
return 0;
}
}
for (int i = 1; i <= n - 1; i++) {
if (ans[i])
cout << ans[i] << ' ';
else
cout << 1 << ' ';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool setExists[500001];
int n;
int d;
int c[50];
int i, j;
int main() {
cin >> n >> d;
for (i = 0; i < n; i++) {
cin >> c[i];
}
setExists[0] = true;
for (i = 1; i <= n * 10000; i++) {
setExists[i] = false;
}
for (i = 0; i < n; i++) {
for (j = i * 10000; j >= 0; j--) {
setExists[c[i] + j] = (setExists[c[i] + j] || setExists[j]);
}
}
int curSet = 0;
int bestOption = 0;
int mindays = 0;
for (i = 0; i <= n * 10000; i++) {
if (i - curSet <= d) {
if (setExists[i]) {
bestOption = i;
}
} else {
if (curSet < bestOption) {
curSet = bestOption;
mindays++;
i = curSet;
} else {
break;
}
}
}
if (curSet < bestOption) {
curSet = bestOption;
mindays++;
}
cout << bestOption << " " << mindays << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 5e5 + 50;
long long n, p;
map<long long, long long> cnt;
vector<long long> x;
long long binpow(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) {
ret *= a;
ret %= mod;
}
a *= a;
a %= mod;
b >>= 1;
}
return ret;
}
long long binpow1(long long a, long long b, long long lim) {
long long ret = 1;
while (b) {
if (b & 1) {
ret *= a;
if (ret > lim) return -1;
}
a *= a;
b >>= 1;
if (b) {
if (ret * a > lim) return -1;
}
}
return ret;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
cin >> n >> p;
x.assign(n, 0);
for (long long i = 0; i < n; i++) {
long long k;
cin >> k;
x[i] = k;
cnt[k]++;
}
sort(x.begin(), x.end());
reverse(x.begin(), x.end());
long long maxi = 0;
for (long long i = 0; i < n;) {
long long j = i;
while (j < n && x[j] == x[i]) {
j++;
}
j--;
if ((j - i + 1) % 2 == 0) {
i = j + 1;
maxi = i;
continue;
}
if (j + 1 == n) break;
j++;
long long needed = binpow1(p, x[i] - x[j], n - j);
if (needed == -1) break;
bool ok = false;
while (j < n && needed > 0) {
long long k = j;
while (k < n && x[k] == x[j] && needed > 0) {
needed--;
k++;
}
if (needed == 0 || k == n) {
ok = needed == 0;
j = k;
break;
}
needed *= binpow1(p, x[j] - x[k], n - k);
if (needed > n - k) needed = -1;
j = k;
if (needed == -1) break;
}
if (ok) {
i = j;
maxi = i;
} else {
break;
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (maxi < n && x[i] < x[maxi]) {
ans += binpow(p, x[i]);
ans %= mod;
}
}
long long bans = maxi < n ? binpow(p, x[maxi]) : 0;
cout << (bans - ans + mod) % mod << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long b, long long e, long long mod) {
long long ans = 1;
for (; e; b = b * b % mod, e /= 2)
if (e & 1) ans = ans * b % mod;
return ans;
}
const int N = 5050;
int dp[N][N][2], c[N], n;
bool vis[N][N][2];
int solve(int x, int y, int z) {
if (x < 0 || y > n || x > y) return (int)1e9;
if (x == 1 && y == n) return 0;
if (vis[x][y][z]) return dp[x][y][z];
vis[x][y][z] = true;
return dp[x][y][z] =
min(solve(x - 1, y, 0) + (c[z ? y : x] == c[x - 1] ? 0 : 1),
solve(x, y + 1, 1) + (c[z ? y : x] == c[y + 1] ? 0 : 1));
}
int32_t main() {
cin >> n;
for (int i = 0; i < (n); ++i) cin >> c[i + 1];
int ans = (int)1e9;
for (int i = 0; i < (n); ++i) ans = min(ans, solve(i + 1, i + 1, 0));
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> sets;
vector<pair<int, int>> tiebreaks;
vector<pair<int, int>> results = {{3, 0}, {3, 1}, {3, 2},
{2, 3}, {1, 3}, {0, 3}};
int dp[4][4][205][205];
void fill() {
for (int i = 0; i < 24; i++) {
sets.push_back({25, i});
sets.push_back({i, 25});
}
for (int r = 0; r < 200; r++) {
if (26 + r <= 200) {
sets.push_back({26 + r, 24 + r});
sets.push_back({24 + r, 26 + r});
}
}
for (int i = 0; i < 14; i++) {
tiebreaks.push_back({15, i});
tiebreaks.push_back({i, 15});
}
for (int r = 0; r < 200; r++) {
if (16 + r <= 200) {
tiebreaks.push_back({16 + r, 14 + r});
tiebreaks.push_back({14 + r, 16 + r});
}
}
for (int i1 = 0; i1 < 4; i1++) {
for (int i2 = 0; i2 < 4; i2++) {
for (int i3 = 0; i3 < 205; i3++) {
for (int i4 = 0; i4 < 205; i4++) {
dp[i1][i2][i3][i4] = -1;
}
}
}
}
}
void precalculate() {
dp[0][0][0][0] = 0;
for (int s1 = 0; s1 <= 3; s1++) {
for (int s2 = 0; s2 <= 3; s2++) {
if (s1 + s2 > 5) continue;
for (int p1 = 0; p1 <= 200; p1++) {
for (int p2 = 0; p2 <= 200; p2++) {
if (s1 + s2 == 5) {
for (int i = 0; i < (int)tiebreaks.size(); i++) {
int pt1 = tiebreaks[i].first;
int pt2 = tiebreaks[i].second;
int w1 = pt1 > pt2;
int w2 = pt2 > pt1;
if (s1 - w1 == 3 || s2 - w2 == 3) continue;
if (s1 >= w1 && s2 >= w2 && p1 >= pt1 && p2 >= pt2) {
if (dp[s1 - w1][s2 - w2][p1 - pt1][p2 - pt2] != -1) {
dp[s1][s2][p1][p2] = i;
break;
}
}
}
} else {
for (int i = 0; i < (int)sets.size(); i++) {
int pt1 = sets[i].first;
int pt2 = sets[i].second;
int w1 = pt1 > pt2;
int w2 = pt2 > pt1;
if (s1 - w1 == 3 || s2 - w2 == 3) continue;
if (s1 >= w1 && s2 >= w2 && p1 >= pt1 && p2 >= pt2) {
if (dp[s1 - w1][s2 - w2][p1 - pt1][p2 - pt2] != -1) {
dp[s1][s2][p1][p2] = i;
break;
}
}
}
}
}
}
}
}
}
vector<pair<int, int>> res;
void reconstruct(int a, int b, int c, int d) {
if (a + b == 0) return;
int val = dp[a][b][c][d];
int p1, p2;
if (a + b == 5) {
p1 = tiebreaks[val].first;
p2 = tiebreaks[val].second;
} else {
p1 = sets[val].first;
p2 = sets[val].second;
}
res.push_back({p1, p2});
int w1 = p1 > p2;
int w2 = p2 > p1;
reconstruct(a - w1, b - w2, c - p1, d - p2);
}
int main() {
fill();
precalculate();
int tests;
scanf("%d", &tests);
while (tests--) {
int a, b;
scanf("%d %d", &a, &b);
bool done = false;
for (int i = 0; i < 6; i++) {
if (dp[results[i].first][results[i].second][a][b] != -1) {
printf("%d:%d\n", results[i].first, results[i].second);
res.clear();
reconstruct(results[i].first, results[i].second, a, b);
reverse(res.begin(), res.end());
for (auto &x : res) {
printf("%d:%d ", x.first, x.second);
}
printf("\n");
done = true;
break;
}
}
if (!done) puts("Impossible");
}
return 0;
}
| 7 |
#include<bits/stdc++.h>
#define int_max 1000000000000000
#define mod 1000000007
#define nl cout<<endl;
typedef long long ll;
using namespace std;
inline ll max(ll a,ll b){ return((a<b)?b:a);}
inline ll min(ll a,ll b){ return((a<b)?a:b);}
void sily()
{
int t;
cin>>t;
while(t--)
{
int n,ss,i,rr,bb,r=0,b=0,e=0;
string red,blue;
cin>>n;
cin>>red;
cin>>blue;
for(i=0;i<n;i++)
{
rr=int(red[i]);
bb=int(blue[i]);
if (rr>bb)
r+=1;
else{
if (bb>rr)
b+=1;
else
e+=1;
}
}
if (r>b)
cout<<"RED";
else
{
if (b>r)
cout<<"BLUE";
else
cout<<"EQUAL";
}
nl;
}
}
int main()
{
ios_base::sync_with_stdio(false);cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("error.txt", "w", stderr);
freopen("output.txt", "w", stdout);
#endif
sily();
cerr<<"time taken : "<<(float)clock()/CLOCKS_PER_SEC<<" secs"<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int N = 1000005;
const double PI = 4 * atan(1);
long long m, x, y, n, p, z, k;
long long h1, m1, h2, m2;
char c, cc;
int main() {
ios::sync_with_stdio(0);
cin >> h1 >> c >> m1 >> h2 >> cc >> m2;
x = (h2 - h1) * 60 + m2 - m1;
x /= 2;
x += m1;
if ((h1 + x / 60) < 10) cout << 0;
cout << h1 + x / 60 << ":";
if (((x) % 60 < 10)) cout << 0;
cout << x % 60;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> v1, v2, v3;
while (n--) {
int temp;
scanf("%d", &temp);
if (temp > 0)
v1.push_back(temp);
else if (temp < 0)
v2.push_back(temp);
else
v3.push_back(temp);
}
if (v2.size() % 2 == 0) {
v3.push_back(v2.back());
v2.pop_back();
}
if (v1.size() == 0) {
int t1 = v2.back();
v2.pop_back();
int t2 = v2.back();
v2.pop_back();
v1.push_back(t1);
v1.push_back(t2);
}
printf("%d ", v2.size());
for (int i = 0; i < v2.size(); i++) printf("%d ", v2[i]);
printf("\n%d ", v1.size());
for (int i = 0; i < v1.size(); i++) printf("%d ", v1[i]);
printf("\n%d ", v3.size());
for (int i = 0; i < v3.size(); i++) printf("%d ", v3[i]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:16777216")
int main() {
int n, i, len;
char word[101];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s", word);
if ((len = strlen(word)) > 10) {
printf("%c%d%c\n", word[0], len - 2, word[len - 1]);
} else {
printf("%s\n", word);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, x;
scanf("%d%d", &n, &x);
if (n < 2) n = 2;
int ans = ((n - 2) + x - 1) / x + 1;
printf("%d\n", ans);
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, s;
long long c[1000010], w[1000010], k[1000010];
long long zhi[1000010], ying[1000010];
struct node {
long long x, y;
bool operator<(const node &xx) const { return xx.x < x; }
};
priority_queue<node> a;
node aaa;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> c[i];
k[i] = c[i] % 100;
zhi[i] = c[i] / 100;
}
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= n; i++)
if (k[i] != 0) {
aaa.x = (100 - k[i]) * w[i];
aaa.y = i;
a.push(aaa);
ying[i] = k[i];
m -= k[i];
if (m < 0) {
m += 100;
zhi[a.top().y]++;
ying[a.top().y] = 0;
s += a.top().x;
a.pop();
}
}
cout << s << endl;
for (int i = 1; i <= n; i++) cout << zhi[i] << " " << ying[i] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, arr[202];
int ans = 0;
int main() {
scanf("%d", &n);
for (int i = 0; i < 2 * n; i++) scanf("%d", &arr[i]);
for (int i = 0; i < 2 * n; i += 2) {
for (int j = i + 1; j < 2 * n; j++) {
if (arr[i] == arr[j]) {
for (int k = j; k >= i + 2; k--) swap(arr[k], arr[k - 1]);
ans += (j - i - 1);
break;
}
}
}
printf("%d", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dp[2001][2001] = {}, content[2001] = {}, content_size = 0;
;
const int mod = 1000003;
bool parse(string s) {
int state = 0;
for (int i = 0; i < s.size(); ++i) {
if (isdigit(s[i])) {
int j = i;
while (isdigit(s[j])) {
++j;
}
i = j - 1;
content[content_size++] = 1;
state = 1;
} else if (s[i] == '+' || s[i] == '-') {
content[content_size++] = 2;
if (i == s.size() - 1 || s[i + 1] == '/' || s[i + 1] == '*') return false;
} else if (s[i] == '*' || s[i] == '/') {
content[content_size++] = 2;
if (i == 0 || i == s.size() - 1 || s[i + 1] == '*' || s[i + 1] == '/')
return false;
}
}
return true;
}
int solve(int p, int b) {
if (b < 0) return 0;
if (p == content_size) return dp[p][b] = (b == 0);
if (dp[p][b] != -1) return dp[p][b];
if (content[p] == 1) {
dp[p][b] = (solve(p + 1, b) + solve(p, b - 1)) % mod;
} else if (content[p] == 2) {
dp[p][b] = solve(p + 1, b + 1);
}
return dp[p][b];
}
int main() {
string s;
memset(dp, -1, sizeof(dp));
cin >> s;
if (parse(s)) {
cout << solve(0, 0) << endl;
} else {
cout << 0 << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
vector<int> p, a;
int n;
char s[N];
int sum[N], dp[N];
bool used[N];
int get(int x, int y) {
y++;
if (x < 0) x = 0;
if (x > y) return 0;
return sum[y] - sum[x];
}
bool can(int x) {
dp[0] = -1;
for (int i = 0; i < p.size(); i++) {
dp[i + 1] = -1;
if (get(dp[i] + 1, p[i] - x - 1) == 0) dp[i + 1] = max(dp[i + 1], p[i]);
if (get(dp[i] + 1, p[i] - 1) == 0) dp[i + 1] = max(dp[i + 1], p[i] + x);
if (i) {
if (get(dp[i - 1] + 1, p[i] - x - 1) == 0)
dp[i + 1] = max(dp[i + 1], p[i - 1] + x);
}
}
return dp[p.size()] >= a.back();
}
int main() {
scanf("%d", &n);
scanf("%s", s);
sum[0] = 0;
for (int i = 0; i < n; i++) {
sum[i + 1] = sum[i];
if (s[i] == 'P')
p.push_back(i);
else if (s[i] == '*')
a.push_back(i), sum[i + 1]++;
}
if (p.size() == 1) {
pair<int, int> le = {sum[p[0]] - sum[0], -max(p[0] - a[0], 0)},
ri = {sum[n] - sum[p[0]], -max(a.back() - p[0], 0)};
if (le < ri) swap(le, ri);
printf("%d %d\n", le.first, -le.second);
return 0;
}
int l = 0, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (can(mid))
r = mid;
else
l = mid + 1;
}
printf("%d %d\n", (int)a.size(), l);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char s[100];
int main() {
int x;
int trans[] = {4, 1, 3, 2, 0, 5};
int t[6];
int y = 0;
scanf("%d", &x);
for (int i = 0; i < 6; i++) t[trans[i]] = i;
for (int i = 0; i < 6; i++) {
if (x >> (i)&1) {
y |= (1 << trans[i]);
}
}
printf("%d\n", y);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, q;
scanf("%d", &q);
while (q--) {
scanf("%d", &n);
if (n == 2)
printf("2\n");
else if (n % 2 == 0)
printf("0\n");
else
printf("1\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> temp(n);
for (int& i : temp) cin >> i;
vector<vector<long long>> dp(10, vector<long long>(n));
dp[0][0] = dp[1][0] = temp[0];
for (int i = 1; i < n; i++) {
dp[0][i] = INT_MIN;
dp[0][i] = max(dp[0][i - 1], (long long)temp[i]);
dp[1][i] = INT_MAX;
dp[1][i] = min(dp[1][i - 1], (long long)temp[i]);
}
int k = 0;
for (int i = 2; i < 10; i += 2) {
k++;
dp[i][k] = max(dp[i - 2][k - 1] * temp[k], dp[i - 1][k - 1] * temp[k]);
dp[i + 1][k] =
min(dp[i - 2][k - 1] * temp[k], dp[i - 1][k - 1] * temp[k]);
for (int j = k + 1; j < n; j++) {
dp[i][j] = max({dp[i][j - 1], dp[i - 2][j - 1] * temp[j],
dp[i - 1][j - 1] * temp[j]});
dp[i + 1][j] = min({dp[i + 1][j - 1], dp[i - 2][j - 1] * temp[j],
dp[i - 1][j - 1] * temp[j]});
}
}
cout << dp[8][n - 1] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, j, i;
cin >> t;
while (t--) {
int n, k1, k2;
cin >> n >> k1 >> k2;
vector<int> v1;
vector<int> v2;
int x, y;
for (i = 0; i < k1; i++) {
cin >> x;
v1.push_back(x);
}
for (j = 0; j < k2; j++) {
cin >> y;
v2.push_back(y);
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
if (v1[k1 - 1] > v2[k2 - 1]) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int pos[300005], s[300005];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= int(n); i++) {
int x;
scanf("%d", &x);
pos[x] = i;
}
for (int i = 1; i <= int(m); i++) {
int l, r;
scanf("%d%d", &l, &r);
int x = max(pos[l], pos[r]);
s[x] = max(s[x], min(pos[l], pos[r]));
}
long long ans = 0, l = 0;
for (int i = 1; i <= int(n); i++) {
if (s[i] - l > 0) {
ans += 1ll * (s[i] - l) * (n - i + 1);
l = s[i];
}
}
printf("%I64d\n", 1ll * n * (n + 1) / 2 - ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int P[N + 1];
vector<int> S;
int n, k, maxPopped;
bool Check() {
for (int i = 1; i < (int)S.size(); ++i)
if (S[i] > S[i - 1]) return false;
return true;
}
void Read() {
scanf("%d %d", &n, &k);
int needed = 1;
S.push_back(n + 1);
for (int i = 0; i < k; ++i) {
int p;
scanf("%d", &p);
P[i] = p;
S.push_back(p);
while (S.size() > 1 && S.back() == needed) {
++needed;
S.pop_back();
}
}
maxPopped = needed - 1;
}
void Solve() {
if (!Check()) {
printf("-1");
return;
}
for (int i = 0; i < k; ++i) printf("%d ", P[i]);
int last = maxPopped;
for (int i = (int)S.size() - 1; i >= 0; --i) {
for (int j = S[i] - 1; j > last; --j) printf("%d ", j);
last = S[i];
}
}
int main() {
Read();
Solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mac = 2e3 + 10;
int a[mac], vis[mac];
int ask(int pos) {
printf("? %d\n", pos + 1);
fflush(stdout);
char s[5];
scanf("%s", s);
if (s[0] == 'Y') return 1;
return 0;
}
int main(int argc, char const *argv[]) {
int n, m;
scanf("%d%d", &n, &m);
int block = m / 2;
if (!block) block = 1;
int nb_block = n / block;
if (block != 1) {
for (int i = 0; i < nb_block; i++) {
int st = i * block;
for (int j = st; j < st + block; j++) {
if (!vis[j])
if (ask(j)) vis[j] = 1;
}
printf("R\n");
fflush(stdout);
}
}
for (int i = 0; i < nb_block; i++) {
for (int j = i + 1; j < nb_block; j++) {
int st = i * block;
for (int k = st; k < st + block; k++)
if (!vis[k]) ask(k);
st = j * block;
for (int k = st; k < st + block; k++)
if (!vis[k])
if (ask(k)) vis[k] = 1;
printf("R\n");
fflush(stdout);
}
}
int ans = 0;
for (int i = 0; i < n; i++)
if (!vis[i]) ans++;
printf("! %d\n", ans);
fflush(stdout);
return 0;
}
| 10 |
#include <bits/stdc++.h>
long long flag[1000005];
int main(void) {
int n, i, x, a;
long long sum = 0;
scanf("%d%d", &n, &x);
for (i = 1; i <= n; i++) {
scanf("%d", &a);
flag[a]++;
}
for (i = 1; i <= 100000; i++) sum += flag[i] * (flag[i ^ x]);
if (x == 0) {
sum = 0;
for (i = 1; i <= 100000; i++) sum += flag[i] * (flag[i] - 1) / 2;
sum *= 2;
}
printf("%I64d\n", sum / 2);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> v;
map<long long, long long> mymap;
for (long long i = 0; i <= n - 1; i++) {
long long a;
cin >> a;
v.push_back(a);
}
for (long long i = 0; i <= k - 1; i++) {
long long a;
cin >> a;
mymap[a - 1] = 1;
}
vector<long long> mark, unmark;
for (long long i = 0; i <= v.size() - 1; i++) {
if (mymap[i] == 1)
mark.push_back(v[i]);
else
unmark.push_back(v[i]);
}
long long sum = 0;
if (unmark.size() != 0) {
for (long long i = 0; i <= unmark.size() - 1; i++) sum = sum + unmark[i];
}
sort(mark.begin(), mark.end(), greater<long long>());
for (long long i = 0; i <= mark.size() - 1; i++) {
if (sum <= mark[i])
sum = sum + mark[i];
else
sum = sum + sum;
}
cout << sum << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n * 2];
for (int i = 0; i < n * 2; i++) arr[i] = i + 1;
for (int i = 1; i < n * 2; i++) {
if (arr[i] - 1 == k) {
swap(arr[1], arr[i]);
swap(arr[0], arr[1]);
if (k % 2 == 1 && k != 1) swap(arr[i], arr[i - 1]);
break;
}
}
for (int i = 0; i < n * 2; i++) cout << arr[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int mod;
long long int dp[5005][5005];
long long int C[5005];
long long int n, m;
long long int a[1000006];
long long int ans[2][5005];
long long int sum[2];
int main() {
scanf("%I64d%I64d%I64d", &n, &m, &mod);
for (long long int i = 0; i < ((long long int)(n)); ++i)
scanf("%I64d", &a[i]);
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (long long int i = 0; i < ((long long int)(5005 - 1)); ++i)
for (long long int j = 0; j < ((long long int)(5005 - 1)); ++j) {
dp[i + 1][j + 1] = (dp[i + 1][j + 1] + dp[i][j]) % mod;
dp[i + 1][j + 0] =
(dp[i + 1][j + 0] + dp[i][j] * max(0ll, (j - 1))) % mod;
}
for (long long int i = 0; i <= 5005; i++) {
vector<long long int> vec;
for (long long int j = 0; j < ((long long int)(i)); ++j)
vec.push_back(m - j);
C[i] = 1;
for (long long int j = 0;
j < ((long long int)(((long long int)(vec).size()))); ++j)
C[i] = (C[i] * vec[j]) % mod;
}
long long int fact[5005];
for (long long int i = 0; i < ((long long int)(5005)); ++i)
fact[i] = (i == 0) ? 1 : (fact[i - 1] * i % mod);
memset(ans, 0, sizeof(ans));
memset(sum, 0, sizeof(sum));
sum[1] = 1;
for (long long int i = 0; i < ((long long int)(n)); ++i) {
int now = i % 2;
int bef = 1 - now;
sum[now] = 0;
if (2 <= i)
for (int j = 0; j <= a[i - 2]; j++) ans[now][j] = 0;
for (int j = 0; j <= a[i]; j++) {
ans[now][j] = sum[bef] * (dp[a[i]][j] * C[j] % mod) % mod;
ans[now][j] = (ans[now][j] + mod -
ans[bef][j] * dp[a[i]][j] % mod * fact[j] % mod) %
mod;
sum[now] = (sum[now] + ans[now][j]) % mod;
}
}
printf("%I64d\n", sum[1 - n % 2]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
vector<bool> arr;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> a >> b;
long long sum = 0;
arr.resize(n);
char ch;
for (int i = 0; i < n; i++) {
cin >> ch;
arr[i] = 1;
if (ch == '.') arr[i] = 0;
}
if (a < b) swap(a, b);
for (int i = 0; i < n; i++) {
if (arr[i]) {
if (a < b) swap(a, b);
} else {
if (a > 0) {
sum++;
a--;
}
swap(a, b);
}
}
cout << sum;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
for (int i = k + 1; i >= 1; i--) cout << i << " ";
for (int i = k + 2; i <= n; i++) cout << i << " ";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int ans = 0, x = 1;
string s;
cin >> s;
while (x == 1) {
x = 5;
for (int i = 0; i < s.length(); i++) {
if (s[i] == s[i + 1]) {
ans++;
if (i == 0) {
s.erase(s.begin() + i);
s.erase(s.begin() + i);
x = 1;
} else {
s.erase(s.begin() + i);
s.erase(s.begin() + i);
x = 1;
}
break;
}
}
}
if (ans % 2 == 0) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e5 + 4;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
vector<long long> first(N, 1), INV(N, 1), minp(N, 0);
vector<bool> prime(N, 0);
vector<long long> p;
long long gd(long long a, long long b) {
if (b == 0) return a;
return gd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gd(a, b); }
long long ex(long long x, long long n) {
long long res = 1;
x = x % mod;
while (n) {
if (n & 1) res = (res * x) % mod;
x = (x * x) % mod;
n = n >> 1;
}
return res % mod;
}
long long fermat(long long n) { return ex(n, mod - 2); }
void fact() {
for (int i = 2; i < N; i++) {
first[i] = (first[i - 1] * i) % mod;
INV[i] = fermat(first[i]);
}
}
long long ncr(long long n, long long r) {
if (r == 0 || n == r) return 1;
if (r > n) return 0;
return (first[n] * INV[r] % mod * INV[n - r] % mod) % mod;
}
void sieve() {
prime[0] = 1, prime[1] = 1;
for (int i = 2; i * i < N; i++) {
if (prime[i] == 0) {
for (int j = i * i; j < N; j += i) prime[j] = 1;
}
}
for (int i = 1; i < N + 1; i++) {
if (prime[i] == 0) p.push_back(i);
}
}
void minprime() {
minp[0] = 0, minp[1] = 1;
for (int i = 2; i < N; i++) {
if (minp[i] == 0) {
minp[i] = i;
for (int j = i * i; j < N; j += i) {
if (minp[j] == 0) minp[j] = i;
}
}
}
}
void JAI_SHREE_RAM() {
long long n, mm;
cin >> n >> mm;
map<long long, long long> m;
for (int i = 0; i < mm; i++) {
long long x, y;
cin >> x >> y;
m[min(x, y)]++;
}
long long q;
cin >> q;
while (q--) {
long long x;
cin >> x;
if (x == 3) {
cout << n - m.size() << "\n";
}
if (x == 1) {
long long z, y;
cin >> z >> y;
m[min(z, y)]++;
}
if (x == 2) {
long long z, y;
cin >> z >> y;
m[min(z, y)]--;
if (m[min(z, y)] == 0) {
m.erase(min(z, y));
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
sieve();
long long tttt = 1;
while (tttt--) {
JAI_SHREE_RAM();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Water {
int degree;
double v;
} w[200005];
bool cmp(Water a, Water b) { return a.degree < b.degree; }
int main() {
int n, l, r, i;
double v = 0, ans = 0, T, engl, engr;
cin >> n >> T;
for (i = 0; i < n; i++) scanf("%lf", &w[i].v);
for (i = 0; i < n; i++) scanf("%d", &w[i].degree);
sort(w, w + n, cmp);
l = -1;
r = n;
for (i = 0; i < n; i++) {
if (w[i].degree == T)
ans += w[i].v;
else if (w[i].degree < T)
l = i;
else
r = min(r, i);
}
while (l != -1 && r != n) {
engl = (w[l].degree - T) * w[l].v;
engr = (w[r].degree - T) * w[r].v;
if (fabs(engl) > fabs(engr)) {
ans += w[r].v + w[l].v;
w[l].v = (engl + engr) / (w[l].degree - T);
ans -= w[l].v;
r++;
} else {
ans += w[l].v + w[r].v;
w[r].v = (engl + engr) / (w[r].degree - T);
ans -= w[r].v;
l--;
}
}
printf("%.7f\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0xffffffffffffff;
const int N = 300 + 5;
const int mod = 998244353;
int main() {
int n, ans;
scanf("%d", &n);
int tp = 1, sttp = 1, ip = 0;
for (int i = 1; i <= n; i++) {
tp = sttp;
if (tp > 0) ip++;
for (int j = 1; j <= n; j++, tp = -tp) {
if (tp > 0)
ans = (j - 1) * n + ip;
else
ans = j * n - ip + 1;
printf("%d%c", ans, " \n"[j == n]);
}
sttp = -sttp;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, k1;
string s1, s2, s;
int main() {
cin >> n;
cin >> s1;
k = 1;
k1 = 0;
for (int i = 1; i < n; i++) {
cin >> s;
if (s1 == s)
k++;
else {
k1++;
s2 = s;
}
}
if (k > k1)
cout << s1;
else
cout << s2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int delt = 'a' - 'A';
const int one = '1';
const int L = 'L' + delt;
bool _equal[1000][1000];
string new_login, old_login;
int cnt_old;
int main() {
cin >> new_login;
for (int i = 0; i < new_login.size(); i++) {
if (('A' <= new_login[i] && new_login[i] <= 'Z')) new_login[i] += delt;
}
for (int i = 'a'; i <= 'z'; i++) {
_equal[i][i] = 1;
}
for (int i = '0'; i <= '9'; i++) {
_equal[i][i] = 1;
}
_equal['_']['_'] = 1;
_equal[one]['i'] = 1;
_equal[one][L] = 1;
_equal[L][one] = 1;
_equal[L]['i'] = 1;
_equal['i'][one] = 1;
_equal['i'][L] = 1;
_equal['0']['o'] = 1;
_equal['o']['0'] = 1;
cin >> cnt_old;
for (int i = 1; i <= cnt_old; i++) {
bool good = 0;
cin >> old_login;
if (old_login.size() != new_login.size()) {
continue;
}
for (int j = 0; j < old_login.size(); j++) {
if (('A' <= old_login[j] && old_login[j] <= 'Z')) old_login[j] += delt;
if (!_equal[new_login[j]][old_login[j]]) {
good = 1;
break;
}
}
if (!good) {
cout << "No\n";
return 0;
}
}
cout << "Yes\n";
}
| 2 |
#include <bits/stdc++.h>
const int INF = 1000000000;
const int MAXN = 500;
int l[2][MAXN], w[MAXN], h[2][MAXN], c[MAXN];
int ceil(int num, int denom) { return (num / denom) + (num % denom > 0); }
int main() {
int n, m, i, j, cost, tmp, ans = 0;
scanf("%d", &n);
for (i = 0; i < n; ++i) scanf("%d%d%d", &l[0][i], w + i, &h[0][i]);
scanf("%d", &m);
for (i = 0; i < m; ++i) scanf("%d%d%d", &h[1][i], &l[1][i], c + i);
for (i = 0; i < n; ++i) {
cost = INF;
for (j = 0; j < m; ++j)
if (h[0][i] <= h[1][j]) {
tmp = ceil(2 * (l[0][i] + w[i]), l[1][j] * (h[1][j] / h[0][i])) * c[j];
if (tmp < cost) cost = tmp;
}
ans += cost;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int l[100005], r[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int lft = 0;
int rgt = 0;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
lft += l[i];
rgt += r[i];
}
l[0] = r[0] = 0;
int ind = 0;
for (int i = 1; i <= n; i++) {
if (abs(lft - rgt - 2 * l[ind] + 2 * r[ind]) <
abs(lft - rgt - 2 * l[i] + 2 * r[i])) {
ind = i;
}
}
cout << ind << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
int k;
int f[500];
int main() {
cin >> k;
cin >> s;
int len = s.size();
for (int i = 0; i < len; i++) f[s[i] - 'a']++;
for (int i = 0; i < 26; i++)
if (f[i] % k != 0) {
cout << -1;
return 0;
}
for (int k1 = 1; k1 <= k; k1++)
for (int i = 0; i < 26; i++)
for (int j = 1; j <= (f[i] / k); j++) cout << (char)('a' + i);
}
| 1 |
#include <bits/stdc++.h>
inline long long read() {
long long x = 0;
char ch = getchar(), w = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * w;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
using namespace std;
int n;
const int N = 210000;
struct Node {
double x, y;
Node operator-(const Node u) { return (Node){x - u.x, y - u.y}; }
double operator*(const Node u) { return x * u.y - y * u.x; }
} a[N], tmp, l, r;
double bin[N];
int Gcd(int x, int y) {
if (!y) return x;
return Gcd(y, x % y);
}
int gcd(int x, int y) { return Gcd(abs(x), abs(y)); }
double kk;
long long c1, c2, kkz;
double tot, now, ans;
int main() {
n = read();
bin[0] = 1;
for (int i = 1; i <= n; ++i) {
a[i].x = read();
a[i].y = read();
bin[i] = bin[i - 1] * 2;
}
kk = bin[n] - 1 - n - (double)n * (n - 1) / 2;
tmp = a[n] - a[1];
c1 += gcd(tmp.x, tmp.y);
r = a[2] - a[1];
c1 += gcd(r.x, r.y);
for (int i = 3; i <= n; ++i) {
l = a[i] - a[1];
tmp = a[i] - a[i - 1];
tot += r * l / 2;
c1 += gcd(tmp.x, tmp.y);
r = l;
}
for (int i = 1; i <= n; ++i) {
r = a[((i % n + 1))] - a[i];
c2 = gcd(r.x, r.y);
now = 0;
for (int j = ((((i % n + 1)) % n + 1)), k = 2;
k <= 35 && ((j % n + 1)) != i; j = ((j % n + 1)), ++k) {
l = a[j] - a[i];
tmp = l - r;
c2 += ((kkz = gcd(l.x, l.y)) + gcd(tmp.x, tmp.y));
now += r * l / 2;
ans += (((now) + 1.0 - 0.5 * (c2)) + (((j % n + 1)) == i ? 0 : kkz - 1)) *
(n >= 100 ? 1 / bin[k + 1] : (bin[n - k - 1] - 1.0) / kk);
r = l;
c2 -= kkz;
}
}
printf("%.7lf\n", ((tot) + 1.0 - 0.5 * (c1)) - ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned int x, y, z, c;
cin >> x >> y >> z;
c = sqrt((y * z) / x);
cout << 4 * (c + (y / c) + (z / c));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool adj[100 + 1][100 + 1];
int a[100 + 1];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> a[i];
memset(adj, 0, sizeof(adj));
int u, v;
for (int j = 0; j < m; ++j) {
cin >> u >> v;
adj[u][v] = true;
adj[v][u] = true;
}
int mini = 9999999;
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j)
for (int k = 0; k <= n; ++k) {
bool x = adj[i][j];
bool y = adj[i][k];
bool z = adj[j][k];
if (x && y && z) mini = min(mini, a[i] + a[j] + a[k]);
}
if (mini == 9999999)
cout << "-1";
else
cout << mini;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = 2e6 + 30;
const int MAXN = 1e3 + 2;
const long long INF = 1e9 + 7;
const long long BINF = 1e15;
const int MOD = 1e9 + 7;
const long double EPS = 1e-15;
const long long dx[] = {0, 0, 1, -1};
const long long dy[] = {1, -1, 0, 0};
long long n;
long long u, v;
long long used[MXN][4];
long long sz;
vector<int> g[MXN];
long long depth[MXN];
long long len;
long long posx[MXN], posy[MXN];
void dfs(long long v, long long p, long long x, long long y, long long sz) {
depth[v] = depth[p] + 1;
len = (1LL << (40LL - depth[v]));
posx[v] = posx[p] + (len * x);
posy[v] = posy[p] + (len * y);
if (g[v].size() > 4) {
cout << "NO";
exit(0);
}
x *= -1, y *= -1;
for (int i = 0; i < 4; i++) {
if (x == dx[i] && y == dy[i]) {
used[v][i] = 1;
}
}
for (auto to : g[v]) {
if (to != p) {
while (used[v][sz]) sz++;
used[v][sz] = 1;
dfs(to, v, dx[sz], dy[sz], 0);
}
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
depth[0] = -1;
dfs(1, 0, 0, 0, 0);
cout << "YES\n";
for (int i = 1; i <= n; i++) {
cout << posx[i] << ' ' << posy[i] << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int p[2];
int cnt;
node() {
cnt = 0;
p[0] = -1;
p[1] = -1;
}
};
vector<node> v;
string tobin(int n) {
string ans = "";
while (n != 0) {
if (n % 2 == 0)
ans += '0';
else
ans += '1';
n /= 2;
}
for (int i = ans.size(); i < 31; i++) ans += '0';
reverse(ans.begin(), ans.end());
return ans;
}
void insert(string n, int ad) {
int cur = 0;
for (int i = 0; i < 31; ++i) {
int b = n[i] - '0';
if (v[cur].p[b] == -1) {
v[cur].p[b] = v.size();
v.push_back(node());
}
cur = v[cur].p[b];
v[cur].cnt += ad;
}
}
string ans(string n) {
int cur = 0;
string ans = tobin(0);
for (int i = 0; i < 31; ++i) {
ans[i] = '1';
int b = n[i] - '0';
int nod = v[cur].p[!b];
if (v[cur].p[!b] != -1 && v[nod].cnt) {
cur = nod;
} else {
ans[i] = '0';
cur = v[cur].p[b];
}
}
return ans;
}
int frombin(string n) {
int k = 0;
for (int i = 0; i < 31; i++) {
k += pow(2.0, 30 - i) * (n[i] - '0');
}
return k;
}
int main() {
int q;
cin >> q;
char c;
int x;
v.push_back(node());
v[0].cnt = 0;
string n = tobin(0);
insert(n, 1);
for (int i = 0; i < q; i++) {
cin >> c >> x;
string v = tobin(x);
if (c == '+') {
insert(v, 1);
} else if (c == '-') {
insert(v, -1);
} else {
string u = ans(v);
int ans = frombin(u);
cout << ans << endl;
}
}
return 0;
}
| 5 |
#pragma GCC optimize("Ofast")
#include "bits/stdc++.h"
#define rep(i,j,n) for(int i=(j);i<=((int)n);++i)
#define rev(i,n,j) for(int i=(n);i>=((int)j);--i)
typedef long long int ll;
#define int long long int
const ll INFL=0x3f3f3f3f3f3f3f3fLL;
const int INF=0x3f3f3f3f;
const int mod=1000000007;
#define endl "\n"
#define mem(a,val) memset(a,val,sizeof(a))
#define all(c) (c).begin(),(c).end()
#define tr(container, it) for(__typeof(container.begin()) it = container.begin(); it != container.end(); it++)
#define present(container, element) (container.find(element) != container.end())
#define pb push_back
#define FAST ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define readmat(a, n, m) int a[n + 5][m + 5] = {}; rep(i, 1, n) {rep(j, 1, m) cin >> a[i][j];}
#define printmat(a, n, m) rep (i, 1, n) {rep (j, 1, m) cout << a[i][j] << " "; cout << endl;} cout << endl;
#define printarr(a, n) rep(i, 1, n) cout << a[i] << " "; cout << endl;
typedef std::map< int,int> mii;
typedef std::vector< int > vi;
typedef std::vector< vi > vvi;
typedef std::pair< int,int > ii;
using namespace std;
const int N = 1e6+5, M = N;
vector<int>g[N];
#define cerr cout
#define cerr cout
#define ts to_string
string ts(char c) { return string(1, c); }
string ts(bool b) { return b ? "true" : "false"; }
string ts(const char* s) { return (string)s; }
string ts(string s) { return s; }
template<class A> string ts(complex<A> c) {
stringstream ss; ss << c; return ss.str(); }
string ts(vector<bool> v) {
string res = "{"; for(int i = 0; i < v.size(); ++i) res += char('0' + v[i]);
res += "}"; return res; }
template<size_t SZ> string ts(bitset<SZ> b) {
string res = ""; for(int i = 0; i < SZ; ++i) res += char('0' + b[i]);
return res; }
template<class A, class B> string ts(pair<A,B> p);
template<class T> string ts(T v) { // containers with begin(), end()
bool fst = 1; string res = "{";
for (const auto& x: v) {
if (!fst) res += ", ";
fst = 0; res += ts(x);
}
res += "}"; return res;
}
template<class A, class B> string ts(pair<A,B> p) {
return "(" + ts(p.first) + ", " + ts(p.second) + ")"; }
void DBG() { cerr << "]" << endl; }
template<class H, class... T> void DBG(H h, T... t) {
cerr << ts(h); if (sizeof...(t)) cerr << ", ";
DBG(t...); }
void EDBG(string names) { names = names; }
template<class H, class... T> void EDBG(string names, H h, T... t) {
auto pos = names.find(',');
auto first_name = names.substr(0, pos);
auto rest = names.substr(pos + 1);
while(rest.front() == ' '){
rest = rest.substr(1);
}
cerr << "[" << first_name << "]: [" << ts(h) << "]" << endl;
EDBG(rest, t...);
}
#ifdef LOCAL // compile with -DLOCAL
#define error(...) cerr << "[" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
#define edbg(...) EDBG(#__VA_ARGS__, __VA_ARGS__)
#else
#define error(...) 0
#define edbg(...) 0
#endif
int a[505][505];
int pos;
int n;
int c[N];
int go(vi z)
{
int x=z.front();
if (z.size()==1)
{
c[x]=a[x][x];
return x;
}
int mx=-INF;
for(auto &i : z)
{
mx=max(mx,a[x][i]);
}
vvi ch;
ch.push_back({x});
for(int i = 1; i <z.size(); ++i)
{
int v=z[i];
int group=-1;
for(int j = 0; j <ch.size(); ++j)
{
if (a[v][ch[j][0]] != mx)
{
group = j;
break;
}
}
if (group==-1)
{
group=ch.size();
ch.push_back({});
}
ch[group].push_back(v);
}
int v=++n;
for(int i = 0; i <ch.size(); ++i)
{
int u=go(ch[i]);
g[v].push_back(u);
}
c[v]=mx;
return v;
}
void solve()
{
cin>>n;
rep(i,1,n)
{
rep(j,1,n)
cin>>a[i][j];
}
vi z;
for(int i = 1; i <=n; ++i)
{
z.push_back(i);
}
int root=go(z);
cout<<n<<endl;
printarr(c,n);
cout<<root<<endl;
for(int i = 1; i <=n; ++i)
{
for(auto &j : g[i])
{
cout<<j<<" "<<i<<endl;
}
}
}
signed main()
{
FAST;
#ifdef LOCAL
freopen("C:\\Users\\hp\\Documents\\input.txt", "r", stdin);
freopen("C:\\Users\\hp\\Documents\\output.txt", "w", stdout);
std::chrono::time_point<std::chrono::high_resolution_clock> start, end;
start = std::chrono::high_resolution_clock::now();
#endif
solve();
#ifdef LOCAL
end = std::chrono::high_resolution_clock::now();
ll elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count();
cout<<endl;
cout << "\nElapsed Time: " << elapsed_time << "ms\n";
#endif
return 0;
}
// vector string set map first second continue break return upper_bound lower_bound length void sort
// stack queue pop size erase empty insert
// #Hala BBCF
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int cost[MAX];
vector<int> tims;
int main() {
int n;
scanf("%d", &n);
int cc = 0;
cost[0] = 0;
tims.push_back(-1);
int cpaid = 0;
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
int val = cost[i - 1] + 20;
int ind =
upper_bound(tims.begin(), tims.end(), max(-1, a - 90)) - tims.begin();
ind--;
val = min(val, cost[ind] + 50);
ind =
upper_bound(tims.begin(), tims.end(), max(-1, a - 1440)) - tims.begin();
ind--;
val = min(val, cost[ind] + 120);
printf("%d\n", val - cpaid);
cpaid = val;
cost[i] = val;
tims.push_back(a);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
long long L, v, l, r;
while (t--) {
cin >> L >> v >> l >> r;
long long ct = 0;
ct = L / v - (r / v - (l - 1) / v);
cout << ct << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 500;
bitset<N> mark;
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
char c[N];
for (long long i = 0; i < 500; ++i) c[i] = 'A';
mark.reset();
long long w = 210, las = 0, st = 501;
bool ne = false;
for (long long i = 0; i < s.size(); ++i)
if (!mark[(long long)(s[i])]) {
mark[(long long)(s[i])] = true;
if (c[w] != 'A' && c[w + 1] == 'A')
w++, c[w] = s[i];
else if (c[w] != 'A' && c[w - 1] == 'A')
w--, c[w] = s[i];
else if (c[w] == 'A')
c[w] = s[i];
else {
ne = true;
break;
}
las = max(las, w);
st = min(st, w);
} else {
if (c[w + 1] == s[i])
w++;
else if (c[w - 1] == s[i])
w--;
else {
ne = true;
break;
}
las = max(las, w);
st = min(st, w);
}
las++;
for (long long i = 97; i < 123; ++i)
if (!mark[i]) {
c[las] = (char)(i);
las++;
}
if (ne)
cout << "NO\n";
else {
cout << "YES\n";
for (long long i = st; i < las; ++i) cout << c[i];
cout << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[10];
int main() {
int n, x;
cin >> n >> x;
n = n % 6;
a[x] = 1;
while (n > 0) {
if (n % 2 == 0) {
swap(a[1], a[2]);
} else
swap(a[0], a[1]);
n--;
}
for (int i = 0; i <= 10; i++) {
if (a[i] == 1) {
cout << i;
break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;
char b[maxn];
string cur;
int l, i;
vector<string> v;
int main() {
gets(b);
l = strlen(b);
for (i = 0; i < l; i++) {
if (b[i] == ' ') {
if (cur.size() && cur != " ") v.push_back(cur);
cur = " ";
continue;
}
if (b[i] == ',') {
if (cur.size()) v.push_back(cur);
cur = "";
v.push_back(",");
continue;
}
if (cur.size() && isdigit(cur[0]) && !isdigit(b[i])) {
v.push_back(cur);
cur = "";
}
if (cur.size() && cur == " ") {
v.push_back(cur);
cur = "";
}
cur += b[i];
if (cur == "...") {
v.push_back(cur);
cur = "";
}
}
if (cur.size()) v.push_back(cur);
for (i = 0; i < v.size(); i++) {
int next = i + 1;
while (next < v.size() && v[next] == " ") ++next;
if (v[i] == ",") {
printf(",");
if (next < v.size()) printf(" ");
continue;
}
if (v[i] == "...") {
int p = i - 1;
while (p >= 0 && v[p] == " ") --p;
if (p >= 0 && v[p] != ",") printf(" ");
printf("...");
continue;
}
if (isdigit(v[i][0])) {
cout << v[i];
if (next < v.size() && isdigit(v[next][0])) printf(" ");
continue;
}
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
const long long INF = 1000000000000000018LL;
int n;
void odd(int n) {
while (n > 5) {
printf("%d - %d = %d\n", n, n - 1, 1);
printf("%d * %d = %d\n", n - 2, 1, n - 2);
n -= 2;
}
printf("5 - 2 = 3\n");
printf("3 - 1 = 2\n");
printf("3 * 2 = 6\n");
printf("4 * 6 = 24\n");
}
void even(int n) {
while (n > 4) {
printf("%d - %d = %d\n", n, n - 1, 1);
printf("%d * %d = %d\n", n - 2, 1, n - 2);
n -= 2;
}
printf("4 * 3 = 12\n");
printf("12 * 2 = 24\n");
printf("24 * 1 = 24\n");
}
int main() {
int i, j, k;
cin >> n;
if (n <= 3) {
printf("NO\n");
return 0;
}
printf("YES\n");
if (n & 1) {
odd(n);
return 0;
}
even(n);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300000;
int aa[N], bb[N], cc[N], qu[3];
bool check(int *aa, int n, int m, int k) {
for (int i = 0; i < n; i++) bb[i] = aa[(i + k) % n];
m -= n;
for (int i = 0; i < n; i++) {
if (bb[i] == -1) continue;
for (int j = i, j_; (j_ = bb[j]) != -1; j = j_) bb[j] = -1;
m++;
}
return m >= 0;
}
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
fill(cc, cc + n, 0);
for (int i = 0; i < n; i++) {
int a;
cin >> a, a--;
cc[(i - (aa[i] = a) + n) % n]++;
}
int cnt = 0;
for (int k = 0; k < n; k++)
if (cc[k] >= n - n / 3 * 2 && check(aa, n, m, k)) qu[cnt++] = k;
cout << cnt;
for (int h = 0; h < cnt; h++) cout << ' ' << qu[h];
cout << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[26];
int main() {
string str;
int n, c = 0;
cin >> str >> n;
if (str.size() < n) {
cout << "impossible";
return 0;
}
for (int i = 0; i < str.size(); ++i) ++arr[str[i] - 'a'];
for (int i = 0; i < 26; ++i)
if (arr[i] > 0) ++c;
if (c >= n)
cout << "0";
else
cout << n - c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int sum1 = 0, sum2 = 0, sum3 = 0, n1, n2, n3;
cin >> n1;
n2 = n1 - 1;
n3 = n2 - 1;
int temp;
while (n1--) {
cin >> temp;
sum1 += temp;
}
while (n2--) {
cin >> temp;
sum2 += temp;
}
while (n3--) {
cin >> temp;
sum3 += temp;
}
cout << sum1 - sum2 << "\n" << sum2 - sum3;
int do_not_hack;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int m) {
if (y == 0) return 1;
long long int a = power(x, y / 2, m);
if (y % 2) {
return (a * ((a * x) % m)) % m;
} else {
return (a * a) % m;
}
}
long long int mod_inverse(long long int x, long long int m) {
return power(x, m - 2, m);
}
long long int fact(long long int n, long long int m) {
if (n <= 1) return 1;
return (fact(n - 1, m) * n) % m;
}
long long int ncr(long long int n, long long int r, long long int m) {
if (r > n) return 0;
long long int n1 = 1, d1 = 1, d2 = 1;
n1 = fact(n, m);
d1 = fact(r, m);
d2 = fact(n - r, m);
long long int ans = mod_inverse((d1 * d2) % m, m);
ans = (ans * n1) % m;
return ans;
}
int ispal(string s) {
int len = s.size();
int flag = 1;
for (int i = 0; i < len; ++i) {
if (s[i] != s[len - i - 1]) {
flag = 0;
break;
}
}
return flag;
}
long long int sroot(long long int n, long long int low = 1,
long long int high = 1e9 + 1) {
if (low == high) return low;
if (low == high - 1) {
if (high * high <= n)
return high;
else
return low;
}
long long int mid = (low + high) / 2;
long long int a = mid * mid;
if (a > n)
return sroot(n, low, mid - 1);
else
return sroot(n, mid, high);
}
long long int croot(long long int n, long long int low = 1,
long long int high = 1e6 + 1) {
if (low == high) return low;
if (low == high - 1) {
if (high * high * high <= n)
return high;
else
return low;
}
long long int mid = (low + high) / 2;
long long int a = mid * mid * mid;
if (a > n)
return croot(n, low, mid - 1);
else
return croot(n, mid, high);
}
int n, m;
vector<int> g[3010];
int dis[3010][3010];
void fun(int u) {
queue<int> qu;
int h[n + 1];
for (int i = 1; i <= n; ++i) h[i] = 10000000;
h[u] = 0;
qu.push(u);
while (qu.size() != 0) {
int v = qu.front();
qu.pop();
for (auto w : g[v]) {
if (h[w] == 10000000) {
h[w] = h[v] + 1;
qu.push(w);
}
}
}
for (int i = 1; i <= n; ++i) dis[u][i] = h[i];
}
int main() {
cin >> n >> m;
int gm[n + 1][n + 1];
memset(gm, 0, sizeof(gm));
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
if (u != v) gm[u][v] = 1;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
if (gm[i][j]) g[i].push_back(j);
}
for (int i = 1; i <= n; ++i) fun(i);
vector<pair<int, int> > left[n + 1], right[n + 1];
for (int i = 1; i <= n; ++i) {
set<pair<int, int> > st;
for (int j = 1; j <= n; ++j) {
if (j == i || dis[i][j] == 10000000) continue;
st.insert({dis[i][j], j});
}
set<pair<int, int> >::iterator it;
it = st.end();
int cnt = 0;
while (cnt < 4 && it != st.begin()) {
it--;
right[i].push_back(*it);
cnt++;
}
st.clear();
for (int j = 1; j <= n; ++j) {
if (j == i || dis[j][i] == 10000000) continue;
st.insert({dis[j][i], j});
}
it = st.end();
cnt = 0;
while (cnt < 4 && it != st.begin()) {
it--;
left[i].push_back(*it);
cnt++;
}
}
int mx = 0;
int ans[5];
for (int u = 1; u <= n; ++u) {
for (int v = 1; v <= n; ++v) {
int tmp = dis[u][v];
if (u == v || dis[u][v] == 10000000) continue;
for (auto a : left[u]) {
for (auto b : right[v]) {
int t1 = a.second, t2 = b.second;
if (t1 == t2 || u == t2 || v == t1) continue;
int temp = tmp + a.first + b.first;
if (temp > mx) {
mx = temp;
ans[1] = t1;
ans[2] = u;
ans[3] = v;
ans[4] = t2;
}
}
}
}
}
for (int i = 1; i <= 4; ++i) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve();
using ll = long long;
template <class T = ll>
using V = vector<T>;
using vi = V<int>;
using vl = V<>;
using vvi = V<V<int> >;
constexpr int inf = 1001001001;
constexpr ll infLL = (1LL << 61) - 1;
struct IoSetupNya {
IoSetupNya() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
cerr << fixed << setprecision(7);
}
} iosetupnya;
template <typename T, typename U>
inline bool amin(T &x, U y) {
return (y < x) ? (x = y, true) : false;
}
template <typename T, typename U>
inline bool amax(T &x, U y) {
return (x < y) ? (x = y, true) : false;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
int s = (int)v.size();
for (long long i = 0; i < (long long)(s); i++) os << (i ? " " : "") << v[i];
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v) is >> x;
return is;
}
void in() {}
template <typename T, class... U>
void in(T &t, U &...u) {
cin >> t;
in(u...);
}
void out() { cout << "\n"; }
template <typename T, class... U>
void out(const T &t, const U &...u) {
cout << t;
if (sizeof...(u)) cout << " ";
out(u...);
}
template <typename T>
void die(T x) {
out(x);
exit(0);
}
int main() { solve(); }
using vd = V<double>;
using vs = V<string>;
using vvl = V<V<> >;
template <typename T>
using heap = priority_queue<T, V<T>, greater<T> >;
using P = pair<ll, ll>;
using vp = V<P>;
constexpr int MOD = 1000000007;
void q() {
int N, M, K;
in(N, M, K);
vi a(N);
in(a);
K = min(K, M - 1);
multiset<int> s;
int l = M - 1, r = N - 1;
while (K <= l) {
s.emplace(max(a[l], a[r]));
l--;
r--;
}
int ans = *s.begin();
while (l >= 0) {
s.erase(s.find(max(a[l + M - K], a[r + M - K])));
s.emplace(max(a[l], a[r]));
amax(ans, *s.begin());
l--;
r--;
}
out(ans);
}
void solve() {
int Q;
in(Q);
for (long long i = 0; i < (long long)(Q); i++) q();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, b, c = 1000000000000000001, d = 0, e = 0;
cin >> n >> k;
long long a[k], err[k];
for (b = 0; b < k; b++) {
cin >> a[b];
err[b] = n % a[b];
}
for (b = 0; b < k; b++) {
if (c > err[b] && err[b] >= 0) {
c = err[b];
d = b;
e = n / a[b];
}
}
cout << d + 1 << " " << e;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int a = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u') {
cout << s[i];
a = 0;
} else {
if (i != 0 && (s[i - 1] == 'a' || s[i - 1] == 'e' || s[i - 1] == 'i' ||
s[i - 1] == 'o' || s[i - 1] == 'u'))
a++;
else if (i != 0 && s[i] == s[i - 1]) {
if (i > 1 && a == 2 && s[i] == s[i - 2]) {
} else
a++;
} else
a++;
if (a == 3) {
a = 1;
cout << " ";
}
cout << s[i];
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, maxi = -1, mini;
scanf("%d %d", &n, &m);
priority_queue<int, std::vector<int>, std::greater<int> > q;
for (int i = 0, a; i < n; i++) {
scanf("%d", &a);
maxi = max(maxi, a);
q.push(a);
}
maxi += m;
while (m > 0) {
int p = q.top();
q.pop();
p++;
q.push(p);
m--;
}
while (!q.empty()) {
mini = q.top();
q.pop();
}
printf("%d %d\n", mini, maxi);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
int n, m, seed, vmax;
set<int> s;
pair<long long, int> b[100005];
int rnd() {
int tmp = seed;
seed = (1ll * seed * 7 + 13) % 1000000007;
return tmp;
}
int power(int x, int y, int p) {
int s = 1 % p;
for (; y; y /= 2, x = 1ll * x * x % p)
if (y & 1) s = 1ll * s * x % p;
return s;
}
int main() {
scanf("%d%d%d%d", &n, &m, &seed, &vmax);
for (int i = 1; i <= n; i++) a[i] = rnd() % vmax + 1, s.insert(i);
s.insert(n + 1);
s.insert(0);
for (int i = 1; i <= m; i++) {
int op = rnd() % 4 + 1;
int l = rnd() % n + 1;
int r = rnd() % n + 1;
if (l > r) swap(l, r);
int x, y;
set<int>::iterator it;
if (op == 3)
x = rnd() % (r - l + 1) + 1;
else
x = rnd() % vmax + 1;
if (op == 4) y = rnd() % vmax + 1;
if (op == 1) {
it = --s.upper_bound(r);
long long lav2 = a[*it];
it = --s.upper_bound(l);
long long lav1 = a[*it];
if (*it != l) s.insert(l);
a[l] = lav1 + x;
it = s.upper_bound(r);
if (*it != r + 1) s.insert(r + 1), a[r + 1] = lav2;
it = s.upper_bound(l);
for (; *it <= r; a[*it++] += x)
;
} else if (op == 2) {
it = --s.upper_bound(r);
long long lav2 = a[*it];
it = --s.upper_bound(l);
if (*it != l) s.insert(l);
a[l] = x;
it = s.upper_bound(r);
if (*it != r + 1) s.insert(r + 1), a[r + 1] = lav2;
it = s.upper_bound(l);
for (; *it <= r;) {
a[*it] = x;
s.erase(it);
it = s.upper_bound(l);
}
} else {
it = --s.upper_bound(l);
int top = 1;
b[1].second = l;
b[1].first = a[*it];
for (it++; *it <= r; it++) {
b[++top].second = *it;
b[top].first = a[*it];
}
int lav = r + 1;
for (int i = top; i; i--) {
int tmp = b[i].second;
b[i].second = lav - b[i].second;
lav = tmp;
}
if (op == 3) {
sort(b + 1, b + top + 1);
for (int i = 1; i <= top; i++)
if (x <= b[i].second) {
printf("%I64d\n", b[i].first);
break;
} else
x -= b[i].second;
} else {
int ans = 0;
for (int i = 1; i <= top; i++)
ans = (ans + 1ll * power(b[i].first % y, x, y) * b[i].second % y) % y;
printf("%d\n", ans);
}
}
}
}
| 9 |
#include <bits/stdc++.h>
const int S = 505;
int n, a[S], f[S][S], m, b[S], px[S][S], py[S][S];
inline int ma(int a, int b) { return a > b ? a : b; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", b + i);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i] == b[j]) {
f[i][j] = 1;
px[i][j] = 0;
py[i][j] = 0;
for (int k = 1; k < i; k++)
if (a[k] < a[i] && f[k][j - 1] + 1 > f[i][j]) {
f[i][j] = f[k][j - 1] + 1;
px[i][j] = k;
py[i][j] = j - 1;
}
} else {
f[i][j] = f[i][j - 1];
px[i][j] = i;
py[i][j] = j - 1;
}
int xx = 0, t, yy = m, ans[S] = {0}, tp = 0;
for (int i = 1; i <= n; i++)
if (f[i][m] > f[xx][m]) xx = i;
printf("%d\n", f[xx][m]);
while (xx && yy) {
if (a[xx] == b[yy]) ans[++tp] = xx;
t = px[xx][yy];
yy = py[xx][yy];
xx = t;
}
for (int i = tp; i; i--) printf("%d ", a[ans[i]]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[110], b[110], c[110], j = 0, k = 0, s1 = 0, s2 = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] >= 0) {
b[j++] = a[i];
} else {
c[k++] = a[i];
}
}
for (int i = 0; i < j; i++) {
s1 = s1 + b[i];
}
for (int i = 0; i < k; i++) {
s2 = s2 + c[i];
}
cout << (s1 - s2) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a, m;
vector<int> hits;
int f(int s) {
if (s < a) return 0;
int times = (s - a) / (a + 1) + 1;
return times;
}
bool solve(int moves) {
if (moves == m + 1) return true;
vector<int> all;
for (int i = 0; i < moves; ++i) all.push_back(hits[i]);
sort(all.begin(), all.end());
int cnt = 0;
cnt += f(all[0] - 1);
cnt += f(n - all.back());
for (int i = 0; i < moves - 1; ++i) cnt += f(all[i + 1] - all[i] - 1);
return cnt >= k;
}
int main() {
cin >> n >> k >> a >> m;
hits.resize(m);
for (int i = 0; i < m; ++i) scanf("%d", &hits[i]);
int lo = 1, hi = m + 1, mid;
while (lo < hi) {
mid = (lo + hi) / 2;
if (!solve(mid))
hi = mid;
else
lo = mid + 1;
}
if (lo == m + 1)
cout << "-1\n";
else
cout << lo << '\n';
};
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string pw, cd[10];
cin >> pw;
for (int i = 0; i < 10; i++) cin >> cd[i];
for (int j = 0; j < 8; j++) {
string pw2 = pw.substr(j * 10, 10);
for (int k = 0; k < 10; k++)
if (pw2 == cd[k]) {
cout << k;
break;
}
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 2010;
int n, sum;
int a[N][N];
bool vis[N];
void dfs(int x, int d) {
vis[x] = 1, sum++;
for (int i = 1; i <= n; i++)
if (!vis[i] && ((d && a[x][i]) || (!d && a[i][x]))) dfs(i, d);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &a[i][j]);
dfs(1, 0);
memset(vis, 0, sizeof(vis));
dfs(1, 1);
printf("%s", sum == n * 2 ? "YES" : "NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 + 50;
const long long int INF = 1000 * 1000 * 100;
bool mark[2][MAXN], check = 0;
int n, m;
vector<int> v[2][MAXN];
vector<pair<pair<int, int>, int> > e;
long long int dis[MAXN];
void dfs(int t, int s) {
mark[t][s] = 1;
for (int i = 0; i < v[t][s].size(); i++) {
int child = v[t][s][i];
if (mark[t][child] == 0) {
dfs(t, child);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
dis[i] = INF;
}
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[0][x].push_back(y);
v[1][y].push_back(x);
e.push_back(make_pair(make_pair(x, y), 2));
e.push_back(make_pair(make_pair(y, x), -1));
}
dfs(0, 1);
dfs(1, n);
for (int i = 0; i <= n; i++) {
for (int j = 0; j < e.size(); j++) {
int x = e[j].first.first;
int y = e[j].first.second;
int z = e[j].second;
if (!mark[0][x]) continue;
if (!mark[1][y]) continue;
if (mark[0][x] or mark[1][y]) {
if (dis[y] > dis[x] + z) {
dis[y] = dis[x] + z;
if (i == n) {
check = 1;
break;
}
}
}
if (check == 1) break;
}
if (check == 1) {
break;
}
}
if (check == 1) {
cout << "No";
return 0;
}
cout << "Yes" << endl;
for (int i = 0; i < e.size(); i++) {
if (e[i].second != -1) {
int x = e[i].first.first;
int y = e[i].first.second;
if (mark[0][x] == 0 or mark[1][y] == 0) {
cout << 1 << endl;
} else
cout << dis[y] - dis[x] << endl;
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, t, ones = 0, zeros = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> t;
ones += t;
zeros += 1 - t;
}
if (ones <= n / 2) {
cout << zeros << endl;
for (int i = 0; i < zeros; ++i) cout << 0 << " ";
cout << endl;
} else {
cout << (ones & (1 ^ -1)) << endl;
for (int i = 0; i < (ones & (1 ^ -1)); ++i) cout << 1 << " ";
cout << endl;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 10;
int a[maxn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
long long ans = 0;
for (int i = 1; i <= n * k; i++) cin >> a[i];
int cnt = 0;
int shu = n / 2;
for (int i = n * k; i >= 1;) {
ans += a[i - shu];
i -= shu + 1;
cnt++;
if (cnt == k) break;
}
cout << ans << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int nextInt() {
int x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') {
p = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * p;
}
const int N = 100500;
const int INF = (int)1e9;
int n, q;
class SegmentTree {
struct Node {
Node *l, *r;
int val;
Node() : val(-INF), l(0), r(0) {}
Node(int val) : val(val), l(0), r(0) {}
void push() {
if (!l) l = new Node(0);
if (!r) r = new Node(0);
}
void modify(int l, int r, int x, int tl, int tr) {
if (l > r) return;
if (tl >= l && tr <= r) {
val = max(val, x);
return;
}
push();
int tm = (tl + tr) / 2;
if (l > tm) {
this->r->modify(l, r, x, tm + 1, tr);
return;
}
if (r <= tm) {
this->l->modify(l, r, x, tl, tm);
return;
}
this->l->modify(l, r, x, tl, tm);
this->r->modify(l, r, x, tm + 1, tr);
}
int get(int ps, int tl, int tr) {
if (!this) return -INF;
if (tl == tr) return val;
push();
int tm = (tl + tr) / 2;
if (ps <= tm) {
return max(val, l->get(ps, tl, tm));
}
return max(val, r->get(ps, tm + 1, tr));
}
};
Node *root;
public:
SegmentTree() { root = new Node(0); }
void modify(int l, int r, int x) { root->modify(l, r, x, 0, n + 1); }
void modify(int ps, int x) { root->modify(ps, ps, x, 0, n + 1); }
int get(int ps) { return root->get(ps, 0, n + 1); }
};
int main() {
n = nextInt();
q = nextInt();
SegmentTree *hor = new SegmentTree();
SegmentTree *ver = new SegmentTree();
for (int qq = 0; qq < q; ++qq) {
int x, y;
char d;
x = nextInt();
y = nextInt();
d = getchar();
if (d == 'U') {
int res = hor->get(x);
hor->modify(x, y);
ver->modify(res + 1, y, x);
printf("%d\n", y - res);
} else {
int res = ver->get(y);
ver->modify(y, x);
hor->modify(res + 1, x, y);
printf("%d\n", x - res);
}
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.