solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int upper = 0, lower = 0, digit = 0;
string n;
cin >> n;
if (n.size() < 5)
cout << "Too weak" << endl;
else {
for (int i = 0; i < n.size(); i++) {
if (isupper(n[i]))
upper++;
else if (islower(n[i]))
lower++;
else if (isdigit(n[i]))
digit++;
}
if (upper >= 1 && lower >= 1 && digit >= 1)
cout << "Correct" << endl;
else
cout << "Too weak" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size(), ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
int index = 0;
for (int k = 0; k < n; ++k) {
if (i <= k && k <= j) continue;
if (index < m && t[index] == s[k]) ++index;
}
if (index == m) ans = max(ans, j - i + 1);
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int maxdigit(int a) {
int maxi = 0;
int d;
while (a) {
d = a % 10;
if (d > maxi) maxi = d;
a /= 10;
}
return maxi;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int cnt = 0;
while (n) {
n -= maxdigit(n);
cnt++;
}
cout << cnt;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool is_upper(long long int x0, long long int y0, long long int x1,
long long int y1, long long int X, long long int Y) {
return (y1 - y0) * X + (x1 - x0) * y0 - (y1 - y0) * x0 < (x1 - x0) * Y;
}
bool is_lower(long long int x0, long long int y0, long long int x1,
long long int y1, long long int X, long long int Y) {
return (x1 - x0) * Y < (y1 - y0) * X + (x1 - x0) * y0 - (y1 - y0) * x0;
}
int main() {
long long int x[3][50005], y[3][50005], n[3], stage;
long long int p[3] = {0, 0, 0}, cnt[3] = {0, 0, 0};
vector<long long int> vx, vy;
for (long long int i = 0; i < ((long long int)(3)); i++) {
cin >> n[i];
for (long long int j = 0; j < ((long long int)(n[i])); j++)
cin >> x[i][j] >> y[i][j];
}
for (long long int i = 0; i < ((long long int)(3)); i++)
for (long long int j = 0; j < ((long long int)(n[i])); j++) {
double d0 =
atan2(y[i][(j + 1) % n[i]] - y[i][j], x[i][(j + 1) % n[i]] - x[i][j]);
double d1 =
atan2(y[i][p[i] + 1] - y[i][p[i]], x[i][p[i] + 1] - x[i][p[i]]);
if (d0 < d1) p[i] = j;
}
vx.push_back(x[0][p[0]] + x[1][p[1]] + x[2][p[2]]);
vy.push_back(y[0][p[0]] + y[1][p[1]] + y[2][p[2]]);
while (n[0] != cnt[0] || n[1] != cnt[1] || n[2] != cnt[2]) {
long long int t = -1;
for (long long int i = 0; i < ((long long int)(3)); i++)
if (n[i] != cnt[i]) {
if (t == -1) {
t = i;
continue;
}
double d0 = atan2(y[i][(p[i] + 1) % n[i]] - y[i][p[i]],
x[i][(p[i] + 1) % n[i]] - x[i][p[i]]);
double d1 = atan2(y[t][(p[t] + 1) % n[t]] - y[t][p[t]],
x[t][(p[t] + 1) % n[t]] - x[t][p[t]]);
if (d0 < d1) t = i;
}
p[t] = (p[t] + 1) % n[t];
cnt[t]++;
vx.push_back(x[0][p[0]] + x[1][p[1]] + x[2][p[2]]);
vy.push_back(y[0][p[0]] + y[1][p[1]] + y[2][p[2]]);
}
long long int m0 = 0, m1 = 0;
for (long long int i = 0; i < ((long long int)(((long long int)vx.size())));
i++) {
if (vx[i] < vx[m0]) m0 = i;
if (vx[m1] < vx[i]) m1 = i;
}
vector<pair<long long int, long long int> > _up, _down, up, down;
for (long long int i = 0; i < ((long long int)(((long long int)vx.size())));
i++) {
if (!is_upper(vx[m0], vy[m0], vx[m1], vy[m1], vx[i], vy[i]))
_down.push_back(make_pair(vx[i], vy[i]));
if (!is_lower(vx[m0], vy[m0], vx[m1], vy[m1], vx[i], vy[i]))
_up.push_back(make_pair(vx[i], vy[i]));
}
sort(_up.begin(), _up.end());
sort(_down.begin(), _down.end());
for (long long int i = 0; i < ((long long int)(((long long int)_up.size())));
i++) {
if (((long long int)up.size()) == 0 || up.back().first != _up[i].first)
up.push_back(_up[i]);
else
up.back().second = max(up.back().second, _up[i].second);
}
for (long long int i = 0;
i < ((long long int)(((long long int)_down.size()))); i++) {
if (((long long int)down.size()) == 0 ||
down.back().first != _down[i].first)
down.push_back(_down[i]);
else
down.back().second = min(down.back().second, _down[i].second);
}
for (cin >> stage; stage--;) {
long long int xx, yy;
cin >> xx >> yy;
xx *= 3;
yy *= 3;
vector<pair<long long int, long long int> >::iterator u1, u0, d1, d0;
u0 = upper_bound(up.begin(), up.end(),
make_pair(xx, (1ll << (long long int)(60))));
d0 = upper_bound(down.begin(), down.end(),
make_pair(xx, (1ll << (long long int)(60))));
if (u0 == up.begin() || d0 == down.begin()) {
cout << "NO" << endl;
continue;
}
u1 = u0--;
d1 = d0--;
if (u1 == up.end()) {
cout << ((xx == u0->first && d0->second <= yy && yy <= u0->second) ? "YES"
: "NO")
<< endl;
continue;
}
bool ok = true;
if (is_upper(u0->first, u0->second, u1->first, u1->second, xx, yy))
ok = false;
if (is_lower(d0->first, d0->second, d1->first, d1->second, xx, yy))
ok = false;
cout << ((ok) ? "YES" : "NO") << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
string s;
cin >> s;
int ans = 0;
int l = 0, r = 0, ch = 0;
if (s[0] == 'U') {
l++;
ch = 1;
} else {
r++;
ch = 2;
}
for (int i = 1; i < n; i++) {
if (s[i] == 'U')
l++;
else
r++;
if (l > r && l - r == 1 && ch == 2) {
ans++;
ch = 1;
}
if (r > l && r - l == 1 && ch == 1) {
ans++;
ch = 2;
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100000];
long long k, sum = 0;
int main() {
scanf("%d%I64d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum = sum + a[i];
}
if (sum < k) {
printf("-1");
return 0;
}
int l = 0, r = 1000000000;
while (l + 1 < r) {
int m = (l + r) / 2;
long long cur = 0;
for (int i = 0; i < n; i++) cur = cur + min(a[i], m);
if (cur >= k)
r = m;
else
l = m;
}
r--;
long long cur = 0;
for (int i = 0; i < n; i++) {
cur = cur + min(r, a[i]);
a[i] = a[i] - r;
}
cur = k - cur;
if (cur == 0) {
for (int i = 0; i < n; i++)
if (a[i] > 0) printf("%d ", i + 1);
} else {
for (int i = 0; i < n; i++)
if (a[i] > 0) {
--cur;
if (cur == 0) {
cur = i;
break;
}
}
for (int i = cur + 1; i < n; i++)
if (a[i] > 0) printf("%d ", i + 1);
for (int i = 0; i <= cur; i++)
if (a[i] - 1 > 0) printf("%d ", i + 1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 201000;
int n, a[N], pos[N], ord[N], nord[N], s[N], top;
long long ret;
int main() {
scanf("%d", &n);
for (int i = 1; i < n + 1; i++) {
scanf("%d", a + i);
}
for (int i = 0; i < 31; i++) pos[i] = 0, ord[i] = i;
top = 1;
a[0] = (1 << 30);
for (int i = 1; i < n + 1; i++) {
int t = 0;
for (int j = 0; j < 31; j++)
if ((a[i] & (1 << j))) pos[j] = i;
sort(ord, ord + 31, [&](int p, int q) { return pos[p] > pos[q]; });
while (top > 0 && a[s[top - 1]] <= a[i]) --top;
s[top++] = i;
s[top] = 0;
int p = 0;
for (int j = 0; j < 31; j++) {
p |= (1 << ord[j]);
int l = pos[ord[j + 1]] + 1, r = pos[ord[j]];
if (j == 30) l = 1;
if (l > r) continue;
int pl = 0, pr = top;
while (pl + 1 < pr) {
int md = (pl + pr) >> 1;
if (a[s[md]] < p)
pr = md;
else
pl = md;
}
l = max(l, s[pr - 1] + 1);
if (l <= r) ret += r - l + 1;
}
}
printf("%lld\n", ret);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int powm(long long int a, int b, int n) {
long long int rm = 1;
while (b) {
if (b % 2) {
rm = (rm * a) % n;
}
a = (a * a) % n;
b /= 2;
}
return rm;
}
char s[6000];
long long int pre[int(5000 + 1000)] = {0}, M[int(5000 + 1000)] = {0},
suf[int(5000 + 1000)] = {0},
M2[int(5000 + 1000)] = {0};
int main() {
cin >> s;
int n = strlen(s);
for (int i = n; i > 0; i--) s[i] = s[i - 1];
for (int i = 1; i <= n; i += 2) {
if (i == 1) {
pre[i] = 0;
M[i] = s[i] - '0';
} else {
if (s[i - 1] == '*') {
M[i] = M[i - 2] * (s[i] - '0');
pre[i] = pre[i - 2];
} else {
M[i] = s[i] - '0';
pre[i] = pre[i - 2] + M[i - 2];
}
}
}
for (int i = n; i >= 1; i -= 2) {
if (i == n) {
suf[i] = 0;
M2[i] = s[i] - '0';
} else {
if (s[i + 1] == '*') {
M2[i] = M2[i + 2] * (s[i] - '0');
suf[i] = suf[i + 2];
} else {
M2[i] = s[i] - '0';
suf[i] = suf[i + 2] + M2[i + 2];
}
}
}
long long int Val2 = 0, ans = 0, Val3, mval2, Val, tmp, m;
for (int i = 1; i <= n; i += 2) {
Val2 = 0;
mval2 = 0;
for (int j = i; j <= n; j += 2) {
if (j == i)
Val2 = 0, mval2 = s[j] - '0';
else {
if (s[j - 1] == '*')
mval2 *= s[j] - '0';
else {
Val2 += mval2;
mval2 = s[j] - '0';
}
}
Val3 = Val2 + mval2;
Val = 0;
m = 1;
if (i > 1) {
Val = pre[i - 2];
if (s[i - 1] == '*')
m = M[i - 2];
else
Val += M[i - 2];
}
if (j < n) {
Val += suf[j + 2];
if (s[j + 1] == '*')
m *= M2[j + 2];
else
Val += M2[j + 2];
}
tmp = Val + m * Val3;
ans = max(ans, tmp);
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int a, b, c, d, k, minn, maxx;
cin >> a >> b >> c >> d >> k;
if (a % c != 0)
minn = a / c + 1;
else
minn = a / c;
if ((k - minn) * d >= b) {
cout << minn << " " << k - minn;
} else {
if (b % d != 0)
minn = b / d + 1;
else
minn = b / d;
if ((k - minn) * c >= a) {
cout << k - minn << " " << minn;
} else
cout << "-1";
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int N = (int)1e5 + 7;
int n;
int cnt[N], cost[N];
int dist[N];
bool seen[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
queue<int> q;
q.push(x);
seen[x] = 1;
vector<int> cur;
while (!q.empty()) {
x = q.front();
cnt[x]++;
q.pop();
cur.push_back(x);
if (2 * x < N && seen[2 * x] == 0) {
dist[2 * x] = 1 + dist[x];
seen[2 * x] = 1;
q.push(2 * x);
}
if (seen[x / 2] == 0) {
dist[x / 2] = 1 + dist[x];
seen[x / 2] = 1;
q.push(x / 2);
}
}
for (auto &it : cur) {
cost[it] += dist[it];
seen[it] = 0;
dist[it] = 0;
}
}
int res = (1 << 30);
for (int i = 1; i < N; i++) {
if (cnt[i] == n) {
res = min(res, cost[i]);
}
}
cout << res << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long s = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) s = s * 10 + ch - '0', ch = getchar();
return s * f;
}
const long long N = 2e6 + 5;
long long n, k;
long long a[N], b[N];
inline long long calc() {
long long ans = 0;
for (long long i = 1; i <= n; i++) ans += max(a[i], b[i]);
return ans;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (long long i = 1; i <= n; i++) a[i] = b[i] = i;
long long nans = calc();
if (nans > k) {
puts("-1");
return 0;
}
long long i = 1;
while (2 * i - 1 <= n) {
long long a1 = a[i], a2 = a[n - i + 1], b1 = b[i], b2 = b[n - i + 1];
long long tans =
nans - max(a1, b1) - max(a2, b2) + max(a1, b2) + max(b1, a2);
if (tans > k) {
swap(b[i], b[n - i + 1 - (tans - k)]);
break;
} else {
swap(b[i], b[n - i + 1]);
nans = tans;
i++;
continue;
}
}
cout << calc() << endl;
for (long long i = 1; i <= n; i++) cout << a[i] << ' ';
cout << endl;
for (long long i = 1; i <= n; i++) cout << b[i] << ' ';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[105];
int vis[105];
int gcd(int c, int b) { return b ? gcd(b, c % b) : c; }
int main() {
int n;
while (cin >> n) {
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
long long t = 1;
int k;
for (int i = 1; i <= n; i++) {
k = a[i];
long long o = 1;
while (i != k) {
k = a[k];
o++;
if (o > 110) {
puts("-1");
return 0;
}
}
if (!(o & 1)) o /= 2;
t = t * (long long)o / gcd(t, (long long)o);
}
cout << t << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, c;
cin >> a >> b >> c;
a += b;
a += c;
if (a[0] == a[8] && a[1] == a[7] && a[2] == a[6] && a[3] == a[5]) {
cout << "YES";
return 0;
} else {
cout << "NO";
return 0;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[200002];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
if (n > m || m == 1) {
cout << 0 << endl;
return 0;
}
sort(a, a + n);
int ans = 1;
for (int i = n - 1; i >= 0; --i) {
for (int j = i - 1; j >= 0; --j) {
ans *= (a[i] - a[j]) % m;
ans %= m;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool gprintf(int debug, const char *format, ...) {
if (0 & debug) {
va_list listpointer;
va_start(listpointer, format);
vfprintf(stderr, format, listpointer);
va_end(listpointer);
return true;
} else
return false;
}
char line[100000];
int N;
int main() {
int H, T;
int i, j;
scanf("%d", &N);
scanf("%s", line);
H = T = 0;
for ((i) = 0; (i) < (N); (i)++)
if (line[i] == 'H')
H++;
else
T++;
int sol = N + 1;
for ((i) = 0; (i) < (N); (i)++) {
int curr = 0;
for ((j) = 0; (j) < (T); (j)++) {
if (line[(i + j) % N] == 'H') curr++;
}
sol = min(sol, curr);
}
printf("%d\n", sol);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using pll = pair<long long, long long>;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t, i, x, j, y, z, k, n;
cin >> n;
long long a[n];
long long e = 0, o = 0;
for (long long i = 0; i < n; i++) cin >> a[i];
;
for (i = 0; i < n; i += 1) {
if (a[i] & 1)
o++;
else
e++;
}
x = z = min(o, e);
o -= z;
z = z + o / 3;
cout << z << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dp[550005];
int main() {
int n, d, c, i, j, x, flog;
scanf("%d %d", &n, &d);
dp[0] = 1;
for (i = 0; i < n; i++) {
scanf("%d", &c);
for (j = 500000; j >= c; j--) {
dp[j] |= dp[j - c];
}
}
int day = 0;
x = 0;
while (1) {
flog = 0;
for (j = x + d; j > x; j--) {
if (dp[j]) {
flog = 1;
day++;
x = j;
break;
}
}
if (!flog) break;
}
printf("%d %d\n", x, day);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int n, m;
string s[N];
int dx[2][2][3] = {{{-1, -1, 0}, {-1, -1, 0}}, {{1, 1, 0}, {1, 1, 0}}},
dy[2][2][3] = {{{0, -1, -1}, {0, 1, 1}}, {{0, -1, -1}, {0, 1, 1}}};
bool good(int i, int j) {
if (!(i >= 0 && i + 1 < n && j >= 0 && j + 1 < m)) return false;
int cnt_s = (s[i][j] == '*') + (s[i + 1][j] == '*') + (s[i][j + 1] == '*') +
(s[i + 1][j + 1] == '*');
return cnt_s == 1;
}
void dfs(int i, int j) {
for (int t = 0; t < 2; t++) {
for (int k = 0; k < 2; k++) {
if (s[i + t][j + k] == '*') {
s[i + t][j + k] = '.';
for (int x = 0; x < 3; x++) {
int nx = i + dx[t][k][x], ny = j + dy[t][k][x];
if (good(nx, ny)) dfs(nx, ny);
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie();
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m - 1; j++) {
if (good(i, j)) dfs(i, j);
}
}
for (int i = 0; i < n; i++) cout << s[i] << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long dx[4] = {1, 0, -1, 0};
long long dy[4] = {0, -1, 0, 1};
template <class T>
void inputVector(vector<T>& v, long long n) {
v.resize(n);
for (long long i = 0; i < v.size(); i++) cin >> v[i];
}
signed main() {
long long n;
cin >> n;
unordered_map<long long, long long> left, right;
long long zeros = 0;
for (long long i = 0; i < (n); i++) {
string S;
cin >> S;
long long lcnt = 0;
long long now = 0;
for (long long j = 0; j < (S.size()); j++) {
if (S[j] == ')') {
now++;
if (now > 0) {
lcnt++;
now = 0;
}
} else {
now--;
}
}
long long rcnt = 0;
now = 0;
for (long long j = S.size() - 1; j >= 0; j--) {
if (S[j] == '(') {
now++;
if (now > 0) {
rcnt++;
now = 0;
}
} else {
now--;
}
}
if (lcnt > 0 && rcnt > 0) {
} else if (lcnt > 0) {
left[lcnt]++;
} else if (rcnt > 0) {
right[rcnt]++;
} else {
zeros++;
}
}
long long ret = zeros / 2;
for (auto pr : left) {
ret += min(pr.second, right[pr.first]);
}
cout << ret << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k, a, b, cnt = 0, x;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a >> b;
if ((b - a) >= 2) {
cnt++;
}
}
cout << cnt;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 9;
bool IsPowerOfTwo(long long int x) { return (x != 0) && ((x & (x - 1)) == 0); }
long long int poer(long long int a, long long int b) {
long long int rs = 1;
while (b > 0) {
if (b & 1) rs *= a;
a *= a;
b /= 2;
}
return rs;
}
long long int mod_poer(long long int a, long long int b, long long int mo) {
long long int rs = 1;
while (b > 0) {
if (b & 1) rs = (rs * a) % mo;
a = (a * a) % mo;
b /= 2;
}
return rs % mo;
}
long long int d, x, y;
void ext_euclid(long long int a, long long int b) {
if (b == 0) {
d = a;
x = 1;
y = 0;
} else {
ext_euclid(b, a % b);
long long int temp = x;
x = y;
y = temp - (a / b) * y;
}
}
long long int mod_inverse1(long long int a, long long int m) {
ext_euclid(a, m);
return (x % m + m) % m;
}
long long int mod_inverse2(long long int a, long long int m) {
return mod_poer(a, m - 2, m);
}
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long int fact[200005];
void fac() {
fact[1] = fact[0] = 1;
for (long long int i = 2; i <= 200005; ++i) {
fact[i] = ((fact[i - 1] % mod) * i) % mod;
}
}
long long int combi(long long int a, long long int b) {
if (b > a) return 0;
if (b == a)
return 1;
else {
long long int x = mod_poer(fact[b], mod - 2, mod) % mod;
long long int y = mod_poer(fact[a - b], mod - 2, mod) % mod;
return ((((fact[a]) * x) % mod) * y) % mod;
}
}
long long int arr[200005], n, m;
map<long long int, long long int> vis;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (long long int i = 1; i <= n; ++i) cin >> arr[i];
long long int pos = 0;
for (long long int i = 1; i <= n; ++i)
if (arr[i] == m) {
pos = i;
break;
}
long long int cnt = 0;
for (long long int i = pos; i <= n; ++i) {
if (arr[i] > m) cnt++;
if (arr[i] < m) cnt--;
vis[cnt]++;
}
cnt = 0;
long long int ans = 0;
for (long long int i = pos; i >= 1; i--) {
if (arr[i] > m) cnt--;
if (arr[i] < m) cnt++;
ans += (vis[cnt] + vis[cnt + 1]);
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, t;
cin >> n >> t;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long x[n], b[n];
for (int i = 0; i < n; i++) {
cin >> x[i];
b[i] = 0;
if (x[i] <= i ||
(i > 0 && (x[i - 1] > x[i] || (x[i - 1] != i && (x[i - 1] != x[i]))))) {
cout << "No";
return 0;
}
}
long long ctr = 0;
for (long long i = 0; i < n; i++) {
ctr = max(ctr, i);
while (ctr < (x[i] - 1)) {
b[ctr++] = 1;
}
}
for (int i = 0; i < n; i++) {
b[i] += i + 1;
}
long long ans[n];
ctr = 0;
for (int i = 0; i < n; i++) {
if (i > 0 && b[i] != b[i - 1]) ctr = 0;
if (b[i] == n || (a[b[i] - 1] + ctr) < a[b[i]]) {
ans[i] = a[b[i] - 1] + t + ctr++;
} else {
cout << "No";
return 0;
}
}
cout << "Yes\n";
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int N = 100005;
using namespace std;
char s[N];
int nxt[N][26];
char w[3][255];
int len[3], f[255][255][255];
int main() {
int n, q, i, j, k;
scanf("%d%d", &n, &q);
scanf("%s", s);
for (i = 0; i < 26; i++) nxt[n][i] = nxt[n + 1][i] = n;
for (i = n - 1; i >= 0; i--) {
for (j = 0; j < 26; j++)
if (s[i] - 'a' == j)
nxt[i][j] = i;
else
nxt[i][j] = nxt[i + 1][j];
}
char op, ch;
int r;
f[0][0][0] = -1;
while (q--) {
scanf("%*c%c%d", &op, &r);
if (op == '+') {
scanf("%*c%c", &ch);
r--;
w[r][len[r]++] = ch;
int p, q;
if (r == 0) {
p = 1;
q = 2;
} else if (r == 1) {
p = 0;
q = 2;
} else {
p = 0;
q = 1;
}
for (i = 0; i <= len[p]; i++)
for (j = 0; j <= len[q]; j++) {
if (r == 0) {
f[len[r]][i][j] = nxt[f[len[r] - 1][i][j] + 1][ch - 'a'];
if (i > 0)
f[len[r]][i][j] =
min(f[len[r]][i][j],
nxt[f[len[r]][i - 1][j] + 1][w[1][i - 1] - 'a']);
if (j > 0)
f[len[r]][i][j] =
min(f[len[r]][i][j],
nxt[f[len[r]][i][j - 1] + 1][w[2][j - 1] - 'a']);
} else if (r == 1) {
f[i][len[r]][j] = nxt[f[i][len[r] - 1][j] + 1][ch - 'a'];
if (i > 0)
f[i][len[r]][j] =
min(f[i][len[r]][j],
nxt[f[i - 1][len[r]][j] + 1][w[0][i - 1] - 'a']);
if (j > 0)
f[i][len[r]][j] =
min(f[i][len[r]][j],
nxt[f[i][len[r]][j - 1] + 1][w[2][j - 1] - 'a']);
} else {
f[i][j][len[r]] = nxt[f[i][j][len[r] - 1] + 1][ch - 'a'];
if (i > 0)
f[i][j][len[r]] =
min(f[i][j][len[r]],
nxt[f[i - 1][j][len[r]] + 1][w[0][i - 1] - 'a']);
if (j > 0)
f[i][j][len[r]] =
min(f[i][j][len[r]],
nxt[f[i][j - 1][len[r]] + 1][w[1][j - 1] - 'a']);
}
}
} else {
r--;
len[r]--;
}
if (f[len[0]][len[1]][len[2]] < n)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string i_s(int x) {
if (x == 0) return "0";
string ret = "";
while (x) {
ret = ret + (char)(x % 10 + '0');
x /= 10;
}
reverse(ret.begin(), ret.end());
return ret;
}
string add(string a, string b) {
if (a == "") a = "0";
if (b == "") b = "0";
if (a.length() < b.length()) swap(a, b);
while (b.length() < a.length()) {
b = '0' + b;
}
for (int i = 0; i < a.length(); i++) {
a[i] = a[i] + (b[i] - '0');
}
bool big = false;
for (int i = a.length() - 1; i >= 0; i--) {
if (big) {
a[i]++;
}
big = false;
if (a[i] > '9') {
a[i] = a[i] - 10;
big = true;
}
}
if (big) a = '1' + a;
return a;
}
string mul(string a, string b) {
vector<int> va, vb;
if (a == "0" || b == "0") return "0";
string ans;
for (int i = 0; i < a.length(); i++) {
va.push_back(a[i] - '0');
}
for (int i = 0; i < b.length(); i++) {
vb.push_back(b[i] - '0');
}
reverse(va.begin(), va.end());
reverse(vb.begin(), vb.end());
vector<int> res;
res.clear();
res.resize(1005);
for (int i = 0; i < a.length(); i++) {
for (int j = 0; j < b.length(); j++) {
res[i + j] += (va[i] * vb[j]);
}
}
for (int i = 0; i < 1005; i++) {
if (res[i] > 9) {
res[i + 1] += (res[i] / 10);
res[i] %= 10;
}
}
for (int i = 0; i < 1005; i++) {
ans += (res[i] + '0');
}
reverse(ans.begin(), ans.end());
int k = 0;
while (ans[k] == '0') {
k++;
}
ans = ans.substr(k);
return ans;
}
bool is_prime(int n) {
if (n < 2) return false;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
int f[505][505];
int g[505][505];
int p[505][505];
char s[505];
int n, m;
void rec(int i, int j) {
if (i == 0) return;
rec(p[i][j], j - 1);
if (p[i][j]) cout << "+";
for (int k = 0; k < i - p[i][j]; k++)
cout << ((s[p[i][j] + 1 + k] != s[i - k] && p[i][j] + 1 + k < i - k)
? s[i - k]
: s[p[i][j] + 1 + k]);
return;
}
int main() {
gets(s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
f[i][j] = 0;
for (int k = 0; k < (j - i + 1) / 2; k++) {
f[i][j] += s[i + k] != s[j - k];
}
}
}
cin >> m;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) g[i][j] = 0x3f3f3f3f;
g[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (g[i][j] < 0x3f3f3f3f) {
for (int k = i + 1; k <= n; k++) {
if (g[i][j] + f[i + 1][k] < g[k][j + 1]) {
g[k][j + 1] = g[i][j] + f[i + 1][k];
p[k][j + 1] = i;
}
}
}
}
}
int x = 0;
for (int i = 1; i <= m; i++) {
if (g[n][i] < g[n][x]) {
x = i;
}
}
cout << g[n][x] << endl;
rec(n, x);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 1;
int n, m, u[MAXN], v[MAXN];
int solve() {
if (m == 0) return n - 1;
set<int> div1, div2;
for (int i = 0; i < m; i++) {
int a = min(u[i], v[i]);
int b = max(u[i], v[i]);
if (div1.count(a)) return 0;
div2.insert(a);
if (div2.count(b)) return 0;
div1.insert(b);
}
int middle = *div1.begin() - *div2.rbegin() - 1;
return max(0, middle + 1);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &u[i], &v[i]);
}
printf("%d\n", solve());
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, count = 0, Min = (int)1e10;
;
cin >> n >> m;
if (n % m == 0) Min = n;
while (1) {
n -= 2;
if (n < 0) break;
count++;
count += n;
if (count % m == 0) {
if (count < Min) Min = count;
}
count -= n;
}
if (Min == (int)1e10)
cout << -1;
else
cout << Min;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
unsigned long long times;
unsigned long long decrementValue;
} result_decrement_1_struct;
result_decrement_1_struct getMinimunTimes(unsigned long long n,
unsigned char maxDigit) {
static map<pair<unsigned long long, unsigned char>, result_decrement_1_struct>
_cache = map<pair<unsigned long long, unsigned char>,
result_decrement_1_struct>();
unsigned long long times = 0;
unsigned long long decrementValue = 0;
pair<unsigned long long, unsigned char> initalInput =
pair<unsigned long long, unsigned char>(n, maxDigit);
if (_cache.count(initalInput)) return _cache[initalInput];
result_decrement_1_struct result;
while (true) {
if (!n) {
result_decrement_1_struct r = {
times : times,
decrementValue : decrementValue
};
result = r;
break;
}
if (n < maxDigit) {
result_decrement_1_struct r = {
times : times,
decrementValue : decrementValue
};
result = r;
break;
}
if (maxDigit == 9) {
result_decrement_1_struct r = {
times : times + n / 9,
decrementValue : decrementValue + (n / 9) * 9
};
result = r;
break;
}
if (n < 10) {
result_decrement_1_struct r = {
times : times + 1,
decrementValue :
decrementValue + max(maxDigit, static_cast<unsigned char>(n))
};
result = r;
break;
}
unsigned long long pow = 1;
while (n >= pow) pow *= 10;
pow /= 10;
unsigned long long maxDigitIterator =
max(maxDigit, static_cast<unsigned char>(n / pow));
unsigned long long low_n = n % pow;
result_decrement_1_struct iteResult =
getMinimunTimes(low_n, maxDigitIterator);
if (iteResult.decrementValue == 0) {
times++;
decrementValue += maxDigitIterator;
n -= maxDigitIterator;
} else {
times += iteResult.times;
decrementValue += iteResult.decrementValue;
n -= iteResult.decrementValue;
}
{
pair<unsigned long long, unsigned char> inputIte =
pair<unsigned long long, unsigned char>(n, maxDigit);
if (_cache.count(inputIte)) {
result = _cache[inputIte];
result.times += times;
result.decrementValue += decrementValue;
break;
}
}
}
_cache[initalInput] = result;
return result;
}
int main() {
unsigned long long n;
cin >> n;
cout << getMinimunTimes(n, 0).times << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<char> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) cout << v[i];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, res = 0;
cin >> n;
while (n--) {
string str;
cin >> str;
if (str[0] == 'X')
if (str[1] == '+')
res++;
else
res--;
else if (str[0] == '+')
res++;
else
res--;
}
cout << res;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int __gcd(int a, int b) {
int c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
long long int powmod(long long int a, int b, int n) {
long long int rm = 1;
while (b) {
if (b % 2) {
rm = (rm * a) % n;
}
a = (a * a) % n;
b /= 2;
}
return rm;
}
long long int a[3000], dp[3000], n, k, Max;
bool f(long long int x) {
for (int i = 1; i <= n; i++) {
dp[i] = i - 1;
for (int j = 1; j < i; j++)
if (abs(a[i] - a[j]) <= x * (i - j))
dp[i] = min(dp[i], dp[j] + i - j - 1);
if (dp[i] + n - i <= k) return 1;
}
return 0;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
long long int l = 0, r = 2e9;
for (; l <= r;) {
long long int m = (l + r) >> 1;
if (f(m))
r = m - 1;
else
l = m + 1;
}
cout << l;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int test;
cin >> test;
while (test--) {
long long n, x, y, d;
cin >> n >> x >> y >> d;
if (abs(y - x) % d == 0) {
cout << abs(x - y) / d << endl;
} else {
long long ans = 20000000000000ll;
long long step1 = 20000000000000ll, step2 = 20000000000000ll, temp2,
temp1;
if ((y - 1) % d == 0) {
temp1 = x - 1;
step1 = temp1 / d + 1;
if (temp1 % d == 0) {
step1--;
}
step1 += (y - 1) / d;
}
if ((n - y) % d == 0) {
temp2 = n - x;
step2 = temp2 / d + 1;
if (temp2 % d == 0) {
step2--;
}
step2 += (n - y) / d;
}
ans = min(step1, step2);
if (ans == 20000000000000ll) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
template <typename T>
inline T Abs(T x) {
return (x >= 0) ? x : -x;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
map<pair<long long, long long>, long long> d;
long long solve(long long n, long long t) {
if (d.count(make_pair(n, t))) return d[make_pair(n, t)];
if (n == 0) return d[make_pair(n, t)] = 0;
long long l = 1, p = 0;
while (2 * l <= n) {
l *= 2;
p++;
}
if (t == 1) return d[make_pair(n, t)] = p + 1;
if (n <= 2) return d[make_pair(n, t)] = 0;
long long ans = solve(l / 2 - 1, t);
if (t % 2 == 0) ans += solve(l / 2 - 1, t / 2);
if (n != l && t % 2 == 0) ans += solve(n - l, t / 2);
return d[make_pair(n, t)] = ans;
}
int main() {
long long n, t;
cin >> n >> t;
long long ans = solve(n + 1, t);
if (t == 1) ans--;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<int> b;
int a, x, max = 0;
cin >> a;
for (int c = 0; c < a; c++) {
cin >> x;
while (b.count(x)) {
b.erase(x);
x++;
}
if (max < x) {
max = x;
}
b.insert(x);
}
cout << max - b.size() + 1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum = 0, n;
char a[3];
cin >> n;
while (n > 0) {
for (int i = 0; i < 3; i++) cin >> a[i];
if (a[0] == 'X') {
if (a[1] == '+')
sum++;
else
sum--;
} else {
if (a[0] == '+')
sum++;
else
sum--;
}
n--;
}
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, x, ans;
vector<pair<pair<int, int>, int> > v;
vector<pair<int, int> > p[200100];
vector<int> len[200100];
int bin(int x, int rg) {
if (x < 0) return -1;
int l = 0, r = (int)p[x].size() - 1, ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (p[x][mid].first > rg)
r = mid - 1, ans = mid;
else
l = mid + 1;
}
return ans;
}
int main() {
cin >> n >> x;
for (int i = 0; i < n; ++i) {
int l, r, cost;
scanf("%d%d%d", &l, &r, &cost);
v.push_back({{l, r}, cost});
}
sort(v.begin(), v.end());
for (int i = 0; i < n; ++i) {
int l = v[i].first.first, r = v[i].first.second, cost = v[i].second;
p[r - l + 1].push_back({l, cost});
len[r - l + 1].push_back(0);
}
for (int i = 0; i < 200100; ++i)
if (p[i].size()) {
len[i][p[i].size() - 1] = p[i][p[i].size() - 1].second;
for (int j = (int)p[i].size() - 2; j >= 0; --j)
len[i][j] = min(p[i][j].second, len[i][j + 1]);
}
ans = 2e9 + 1;
for (int i = 0; i < n; ++i) {
int l = v[i].first.first, r = v[i].first.second, cost = v[i].second;
int second = bin(x - r + l - 1, r);
if (second != -1) ans = min(ans, len[x - r + l - 1][second] + cost);
}
cout << (ans == 2e9 + 1 ? -1 : ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
int ct[4];
vector<int> a;
vector<int> b;
vector<int> c;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> t;
++ct[t];
if (t == 1)
a.push_back(i + 1);
else if (t == 2)
b.push_back(i + 1);
else
c.push_back(i + 1);
}
int sol = min(ct[1], min(ct[2], ct[3]));
cout << sol << "\n";
for (int i = 0; i < sol; ++i) {
cout << a[i] << " " << b[i] << " " << c[i] << "\n";
}
}
| 0 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long ll;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
cout << s.length() << '\n';
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int block_size = 320;
const long long mod = 1e9 + 7;
const long double eps = 1e-9;
const int inf = mod;
const double PI = atan(1) * 4;
template <typename T>
inline int sign(const T& a) {
if (a < 0) return -1;
if (a > 0) return 1;
return 0;
}
template <typename T>
inline void in(T& x) {
x = 0;
T f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
long long twop(int x) { return 1LL << x; }
template <typename A, typename B>
inline void in(A& x, B& y) {
in(x);
in(y);
}
template <typename A, typename B, typename C>
inline void in(A& x, B& y, C& z) {
in(x);
in(y);
in(z);
}
template <typename A, typename B, typename C, typename D>
inline void in(A& x, B& y, C& z, D& xx) {
in(x);
in(y);
in(z);
in(xx);
}
struct SegTree {
static const int maxn = 200010;
struct node {
long long contri[10];
int to[10];
int l, r;
};
node no[maxn * 4];
void push_up(int ind) {
for (long long i = 0; i < 10; i++) no[ind].to[i] = i;
memset(no[ind].contri, 0, sizeof(no[ind].contri));
for (long long i = 0; i < 10; i++) {
no[ind].contri[no[(ind << 1)].to[i]] += no[(ind << 1)].contri[i];
no[ind].contri[no[(ind << 1 | 1)].to[i]] += no[(ind << 1 | 1)].contri[i];
}
}
void push_down(int ind) {
for (long long i = 0; i < 10; i++)
no[(ind << 1)].to[i] = no[ind].to[no[(ind << 1)].to[i]];
for (long long i = 0; i < 10; i++)
no[(ind << 1 | 1)].to[i] = no[ind].to[no[(ind << 1 | 1)].to[i]];
}
void build(int l, int r, int ind) {
no[ind].l = l;
no[ind].r = r;
for (long long i = 0; i < 10; i++) no[ind].to[i] = i;
if (l == r) {
long long val;
in(val);
long long ten = 1;
while (val) {
no[ind].contri[val % 10] += ten;
val /= 10;
ten *= 10;
}
} else {
int mid = (l + r) / 2;
build(l, mid, (ind << 1));
build(mid + 1, r, (ind << 1 | 1));
for (long long i = 0; i < 10; i++) {
no[ind].contri[i] =
no[(ind << 1)].contri[i] + no[(ind << 1 | 1)].contri[i];
}
}
}
void update(int l, int r, int ind, int from, int to) {
if (l > no[ind].r || r < no[ind].l) return;
if (l <= no[ind].l && no[ind].r <= r) {
for (long long i = 0; i < 10; i++) {
if (no[ind].to[i] == from) no[ind].to[i] = to;
}
} else {
push_down(ind);
update(l, r, (ind << 1), from, to);
update(l, r, (ind << 1 | 1), from, to);
push_up(ind);
}
}
void query(int l, int r, int ind, long long& ans) {
if (l > no[ind].r || r < no[ind].l) return;
if (l <= no[ind].l && no[ind].r <= r) {
for (long long i = 0; i < 10; i++)
ans += no[ind].to[i] * no[ind].contri[i];
} else {
push_down(ind);
query(l, r, (ind << 1), ans);
query(l, r, (ind << 1 | 1), ans);
push_up(ind);
}
}
};
SegTree tree;
int main() {
int n, q;
in(n, q);
tree.build(1, n, 1);
for (long long i = 0; i < q; i++) {
int t;
in(t);
if (t == 1) {
int l, r, x, y;
in(l, r, x, y);
tree.update(l, r, 1, x, y);
} else {
int l, r;
in(l, r);
long long sum = 0;
tree.query(l, r, 1, sum);
printf("%lld\n", sum);
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solve(int ncase) {
int n;
cin >> n;
vector<int> lastSolution(100010, -1);
bool isChron = true;
for (int i = 0; i < n; i++) {
int x, k;
cin >> x >> k;
if (lastSolution[k] != -1 && lastSolution[k] >= x) {
continue;
}
if (lastSolution[k] != x - 1) {
isChron = false;
break;
}
lastSolution[k] = x;
}
cout << (isChron ? "YES" : "NO") << endl;
}
int main() {
int T = 1;
int ncase = 0;
while (T--) {
solve(++ncase);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int count = 0;
cin >> s;
for (int i = 0; i < s.length(); i++)
for (int k = i; k < s.length(); k++)
if (s[k] == 'b' && s[k + 1] == 'e' && s[k + 2] == 'a' &&
s[k + 3] == 'r') {
count++;
count += (s.length() - (k + 4));
break;
}
cout << count;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, M;
char ch[100005];
int mp[25][25];
long long f[1 << 20];
int siz[1 << 20];
int fa[1 << 20];
int main() {
scanf("%d%d", &n, &m);
M = 1 << m;
scanf("%s", ch + 1);
for (int i = 1; i < n; i++) {
if (ch[i] != ch[i + 1]) {
mp[ch[i] - 'a'][ch[i + 1] - 'a']++;
mp[ch[i + 1] - 'a'][ch[i] - 'a']++;
}
}
siz[0] = 0;
for (int s = 1; s < M; s++) {
if (s & 1)
siz[s] = siz[s >> 1] + 1;
else
siz[s] = siz[s >> 1];
for (int l = 0; l < m; l++) {
if (!(s & (1 << l))) continue;
for (int L = 0; L < m; L++) {
if ((s & (1 << L))) continue;
fa[s] += mp[l][L];
}
}
}
memset(f, 0x3f, sizeof(f));
f[0] = 0;
for (int i = 1; i <= m; i++) {
for (int s = 0; s < M; s++) {
if (siz[s] != i) continue;
for (int k = 0; k < m; k++) {
if (!(s & (1 << k))) continue;
int rs = s ^ (1 << k);
f[s] = min(f[s], f[rs] + fa[s]);
}
}
}
cout << f[M - 1] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool fsort(tuple<int, int, int> a, tuple<int, int, int> b) {
if (get<0>(a) == get<0>(b)) {
if (get<1>(a) == get<1>(b)) {
return get<2>(a) > get<2>(b);
}
return get<1>(a) < get<1>(b);
}
return get<0>(a) < get<0>(b);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v[i] = a;
}
vector<tuple<int, int, int>> vii;
for (int i = 0; i < n - 1; i++) {
for (int j = n - 1; j > i; j--) {
if (v[j] < v[i]) {
vii.push_back(make_tuple(v[i], i + 1, j + 1));
}
}
}
int s = vii.size();
sort(vii.begin(), vii.end(), fsort);
cout << s << '\n';
for (int i = 0; i < s; i++) {
cout << get<1>(vii[i]) << " " << get<2>(vii[i]) << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int modp(long long int a, long long int p, long long int n) {
int d[100];
int i, j, k, l;
if (n == 0) return 1;
for (i = 0; n >= 1; i++) {
d[i] = n % 2;
n /= 2;
}
l = i;
long long int e = 1;
if (d[0] == 1) e *= (a % p);
for (i = 1; i < l; i++) {
a *= a;
a = a % p;
if (d[i] == 1) {
e *= a;
e = e % p;
}
}
return e % p;
}
long long int modInverse(long long int n, long long int p) {
return modp(n, p, p - 2);
}
long long int nCrModPFermat(long long int n, long long int r, long long int p) {
if (r == 0) return 1;
long long int fac[n + 1];
fac[0] = 1;
for (long long int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
long long int gcd(long long int b, long long int a) {
if (a < b) return gcd(a, b);
if (a % b == 0) return b;
return gcd(a % b, b);
}
long long int l, r, mid, ans;
long long int n, m, i, j, k;
long long int x, y, d;
void solve() {
cin >> n >> m;
long long int a[1000], b[1000];
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < m; i++) cin >> b[i];
j = 0;
for (i = 0; i < n; i++) {
if (a[i] <= b[j]) j += 1;
if (j == m) break;
}
cout << j;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long m, n;
cin >> m >> n;
int markr[10000] = {0}, markc[10000] = {0};
long long a[m + 5][n + 5];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
if (a[i][j] == 1) {
markr[i] = 1;
markc[j] = 1;
}
}
}
int countr = 0;
int countc = 0;
for (int i = 0; i < m; i++) {
if (markr[i] == 1) countr++;
}
for (int i = 0; i < n; i++) {
if (markc[i] == 1) countc++;
}
int val = min(m - countr, n - countc);
if (val % 2 == 0) {
cout << "Vivek" << endl;
} else {
cout << "Ashish" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 2e5 + 100;
struct edge {
int to, num, color, rev, next;
} E[max_n << 1];
int head[max_n];
int cnt = 1;
void add(int from, int to, int num, int rev, int color = 0) {
E[cnt].to = to;
E[cnt].next = head[from];
E[cnt].num = num;
E[cnt].color = color;
E[cnt].rev = rev;
head[from] = cnt++;
}
int n;
void dfs(int u, int color) {
int tot = 1;
for (int i = head[u]; i; i = E[i].next) {
if (E[i].color == color) continue;
if (tot == color) ++tot;
E[i].color = tot;
E[E[i].rev].color = tot;
dfs(E[i].to, tot);
++tot;
}
}
vector<int> res[max_n];
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1, u, v; i < n; ++i) {
cin >> u >> v;
add(u, v, i, cnt + 1);
add(v, u, i, cnt - 1);
}
dfs(1, -1);
int tot = 0;
for (int u = 1; u <= n; ++u) {
for (int i = head[u]; i; i = E[i].next) {
tot = max(tot, E[i].color);
if (u < E[i].to) res[E[i].color].push_back(E[i].num);
}
}
cout << tot << endl;
for (int i = 1; i <= tot; ++i) {
cout << res[i].size() << " ";
while (!res[i].empty()) {
cout << res[i].back() << " ";
res[i].pop_back();
}
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng((int)std::chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
vector<vector<int> > g(n);
vector<int> degree(n);
for (int i = 0, u, v; i < n - 1; i++) {
cin >> u >> v, u--, v--;
g[u].push_back(v);
g[v].push_back(u);
degree[u]++;
degree[v]++;
}
queue<int> bfs;
for (int i = 0; i < n; i++) {
if (degree[i] == 1) bfs.push(i);
}
vector<int> depth(n);
vector<int> curdegree = degree;
vector<bool> vis(n);
while (!bfs.empty()) {
int u = bfs.front();
bfs.pop();
degree[u] = 0;
vis[u] = true;
for (auto &v : g[u]) {
if (vis[v]) continue;
depth[v] = depth[u] + 1;
degree[v]--;
if (degree[v] == 1) {
bfs.push(v);
}
}
}
map<int, vector<int> > depths;
for (int i = 0; i < n; i++) {
depths[depth[i]].push_back(i);
if (depth[i] > k) {
cout << "NO" << endl;
return 0;
} else if (depth[i] == k) {
if (curdegree[i] < 3) {
cout << "NO" << endl;
return 0;
}
} else if (depth[i] > 0 and curdegree[i] < 4) {
cout << "NO" << endl;
return 0;
}
for (auto &v : g[i]) {
if (abs(depth[i] - depth[v]) != 1) {
cout << "NO" << endl;
return 0;
}
}
}
for (int i = 0; i <= k; i++) {
if (depths[i].size() == 0) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct qeury {
int a, b, c;
};
const int N = 5000 + 5;
int ans[N][N];
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
set<pair<int, int>> in;
set<int> r, cc;
for (int i = 0; i < n; i++) {
r.insert(i);
}
for (int i = 0; i < m; i++) {
cc.insert(i);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
in.insert({i, j});
}
}
vector<qeury> q;
int a, b, c;
for (int i = 0; i < k; i++) {
cin >> a >> b >> c;
q.push_back({a, b, c});
}
reverse(q.begin(), q.end());
for (int i = 0; i < q.size(); i++) {
a = q[i].a;
b = q[i].b - 1;
c = q[i].c;
if (a == 1) {
if (r.count(b)) {
r.erase(b);
for (int j = 0; j < m; j++) {
if (in.count({b, j})) {
ans[b][j] = c;
in.erase({b, j});
}
}
}
} else {
if (cc.count(b)) {
cc.erase(b);
for (int j = 0; j < n; j++) {
if (in.count({j, b})) {
ans[j][b] = c;
in.erase({j, b});
}
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << ans[i][j];
if (j < m - 1) cout << " ";
}
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const long long int INF = 1000111000111000111LL;
const long long int MAX = 1001713;
long long int a[1005][1005];
long long int dp1[1005][1005];
long long int dp2[1005][1005];
long long int dp3[1005][1005];
long long int dp4[1005][1005];
int32_t main() {
long long int n, m;
cin >> n >> m;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
dp1[1][1] = a[1][1];
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
if (i == 1 && j == 1) continue;
dp1[i][j] = max(dp1[i - 1][j], dp1[i][j - 1]) + a[i][j];
}
}
dp2[1][m] = a[1][m];
for (long long int i = 1; i <= n; i++) {
for (long long int j = m; j >= 1; j--) {
if (i == 1 && j == m) continue;
dp2[i][j] = max(dp2[i - 1][j], dp2[i][j + 1]) + a[i][j];
}
}
dp3[n][m] = a[n][m];
for (long long int i = n; i >= 1; i--) {
for (long long int j = m; j >= 1; j--) {
if (i == n && j == m) continue;
dp3[i][j] = max(dp3[i + 1][j], dp3[i][j + 1]) + a[i][j];
}
}
dp4[n][1] = a[n][1];
for (long long int i = n; i >= 1; i--) {
for (long long int j = 1; j <= m; j++) {
if (i == n && j == 1) continue;
dp4[i][j] = max(dp4[i + 1][j], dp4[i][j - 1]) + a[i][j];
}
}
long long int ans = 0;
for (long long int i = 2; i <= n - 1; i++) {
for (long long int j = 2; j <= m - 1; j++) {
long long int t1 =
dp4[i + 1][j] + dp2[i - 1][j] + dp1[i][j - 1] + dp3[i][j + 1];
long long int t2 =
dp4[i][j - 1] + dp2[i][j + 1] + dp1[i - 1][j] + dp3[i + 1][j];
ans = max({ans, t1, t2});
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 2) {
cout << 2 << endl;
} else {
cout << 1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110000;
int n, t;
int b[MAXN];
pair<int, int> _b[MAXN];
int ans[MAXN];
int ptr[MAXN];
void solve() {
for (int i = 0; i < n; i++) {
scanf("%d", &_b[i].first);
_b[i].second = i;
}
sort(_b, _b + n);
int maxc = 0;
for (int i = 0; i < n; i++) {
if (i && _b[i].first != _b[i - 1].first) maxc++;
b[_b[i].second] = maxc;
}
maxc++;
memset(ans, 0x3f, sizeof(ans));
memset(ptr, 0, sizeof(ptr));
int tmp;
for (int i = 0; i < t && i < maxc; i++) {
for (int j = 0; j < n; j++) {
tmp = b[j];
while (ans[ptr[tmp]] < tmp) ptr[tmp]++;
ans[ptr[tmp]] = tmp;
}
}
cout << *max_element(ptr, ptr + maxc) + 1 << endl;
}
int main() {
int tests;
scanf("%d %d %*d %d", &tests, &n, &t);
for (int i = 0; i < tests; i++) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long LE5 = 100000;
const long long MAXN = LE5 * 10 + 50;
int side[4];
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
for (int i = 0; i < MAXN; i++) {
a *= 10;
int cur = a / b;
a = a % b;
if (cur == c) {
cout << i + 1 << endl;
return 0;
}
}
cout << -1 << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool isprime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int p[300], top = 0;
int exgcd(int a, int b, int &x, int &y) {
if (b == 0) {
return x = 1, y = 0, a;
}
int d = exgcd(b, a % b, x, y), t = x;
y = t - (a / b) * (x = y);
return d;
}
pair<int, int> calc(int a, int b, int c) {
int x, y;
exgcd(a, b, x, y);
x *= c;
y *= c;
if (x < 0) {
while (x < 0) x += b, y -= a;
}
if (y < 0) {
while (y < 0) y += a, x -= b;
}
return make_pair(x, y);
}
int main() {
scanf("%d", &n);
if (isprime(n)) {
puts("NO");
} else if (n & 1) {
int t = n;
for (int i = 2; i * i <= n; i++) {
if (t % i == 0) {
p[++top] = i;
while (t % i == 0) t /= i;
}
if (t == 1) break;
}
if (t != 1) p[++top] = t;
if (top == 1)
puts("NO");
else if (p[1] * p[2] == n) {
int A = -1, B = -1;
for (int i = 1; i < p[1]; i++) {
if ((n - 1 - i * p[2]) % p[1] == 0) {
A = i * p[2];
B = n - 1 - i * p[2];
}
}
if (A == -1)
puts("NO");
else {
puts("YES");
puts("2");
printf("%d %d\n", A / gcd(A, n), n / gcd(A, n));
printf("%d %d\n", B / gcd(B, n), n / gcd(B, n));
}
} else {
puts("YES");
pair<int, int> ans = calc(p[1], p[2], n - 1);
puts("2");
int A = p[1] * ans.first;
int B = p[2] * ans.second;
printf("%d %d\n", A / gcd(A, n), n / gcd(A, n));
printf("%d %d\n", B / gcd(B, n), n / gcd(B, n));
}
} else {
int c = -1;
for (int i = 3; i < n; i += 2) {
if (n % i == 0) {
c = i;
break;
}
}
if (c == -1)
puts("NO");
else {
puts("YES");
puts("2");
printf("%d %d\n", c / gcd(c, n), n / gcd(c, n));
printf("%d %d\n", (n - c - 1) / gcd(n - c - 1, n), n / gcd(n - c - 1, n));
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int A[105];
int sum = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &A[i]);
sum += A[i];
}
int res = 0;
for (int i = 0; i < n; ++i)
if ((sum - A[i]) % 2 == 0) ++res;
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long int n;
cin >> n;
vector<long long int> a(n);
map<long long int, long long int> indx, found;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
indx[a[i]] = i;
}
long long int ind = 0, ans = 0, ele;
for (long long int i = 0; i < n; i++) {
cin >> ele;
if (indx[ele] == ind) {
found[ind] = 1;
while (ind <= n && found[ind]) {
ind++;
}
if (ind > n)
break;
else
continue;
} else
ans++;
found[indx[ele]] = 1;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> ma;
int a[100100], b[260];
int main() {
int n, x = -1, k, t;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(b, -1, sizeof(b));
for (int i = 1; i <= n; i++) {
if (a[i] == 0)
printf("0 ");
else if (b[a[i]] != -1)
printf("%d ", b[a[i]]);
else {
int t = a[i] - k + 1;
if (t <= 0) {
printf("0 ");
for (int j = 0; j <= a[i]; j++) b[j] = 0;
} else {
int temp = -1;
for (int j = t; j < t + k; j++) {
if (temp != -1)
b[j] = temp;
else if (b[j] != -1 && b[j - 1] != b[j])
temp = j;
else if (b[j] != -1)
continue;
else {
b[j] = j;
temp = j;
}
}
printf("%d ", b[a[i]]);
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-8;
long long comb[5201][5201], p, s, r;
long long fastPow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long calc(long long p, long long up, long long sum) {
if (p == 0) return sum == 0;
long long ans = 0;
for (int i = 0; i <= p; i++) {
if (i * up > sum) break;
if (i & 1)
ans = (ans - comb[p][i] * comb[sum - i * up + p - 1][p - 1] % mod + mod) %
mod;
else
ans = (ans + comb[p][i] * comb[sum - i * up + p - 1][p - 1] % mod) % mod;
}
return ans;
}
int main() {
for (int i = 0; i <= 5200; i++)
for (int j = comb[i][0] = 1; j <= i; j++)
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % mod;
scanf("%lld%lld%lld", &p, &s, &r);
if (p == 1) {
puts("1");
} else if (s == 0) {
printf("%d\n", fastPow(p, mod - 2));
} else {
long long Q = 0, P = 0;
for (int i = r; i <= s; i++) {
Q = (Q + comb[s - i + p - 2][p - 2]) % mod;
for (int j = 0; j < p && j * i + i <= s; j++) {
long long cnt1 = comb[p - 1][j];
long long cnt2 = calc(p - j - 1, i, s - (j * i + i));
P = (P + cnt1 * cnt2 % mod * fastPow(j + 1, mod - 2) % mod) % mod;
}
}
printf("%lld\n", P * fastPow(Q, mod - 2) % mod);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int n, k;
int head[maxn], tot, keep[maxn], f[maxn][25];
struct Edge {
int to, nxt;
} e[maxn << 1];
void add(int u, int v) {
e[++tot].nxt = head[u];
e[tot].to = v;
head[u] = tot;
}
void dfs(int u, int fa) {
f[u][0] = fa;
for (int i = 0; i <= 19; i++) f[u][i + 1] = f[f[u][i]][i];
for (int i = head[u]; i != 0; i = e[i].nxt) {
int v = e[i].to;
if (v == fa) continue;
dfs(v, u);
}
}
int dis(int u) {
int d = 0;
for (int i = 20; i >= 0; i--)
if (f[u][i] != 0 && keep[f[u][i]] == 0) d += (1 << i), u = f[u][i];
d += 1;
return d;
}
int main() {
cin >> n >> k;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v), add(v, u);
}
dfs(n, n);
keep[n] = 1;
int remain = n - k - 1;
for (int i = n - 1; i >= 1; i--) {
if (!remain) break;
if (keep[i]) continue;
int d = dis(i);
if (d <= remain) {
int u = i;
remain -= d;
while (!keep[u]) {
keep[u] = 1;
u = f[u][0];
}
}
}
for (int i = 1; i <= n; i++)
if (!keep[i]) printf("%d ", i);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans, ans2;
int s = 0;
int r[1005];
struct grup {
int i;
int k;
int s;
};
grup gr[1001];
bool cmp(grup a, grup b) { return a.s > b.s; }
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
gr[i].i = i;
cin >> gr[i].k >> gr[i].s;
}
sort(gr + 1, gr + n + 1, cmp);
int k;
cin >> k;
r[0] = 1000000;
for (int i = 1; i <= k; i++) cin >> r[i];
for (int i = 1; i <= n; i++) {
int j1 = 0;
for (int j = 1; j <= k; j++)
if (gr[i].k <= r[j] && r[j] <= r[j1]) j1 = j;
if (j1 != 0) {
s += gr[i].s;
ans.push_back(gr[i].i);
ans2.push_back(j1);
r[j1] = 0;
}
}
cout << ans.size() << " " << s << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " " << ans2[i] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (int)(1e9) + 7;
long long A[510];
long long C[510][510];
long long dp[310][500];
int n, nn;
int seq[310];
int belong[310], a[310];
void pre() {
A[0] = A[1] = 1;
for (int i = 2; i < 500; ++i) {
A[i] = A[i - 1] * i % mod;
}
for (int i = 0; i < 500; ++i) {
C[0][i] = 1;
for (int j = 1; j <= i; ++j) {
C[j][i] = (C[j][i - 1] + C[j - 1][i - 1]) % mod;
}
}
}
int solve() {
memset(dp, 0, sizeof(dp));
dp[1][seq[1] - 1] = 1;
long long sum = seq[1];
for (int i = 2; i <= n; ++i) {
for (int j = 0; j < sum; ++j) {
for (int k = 1; k <= seq[i]; ++k) {
for (int h = 0; h <= j && h <= k; ++h) {
dp[i][j - h + seq[i] - k] += dp[i - 1][j] * C[h][j] % mod *
C[k - h][sum + 1 - j] % mod *
C[k - 1][seq[i] - 1] % mod;
dp[i][j - h + seq[i] - k] %= mod;
}
}
}
sum += seq[i];
}
long long ret = dp[n][0];
for (int i = 1; i <= nn; ++i) {
ret = ret * A[seq[i]] % mod;
}
return ret;
}
bool ok(int i, int j) {
long long p = (long long)a[i] * a[j];
long long q = sqrt(p);
if (q * q == p)
return 1;
else
return 0;
}
void getseq() {
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
nn = 0;
for (int i = 1; i <= n; ++i) {
if (belong[i] == 0) {
int num = 1;
belong[i] = ++nn;
for (int j = i + 1; j <= n; ++j)
if (ok(i, j)) {
belong[j] = nn;
num++;
}
seq[nn] = num;
}
}
n = nn;
}
int main() {
pre();
scanf("%d", &n);
getseq();
printf("%d\n", solve());
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, a;
set<int> s;
set<int>::iterator it;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
s.insert(a);
}
if (s.size() < 2)
cout << "NO\n";
else {
it = s.begin();
it++;
cout << *it << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, tot, x[100005], cnt, ti[100005];
bool y[100005];
bool test(int r) {
cnt = 0;
tot = m;
y[0] = 1;
for (int i = r; i >= 1; i--) {
if (!y[x[i]]) {
if (cnt > 0) cnt = 0;
y[x[i]] = 1;
tot--;
cnt -= ti[x[i]];
} else
cnt++;
}
if (tot > 0 || cnt < 0) return 0;
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d", &ti[i]);
}
int l = 1, r = n, mid;
while (l < r) {
mid = l + r >> 1;
if (test(mid))
r = mid;
else
l = mid + 1;
memset(y, 0, sizeof(y));
}
if (l == n)
if (!test(l)) {
printf("-1\n");
return 0;
}
printf("%d\n", l);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a1, b1, c1, a2, b2, c2;
int main() {
cin >> a1 >> b1 >> c1 >> a2 >> b2 >> c2;
int D, Dx, Dy;
if (a1 == 0 && b1 == 0) {
if (c1 != 0) {
cout << 0;
return 0;
}
}
if (a2 == 0 && b2 == 0) {
if (c2 != 0) {
cout << 0;
return 0;
}
}
c1 = -c1;
c2 = -c2;
D = a1 * b2 - a2 * b1;
Dx = c1 * b2 - c2 * b1;
Dy = a1 * c2 - a2 * c1;
if (D == 0) {
if (Dx == 0 && Dy == 0)
cout << -1;
else
cout << 0;
} else
cout << 1;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long Nfact = 200005;
const long long mod = 1000000007;
const long long Nsieve = 1000005;
vector<bool> is_prime(Nsieve, true);
void sieve() {
is_prime[0] = is_prime[1] = false;
for (long long i = 2; i * i <= Nsieve; i++) {
if (is_prime[i]) {
for (long long j = i * i; j <= Nsieve; j += i) is_prime[j] = false;
}
}
}
long long bSearch(long long l, long long r, long long x,
vector<long long> arr) {
while (l <= r) {
long long m = l + (r - l) / 2;
if (arr[m] == x) return m;
if (arr[m] < x)
l = m + 1;
else
r = m - 1;
}
return -1;
}
void primeFactors(long long n) {
while (n % 2 == 0) {
n = n / 2;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
n = n / i;
}
}
if (n > 2) cout << n << " ";
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long modulo(long long a, long long b) {
long long c = a % b;
return (c < 0) ? c + b : c;
}
long long mul(long long x, long long y) { return (x * y) % mod; }
long long inv(long long x) { return power(x, mod - 2, mod); }
long long divide(long long x, long long y) { return mul(x, inv(y)); }
long long fact[Nfact];
void precalc() {
fact[0] = 1;
for (long long i = 1; i < Nfact; i++) fact[i] = mul(fact[i - 1], i);
}
long long nCr(long long n, long long k) {
if (n < k) return 0;
return divide(fact[n], mul(fact[k], fact[n - k]));
}
void solve() {
long long m, t, r;
cin >> m >> t >> r;
vector<long long> gh(m);
for (auto &it : gh) cin >> it;
if (r > t) {
cout << -1 << "\n";
return;
}
vector<long long> vec(605, 0);
for (long long i = 0; i < m; i++) {
vec[gh[i] + 300] = 7;
}
long long ct = 0, ans = 0;
for (long long i = gh[0] + 300; i < gh[m - 1] + 301; i++) {
if (vec[i] == 7) {
ct = 0;
for (long long j = i - 1; j >= i - t; j--) {
if (vec[j] == 1) ct++;
}
for (long long j = i - 1; j >= i - t && ct < r; j--) {
if (!vec[j] || vec[j] == 7) {
vec[j] = 1;
ct++;
ans++;
}
}
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs"
<< "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1000000007;
const long long linf = 0x3f3f3f3f3f3f3f3f;
map<int, int> le[300], ri[300];
vector<int> pr[300], su[300];
int a[200100];
int f(int meio) {
int r = 0;
for (int i = 1; i <= 200; i++) {
if (2 * meio > le[i].size()) continue;
int x = pr[i][meio], y = su[i][meio];
if (x == y) {
r = max(r, 2 * meio - 1);
continue;
}
for (int j = 1; j <= 200; j++) {
auto it1 = le[j].lower_bound(x + 1);
auto it2 = le[j].lower_bound(y);
r = max(r, 2 * meio + (*it2).second - (*it1).second);
}
}
return r;
}
int tsearch(int r) {
int l = 0;
while (r - l >= 7) {
int mid = (r + l) / 2;
if (f(mid) > f(mid + 1))
r = mid + 1;
else
l = mid;
}
for (int i = l + 1; i <= r; ++i) {
if (f(l) < f(i)) l = i;
}
return l;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
for (int i = 1; i <= 200; i++)
le[i].clear(), ri[i].clear(), pr[i].clear(), su[i].clear();
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= 200; i++) {
pr[i].push_back(0);
su[i].push_back(n + 1);
}
for (int i = 1; i <= n; i++)
le[a[i]][i] = le[a[i]].size(), pr[a[i]].push_back(i);
for (int i = n; i >= 1; i--) su[a[i]].push_back(i);
for (int i = 1; i <= 200; i++) {
le[i][inf] = le[i].size();
}
int ans = 0;
for (int i = 1; i <= n; i++) ans = max(ans, f(i));
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
constexpr int MAXN = 1e5 + 4;
constexpr int MAXK = 1e3 + 5;
constexpr int MOD = 1e9 + 7;
constexpr long long INF = 9187201950435737471;
constexpr int LOG = 11;
struct edge {
long long u, v, w;
void Get() { cin >> u >> v >> w; }
void Debug() { cout << u << "->" << v << "\n"; }
};
int n, m, s, t, deg[MAXN], cnt;
string ans[MAXN];
long long dist[2][MAXN], val[MAXN];
bool mark[MAXN];
edge E[MAXN];
vector<int> G[MAXN][2], T[MAXN][2], rec;
void dijkstra(int src, int type) {
set<pair<int, int> > st;
dist[type][src] = 0;
st.insert(make_pair(0, src));
while (!st.empty()) {
int u = (*st.begin()).second;
st.erase(st.begin());
for (auto i : G[u][type]) {
int v = E[i].u ^ E[i].v ^ u, w = E[i].w;
if (dist[type][v] > dist[type][u] + w) {
st.erase(make_pair(dist[type][v], v));
dist[type][v] = dist[type][u] + w;
st.insert(make_pair(dist[type][v], v));
}
}
}
}
void Create_DAG(int u) {
mark[u] = true;
for (auto i : G[u][1]) {
int v = E[i].u ^ E[i].v ^ u, w = E[i].w;
if (dist[0][u] == dist[0][v] + w) {
T[v][0].push_back(i);
T[u][1].push_back(i);
if (!mark[v]) {
Create_DAG(v);
}
}
}
}
void Check_Yes() {
int u = rec.back();
rec.pop_back();
if (T[u][0].size() == 1 && rec.empty() && !cnt) {
int idx = T[u][0].back();
if (T[E[idx].v][1].size() == 1) {
ans[idx] = "YES";
}
}
for (auto i : T[u][0]) {
int v = E[i].v;
deg[v]--;
if (!deg[v]) {
rec.push_back(v);
if (T[v][1].size() > 1) {
cnt -= T[v][1].size();
cnt++;
}
} else {
cnt++;
}
}
if (!rec.empty()) {
Check_Yes();
}
}
void Check_Other() {
for (int i = 1; i <= m; i++) {
if (ans[i] != "YES") {
if (dist[0][E[i].u] != INF && dist[1][E[i].v] != INF &&
dist[0][E[i].u] + dist[1][E[i].v] + 1 < dist[0][t]) {
ans[i] = "CAN";
val[i] = dist[0][E[i].u] + dist[1][E[i].v] + E[i].w - dist[0][t] + 1;
} else {
ans[i] = "NO";
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> s >> t;
for (int i = 1; i <= m; i++) {
E[i].Get();
G[E[i].u][0].push_back(i);
G[E[i].v][1].push_back(i);
}
memset(dist, 127, sizeof dist);
dijkstra(s, 0);
dijkstra(t, 1);
Create_DAG(t);
for (int i = 1; i <= n; i++) {
deg[i] = T[i][1].size();
}
rec.push_back(s);
Check_Yes();
Check_Other();
for (int i = 1; i <= m; i++) {
cout << ans[i] << " ";
if (ans[i] == "CAN") {
cout << val[i];
}
cout << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, a, b, c, d, start, len;
cin >> n >> a >> b >> c >> d >> start >> len;
vector<int> t(n + 1), q(n + 1);
vector<int> pos;
pos.push_back(0);
for (int i = 1; i <= n; i++) {
cin >> t[i] >> q[i];
pos.push_back(t[i]);
pos.push_back(t[i] + 1);
if (t[i] - len >= 0) {
pos.push_back(t[i] - len);
pos.push_back(t[i] - len + 1);
}
}
sort(pos.begin(), pos.end());
pos.resize(unique(pos.begin(), pos.end()) - pos.begin());
vector<long long> pmin, pcur, pnew;
const int offset = 1 << 19;
vector<long long> pnewtree(offset * 2 + 1, (long long)1e18);
vector<long long> pcurtree(offset * 2 + 1, (long long)1e18);
pmin.push_back(start);
pcur.push_back(start);
pnew.push_back(0);
pnewtree[offset] = 0;
pcurtree[offset] = start;
{
long long cur = start;
for (int i = 1; i <= n; i++) {
cur += (q[i] == 0) ? -b : +a;
pmin.push_back(min(cur, pmin.back()));
pcur.push_back(cur);
pnew.push_back(pnew.back() + (q[i] == 0 ? -d : +c));
pnewtree[offset + i] = pnew.back();
pcurtree[offset + i] = cur;
}
}
for (int i = offset - 1; i > 0; i--) {
pnewtree[i] = min(pnewtree[i * 2], pnewtree[i * 2 + 1]);
pcurtree[i] = min(pcurtree[i * 2], pcurtree[i * 2 + 1]);
}
for (int p : pos) {
auto it = lower_bound(t.begin(), t.end(), p);
if (it == t.end()) continue;
int i = it - t.begin();
auto it2 = lower_bound(t.begin(), t.end(), p + len);
if (it2 == t.begin()) continue;
it2--;
int j = it2 - t.begin();
if (i > j) {
if (pmin.back() >= 0) {
cout << p << endl;
return 0;
}
}
if (i - 1 >= 0 && pmin[i - 1] < 0) {
continue;
}
{
int l = i + offset, r = j + offset;
long long v = 1e18;
while (l <= r) {
if (l % 2 == 1) v = min(v, pnewtree[l]);
if (r % 2 == 0) v = min(v, pnewtree[r]);
l = (l + 1) / 2;
r = (r - 1) / 2;
}
long long cur = (i - 1 >= 0 ? pcur[i - 1] : start);
cur += (v - (i - 1 >= 0 ? pnew[i - 1] : 0));
if (cur < 0) {
continue;
}
}
cout << p << endl;
return 0;
}
if (pmin.back() >= 0) {
long long ans = t.back() + 1;
cout << ans << endl;
return 0;
}
cout << -1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int cnt[1010], cost[1010];
long long int dp[1010][10010];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, w, b, x;
cin >> n >> w >> b >> x;
for (int i = 1; i <= n; i++) cin >> cnt[i];
for (int i = 1; i <= n; i++) cin >> cost[i];
memset(dp, -1, sizeof dp);
dp[0][0] = w;
int tot = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= tot; j++) {
for (int k = 0; k <= cnt[i]; k++) {
if (dp[i - 1][j] >= 0) {
dp[i][j + k] =
max(dp[i][j + k],
min(dp[i - 1][j] + x, w + 1LL * j * b) - 1LL * cost[i] * k);
}
}
}
tot += cnt[i];
}
for (int i = tot; i >= 0; i--)
if (dp[n][i] >= 0) {
cout << i << endl;
break;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long _n = 1e5 + 11;
const long long inf = 1e18 + 11;
const long long mod = 1e9 + 7;
const double eps = 1e-7;
long long x, y, l, r;
vector<long long> a, b, c;
set<long long> s;
signed main() {
ios_base ::sync_with_stdio(0);
cin.tie();
cout.tie();
cout << fixed;
cout << setprecision(15);
srand(time(NULL));
cin >> x >> y >> l >> r;
a.push_back(1);
b.push_back(1);
for (long long i = 1; i < 61; i++) {
if (inf / a.back() < x) continue;
a.push_back(a.back() * x);
}
for (long long i = 1; i < 61; i++) {
if (inf / b.back() < y) continue;
b.push_back(b.back() * y);
}
for (auto v1 : a) {
for (auto v2 : b) {
if (inf - v1 < v2) continue;
s.insert(v1 + v2);
}
}
long long res = 0;
for (auto v : s)
if (l <= v && v <= r) c.push_back(v);
c.push_back(l - 1);
c.push_back(r + 1);
sort(c.begin(), c.end());
for (long long i = 1; i < (long long)c.size(); i++) {
res = max(res, c[i] - c[i - 1] - 1);
}
cout << res << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, q, arrs[100009], arrd[100009], g, arrp[100009], va = 0;
int ans = 0;
pair<long long, long long> arr[100009];
int bs(int l, int r, int val) {
int mid = (l + r) / 2;
if (arr[mid].first <= val) ans = max(ans, mid);
if (l == r) return mid;
if (arr[mid].first > val)
return bs(l, mid, val);
else
return bs(mid + 1, r, val);
}
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> arrs[i];
}
for (int i = 1; i <= q; i++) {
cin >> arr[i].first >> arr[i].second;
}
sort(arr + 1, arr + 1 + q);
for (int i = 1; i <= q; i++) {
arrp[i] = arr[i].second + arrp[i - 1];
}
for (int i = 1; i <= n; i++) {
ans = 0;
bs(1, q, arrs[i]);
cout << arrp[ans] << " ";
}
}
| 3 |
#pragma GCC optimize("O3","Ofast","unroll-loops")
#include <bits/stdc++.h>
using namespace std;
string dp[502][2][26];
vector <int> pr[502][2][26];
int32_t main()
{
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int t;
cin>>t;
while(t--)
{
int n,k;
cin>>n>>k;
string s;
cin>>s;
char opt[k];
for(int i=0;i<k;++i)
{
opt[i]=min('a'+i,'a'+max(0,min(i-1,(i+1)%k)));
//cout<<i<<" i "<<opt[i]<<" opt[i] "<<endl;
}
for(int i=0;i<=(n+1);++i) for(int j=0;j<2;++j) for(int k=0;k<26;++k) {pr[i][j][k]={-1,-1,-1};dp[i][j][k]="";}
for(int i=n;i<=n;++i)
{
for(int j=1;j<=1;++j)
{
for(int k=0;k<26;++k)
{
dp[i][j][k]=('a'+k);
pr[i][j][k]={-1,-1,-1};
}
}
}
for(int i=(n-1);i>=0;i--)
{
for(int j=0;j<2;++j)
{
for(int k=0;k<26;++k)
{
if(j==0)
{
dp[i][j][k]=opt[s[i]-'a'];
pr[i][j][k]={i+1,j,k};
if((i+1)<n && opt[s[i+1]-'a']<dp[i][j][k][0] && s[i+1]=='a')
{
dp[i][j][k]=s[i+1];
pr[i][j][k]={i+2,1,opt[s[i]-'a']-'a'};
}
else if((i+1)<n && opt[s[i+1]-'a']<dp[i][j][k][0])
{
dp[i][j][k]=opt[s[i+1]-'a'];
pr[i][j][k]={i+2,1,s[i]-'a'};
}
if((i+2)<n && s[i+2]<dp[i][j][k][0])
{
dp[i][j][k]=s[i+2];
dp[i][j][k]+=opt[s[i]-'a'];
pr[i][j][k]={i+3,1,s[i+1]-'a'};
}
/*if((i+2)<n && s[i+2]==dp[i][j][k][0] && s[i]<dp[i][j][k][1])
{
dp[i][j][k]=s[i+2];
dp[i][j][k]+=s[i];
pr[i][j][k]={i+3,1,s[i+1]-'a'};
}*/
for(int k=1;k<26;++k)
{
dp[i][j][k]=dp[i][j][0];
pr[i][j][k]=pr[i][j][0];
}
break;
}
else
{
dp[i][j][k]=('a'+k);
pr[i][j][k]={i,0,0};
if(s[i]<('a'+k))
{
dp[i][j][k]=s[i];
pr[i][j][k]={i+1,j,k};
}
if((i+1)<n && s[i+1]<dp[i][j][k][0])
{
dp[i][j][k]=s[i+1];
dp[i][j][k]+=('a'+k);
pr[i][j][k]={i+2,j,s[i]-'a'};
}
}
}
}
}
if(s.size()>=5)
{
//cout<<dp[4][0][0]<<" dp "<<endl;
//cout<<pr[4][0][0][0]<<' '<<pr[4][0][0][1]<<' '<<pr[4][0][0][2]<<" pr "<<endl;
}
string ans;
vector <int> v={0,0,0};
while(true)
{
ans+=dp[v[0]][v[1]][v[2]];
v=pr[v[0]][v[1]][v[2]];
if(v[0]==(-1))
{
break;
}
}
cout<<ans<<'\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int N = 1e9 + 6;
const int MD = 1e9 + 7;
void solve() {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long long l = 0, r = 0, mid = 0;
int n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] == '^') {
mid = i;
break;
}
}
for (int i = 0; i < mid; i++) {
if (s[i] >= '1' && s[i] <= '9') l += (s[i] - '0') * (mid - i);
}
for (int i = mid + 1; i < n; i++) {
if (s[i] >= '1' && s[i] <= '9') r += (s[i] - '0') * (i - mid);
}
if (r == l)
cout << "balance";
else if (r > l)
cout << "right";
else
cout << "left";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<int> v(n);
vector<bool> p(n, false);
for (int i = 0; i < n; ++i) cin >> v[i];
for (int i = 1; i < n - 1; ++i) {
if (v[i - 1] < v[i] && v[i] > v[i + 1]) p[i] = true;
}
int cant = 0, best = 0, index = 0, i = 1;
for (; i < k - 1; ++i) {
if (p[i]) cant++;
}
best = cant;
i = k;
while (i < n) {
if (p[i - 1] && !p[i - k + 1]) {
cant++;
}
if (!p[i - 1] && p[i - k + 1]) {
cant--;
}
if (cant > best) {
best = cant;
index = i - k + 1;
}
i++;
}
cout << best + 1 << " " << index + 1 << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int a[1000], n, t, i, d, m;
scanf("%d", &n);
d = n;
while (n--) {
scanf("%d", &m);
while (m--) {
scanf("%d", &t);
a[t]++;
if (a[t] == d) {
printf("%d ", t);
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int u[500005], v[500005], wt[500005], par[500005],
waqt = 0, waqtForNodes[500005], parr[500005];
map<int, bool> M;
vector<pair<int, int> > offlineStoredQueries[500005];
vector<int> eg[500005];
int find2(int x) {
if (waqtForNodes[x] != waqt) {
waqtForNodes[x] = waqt;
parr[x] = par[x];
}
if (parr[x] != x) parr[x] = find2(parr[x]);
return parr[x];
}
int find(int x) {
if (par[x] != x) par[x] = find(par[x]);
return par[x];
}
void Union(int x, int y) {
int xset = find(par[x]);
int yset = find(par[y]);
if (xset != yset) par[xset] = yset;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u[i] >> v[i] >> wt[i];
eg[wt[i]].push_back(i);
}
for (int i = 1; i <= n; i++) par[i] = i;
cin >> q;
for (int i = 0; i < q; i++) {
int numEdges;
cin >> numEdges;
for (int j = 0; j < numEdges; j++) {
int edgeNo;
cin >> edgeNo;
int weight = wt[edgeNo];
offlineStoredQueries[weight].push_back(make_pair(edgeNo, i));
}
}
for (int weight = 1; weight < 500005; weight++) {
for (int i = 0; i < offlineStoredQueries[weight].size(); i++) {
if (i == 0 || offlineStoredQueries[weight][i - 1].second !=
offlineStoredQueries[weight][i].second)
waqt++;
int edgeNo = offlineStoredQueries[weight][i].first;
int queryNo = offlineStoredQueries[weight][i].second;
if (find2(u[edgeNo]) == find2(v[edgeNo])) M[queryNo];
parr[find2(u[edgeNo])] = parr[find2(v[edgeNo])];
}
for (int i = 0; i < eg[weight].size(); i++) {
Union(u[eg[weight][i]], v[eg[weight][i]]);
}
}
for (int i = 0; i < q; i++) {
if (M.count(i) != 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
}
| 7 |
#include <bits/stdc++.h>
const int MAXN = 1e5 + 5;
int n, m;
struct Edge {
int to, w, nxt;
} e[MAXN << 1];
int head[MAXN], cnt;
inline void add(int u, int v, int w) {
e[++cnt] = (Edge){v, w, head[u]};
head[u] = cnt;
}
long long dis[MAXN];
inline void dfs(int v) {
for (int i = head[v]; i; i = e[i].nxt) {
dis[e[i].to] = dis[v] + e[i].w;
dfs(e[i].to);
}
}
int ch[MAXN][2], fa[MAXN];
long long tag[MAXN], ts[MAXN];
inline bool nroot(int x) { return ch[fa[x]][0] == x || ch[fa[x]][1] == x; }
inline void rotate(int x) {
int y = fa[x], z = fa[y], k = ch[y][1] == x, w = ch[x][!k];
if (nroot(y)) ch[z][ch[z][1] == y] = x;
fa[x] = z;
ch[x][!k] = y;
fa[y] = x;
ch[y][k] = w;
if (w) fa[w] = y;
}
inline void pushdown(int x) {
if (tag[x] != -1) {
if (ch[x][0]) tag[ch[x][0]] = ts[ch[x][0]] = tag[x];
if (ch[x][1]) tag[ch[x][1]] = ts[ch[x][1]] = tag[x];
tag[x] = -1;
}
}
int st[MAXN];
inline void splay(int x) {
int y = x, z;
st[z = 1] = y;
while (nroot(y)) st[++z] = y = fa[y];
while (z) pushdown(st[z--]);
while (nroot(x)) {
y = fa[x], z = fa[y];
if (nroot(y)) rotate((ch[z][1] == y) ^ (ch[y][1] == x) ? x : y);
rotate(x);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 2; i <= n; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
add(u, v, w);
ch[u][1] = v;
fa[v] = u;
}
dfs(1);
for (int i = 1; i <= n; ++i) tag[i] = -1, ts[i] = -dis[i];
std::vector<std::pair<long long, long long> > S;
while (m--) {
int s, t;
scanf("%d%d", &s, &t);
splay(s);
for (int x = fa[s], y = s; x; y = x, x = fa[x]) {
splay(x);
ch[x][1] = y;
S.push_back(std::make_pair(ts[x] + dis[x] + 1, t + dis[x]));
}
splay(s);
if (ch[s][0]) tag[ch[s][0]] = ts[ch[s][0]] = t;
}
std::sort(S.begin(), S.end());
long long now = 0;
int cnt = 0;
std::priority_queue<long long, std::vector<long long>,
std::greater<long long> >
q;
for (int i = 0; i <= (int)S.size() - 1; ++i) {
while (!q.empty() && now < S[i].first) {
long long r = q.top();
q.pop();
if (now > r) {
for (int j = 0; j <= i - 1; ++j) cnt -= (S[j].second >= r);
while (!q.empty()) cnt += (q.top() >= r), q.pop();
printf("%lld %d\n", r, cnt + 1);
return 0;
}
now++;
++cnt;
}
if (now < S[i].first) now = S[i].first;
q.push(S[i].second);
}
while (!q.empty()) {
long long r = q.top();
q.pop();
if (now > r) {
for (auto x : S) cnt -= (x.second >= r);
while (!q.empty()) cnt += (q.top() >= r), q.pop();
printf("%lld %d\n", r, cnt + 1);
return 0;
}
++now;
++cnt;
}
printf("-1 %d\n", cnt);
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128000000")
using namespace std;
map<string, int> a;
map<string, int>::iterator ii, jj;
string s;
int main() {
int k, i, v, u, j, n, m, d, d2, y, r, p, t1, t2, x, l, t, z, fl, to;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s >> p;
if (a[s] <= p) a[s] = p;
}
k = 0;
for (ii = a.begin(); ii != a.end(); ii++) k++;
cout << k << endl;
for (ii = a.begin(); ii != a.end(); ii++) {
t = 0;
p = 0;
for (jj = a.begin(); jj != a.end(); jj++) {
if ((*ii).second >= (*jj).second) t++;
if ((*ii).second < (*jj).second) p++;
}
if ((double)p / (double)k > 0.5) {
cout << (*ii).first << " "
<< "noob" << endl;
continue;
}
if ((double)t / (double)k >= 0.5 && (double)p / (double)k > 0.2) {
cout << (*ii).first << " "
<< "random" << endl;
continue;
}
if ((double)t / (double)k >= 0.8 && (double)p / (double)k > 0.1) {
cout << (*ii).first << " "
<< "average" << endl;
continue;
}
if ((double)t / (double)k >= 0.9 && (double)p / (double)k > 0.01) {
cout << (*ii).first << " "
<< "hardcore" << endl;
continue;
}
if ((double)t / (double)k >= 0.99) {
cout << (*ii).first << " "
<< "pro" << endl;
continue;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
struct opt {
int id, l, r, k;
opt() {}
opt(int id, int l, int r, int k) : id(id), l(l), r(r), k(k) {}
bool operator<(const opt& cmp) const {
if (r != cmp.r)
return r > cmp.r;
else
return l < cmp.l;
}
} a[MAXN], b[MAXN];
int ans[MAXN];
int n, m;
multiset<opt> S;
void work() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].l, &a[i].r);
a[i].id = i;
a[i].k = 0;
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &b[i].l, &b[i].r, &b[i].k);
b[i].id = i;
}
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + m);
for (int i = 1, j = 1; i <= n; i++) {
while (j <= m && b[j].r >= a[i].r) {
b[j].r = 0;
S.insert(b[j]);
++j;
}
set<opt>::iterator it = S.upper_bound(opt(0, a[i].l, 0, 0));
if (it == S.begin()) {
puts("NO");
return;
}
it--;
opt tmp = *it;
S.erase(it);
if (--tmp.k != 0) {
S.insert(tmp);
}
ans[a[i].id] = tmp.id;
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], " \n"[i == n]);
return;
}
int main() {
work();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int ans = 0;
char vowel[] = {'a', 'e', 'i', 'o', 'u'};
for (int i = 0; s[i]; i++)
if (find(vowel, vowel + 5, s[i]) != vowel + 5 or
(s[i] >= '0' and s[i] <= '9' and (s[i] - '0') % 2 == 1))
ans++;
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
const int INF = 1e9 + 10;
int n, m, x;
char ch[60][60];
int q;
char s[maxn];
int ans[26];
bool has[26];
int dist(pair<int, int> A, pair<int, int> B) {
int tx = A.first - B.first, ty = A.second - B.second;
return tx * tx + ty * ty;
}
int get_ans(char c) {
if (!has[c - 'A']) return 0;
int res = n * n + m * m;
vector<pair<int, int> > S, C;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ch[i][j] == 'S')
S.push_back(make_pair(i, j));
else if (ch[i][j] - 'a' == c - 'A')
C.push_back(make_pair(i, j));
}
}
for (int i = 0; i < S.size(); i++) {
for (int j = 0; j < C.size(); j++) {
res = min(res, dist(S[i], C[j]));
}
}
if (res <= x * x) return 0;
return 1;
}
int main() {
while (cin >> n >> m >> x) {
memset(has, 0, sizeof(has));
int S = 0;
for (int i = 1; i <= n; i++) {
scanf("%s", ch[i] + 1);
for (int j = 1; j <= m; j++) {
if (ch[i][j] != 'S')
has[ch[i][j] - 'a'] = 1;
else
S = 1;
}
}
cin >> q;
scanf("%s", s);
if (!S) {
int res = 0;
for (int i = 0; i < q; i++) {
if (isupper(s[i])) {
res = -1;
break;
} else if (has[s[i] - 'a'] == 0) {
res = -1;
break;
}
}
cout << res << endl;
continue;
}
for (int i = 0; i < 26; i++) ans[i] = get_ans('A' + i);
int res = 0;
for (int i = 0; i < q; i++) {
if (islower(s[i])) {
if (!has[s[i] - 'a']) {
res = -1;
break;
}
} else {
if (!has[s[i] - 'A']) {
res = -1;
break;
} else
res += ans[s[i] - 'A'];
}
}
cout << res << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:10240000000,10240000000")
char ch;
int bo;
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline void rd(int &x) {
x = bo = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') bo = 1;
for (; ch >= '0' && ch <= '9';
x = (x << 1) + (x << 3) + ch - '0', ch = getchar())
;
if (bo) x = -x;
}
inline void RD(long long &x) {
x = bo = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') bo = 1;
for (; ch >= '0' && ch <= '9';
x = (x << 1) + (x << 3) + ch - '0', ch = getchar())
;
if (bo) x = -x;
}
inline long long RD() {
long long x;
RD(x);
return x;
}
inline int rd() {
int x;
rd(x);
return x;
}
inline void RD(char *s) {
for (ch = getchar(); blank(ch); ch = getchar())
;
for (; !blank(ch); ch = getchar()) *s++ = ch;
*s = 0;
}
inline void RD(char &c) {
for (ch = getchar(); blank(c); ch = getchar())
;
}
template <class T>
inline void OT(T x) {
static char buf[20];
char *p1 = buf;
if (!x) *p1++ = '0';
if (x < 0) putchar('-'), x = -x;
while (x) *p1++ = x % 10 + '0', x /= 10;
while (p1-- != buf) putchar(*p1);
}
const int maxn = 1e6 + 20;
const int mod = 1e9 + 7;
long long dp[45][2];
long long dfs(bitset<45> a, bitset<45> b, int pos, int k) {
if (pos < 0) {
if (!k)
return 1;
else
return 0;
}
if (dp[pos][k] != -1) return dp[pos][k];
int s = a[pos];
int x = b[pos];
long long ret;
if (k == 0) {
if (s == 0 && x == 1) {
ret = 0;
} else if (s == 0 && x == 0) {
ret = dfs(a, b, pos - 1, 0);
} else if (s == 1 && x == 0) {
ret = dfs(a, b, pos - 1, 1);
} else if (s == 1 && x == 1) {
ret = 2 * dfs(a, b, pos - 1, 0);
}
} else {
if (s == 0 && x == 1) {
ret = 2 * dfs(a, b, pos - 1, 1);
} else if (s == 0 && x == 0) {
ret = dfs(a, b, pos - 1, 0);
} else if (s == 1 && x == 0) {
ret = dfs(a, b, pos - 1, 1);
} else if (s == 1 && x == 1) {
ret = 0;
}
}
return dp[pos][k] = ret;
}
int main() {
long long s, x;
RD(s), RD(x);
bitset<45> a(s);
bitset<45> b(x);
memset(dp, -1, sizeof(dp));
long long res = dfs(a, b, 43, 0);
if (s == x) res -= 2;
OT(res), puts("");
;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int intmax = 0x3f3f3f3f;
double eps = 1e-6;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
inline T checkmod(T n, T m) {
return (n % m + m) % m;
}
inline int rand(int a, int b) {
if (a >= b) return a;
return rand() % (b - a) + a;
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T euclid(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclid(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclid(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclid(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline vector<pair<T, int> > factorize(T n) {
vector<pair<T, int> > R;
for (T i = 2; n > 1;) {
if (n % i == 0) {
int C = 0;
for (; n % i == 0; C++, n /= i)
;
R.push_back(make_pair(i, C));
}
i++;
if (i > n / i) i = n;
}
if (n > 1) R.push_back(make_pair(n, 1));
return R;
}
template <class T>
inline bool isPrimeNumber(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
template <class T>
inline T eularFunction(T n) {
vector<pair<T, int> > R = factorize(n);
T r = n;
for (int i = 0; i < R.size(); i++) r = r / R[i].first * (R[i].first - 1);
return r;
}
template <class T>
inline int dblcmp(T a, const T b) {
a -= b;
return a > eps ? 1 : (a < -eps ? -1 : 0);
}
template <class T>
inline int sgn(T a) {
return a > eps ? 1 : (a < -eps ? -1 : 0);
}
struct vec2 {
double x, y;
vec2(double x = 0.0, double y = 0.0) : x(x), y(y) {}
vec2 operator+(const vec2 &b) const { return vec2(x + b.x, y + b.y); }
vec2 operator-(const vec2 &b) const { return vec2(x - b.x, y - b.y); }
vec2 operator*(const double &b) const { return vec2(x * b, y * b); }
vec2 operator/(const double &b) const { return vec2(x / b, y / b); }
double operator*(const vec2 &b) const { return x * b.x + y * b.y; }
double operator^(const vec2 &b) const { return x * b.y - y * b.x; }
double len() { return sqrt(x * x + y * y); }
vec2 unit() { return *this / len(); }
vec2 rotate(double r) {
vec2 t(sin(r), cos(r));
return vec2(*this ^ t, *this * t);
}
bool operator<(const vec2 &b) const {
if (dblcmp(x, b.x) != 0)
return dblcmp(x, b.x) < 0;
else
return dblcmp(y, b.y) < 0;
}
};
const int N = 130, M = 7;
const long long P = 1000000007;
int cnt[N];
int n, m, t;
int mod[N * 3];
struct BIT {
unsigned long long a[2];
};
int len, l;
unsigned long long temp;
BIT move(const BIT &a, int i) {
BIT ans;
if (i < 0) i += m;
if (m <= 64) {
ans.a[0] = a.a[0] >> i;
ans.a[0] |= ((a.a[0]) & (((long long)1 << (i)) - 1)) << (m - i);
} else {
if (i <= m - 64) {
ans.a[0] = a.a[0] >> i;
ans.a[1] = a.a[1] >> i;
ans.a[0] |= ((a.a[1]) & (((long long)1 << (i)) - 1)) << (64 - i);
ans.a[1] |= ((a.a[0]) & (((long long)1 << (i)) - 1)) << (m - 64 - i);
} else if (i >= 64) {
i = m - i;
ans.a[0] = a.a[0] << i;
ans.a[1] = ((a.a[1] << i) & (((long long)1 << (m - 64)) - 1));
ans.a[0] |= a.a[1] >> (m - 64 - i);
ans.a[1] |= a.a[0] >> (64 - i);
} else {
temp = ((a.a[0]) & (((long long)1 << (i)) - 1));
ans.a[0] = a.a[0] >> i;
ans.a[0] |= a.a[1] << (64 - i);
ans.a[1] = temp >> (i - m + 64);
ans.a[0] |= ((temp) & (((long long)1 << (i - m + 64)) - 1))
<< (64 - i + (m - 64));
}
}
return ans;
}
void huo(BIT &a, const BIT &b) {
a.a[0] |= b.a[0];
a.a[1] |= b.a[1];
}
void print(int deep) {
while (deep--) {
printf(" ");
}
}
BIT table[M];
long long gao(int deep, int begin, long long way) {
long long ans = 1, temp;
if (deep < 7) {
for (int i = begin; i < m; ++i) {
if (cnt[i] == 0 || (table[deep].a[0] & ((long long)1 << (i)))) continue;
table[deep + 1].a[0] = table[deep].a[0];
table[deep + 1].a[1] = table[deep].a[1];
huo(table[deep + 1], move(table[deep], i));
huo(table[deep + 1], move(table[deep], -i));
temp = gao(deep + 1, i + 1, cnt[i]);
ans += temp;
}
}
ans %= P;
return ans * way % P;
}
void print(BIT d) { printf("%llx %llx\n", d.a[0], d.a[1]); }
int main() {
while (scanf("%d%d%d", &n, &m, &t) != EOF) {
memset(cnt, 0, sizeof(cnt));
int a;
for (int i = 0; i < t; ++i) {
scanf("%d", &a);
a %= m;
cnt[min(a, m - a)]++;
}
table[0].a[0] = 1;
table[0].a[1] = 0;
cout << gao(0, 0, 1) << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
std::vector<long long> edge[100045];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, i, j, n, m, k, q, temp, x, y;
{
long long count = 0;
bool flag = 0;
long long a[200050] = {0};
string s;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
edge[x].push_back(y);
edge[y].push_back(x);
}
{
flag = true;
for (i = 1; i <= n; i++) {
if (edge[i].size() == 2) {
flag = false;
}
}
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int digits(long long a) {
if (!a) return 0;
return 1 + digits(a / 10);
}
int main() {
long long w, m, k;
cin >> w >> m >> k;
long long first = m;
while (true) {
long long last = pow(10.0, digits(m));
long long possible = m + w / (digits(m) * k);
if (possible < last) break;
long long cost = (last - m) * k * digits(m);
if (w >= cost) {
w -= cost;
m = last;
} else
break;
}
m += w / (digits(m) * k);
cout << m - first;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int m, n;
scanf("%lld %lld", &m, &n);
if (n % m != 0) {
printf("%lld\n", (n / m) + 1);
} else {
printf("%lld\n", n / m);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
constexpr int MAXN = 503;
constexpr int MOD = 1e9 + 7;
int n;
int a[MAXN][MAXN];
int dp[2][MAXN][MAXN];
int sum(const int& a, const int& b) {
int c = a + b;
if (c >= MOD) c -= MOD;
return c;
}
int prod(const int& a, const int& b) { return (1LL * a * b) % MOD; }
int modpow(const int& base, const int& exp) {
int res = 1;
int cur = base;
for (int p = 1; p <= exp; p <<= 1) {
if (exp & p) res = prod(res, cur);
cur = prod(cur, cur);
}
return res;
}
int solve(int has_edge, int start, int end) {
if (start == end) return 0;
if ((start + 1) % n == end) return 1;
if (dp[has_edge][start][end] != -1) return dp[has_edge][start][end];
int ret = 0;
for (int mid = (start + 1) % n; mid != end; mid = (mid + 1) % n) {
if (a[start][mid] and !has_edge) {
ret = sum(ret, prod(solve(0, start, mid), solve(0, mid, end)));
}
if (a[mid][end]) {
ret = sum(ret, prod(solve(1, start, mid), solve(0, mid, end)));
}
}
return dp[has_edge][start][end] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
scanf("%d", &a[i][j]);
}
}
memset(dp, -1, sizeof(dp));
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (a[i][j]) {
ans = sum(ans, prod(solve(0, i, j), solve(0, j, i)));
}
}
}
ans = prod(ans, modpow(n - 1, MOD - 2));
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int low[2 * 220];
int num[2 * 220];
vector<int> V[2 * 220];
vector<int> sv[2 * 220];
int ans[2 * 220];
int pos[2 * 220];
stack<int> st;
int cnt = 0;
int curr = 0;
void minimize(int &a, int b) {
if (a > b) a = b;
}
void dfs(int u) {
st.push(u);
cnt++;
low[u + 220] = cnt;
num[u + 220] = cnt;
for (int i = 0; i < V[u + 220].size(); i++) {
int v = V[u + 220][i];
if (pos[v + 220] != 0) continue;
if (num[v + 220] == 0) {
dfs(v);
minimize(low[u + 220], low[v + 220]);
} else
minimize(low[u + 220], num[v + 220]);
}
if (low[u + 220] == num[u + 220]) {
int v;
curr++;
do {
v = st.top();
sv[curr].push_back(v);
pos[v + 220] = curr;
st.pop();
} while (u != v);
}
}
int n, m;
void oor(int xi, int yi) {
V[-xi + 220].push_back(yi);
V[-yi + 220].push_back(xi);
}
void loadgraph() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v, c;
scanf("%d %d %d", &u, &v, &c);
if (c) {
oor(u, -v);
oor(-u, v);
} else {
oor(u, v);
oor(-u, -v);
}
}
}
void two_sat() {
for (int i = -n; i <= n; i++)
if (i != 0 && num[i + 220] == 0) dfs(i);
memset(ans, 0, sizeof ans);
for (int i = 1; i <= curr; i++)
if (ans[i] == 0) {
ans[i] = 1;
for (int j = 0; j < sv[i].size(); j++) {
int u = sv[i][j];
if (pos[u + 220] == pos[-u + 220]) {
printf("Impossible");
return;
}
ans[pos[-u + 220]] = 2;
}
}
int res = 0;
for (int i = 1; i <= n; i++)
if (ans[pos[i + 220]] == 1) res++;
printf("%d\n", res);
for (int i = 1; i <= n; i++)
if (ans[pos[i + 220]] == 1) printf("%d ", i);
}
int main() {
loadgraph();
two_sat();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, d[10005];
int mo(int a, int b) {
cout << "? " << a << ' ' << b << endl;
cout.flush();
int c;
cin >> c;
return c;
}
int main() {
cin >> n;
int mx = 1;
for (int i = 2; i <= n; i++) {
int a = mo(mx, i), b = mo(i, mx);
if (a > b) {
d[mx] = a;
mx = i;
} else
d[i] = b;
}
d[mx] = n;
cout << "! ";
cout.flush();
for (int i = 1; i <= n; i++) {
cout << d[i] << ' ';
cout.flush();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int checkLower(string op, string sw) {
if (sw == "Y") {
if (op == ">")
return 1;
else if (op == ">=")
return 0;
else
return -1;
} else {
if (op == "<")
return 0;
else if (op == "<=")
return 1;
else
return -1;
}
}
int checkUpper(string op, string sw) {
if (sw == "Y") {
if (op == "<")
return 1;
else if (op == "<=")
return 0;
else
return -1;
} else {
if (op == ">")
return 0;
else if (op == ">=")
return 1;
else
-1;
}
}
int main() {
int n;
cin >> n;
long long lowerB = -1e10, upperB = 1e10;
for (int i = 0; i < n; i++) {
string op, sw;
long long a;
cin >> op >> a >> sw;
if (checkLower(op, sw) == 1) {
if (lowerB < a + 1) lowerB = a + 1;
} else if (checkLower(op, sw) == 0) {
if (lowerB < a + 1) lowerB = a;
}
if (checkUpper(op, sw) == 1) {
if (upperB >= a - 1) upperB = a - 1;
} else if (checkUpper(op, sw) == 0) {
if (upperB >= a) upperB = a;
}
}
if (upperB >= lowerB) {
if (upperB == 1e10)
cout << lowerB << endl;
else
cout << upperB << endl;
} else
cout << "Impossible" << endl;
cerr << upperB << lowerB;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, k;
int a[N];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int now = a[i - 1] + a[i];
ans += now / k;
now %= k;
if (now > a[i] && i != n) {
ans++;
a[i] = a[i - 1] = 0;
} else {
a[i - 1] = 0;
a[i] = now;
}
if (i == n && now) ans++;
}
printf("%I64d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, q, t, k, d, lastwork[101], cnt, sum, cur;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) lastwork[i] = 0;
while (q--) {
scanf("%d%d%d", &t, &k, &d);
cnt = 0;
for (int i = 1; i <= n; ++i)
if (lastwork[i] <= t) ++cnt;
if (cnt >= k) {
sum = 0;
cur = 0;
for (int i = 1; i <= n; ++i) {
if (lastwork[i] <= t) {
lastwork[i] = t + d;
++cur;
sum += i;
if (cur == k) break;
}
}
printf("%d\n", sum);
} else
printf("-1\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long nums[300002];
long long eabs(long long num) {
if (num < 0)
return num * -1;
else
return num;
}
int main() {
long long i, j, n, ans = 0;
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d", &nums[i]);
}
sort(nums + 1, nums + n + 1);
for (i = 1; i <= n; i++) {
ans += eabs(i - nums[i]);
}
printf("%I64d", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300300;
bool matched[N];
int main() {
int tc;
scanf("%d", &tc);
while (tc--) {
int n, m;
scanf("%d %d", &n, &m);
vector<int> mcm;
memset(matched, 0, sizeof matched);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
if (matched[u] + matched[v] == 0) {
mcm.push_back(i + 1);
matched[u] = matched[v] = 1;
}
}
if (mcm.size() >= n) {
puts("Matching");
for (int i = 0; i < n; ++i) printf("%d%c", mcm[i], " \n"[i == n - 1]);
} else {
puts("IndSet");
int cn = 0;
for (int i = 1; i <= 3 * n; ++i) {
if (!matched[i]) {
printf("%d%c", i, " \n"[cn == n - 1]);
++cn;
}
if (cn == n) break;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z;
int a, b, c;
int d;
cin >> x >> y >> z;
cin >> a >> b >> c;
d = min(x, a);
x -= d;
a -= d;
d = min(y, a + b);
y -= d;
d = min(z, a + b + c - d);
z -= d;
if (x == 0 && y == 0 && z == 0) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int MAXN = 1000000;
int main() {
int n;
scanf("%d", &n);
int sqn = (int)sqrt(n);
int rem = n - sqn * sqn;
int adt = 0;
if (rem == 0)
;
else if (rem <= sqn)
adt = 2;
else
adt = 4;
printf("%d\n", 4 * sqn + adt);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e2 + 12;
int x[maxn], y[maxn], n;
double save[maxn][maxn];
int cross(int a, int b, int c) {
return (x[b] - x[a]) * (y[c] - y[a]) - (y[b] - y[a]) * (x[c] - x[a]);
}
double dis(int a, int b) {
if (save[a][b]) return save[a][b];
return save[a][b] = sqrt((y[a] - y[b]) * (y[a] - y[b]) +
(x[a] - x[b]) * (x[a] - x[b]));
}
double s(int a, int b, int c) {
double p = (dis(a, b) + dis(b, c) + dis(c, a)) / 2.0;
return sqrt(p * (p - dis(a, b)) * (p - dis(a, c)) * (p - dis(c, b)));
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", x + i, y + i);
double l = 0, r = 0, ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n;
j++, l && r ? (ans = max(ans, l + r), l = r = 0) : l = r = 0)
if (i != j)
for (int k = 0; k < n; k++)
if (i != k && j != k)
cross(i, j, k) > 0 ? l = max(l, s(i, j, k))
: r = max(r, s(i, j, k));
cout << fixed << setprecision(9) << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
int n;
char s[maxn][maxn];
int sum[maxn][maxn];
int dp[maxn][maxn][maxn][maxn];
int js(int x1, int y1, int x2, int y2) {
return sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];
}
int dfs(int x1, int y1, int x2, int y2) {
if (dp[x1][y1][x2][y2] != -1) return dp[x1][y1][x2][y2];
if (x1 == x2 && y2 == y1) {
dp[x1][y1][x2][y2] = (s[x1][y1] == '#');
return dp[x1][y1][x2][y2];
}
if (js(x1, y1, x2, y2) == 0) {
return dp[x1][y1][x2][y2] = 0;
}
dp[x1][y1][x2][y2] = max(x2 - x1 + 1, y2 - y1 + 1);
for (int i = x1; i < x2; i++)
dp[x1][y1][x2][y2] =
min(dp[x1][y1][x2][y2], dfs(x1, y1, i, y2) + dfs(i + 1, y1, x2, y2));
for (int i = y1; i < y2; i++)
dp[x1][y1][x2][y2] =
min(dp[x1][y1][x2][y2], dfs(x1, y1, x2, i) + dfs(x1, i + 1, x2, y2));
return dp[x1][y1][x2][y2];
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= n; j++)
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] +
(s[i][j] == '#' ? 1 : 0);
}
dfs(1, 1, n, n);
printf("%d\n", dp[1][1][n][n]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return (!a) ? b : gcd(b % a, a); }
long long lcm(long long x, long long y) { return x * (y / gcd(x, y)); }
void pArr(int arr[], int s) {
for (int i = 0; i < s; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
void pVec(vector<int> v) {
for (int i = 0; i < v.size(); i++) {
cout << v.at(i) << " ";
}
cout << endl;
}
bool isPrime(int x) {
if (x == 1) {
return false;
}
if (x == 2) {
return true;
}
for (int i = 2; i <= (int)(pow(x, 0.5)); i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
int vBinarySearch(vector<long long> v, int l, int r, long long x) {
while (l <= r) {
int m = l + (r - l) / 2;
if (v.at(m) == x) return m;
if (v.at(m) < x)
l = m + 1;
else
r = m - 1;
}
return r + 1;
}
int binarySearch(long long arr[], long long l, long long r, long long x) {
while (l <= r) {
int m = l + (r - l) / 2;
if (arr[m] == x) return m;
if (arr[m] < x)
l = m + 1;
else
r = m - 1;
}
return r;
}
long long nChoosek(long long n, long long k) {
if (k > n) return 0;
if (k * 2 > n) k = n - k;
if (k == 0) return 1;
int result = n;
for (int i = 2; i <= k; ++i) {
result *= (n - i + 1);
result /= i;
}
return result;
}
long long raiseto(long long a, long long b) {
long long m = 1;
for (int i = 0; i < b; i++) {
m *= a;
}
return m;
}
const int mod = 1e9 + 7;
void solve() {
long long n, x, y;
cin >> n >> x >> y;
string s;
cin >> s;
vector<long long> v;
v.push_back(-1);
for (int i = 0; i < s.length(); i++) {
if (s.at(i) == '1') {
v.push_back(i);
}
}
v.push_back(s.length());
long long seg = 0;
for (int i = 1; i < v.size(); i++) {
if (v[i] - v[i - 1] > 1) {
seg++;
}
}
if (seg == 0) {
cout << 0 << endl;
return;
}
if (x >= y) {
cout << seg * y << endl;
} else {
cout << (seg - 1) * x + y << endl;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n;
int x = 0, y = (1 << 10) - 1;
for (int i = 1; i <= n; i++) {
char op[3];
cin >> op >> t;
if (*op == '&') x &= t, y &= t;
if (*op == '|') x |= t, y |= t;
if (*op == '^') x ^= t, y ^= t;
}
int a = 0, b = 0, c = (1 << 10) - 1;
for (int i = 0; i < 10; i++) {
int x1 = (1 << i) & x;
int x2 = (1 << i) & y;
if (!x1 && x2) continue;
if (!x1 && !x2) c -= 1 << i;
if (x1 && x2) a += 1 << i;
if (x1 && !x2) b += 1 << i;
}
cout << 3 << endl;
cout << '&' << ' ' << c << endl;
cout << '|' << ' ' << a << endl;
cout << '^' << ' ' << b << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int diru[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dirv[] = {-1, 0, 1, -1, 1, -1, 0, 1};
using namespace std;
template <class T>
T sq(T n) {
return n * n;
}
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
bool inside(T a, T b, T c) {
return a <= b && b <= c;
}
template <class T>
void setmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void setmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
T power(T N, T P) {
return (P == 0) ? 1 : N * power(N, P - 1);
}
string in[1010];
string ans[1010];
int P[1010];
char nm[100000];
int p;
map<string, int> M;
string A;
int main() {
int n, T, t = 1, m, i, j, k, bet, wor;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s%d", nm, &p);
A = nm;
M[A] = max(M[A], p);
}
n = 0;
for (__typeof((M).begin()) it = (M).begin(); it != (M).end(); ++it) {
in[n] = it->first;
P[n++] = it->second;
}
for (i = 0; i < n; i++) {
int bet = 0;
for (j = 0; j < n; j++) {
if (P[j] > P[i]) bet++;
}
wor = n - bet;
if (n * 50 < bet * 100) {
ans[i] = "noob";
continue;
}
if (n * 50 <= wor * 100 && n * 20 < bet * 100) {
ans[i] = "random";
continue;
}
if (n * 80 <= wor * 100 && n * 10 < bet * 100) {
ans[i] = "average";
continue;
}
if (n * 90 <= wor * 100 && n * 1 < bet * 100) {
ans[i] = "hardcore";
continue;
}
if (n * 99 <= wor * 100) {
ans[i] = "pro";
}
}
printf("%d\n", n);
for (i = 0; i < n; i++) {
printf("%s %s\n", in[i].c_str(), ans[i].c_str());
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void pass() { return; }
mt19937 rnd(rand());
const int MOD = 1e9 + 7;
const long long BIG_MOD = 1e18 + 7;
const int MAXN = 1e5 + 7;
const int q1 = 501;
const int q2 = 997;
signed main() {
cout.precision(20);
int n, s, first;
cin >> n >> s >> first;
fflush(stdout);
int num = s;
int val, next;
for (int i = 0; i < q1; ++i) {
if (num == -1) {
break;
}
cout << "? " << num << endl;
fflush(stdout);
cin >> val >> next;
if (val >= first) {
cout << "! " << val << endl;
fflush(stdout);
return 0;
}
num = next;
}
int mx_ind = -1;
int mx_val = -MOD;
for (int i = 0; i < q2; ++i) {
num = (rnd() % n) + 1;
cout << "? " << num << endl;
fflush(stdout);
cin >> val >> next;
if (val < first && val > mx_val) {
mx_val = val;
mx_ind = num;
}
}
num = mx_ind;
for (int i = 0; i < q1; ++i) {
if (num == -1) {
break;
}
cout << "? " << num << endl;
fflush(stdout);
cin >> val >> next;
if (val >= first) {
cout << "! " << val << endl;
fflush(stdout);
return 0;
}
num = next;
}
cout << "! -1" << endl;
fflush(stdout);
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.