solution
stringlengths 53
181k
| difficulty
int64 0
27
|
---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
if (s.size() == 1)
cout << s << '\n';
else {
string t = s;
for (int i = 1; i < t.size(); ++i) {
t[i] = '9';
}
if (t > s)
--t[0];
else {
cout << t << '\n';
return 0;
}
string p = t;
++p[0];
--p[1];
if (p <= s) {
string y = p;
for (int i = 2; i < p.size(); ++i) {
swap(y[i], y[i - 1]);
if (y <= s) {
p = y;
} else {
i = 100;
}
}
cout << p << '\n';
} else {
if (t[0] == '0') {
for (int i = 1; i < t.size(); ++i) {
cout << t[i];
}
cout << '\n';
} else {
for (int i = 0; i < t.size(); ++i) {
cout << t[i];
}
cout << '\n';
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const long long mod = 1e9 + 7, INF = 1 << 30;
long long n, r, avg, tl = 0, res = 0;
vector<pair<long long, long long> > a;
void init(void) {
scanf("%I64d%I64d%I64d", &n, &r, &avg);
for (int i = 1; i <= n; i++) {
pair<long long, long long> x;
scanf("%I64d%I64d", &x.second, &x.first);
tl += x.second;
a.push_back(x);
}
sort(a.begin(), a.end());
}
void process(void) {
long long it = 0, tar = avg * n;
while (tl < tar) {
if (a[it].second < r) {
long long b = min(tar - tl, r - a[it].second);
tl += b;
a[it].second += b;
res += a[it].first * b;
}
it++;
}
printf("%I64d", res);
}
int main(void) {
init();
process();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(long long a, long long b) { return (a > b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, i, j, a, b, c, d;
cin >> n;
vector<long long> v(n), v1(n);
set<long long int> s, s1;
for (long long int i = 0; i < n; i++) cin >> v[i];
v1[0] = v[0];
a = v[0];
for (i = 1; i < n; i++) {
a = a ^ v[i];
v1[i] = a;
}
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
s.insert(v1[i]);
} else {
s1.insert(v1[i]);
}
}
map<long long, long long> k, k1;
for (auto it = s.begin(); it != s.end(); it++) {
k.insert({*it, 0});
}
for (auto it = s1.begin(); it != s1.end(); it++) {
k1.insert({*it, 0});
}
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
k[v1[i]]++;
} else {
k1[v1[i]]++;
}
}
a = 0;
for (auto it = k.begin(); it != k.end(); it++) {
b = it->second;
a += (b * (b - 1)) / 2;
}
for (auto it = k1.begin(); it != k1.end(); it++) {
b = it->second;
if (it->first == 0) {
a += it->second;
}
a += (b * (b - 1)) / 2;
}
cout << a;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int main() {
int n, k, x, ans = 0;
scanf("%d%d%d", &n, &k, &x);
for (int i = 1; i <= n; i++) {
int xx;
scanf("%d", &xx);
if (i <= n - k) ans += xx;
}
printf("%d\n", ans + k * x);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <class T>
void pvp(T a, T b) {
for (T i = a; i != b; ++i)
cout << "(" << i->first << ", " << i->second << ") ";
cout << endl;
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
int in_c() {
int c;
for (; (c = getchar()) <= ' ';) {
if (!~c) throw ~0;
}
return c;
}
int in() {
int x = 0, c;
for (; (unsigned)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -in();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned)((c = getchar()) - '0') < 10);
return x;
}
long long In() {
long long x = 0, c;
for (; (unsigned)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -In();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned)((c = getchar()) - '0') < 10);
return x;
}
void Out(long long x) {
if (x >= 10) Out(x / 10);
putchar('0' + x % 10);
}
long long N;
int Q;
long long MO;
long long mul(long long a, long long b) {
a %= MO;
b %= MO;
return a * b % MO;
}
long long mulDiv2(long long a, long long b) {
a %= MO;
b %= MO;
if (a % 2 == 0)
a /= 2;
else
b /= 2;
return a * b % MO;
}
long long calc(long long u, long long p, long long m) {
chmin(u, N);
if (u < p) return 0;
long long k = (u - p) / m;
return (mul(mulDiv2(k, k + 1), m) + mul(k + 1, p)) % MO;
}
long long calc(long long u, long long v, long long p, long long m) {
long long ret = 0;
ret += calc(v, p, m);
ret -= calc(u - 1, p, m);
ret %= MO;
return ret;
}
long long solve(long long l, long long r, long long u, long long v, long long a,
long long b, long long p, long long m) {
chmax(l, a);
chmin(r, b);
if (l > r) return 0;
long long ret = 0;
if (l == a && r == b) {
ret += calc(u, v, p, m);
} else {
long long odd = (b - a + 1 + 1) / 2;
ret += solve(l, r, u, v, a, a + odd - 1, p, m * 2);
ret += solve(l, r, u, v, a + odd, b, p + m, m * 2);
}
ret %= MO;
return ret;
}
int main() {
int q;
long long l, r, u, v;
for (; cin >> N >> Q >> MO;) {
for (q = 0; q < Q; ++q) {
l = In();
r = In();
u = In();
v = In();
long long res = solve(l, r, u, v, 1, N, 1, 1);
res %= MO;
res += MO;
res %= MO;
Out(res);
puts("");
}
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, a;
cin >> n;
char s[101];
int len;
for (i = 0; i < n; i++) {
cin >> s;
len = strlen(s);
if (len > 10) {
cout << s[0] << len - 2 << s + (len - 1) << "\n";
} else {
cout << s << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
inline void read(long long *a, long long n) {
for (long long i = 0; i < n; i++) a[i] = in();
}
inline void readL(long long *a, long long n) {
for (long long i = 0; i < n; i++) a[i] = lin();
}
const long long maxn = 2e6 + 10;
const long long mod = 1e9 + 7;
const long long MAX_VAL = 1e18 + 10;
const long long MAGIC = 350;
map<char, bool> mp = {{'I', true}, {'E', true}, {'A', true},
{'O', true}, {'U', true}, {'Y', true}};
long long dp0[maxn], dp[maxn];
int32_t main() {
string s;
cin >> s;
long long n = (long long)s.size();
for (long long i = 0; i < n; i++) {
if (!mp[s[i]]) continue;
long long left = i, right = n - 1 - left;
long long firstBeg = 1, lastBeg = left + firstBeg;
long long firstEn = right + 1, lastEn = left + firstEn;
dp0[firstBeg]++;
dp0[lastBeg + 1]--;
dp0[firstEn + 1]--;
dp0[lastEn + 2]++;
}
for (long long i = 1; i < maxn; i++) dp0[i] += dp0[i - 1];
for (long long i = 0; i < maxn; i++) dp[i] = dp0[i];
for (long long i = 1; i < maxn; i++) dp[i] += dp[i - 1];
double res = 0;
for (long long i = 1; i < maxn; i++) {
res += (double)1.0 / i * dp[i];
}
cout << fixed << setprecision(10) << res << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long a[1001][1001];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
}
}
long long t = a[1][2] * a[1][3] / a[2][3];
t = sqrt(t);
cout << t << ' ';
for (int i = 2; i <= n; i++) cout << a[1][i] / t << ' ';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<string> arr;
vector<string> arr_res;
arr_res.resize(n);
arr.resize(n);
for (int i = 0; i < n; i++) {
string s;
cin >> s;
arr[i] = s;
arr_res[i] = s;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < m; k++) {
if (arr[i][k] == arr[i][j] && k != j) {
arr_res[i][k] = '@';
arr_res[i][j] = '@';
}
}
for (int l = 0; l < n; l++) {
if (arr[l][j] == arr[i][j] && l != i) {
arr_res[l][j] = '@';
arr_res[i][j] = '@';
}
}
}
}
string res = "";
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr_res[i][j] != '@') {
res = res + arr_res[i][j];
}
}
}
cout << res;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s, s1;
long long dp[105][5];
int n;
void calc() {
memset(dp, 0, sizeof(dp));
if (s[0] != s[1]) {
dp[0][0] = 1, dp[0][2] = 1;
} else
dp[0][0] = 1;
for (int i = 1; i < (int)s.size(); i++) {
if (s[i] == 'A') {
if (s[i - 1] == 'B')
dp[i][0] = dp[i - 1][0], dp[i][1] = dp[i - 1][2];
else
dp[i][0] = dp[i - 1][0] + dp[i - 1][1];
} else {
if (s[i - 1] == 'A') {
if (i + 1 < n && s[i + 1] == 'A')
dp[i][2] = dp[i - 1][0] + dp[i - 1][1];
dp[i][0] = dp[i - 1][1];
} else {
if (i + 1 < n && s[i + 1] == 'A') dp[i][2] = dp[i - 1][0];
dp[i][0] = dp[i - 1][0];
}
}
}
}
int main() {
cin >> s;
s1 = s;
for (int i = 0; i < (int)s.size(); i++) s1 += s[i];
bool flag = 0;
n = (int)s.size();
for (int i = 0; i < n; i++)
if (s1[i] == 'B') {
flag = 1;
s = "";
for (int j = i; j < i + n; j++) s += s1[j];
break;
}
if (!flag) {
printf("1\n");
return 0;
}
calc();
long long ans = 0;
if (s[n - 1] == 'B')
ans = dp[n - 1][0];
else
ans = dp[n - 1][0] + dp[n - 1][1];
if (s[n - 1] == 'A') {
s1 = s;
s = "";
for (int i = 1; i < (int)s1.size() - 1; i++) s += s[i];
n = s.size();
calc();
if (s[n - 1] == 'B')
ans -= dp[n - 1][0];
else
ans -= dp[n - 1][0] + dp[n - 1][1];
}
printf("%lld\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct candy {
int v, u;
} c[100100];
int n, m, temp;
int x, y, z, p;
int main() {
scanf("%d %d %d %d %d %d", &n, &m, &x, &y, &z, &p);
for (int i = 1; i <= p; i++) scanf("%d %d", &c[i].v, &c[i].u);
x %= 4;
y %= 2;
z %= 4;
switch (x) {
case 1:
for (int i = 1; i <= p; i++) {
temp = c[i].v;
c[i].v = c[i].u;
c[i].u = n - temp + 1;
}
temp = m;
m = n;
n = temp;
break;
case 2:
for (int i = 1; i <= p; i++) {
c[i].v = n - c[i].v + 1;
c[i].u = m - c[i].u + 1;
}
break;
case 3:
for (int i = 1; i <= p; i++) {
temp = c[i].v;
c[i].v = m - c[i].u + 1;
c[i].u = temp;
}
temp = m;
m = n;
n = temp;
break;
}
switch (y) {
case 1:
for (int i = 1; i <= p; i++) c[i].u = m - c[i].u + 1;
}
switch (z) {
case 1:
for (int i = 1; i <= p; i++) {
temp = c[i].v;
c[i].v = m - c[i].u + 1;
c[i].u = temp;
}
break;
case 2:
for (int i = 1; i <= p; i++) {
c[i].v = n - c[i].v + 1;
c[i].u = m - c[i].u + 1;
}
break;
case 3:
for (int i = 1; i <= p; i++) {
temp = c[i].v;
c[i].v = c[i].u;
c[i].u = n - temp + 1;
}
break;
}
for (int i = 1; i <= p; i++) printf("%d %d\n", c[i].v, c[i].u);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, b, k, x;
long long mod = 1000000007;
long long mul(long long a, long long b) {
a = a % mod;
b = b % mod;
return a * b % mod;
}
long long add(long long a, long long b) { return (a + b) % mod; }
vector<vector<long long> > t;
vector<vector<long long> > mat_mul(vector<vector<long long> > a,
vector<vector<long long> > b) {
long long m = (long long)a.size();
long long r = (long long)b.size();
long long n = (long long)b[0].size();
vector<vector<long long> > re(m, vector<long long>(n, 0));
for (long long i = 0; i < m; i++) {
for (long long j = 0; j < n; j++) {
for (long long k = 0; k < r; k++) {
re[i][j] = add(re[i][j], mul(a[i][k], b[k][j]));
}
}
}
return re;
}
vector<vector<long long> > mat_pow(vector<vector<long long> > a,
long long pow) {
if (pow == 0LL) {
long long l = (long long)a.size();
vector<vector<long long> > re(l, vector<long long>(l, 0));
for (long long i = 0; i < l; i++) {
re[i][i] = 1;
}
return re;
}
vector<vector<long long> > temp = mat_pow(a, pow / 2);
vector<vector<long long> > re = mat_mul(temp, temp);
if (pow % 2) {
re = mat_mul(re, a);
}
return re;
}
int main() {
vector<long long> a(10, 0);
cin >> n >> b >> k >> x;
for (int i = 0; i < n; i++) {
int y;
scanf("%d", &y);
a[y]++;
}
t.assign(x, vector<long long>(x, 0));
for (long long i = 0; i < x; i++) {
for (long long j = 1; j <= 9; j++) {
t[i][(i * 10 + j) % x] += a[j];
}
}
vector<vector<long long> > re = mat_pow(t, b - 1);
vector<vector<long long> > dp(1, vector<long long>(x, 0));
for (long long i = 1; i <= 9; i++) {
dp[0][i % x] += a[i];
}
dp = mat_mul(dp, re);
cout << dp[0][k] << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
const double eps = (1e-5);
using namespace std;
int dcmp(long double a, long double b) {
return fabsl(a - b) <= eps ? 0 : (a > b) ? 1 : -1;
}
int getBit(int num, int idx) { return ((num >> idx) & 1) == 1; }
int setBit1(int num, int idx) { return num | (1 << idx); }
long long setBit0(long long num, int idx) { return num & ~(1ll << idx); }
long long flipBit(long long num, int idx) { return num ^ (1ll << idx); }
void M() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int countNumBit1(int mask) {
int ret = 0;
while (mask) {
mask &= (mask - 1);
++ret;
}
return ret;
}
int main() {
int n, m, x1, x2, y1, y2;
cin >> n >> m >> x1 >> y1 >> x2 >> y2;
int dx = abs(x2 - x1);
int dy = abs(y2 - y1);
bool ok = ((dx == 0 || dx == 1 || dx == 2) && dy <= 4) ||
((dy == 0 || dy == 1 || dy == 2) && dx <= 4) ||
(dx == 3 && dy <= 3) || (dy == 3 && dx <= 3);
if (ok)
cout << "First";
else
cout << "Second";
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2100;
int n, N, K, B[maxn], An[maxn];
char T[maxn], *A[maxn];
struct Tpair {
int x, y;
Tpair(int _x = 0, int _y = 0) { x = _x, y = _y; }
inline bool operator<(const Tpair &b) const {
return x != b.x ? x < b.x : y < b.y;
}
inline bool operator!=(const Tpair &b) const { return x != b.x || y != b.y; }
};
namespace Ninit {
char buf[1100000];
void init() {
int i;
scanf("%d", &K);
for (A[0] = buf, i = 1; i <= K; ++i) {
A[i] = A[i - 1] + An[i - 1] + 1;
scanf("%s", A[i]), An[i] = strlen(A[i]);
}
scanf("%d", &N);
for (i = 0; i < N; ++i) scanf("%d", B + i);
scanf("%s", T + 1), n = strlen(T + 1);
}
} // namespace Ninit
namespace Nsolve {
int ans;
int *G[26][maxn];
Tpair Gp[26][maxn];
namespace Nprep {
int buf[27000000];
void solve() {
int ni, i, j, k;
Tpair u;
for (G[25][0] = buf, i = 1; i <= K; ++i) {
G[0][i] = G[25][i - 1] + An[i - 1] + 1;
for (ni = An[i], k = 1; k < 26; ++k) G[k][i] = G[k - 1][i] + ni + 1;
}
for (i = 1; i <= K; ++i) {
ni = An[i];
for (k = 0; k < 26; ++k) {
for (G[k][i][ni] = ni, j = ni - 1; j >= 0; --j)
A[i][j] == k + 'a' ? G[k][i][j] = j : G[k][i][j] = G[k][i][j + 1];
}
}
for (k = 0; k < 26; ++k) {
Gp[k][N] = Tpair(N, 0);
for (i = 0; i < N; ++i) {
u = Tpair(i, G[k][B[i]][0]);
for (; u.x < N && u.y == An[B[u.x]];)
++u.x, u.x < N ? u.y = G[k][B[u.x]][0] : 0;
Gp[k][i] = u;
}
}
}
} // namespace Nprep
namespace Nlcs {
Tpair F[maxn][maxn];
Tpair next(Tpair x, int c) {
if (x.x == N) return x;
int p = G[c][B[x.x]][x.y + 1];
return p < An[B[x.x]] ? Tpair(x.x, p) : Gp[c][x.x + 1];
}
void solve() {
int i, j, k;
ans = 0;
for (i = 1; i <= n; ++i) F[1][i] = Gp[T[i] - 'a'][0];
for (i = 1; i <= n; ++i)
if (F[1][i].x < N) break;
if (i > n) return;
for (k = 2; k <= n; ++k) {
for (i = 1; i <= n; ++i) {
F[k][i] = Tpair(N, 0);
for (j = i - 1; j > 0 && T[i] != T[j]; --j)
F[k][i] = min(F[k][i], next(F[k - 1][j], T[i] - 'a'));
if (!j) continue;
F[k][i] = min(F[k][i], next(F[k - 1][j], T[i] - 'a'));
F[k][i] = min(F[k][i], F[k][j]);
}
for (i = k; i <= n; ++i)
if (F[k][i].x < N) break;
if (i > n) break;
}
ans = k - 1;
}
} // namespace Nlcs
void solve() {
Nprep::solve();
Nlcs::solve();
cout << ans << endl;
}
} // namespace Nsolve
int main() {
Ninit::init();
Nsolve::solve();
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
long long n;
cin >> n;
bool found = 0;
string arr[n + 1];
for (long long i = 1; i <= n; i++) {
cin >> arr[i];
if (arr[i] == s) {
found = 1;
}
}
if (found == 1) {
cout << "YES\n";
} else {
long long counter1 = 0, counter2 = 0;
long long found1 = 0, found2 = 0;
for (long long i = 1; i <= n; i++) {
if (arr[i][0] == s[1]) {
found2 = i;
counter2++;
}
if (arr[i][1] == s[0]) {
counter1++;
found1 = i;
}
}
if (counter1 > 0 && counter2 > 0) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
vector<int> a(n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a.begin(), a.end());
int ans;
if (k == 0) {
ans = a[0] - 1;
} else {
ans = a[k - 1];
}
int cnt = 0;
for (int i = 0; i < n; ++i)
if (a[i] <= ans) ++cnt;
if (cnt != k || !(1 <= ans && ans <= 1000 * 1000 * 1000)) {
puts("-1");
return 0;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const int N = 1e5 + 5;
const int M = 105;
int n, m, check[N], nex[N];
int dp[N], minn[N], st[4 * N], st1[4 * N];
pair<int, int> ant[M];
void update(int id, int l, int r, int i, int val) {
if (l > i || r < i) {
return;
}
if (l == r) {
st[id] = val;
return;
}
int mid = (l + r) >> 1;
update(id << 1, l, mid, i, val);
update(id << 1 | 1, mid + 1, r, i, val);
st[id] = min(st[id << 1], st[id << 1 | 1]);
}
int get(int id, int l, int r, int i, int j) {
if (l > j || r < i || i > j) {
return 1e9;
}
if (l >= i && r <= j) {
return st[id];
}
int mid = (l + r) >> 1;
return min(get(id << 1, l, mid, i, j), get(id << 1 | 1, mid + 1, r, i, j));
}
void update1(int id, int l, int r, int i, int val) {
if (l > i || r < i) {
return;
}
if (l == r) {
st1[id] = val;
return;
}
int mid = (l + r) >> 1;
update1(id << 1, l, mid, i, val);
update1(id << 1 | 1, mid + 1, r, i, val);
st1[id] = min(st1[id << 1], st1[id << 1 | 1]);
}
int get1(int id, int l, int r, int i, int j) {
if (l > j || r < i || i > j) {
return 1e9;
}
if (l >= i && r <= j) {
return st1[id];
}
int mid = (l + r) >> 1;
return min(get1(id << 1, l, mid, i, j), get1(id << 1 | 1, mid + 1, r, i, j));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> ant[i].first >> ant[i].second;
for (int j = max(1, ant[i].first - ant[i].second);
j <= min(m, ant[i].first + ant[i].second); j++) {
check[j] = 1;
}
}
sort(ant + 1, ant + 1 + n);
for (int i = 1; i <= 4 * m; i++) st[i] = st1[i] = 1e9;
for (int i = 1; i <= m; i++) dp[i] = 1e9;
update(1, 0, m, 0, 0);
update1(1, 0, m, 0, -1);
int luu = 0;
for (int i = 1; i <= m; i++) {
if (check[i] == 1) dp[i] = luu;
for (int j = 1; j <= n; j++) {
if (ant[j].first + ant[j].second <= i) {
int val = i - ant[j].first - ant[j].second,
lef = max(1, ant[j].first - ant[j].second - val);
int L = max(1, ant[j].first - ant[j].second);
dp[i] = min(dp[i], get(1, 0, m, lef - 1, i - 1) + val);
if (lef > 1) {
dp[i] = min(dp[i], get1(1, 0, m, 0, lef - 1) + L);
}
}
}
update(1, 0, m, i, dp[i]);
update1(1, 0, m, i, dp[i] - i - 1);
if (check[i] == 0) luu = dp[i];
}
cout << dp[m];
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return ((power(x, y / 2)) * (power(x, y / 2)));
else
return (((x * (power(x, y / 2)))) * (power(x, y / 2)));
}
long long ceiling(long long d, long long x) {
long long res = d / x;
if (d % x != 0) res++;
return res;
}
bool powerOfx(long long n, long long x) {
long long count = 0;
while (n % x == 0) {
n /= x;
count++;
}
if (n == 1) return true;
return false;
}
long long maxArr(long long arr[], long long n) {
long long max = arr[0];
for (long long i = 0; i < n; i++) {
if (max < arr[i]) max = arr[i];
}
return max;
}
long long minArr(long long arr[], long long n) {
long long min = arr[0];
for (long long i = 0; i < n; i++) {
if (min > arr[i]) min = arr[i];
}
return min;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long pal(string s, long long l, long long r) {
if (l > r)
return 0;
else if (l == r)
return 1;
else if (s[l] == s[r])
return 2 + pal(s, l + 1, r - 1);
else
return max(pal(s, l, r - 1), pal(s, l + 1, r));
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
map<long long, long long> m;
vector<long long> c;
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (m[a[i]] == 0) c.push_back(a[i]);
m[a[i]]++;
}
long long max = 0;
long long count = 0;
for (long long i = 0; i < c.size(); i++) {
if (m[c[i]] > max) {
max = m[c[i]];
count = 1;
} else if (m[c[i]] == max) {
count++;
}
}
long long res = (n - count * max) / (max - 1) + count - 1;
cout << res << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int dp[55][55][55][55];
int n, m;
int s;
vector<pair<int, int> > nei[55];
int cnt[55];
int dist[55][55];
int CountCriminals(int now, int lst) {
int sum = cnt[now];
for (auto i : nei[now]) {
if (i.first != lst) {
sum += CountCriminals(i.first, now);
}
}
return sum;
}
int dfsdp(int s, int t, int all, int rem) {
int &ans = dp[s][t][all][rem];
if (ans != -1) {
return ans;
}
if (!rem) {
return ans = 0;
}
if (nei[t].size() == 1) {
return ans = (dfsdp(t, s, rem - all, rem - all) + nei[t][0].second);
}
int DP[55];
memset(DP, 0, sizeof(DP));
DP[0] = 0x3f3f3f3f;
for (auto i : nei[t]) {
if (i.first != s) {
for (int j = all; j >= 1; j--) {
for (int k = 1; k <= j; k++) {
DP[j] = max(DP[j],
min(DP[j - k], dfsdp(t, i.first, k, rem) + dist[s][t]));
}
}
}
}
return ans = DP[all];
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
nei[a].emplace_back(b, c);
nei[b].emplace_back(a, c);
dist[a][b] = dist[b][a] = c;
}
scanf("%d%d", &s, &m);
for (int i = 0; i < m; i++) {
int xx;
scanf("%d", &xx);
cnt[xx]++;
}
int ans = 0x3f3f3f3f;
memset((int *)dp, -1, sizeof(dp));
for (auto i : nei[s]) {
int all = CountCriminals(i.first, s);
ans = min(ans, dfsdp(s, i.first, all, m));
}
printf("%d\n", ans);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long q, c, m, x;
cin >> q;
while (q--) {
cin >> c >> m >> x;
long long tmp = min(min(m, c), x), res = tmp;
c -= tmp;
m -= tmp;
if (c == 0 || m == 0)
cout << res << "\n";
else {
tmp = min(c, min(m, (c + m) / 3));
cout << res + tmp << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int p[N], l[N], st[N], en[N], t, lvl[N];
vector<int> adj[N];
void dfs(int u, int P) {
p[u] = P;
lvl[u] = lvl[P] + 1;
st[u] = ++t;
for (int v : adj[u])
if (v != P) {
dfs(v, u);
}
en[u] = ++t;
}
int chk(int a, int b) { return st[a] <= st[b] && en[b] <= en[a]; }
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 1);
for (int i = 1; i <= m; i++) {
int k;
cin >> k;
vector<int> l(k);
for (int &x : l) cin >> x, x = p[x];
sort(l.begin(), l.end(), [](int x, int y) { return lvl[x] < lvl[y]; });
int f = 1;
for (int i = 1; i < k; i++) {
f &= chk(l[i - 1], l[i]);
}
cout << (f ? "YES" : "NO") << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
long long cnt = 1, lnt = 2;
while (true) {
a -= cnt;
cnt += 2;
if (a < 0) {
cout << "Vladik";
break;
}
b -= lnt;
lnt += 2;
if (b < 0) {
cout << "Valera";
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
constexpr int64_t inf = numeric_limits<int64_t>::max() / 2;
int64_t truncAdd(int64_t a, int64_t b) {
int64_t c = a + b;
if (c > inf) {
c = inf;
}
return c;
}
struct PWL {
int64_t slopeStarts[6];
int64_t yIntercept;
friend ostream& operator<<(ostream& o, PWL& f);
void insertSlope(int s, int64_t len) {
for (s++; s < 6; s++) {
slopeStarts[s] = truncAdd(slopeStarts[s], len);
}
}
void shift(int64_t amt) {
for (int s = 0; s < 6; s++) {
slopeStarts[s] += amt;
}
int64_t y = yIntercept;
for (int s = 1; s < 6; s++) {
if (s == 5 || slopeStarts[s + 1] > 0) {
y += (-slopeStarts[s]) * s;
break;
}
y += (slopeStarts[s + 1] - slopeStarts[s]) * s;
}
yIntercept = y;
for (int s = 1; s < 6; s++) {
if (slopeStarts[s] < 0) slopeStarts[s] = 0;
}
}
PWL() : slopeStarts{0, 0, 0, 0, 0, 0}, yIntercept(0) {}
};
void advance(PWL& f, char t, int64_t len) {
if (t == 'G' || t == 'W') {
int c = (t == 'G' ? 4 : 2);
f.insertSlope(c / 2, len * 2);
c++;
f.insertSlope(c, inf);
}
f.shift(-len);
f.yIntercept += len;
}
int main() {
int n;
cin >> n;
vector<int64_t> lens(n);
for (int i = 0; i < n; i++) {
cin >> lens[i];
}
string terrains;
cin >> terrains;
PWL f;
for (int i = 0; i < n; i++) {
advance(f, terrains[i], lens[i]);
}
cout << f.yIntercept << endl;
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
string a, b, c;
int len1, len2, len3, nu1 = 0, nu2 = 0, nu = 0;
unsigned long long h1[2005], h2[2005], b1[2005], b2[2005], h[4000005];
int lo1[2005], lo2[2005];
void pre() {
b1[0] = b2[0] = 1;
for (int i = 1; i < 2005; i++) {
b1[i] = 19760817 * b1[i - 1];
b2[i] = 1610612741 * b2[i - 1];
}
}
void gethash(string s, int n) {
for (int i = 1; i <= n; i++) {
h1[i] = h1[i - 1] * 19760817 + s[i - 1] - 'a' + 1;
h2[i] = h2[i - 1] * 1610612741 + s[i - 1] - 'a' + 1;
}
}
unsigned long long get1(int l, int r) {
return h1[r] - h1[l - 1] * b1[r - l + 1];
}
unsigned long long get2(int l, int r) {
return h2[r] - h2[l - 1] * b2[r - l + 1];
}
int main() {
pre();
unsigned long long hashb1, hashb2, hashc1, hashc2;
cin >> a >> b >> c;
len1 = a.length();
len2 = b.length();
len3 = c.length();
gethash(b, len2);
hashb1 = h1[len2], hashb2 = h2[len2];
gethash(c, len3);
hashc1 = h1[len3], hashc2 = h2[len3];
gethash(a, len1);
for (int i = 1; i <= len1 - len2 + 1; i++) {
if (get1(i, i + len2 - 1) == hashb1 && get2(i, i + len2 - 1) == hashb2)
lo1[nu1++] = i;
}
for (int i = 1; i <= len1 - len3 + 1; i++) {
if (get1(i, i + len3 - 1) == hashc1 && get2(i, i + len3 - 1) == hashc2)
lo2[nu2++] = i;
}
for (int i = 0; i < nu1; i++)
for (int j = 0; j < nu2; j++) {
if (lo2[j] >= lo1[i] && lo2[j] + len3 >= lo1[i] + len2)
h[nu++] = get2(lo1[i], lo2[j] + len3 - 1);
}
if (nu == 0) {
cout << "0" << endl;
return 0;
}
sort(h, h + nu);
int ans = 1;
for (int i = 0; i < nu - 1; i++) {
if (h[i] != h[i + 1]) ans++;
}
cout << ans << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
scanf("%I64d%I64d", &n, &m);
long long sol = max(0LL, n - m * 2);
printf("%I64d ", sol);
for (int i = 0; i <= n; i++)
if (1LL * i * (i - 1) / 2 >= m) {
printf("%d", n - i);
break;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long const mod = 1e9 + 7;
long long power(long long x, long long y, long long mod = 2e18) {
long long ans = 1;
x %= mod;
while (y) {
if (y & 1) ans = (x * ans) % mod;
x = (x * x) % mod;
y >>= 1;
}
return ans;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
if (m % n) {
cout << -1;
return 0;
}
m /= n;
long long ct = 0;
while (m % 2 == 0) {
m /= 2;
ct++;
}
while (m % 3 == 0) {
m /= 3;
ct++;
}
if (m != 1) {
cout << -1;
return 0;
}
cout << ct << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 1ll << 60;
const double PI = acos(-1.0);
const int maxn = 100500;
int a[maxn], b[maxn];
int pos[maxn];
int n, m, d, k;
long long x;
int getNextX() {
x = (x * 37 + 10007) % 1000000007;
return x;
}
void initAB() {
for (int i = 0; i < n; i++) a[i] = i + 1;
for (int i = 0; i < n; i++) swap(a[i], a[getNextX() % (i + 1)]);
for (int i = 0; i < n; i++)
if (i < d)
b[i] = 1;
else
b[i] = 0;
for (int i = 0; i < n; i++) swap(b[i], b[getNextX() % (i + 1)]);
}
int main() {
while (~scanf("%d%d%I64d", &n, &d, &x)) {
vector<int> z;
initAB();
for (int i = 0; i < n; i++) pos[a[i]] = i;
for (int i = 0; i < n; i++)
if (b[i]) z.push_back(i);
int s = 30;
for (int i = 0; i < n; i++) {
int j;
for (j = n; j >= n - s + 1 && j > 0; j--) {
if (pos[j] <= i && b[i - pos[j]] == 1) {
printf("%d\n", j);
break;
}
}
if (!j || j < n - s + 1) {
int mx = 0;
for (int k = 0; k < z.size() && z[k] <= i; k++)
mx = max(mx, a[i - z[k]]);
printf("%d\n", mx);
}
}
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char s[100][105];
int d[100][100][11], p[100][100][11], pq[100][100][11];
string ans;
int main() {
scanf("%d%d%d", &n, &m, &k), ++k;
for (int i = 0; i < (int)(n); ++i) scanf("%s", s[i]);
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(m); ++j)
for (int q = 0; q < (int)(k); ++q) d[i][j][q] = -1;
for (int i = 0; i < (int)(m); ++i)
d[n - 1][i][(s[n - 1][i] - '0') % k] = s[n - 1][i] - '0';
for (int i = n - 1; i > 0; --i) {
for (int j = 0; j < (int)(m - 1); ++j)
for (int q = 0; q < (int)(k); ++q)
if (d[i][j][q] != -1) {
int cnt = d[i][j][q] + s[i - 1][j + 1] - '0';
int mo = cnt % k;
if (d[i - 1][j + 1][mo] < cnt) {
d[i - 1][j + 1][mo] = cnt;
p[i - 1][j + 1][mo] = 0;
pq[i - 1][j + 1][mo] = q;
}
}
for (int j = 1; j < m; ++j)
for (int q = 0; q < (int)(k); ++q)
if (d[i][j][q] != -1) {
int cnt = d[i][j][q] + s[i - 1][j - 1] - '0';
int mo = cnt % k;
if (d[i - 1][j - 1][mo] < cnt) {
d[i - 1][j - 1][mo] = cnt;
p[i - 1][j - 1][mo] = 1;
pq[i - 1][j - 1][mo] = q;
}
}
}
int best = 0;
for (int i = 1; i < m; ++i)
if (d[0][i][0] > d[0][best][0]) {
best = i;
}
if (d[0][best][0] == -1) {
printf("-1\n");
return 0;
}
int q = 0;
printf("%d\n", d[0][best][0]);
for (int i = 0; i < (int)(n - 1); ++i) {
if (p[i][best][q] == 0) {
ans += 'R';
q = pq[i][best][q];
--best;
} else {
ans += 'L';
q = pq[i][best][q];
++best;
}
}
reverse(ans.begin(), ans.end());
printf("%d\n%s\n", best + 1, ans.c_str());
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
double w;
double milk[1001];
vector<pair<int, double> > cups[1001];
vector<int> cnt[1001];
bool eps_gt(double a, double b) {
if ((a - b) > 1e-8) return 1;
return 0;
}
bool eps_lt(double a, double b) {
if ((a - b) < -(1e-8)) return 1;
return 0;
}
bool eps_eq(double a, double b) {
if (fabs(a - b) < 1e-8) return 1;
return 0;
}
int main() {
cin >> n >> w >> m;
double e = n * w * 1.0 / (1.0 * m);
for (int i = 1; i <= n; i++) milk[i] = w;
int j = 1;
double q = 0;
for (int i = 1; i <= m; i++) {
q = e;
while (q > 0) {
if (!eps_lt(milk[j], q)) {
cnt[j].push_back(i);
cups[i].push_back(make_pair(j, q));
milk[j] -= q;
q = 0;
if (eps_eq(milk[j], 0)) milk[j] = 0;
} else {
cnt[j].push_back(i);
cups[i].push_back(make_pair(j, milk[j]));
q -= milk[j];
if (eps_eq(q, 0)) q = 0;
milk[j] = 0;
}
if (milk[j] == 0) j++;
}
}
for (int i = 1; i <= n; i++)
if (cnt[i].size() >= 3) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (int i = 1; i <= m; i++) {
for (int j = 0; j < cups[i].size(); j++)
if (j == 0)
printf("%d %lf", cups[i][j].first, cups[i][j].second);
else
printf(" %d %lf", cups[i][j].first, cups[i][j].second);
printf("\n");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N6 = 1e6 + 6, N3 = 1e3 + 6, oo = 1e9 + 9, base = 1e9 + 7;
const long long ool = 1e18 + 9;
int n;
bool pr[N6], u[N6];
vector<int> v, v2;
vector<pair<int, int> > ans;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 2; i <= n / 2; ++i) {
if (pr[i]) continue;
if (i != 2) v.push_back(i);
if (i * i > n) continue;
for (long long j = i * i; j <= n / 2; j += i) {
pr[j] = 1;
}
}
for (auto x : v) {
int cnt = 0;
for (int i = x; i <= n; i += x) {
if (u[i]) continue;
++cnt;
}
int cur = 0;
if (cnt == 1) continue;
for (int i = x; i <= n; i += x) {
if (u[i] || ((cnt & 1) && i == x * 2)) continue;
u[i] = 1;
if (!cur)
cur = i;
else {
ans.push_back(pair<int, int>(cur, i));
cur = 0;
}
}
}
int cur = 0;
for (int i = 2; i <= n; i += 2) {
if (u[i]) continue;
if (!cur)
cur = i;
else {
ans.push_back(pair<int, int>(cur, i));
cur = 0;
}
}
cout << (int)ans.size() << "\n";
for (auto it : ans) {
cout << it.first << " " << it.second << "\n";
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 77;
int dp[MX][MX][MX][2];
int n, cnt[3][MX];
string str;
vector<int> occK, occV, occR;
int calc(int V, int K, int R, int flag) {
if (V + K + R == n) return 0;
int &ret = dp[V][K][R][flag];
if (ret != -1) return ret;
ret = (1 << 30);
if (V + 1 <= occV.size()) {
int pos = occV[V], remK = K, remR = R;
for (int j = 1; j <= pos; j++)
if (str[j] == 'K')
remK--;
else if (str[j] != 'V')
remR--;
ret = min(ret, max(remK, 0) + max(remR, 0) + calc(V + 1, K, R, 1));
}
if (K + 1 <= occK.size() && !flag) {
int pos = occK[K], remV = V, remR = R;
for (int j = 1; j <= pos; j++)
if (str[j] == 'V')
remV--;
else if (str[j] != 'K')
remR--;
ret = min(ret, max(remV, 0) + max(remR, 0) + calc(V, K + 1, R, 0));
}
if (R + 1 <= occR.size()) {
int pos = occR[R], remV = V, remK = K;
for (int j = 1; j <= pos; j++)
if (str[j] == 'V')
remV--;
else if (str[j] == 'K')
remK--;
ret = min(ret, max(remV, 0) + max(remK, 0) + calc(V, K, R + 1, 0));
}
return ret;
}
int main() {
cin >> n >> str;
str = "#" + str;
for (int j = 1; j <= n; j++) {
if (str[j] == 'V')
occV.push_back(j);
else if (str[j] == 'K')
occK.push_back(j);
else
occR.push_back(j);
}
memset(dp, -1, sizeof(dp));
cout << calc(0, 0, 0, 0) << endl;
}
| 17 |
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
#define LSOne(S) ((S) & -(S))
const long long P = 1e9 + 7;
const double EPS = 1e-9;
using namespace std;
char getReflect(char c) {
switch (c) {
case '0':
case '1':
case '8':
return c;
case '2':
return '5';
case '5':
return '2';
default:
return ' ';
}
}
bool isReflectedTimeValid(string hstr, string mstr, int h, int m) {
// cout << "hstr : " << hstr << " mstr: " << mstr << endl;
string htemp = "";
int mul = 1;
int hres = 0;
for (char c : mstr) {
char r = getReflect(c);
if (r == ' ')
return false;
htemp = to_string(r) + htemp;
hres += (r - '0') * mul;
mul *= 10;
}
string mtemp = "";
mul = 1;
int mres = 0;
for (char c : hstr) {
char r = getReflect(c);
if (r == ' ')
return false;
mtemp = to_string(r) + mtemp;
mres += (r - '0') * mul;
mul *= 10;
}
// cout << "isvalid: hres: " << hres << " mres: " << mres << endl;
return hres < h && mres < m;
}
pair<string, string> extract(string s) {
return {s.substr(0, 2), s.substr(3, 2)};
}
string toString(int h, int m) {
string hstr = "";
while (h > 0) {
hstr = to_string(h % 10) + hstr;
h /= 10;
}
string mstr = "";
while (m > 0) {
mstr = to_string(m % 10) + mstr;
m /= 10;
}
while (hstr.length() < 2) {
hstr = '0' + hstr;
}
while (mstr.length() < 2) {
mstr = '0' + mstr;
}
return hstr + ":" + mstr;
}
string increment(string s, int h, int m) {
auto [hstr, mstr] = extract(s);
int hres = 0;
int mul = 10;
for (char c : hstr) {
hres += (c - '0') * mul;
mul /= 10;
}
int mres = 0;
mul = 10;
for (char c : mstr) {
mres += (c - '0') * mul;
mul /= 10;
}
if (mres + 1 < m) {
mres++;
} else {
mres = 0;
if (hres + 1 < h) {
hres++;
} else {
hres = 0;
}
}
return toString(hres, mres);
}
/*
YOU CAN DO THIS!! ;)
1. Note the limits!
2. Give logical, short variable names
3. If you are stuck for a long time, skip to next problem
*/
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int maxx = 60 * 60;
int h, m;
cin >> h >> m;
string s;
cin >> s;
auto [hstr, mstr] = extract(s);
// cout << hstr << " " << mstr << endl;
while (maxx > 0 && !isReflectedTimeValid(hstr, mstr, h, m)) {
s = increment(s, h, m);
// cout << "incremented : " << s << endl;
// cout << s << endl;
auto [a, b] = extract(s);
hstr = a;
mstr = b;
maxx--;
}
cout << s << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
{
string s;
cin >> s;
long long n = (long long)s.size();
cout << 3 << endl;
cout << "L " << n - 1 << endl;
cout << "R " << n - 1 << endl;
cout << "R " << 2 * n - 1 << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int f[5], A[1010][1010], P[1010], n, m, i, j, k, t, q, N, ss;
char s[1010][1010], S[1010][1010];
int main() {
f[4] = 4;
f[3] = 2;
f[2] = 3;
f[1] = 1;
f[0] = 0;
scanf("%d%d", &n, &m);
P[0] = 1;
for (i = 1; i <= n; i++) P[i] = (P[i - 1] * 5ll) % 1000000007;
for (i = 1; i <= n; i++) scanf("%s", s[i] + 1);
scanf("%d", &q);
for (i = 1; i <= q; i++) scanf("%s", S[i] + 1);
N = n + q;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) A[j][i] = s[i][j] - 'a';
for (i = 1; i <= q; i++)
for (j = 1; j <= m; j++) A[j][i + n] = S[i][j] - 'a';
for (i = t = 1; i <= n; i++) {
for (j = t; j <= m; j++)
if (A[j][i]) break;
if (j > m) continue;
if (j != t)
for (k = 1; k <= N; k++) swap(A[t][k], A[j][k]);
for (j = 1; j <= m; j++)
if (j != t && A[j][i]) {
ss = A[j][i] * f[A[t][i]] % 5;
for (k = 1; k <= N; k++) A[j][k] = (A[j][k] - A[t][k] * ss + 25) % 5;
}
t++;
}
t--;
for (i = 1; i <= q; i++) {
for (j = 1; j <= m; j++)
if (A[j][i + n]) {
for (k = 1; k <= n; k++)
if (A[j][k]) break;
if (k > n) break;
}
if (j > m)
printf("%d\n", P[n - t]);
else
puts("0");
}
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s1, s2;
cin >> s1 >> s2;
for (long long i = 0; i < s1.length(); i++) {
if (s1[i] == '1' && s2[i] == '0') {
cout << "1";
} else if (s1[i] == '0' && s2[i] == '1') {
cout << "1";
} else {
cout << "0";
}
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int x[2020][2020];
int t[2020][2020];
int main() {
int n;
cin >> n;
memset(x, 0, sizeof(x));
char s;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
cin >> s;
if (s == '0')
x[i][j] = 0;
else
x[i][j] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) t[i][j] = 0;
int an = 0;
int g = 0;
for (int i = n; i >= 1; i--) {
g = 0;
for (int j = 1; j < i; j++) {
if ((x[i][0] ^ x[0][j]) != x[i][j]) {
x[i][i] ^= 1;
x[j][j] ^= 1;
x[i][0] ^= 1;
x[0][j] ^= 1;
an++;
} else if (j == 1)
g = 1;
}
}
for (int i = 1; i <= n; i++) {
g = 0;
for (int j = n; j > i; j--) {
if ((x[n + 2][j] ^ x[i][n + 1]) != x[i][j]) {
if (j == n) g = 1;
x[i][i] ^= 1;
x[j][j] ^= 1;
x[i][n + 1] ^= 1;
x[n + 2][j] ^= 1;
an++;
} else if (j == n)
g = 1;
}
}
for (int i = 1; i <= n; i++)
if (0 != x[i][i]) an++;
cout << an << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
long long a[1010];
cin >> n >> k;
long long i, j;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long ans = 0;
for (i = 0; i < n; i++) {
while (k * 2 < a[i]) {
ans++;
k = k * 2;
}
k = max(a[i], k);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int X, Y, A, B, i, j, k, l, P;
int main() {
scanf("%d%d%d%d", &X, &Y, &A, &B);
for (i = A; i <= X; i++) {
for (j = B; j <= Y; j++) {
if (i > j) P++;
}
}
printf("%d\n", P);
for (i = A; i <= X; i++) {
for (j = B; j <= Y; j++) {
if (i > j) printf("%d %d\n", i, j);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char ar[1000], er[1000];
void oku() {
int i, t, a;
scanf("%s", ar);
scanf("%d", &t);
a = strlen(ar);
for (int i = 0; i < a; i++)
if (ar[i] <= 'Z') ar[i] += 32;
for (int i = 0; i < a; i++) {
if (ar[i] < 97 + t) ar[i] = ar[i] - 32;
}
cout << ar << endl;
}
int main() {
oku();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int ans = 0, ss[500000];
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i += 2) {
ss[++ans] = i;
}
for (int i = 1; i <= n; i += 2) {
ss[++ans] = i;
}
for (int i = 2; i <= n; i += 2) {
ss[++ans] = i;
}
printf("%d\n", ans);
for (int i = 1; i <= ans; i++) {
printf("%d ", ss[i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print(const vector<T>& a, const string& name = "") {
if (!name.empty()) cout << name << ": ";
for (const auto& item : a) {
cout << item << " ";
}
cout << endl;
}
template <typename T1, typename T2>
void print(const pair<T1, T2>& p, const string& name = "") {
if (!name.empty()) cout << name << ": ";
cout << "(" << p.first << ", " << p.second << ") " << endl;
}
template <typename T1, typename T2>
void print(const vector<pair<T1, T2>>& pairs, const string& name = "") {
if (!name.empty()) cout << name << ": ";
for (const auto& pair : pairs) {
cout << "(" << pair.first << ", " << pair.second << ") ";
}
cout << endl;
}
template <typename T, typename Compare>
void print(const set<T, Compare>& s, const string& name = "") {
if (!name.empty()) cout << name << ": ";
for (const auto& element : s) {
cout << element << " ";
}
cout << endl;
}
template <typename T1, typename T2, typename Compare>
void print(const map<T1, T2, Compare>& m, const string& name = "") {
if (!name.empty()) cout << name << ": ";
for (const auto& p : m) {
cout << "(" << p.first << ", " << p.second << ") ";
}
cout << endl;
}
template <typename T>
void print(const unordered_set<T>& s, const string& name = "") {
if (!name.empty()) cout << name << ": ";
for (const auto& element : s) {
cout << element << " ";
}
cout << endl;
}
template <typename T1, typename T2>
void print(const unordered_map<T1, T2>& m, const string& name = "") {
if (!name.empty()) cout << name << ": ";
for (const auto& p : m) {
cout << "(" << p.first << ", " << p.second << ") ";
}
cout << endl;
}
template <typename T>
void print(const vector<vector<T>>& matrix, const string& name = "") {
if (!name.empty()) cout << name << ": " << endl;
for (const auto& row : matrix) {
for (const auto& element : row) {
cout << element << " ";
}
cout << endl;
}
}
struct Thing {
int64_t weight;
int64_t out_degree;
bool operator<(const Thing& thing) const {
if (thing.weight != weight) {
return weight > thing.weight;
} else {
return out_degree < thing.out_degree;
}
}
};
void solve() {
int N;
cin >> N;
vector<int64_t> weight(N);
for (int i = 0; i < N; ++i) {
cin >> weight[i];
}
vector<vector<int>> graph(N);
for (int i = 0; i < N - 1; ++i) {
int from, to;
cin >> from >> to;
--from; --to; // Convert to 0-based indexing.
graph[from].push_back(to);
graph[to].push_back(from);
}
multiset<Thing> vert; // { weight, out degree }
for (int i = 0; i < N; ++i) {
vert.insert({ weight[i], (int64_t) graph[i].size() - 1 });
}
int64_t value = accumulate(weight.begin(), weight.end(), (int64_t) 0);
for (int k = 0; k < N - 1; ++k) {
cout << value << " ";
while (!vert.empty() && vert.begin()->out_degree == 0) {
vert.erase(vert.begin());
}
// Take minimum.
if (!vert.empty()) {
auto top = *vert.begin();
value += top.weight;
vert.erase(vert.begin());
vert.insert({ top.weight, top.out_degree - 1 });
}
}
cout << endl;
}
int main() {
int num_cases;
cin >> num_cases;
for (int i = 0; i < num_cases; ++i) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int cnt = 0;
for (int i = 1; i < n - 1; i++) {
if (a[i] == 0 && a[i - 1] == 1 && a[i + 1] == 1) {
if (i + 3 < n && a[i + 2] == 0 && a[i + 3] == 1) {
a[i + 1] = 0;
cnt++;
} else {
a[i - 1] = 0;
cnt++;
}
}
}
cout << cnt << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int n, k;
cin >> n;
pair<int, int> *c = new pair<int, int>[n + 2];
int *a = new int[n + 2];
int *b = new int[n + 2];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) {
cin >> k;
c[i] = pair<int, int>(k, i);
}
sort(c, c + n);
for (int i = 0; i < n; i++) b[c[i].second] = i;
for (int i = 0; i < n; i++) {
if (i != 0) cout << ' ';
cout << a[n - b[i] - 1];
}
cout << "\n";
cout.flush();
return 0;
}
| 5 |
#include <bits/stdc++.h>
int min(int a, int b) { return a < b ? a : b; }
int main() {
static char aa[4000 + 1], bb[4000 + 1];
static int dp[4000 + 1][4000 + 1], dq[4000 + 1][4000 + 1], pp[4000][26],
qq[4000][26];
int n, m, ti, td, tr, te, i, j, a, b;
scanf("%d%d%d%d%s%s", &ti, &td, &tr, &te, aa, bb), n = strlen(aa),
m = strlen(bb);
for (i = 0; i < n; i++)
for (a = 0; a < 26; a++)
pp[i][a] = i == 0 ? -1 : aa[i - 1] == a + 'a' ? i - 1 : pp[i - 1][a];
for (j = 0; j < m; j++)
for (a = 0; a < 26; a++)
qq[j][a] = j == 0 ? -1 : bb[j - 1] == a + 'a' ? j - 1 : qq[j - 1][a];
for (i = 0; i <= n; i++)
for (j = 0; j <= m; j++)
if (i == 0 && j == 0)
dp[i][j] = 0;
else {
int p, q;
dp[i][j] = 0x3f3f3f3f;
if (i > 0) dp[i][j] = min(dp[i][j], dp[i - 1][j] + td);
if (j > 0) dp[i][j] = min(dp[i][j], dp[i][j - 1] + ti);
if (i > 0 && j > 0) {
a = aa[i - 1] - 'a', b = bb[j - 1] - 'a';
if (a == b)
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1]);
else {
p = pp[i - 1][b] + 1, q = qq[j - 1][a] + 1;
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + tr);
if (p > 0 && q > 0)
dp[i][j] = min(dp[i][j], dq[p][q] + (i - 1 - p) * td +
(j - 1 - q) * ti + te);
}
dq[i][j] = dp[i - 1][j - 1];
p = pp[i - 1][a] + 1, q = qq[j - 1][b] + 1;
if (p > 0) dq[i][j] = min(dq[i][j], dq[p][j] + (i - p) * td);
if (q > 0) dq[i][j] = min(dq[i][j], dq[i][q] + (j - q) * ti);
}
}
printf("%d\n", dp[n][m]);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int n;
long double score = 0.0;
long double prop[100005];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> prop[i];
score -= prop[i];
}
long double bck = 0.0;
for (int i = 0; i < n; i++)
score += (2.0 * (1 + bck) * prop[i]), bck = (bck + 1.0) * prop[i];
cout << fixed << setprecision(30) << score << '\n';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, p2[10], p3[10];
long long a[10];
int f[10][10][6666], g[10][444], ans, OR[6666][444], r32[6666],
cost[1000000 + 10], prime[1000000 + 10], kA[10], s[444];
int bit2(int mask, int x) { return (mask >> x) % 2; }
int bit3(int mask, int x) { return (mask / p3[x]) % 3; }
void set2(int &mask, int x, int val) {
if (val == 1)
mask |= p2[x];
else
mask &= (p2[n] - 1 - p2[x]);
}
void set3(int &mask, int x, int val) {
mask = ((mask / p3[x + 1]) * 3 + val) * p3[x] + (mask % p3[x]);
}
void upd(int i, int j, int mask, int val) {
if (j == n) {
int x = r32[mask];
if ((g[i][x] == -1) || (val < g[i][x])) g[i][x] = val;
return;
}
if ((f[i][j][mask] == -1) || (val < f[i][j][mask])) f[i][j][mask] = val;
}
long long gcd(long long x, long long y) {
while ((x > 0) && (y > 0))
if (x > y)
x %= y;
else
y %= x;
return x + y;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
p3[0] = 1;
for (int i = 1; i <= n; i++) p3[i] = p3[i - 1] * 3;
p2[0] = 1;
for (int i = 1; i <= n; i++) p2[i] = p2[i - 1] * 2;
s[0] = 0;
for (int i = 1; i < p2[n]; i++) s[i] = 1000000000;
for (int i = 1; i <= 1000000; i++) prime[i] = i;
for (int i = 2; i <= 1000000; i++)
if (prime[i] == i)
for (int j = i + i; j <= 1000000; j += i) prime[j] = i;
cost[1] = 0;
for (int i = 2; i <= 1000000; i++) cost[i] = cost[i / prime[i]] + 1;
for (int mask = 0; mask < p3[n]; mask++) {
int m2 = 0;
for (int i = 0; i < n; i++)
if (bit3(mask, i) != 0) set2(m2, i, 1);
r32[mask] = m2;
}
for (int mask1 = 0; mask1 < p3[n]; mask1++)
for (int mask2 = 0; mask2 < p2[n]; mask2++) {
int newmask = mask1;
for (int i = 0; i < n; i++)
if ((bit2(mask2, i) != 0) && (bit3(newmask, i) == 0))
set3(newmask, i, 1);
OR[mask1][mask2] = newmask;
}
for (int i = 0; i < n; i++) {
long long x = a[i];
int kr = 0;
for (long long t = 2; t * t <= a[i]; t++)
while (x % t == 0) {
x /= t;
kr++;
}
if (x != 1) kr++;
kA[i] = kr;
}
memset(f, -1, sizeof(f));
memset(g, -1, sizeof(g));
for (int i = 0; i < n; i++) {
if (kA[i] == 1) {
g[i][1 << i] = 1;
continue;
}
for (int mask = 0; mask < p2[n]; mask++) {
if ((mask & (1 << i)) != 0) continue;
long long x = a[i];
int m2 = 0;
for (int j = 0; j < n; j++)
if (bit2(mask, j) == 1) {
set3(m2, j, 2);
if (x % a[j] != 0) {
x = -1;
break;
}
x /= a[j];
}
if (x < 0) continue;
set3(m2, i, 1);
int kr;
if (x <= 1000000)
kr = cost[x];
else
kr = kA[i] - cost[a[i] / x];
f[i][0][m2] = kr + 1;
}
for (int j = 0; j < n; j++)
for (int mask = 0; mask < p3[n]; mask++)
if (f[i][j][mask] != -1) {
if (bit3(mask, j) != 2) {
upd(i, j + 1, mask, f[i][j][mask]);
continue;
}
for (int mask2 = 0; mask2 < p2[n]; mask2++)
if (g[j][mask2] != -1)
upd(i, j + 1, OR[mask][mask2], f[i][j][mask] + g[j][mask2]);
}
}
ans = 1000000000;
for (int i = 0; i < n; i++)
for (int mask = 0; mask < p2[n]; mask++)
if (g[i][mask] != -1) {
int cr = g[i][mask];
for (int mask2 = p2[n] - 1; mask2 >= 0; mask2--)
if ((s[mask2] != -1) && (s[mask2] + g[i][mask] < s[mask2 | mask]))
s[mask2 | mask] = s[mask2] + g[i][mask];
}
long long x = 1;
for (int i = 0; i < n - 1; i++) {
if ((a[n - 1] % x != 0) || (a[n - 1] % a[i] != 0)) {
x = -1;
break;
}
x = (x / gcd(x, a[i])) * a[i];
}
int ans = s[p2[n] - 1] + 1;
if ((x > 0) && (g[n - 1][p2[n] - 1] != -1) && (g[n - 1][p2[n] - 1] < ans))
ans = g[n - 1][p2[n] - 1];
printf("%d\n", ans);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int boy, girl, n;
cin >> boy >> girl >> n;
if (boy + girl == n) {
cout << 1 << "\n";
return 0;
}
if (boy >= n)
cout << min(n, girl) + 1 << '\n';
else if (girl >= n)
cout << min(n, boy) + 1 << '\n';
else {
int maxx = max(boy, girl);
int minn = min(boy, girl);
cout << maxx - (n - minn) + 1 << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b, d, a, wSize = 0, result = 0;
cin >> n >> b >> d;
for (int i = 0; i < n; ++i) {
cin >> a;
if (a > b)
continue;
else {
wSize += a;
if (wSize > d) {
result++;
wSize = 0;
}
}
}
cout << result;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (long long)2e5 + 7;
long long n, l, x[N], y[N];
long long rep(long long x) {
x %= n;
if (x < 0) x += n;
return x;
}
long long cnt[N];
long long geta(long long i) { return x[i % n] + i / n * l; }
long long getb(long long i) { return y[i % n] + i / n * l; }
bool ok(long long d) {
for (long long i = 1; i <= n; i++) cnt[i] = 0;
long long j1 = 0, j2 = 0;
for (long long i = 3 * n; i < 4 * n; i++) {
while (j2 + 1 < 6 * n && getb(j2 + 1) <= geta(i) + d) j2++;
while (getb(j1) < geta(i) - d) {
j1++;
}
if (j1 <= j2) {
j1 *= -1;
j2 *= -1;
swap(j1, j2);
long long st = rep(i + j1), dr = rep(i + j2);
st++;
dr++;
if (st <= dr) {
cnt[st]++;
cnt[dr + 1]--;
} else {
cnt[st]++;
cnt[1]++;
cnt[dr + 1]--;
}
j1 *= -1;
j2 *= -1;
swap(j1, j2);
}
}
for (long long i = 1; i <= n; i++) cnt[i] += cnt[i - 1];
for (long long i = 1; i <= n; i++)
if (cnt[i] == n) return 1;
return 0;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> l;
for (long long i = 0; i < n; i++) cin >> x[i];
for (long long i = 0; i < n; i++) cin >> y[i];
sort(x, x + n);
sort(y, y + n);
long long lo = 0, hi = l - 1, ret = -1;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (ok(mid)) {
ret = mid, hi = mid - 1;
} else {
lo = mid + 1;
}
}
cout << ret << "\n";
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int NMax = 1100, MMax = 10000, INF = 1000000000;
struct edge {
int num, len;
edge *next;
} * G1[NMax], pool[MMax];
int N, M, F[NMax], F1[NMax], L;
void Build(int x, int y, int z) {
edge *p = &pool[L++];
p->num = y;
p->len = z;
p->next = G1[x];
G1[x] = p;
}
vector<int> G[NMax];
void DFS(int a) {
F[a] = 1;
for (int i = 0; i < G[a].size(); i++)
if (!F[G[a][i]]) DFS(G[a][i]);
}
void DFS1(int a) {
F1[a] = 1;
for (int i = 0; i < G[a].size(); i++)
if (!F1[G[a][i]]) DFS1(G[a][i]);
}
int num[NMax][NMax];
int ans[MMax];
int D[NMax];
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= M; i++) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
num[x][y] = i;
}
DFS(1);
for (int i = 1; i <= N; i++) {
memset(F1, 0, sizeof(F1));
DFS1(i);
if (!F1[N]) F[i] = 0;
}
if (!F[1] || !F[N]) {
puts("No");
getchar();
getchar();
return 0;
}
for (int i = 1; i <= N; i++)
if (F[i]) {
for (int j = 0; j < G[i].size(); j++)
if (F[G[i][j]]) {
Build(G[i][j], i, -1);
Build(i, G[i][j], 2);
}
}
for (int i = 1; i <= N; i++) D[i] = INF;
D[1] = 0;
for (int I = 1; I <= N; I++) {
int flag = 0;
for (int i = 1; i <= N; i++)
if (F[i]) {
for (edge *p = G1[i]; p; p = p->next)
if (D[p->num] > D[i] + p->len) {
D[p->num] = D[i] + p->len;
flag = 1;
}
}
if (flag && I == N) {
puts("No");
getchar();
getchar();
return 0;
}
}
puts("Yes");
for (int i = 1; i <= N; i++) {
for (int j = 0; j < G[i].size(); j++) {
if (!F[i] || !F[G[i][j]])
ans[num[i][G[i][j]]] = 1;
else {
if (D[G[i][j]] == D[i] + 2)
ans[num[i][G[i][j]]] = 2;
else
ans[num[i][G[i][j]]] = 1;
}
}
}
for (int i = 1; i <= M; i++) printf("%d\n", ans[i]);
getchar();
getchar();
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
int n, a[N], b[N], A[N], B[N], c[N];
map<int, int> M;
int main() {
scanf("%d", &n);
for (int i = n; i >= 1; i--) {
scanf("%d", &b[i]);
B[b[i]] = i;
}
for (int i = n; i >= 1; i--) {
scanf("%d", &a[i]);
A[a[i]] = i;
}
M.clear();
for (int i = 1; i <= n; i++) {
c[i] = A[i] - B[i];
M[c[i]]++;
}
for (int i = 0; i < n; i++) {
map<int, int>::iterator t1 = M.lower_bound(-i);
int ans = 10000000;
if (t1 != M.end()) {
ans = (*t1).first + i;
}
if (t1 != M.begin()) {
t1--;
ans = min(ans, -i - (*t1).first);
}
printf("%d\n", ans);
M[c[a[n - i]]]--;
if (M[c[a[n - i]]] == 0) M.erase(c[a[n - i]]);
M[-i - B[a[n - i]]]++;
}
}
| 13 |
#include <bits/stdc++.h>
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
using namespace std;
long long isprime(long long n) {
long long c = 0;
if (n == 2)
return 2;
else if (n == 3)
return 3;
else {
long long x = (long long)(sqrt(n));
for (long long i = 2; i < x + 1; i++) {
if (n % i == 0) {
c++;
break;
}
}
if (c == 0) {
return n;
} else
return -2;
}
}
long long nextprime(long long x) {
x++;
long long n = x;
long long c = 0, c1 = 0;
while (true) {
long long x1 = (long long)(sqrt(n));
c1 = 0;
for (long long i = 2; i < x1 + 1; i++) {
if (n % i == 0) {
c1++;
break;
}
}
if (c1 == 0) {
break;
} else
n++;
}
return n;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool sortbysecdesc(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.second > b.second;
}
void solve() {
long long n;
cin >> n;
long long c = 0;
vector<long long> v;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
for (long long i = 1; i < n; i++) {
if (n > 1 && (v[i] - v[i - 1]) == 1) {
c++;
break;
}
}
if (c > 0)
cout << 2 << "\n";
else
cout << 1 << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T = 1;
cin >> T;
while (T--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
char ch;
template <class T>
inline void read(T &x) {
x = 0;
ch = getchar();
while (ch <= 32) ch = getchar();
while (ch > 32) {
x = x * 10 + ch - 48;
ch = getchar();
};
};
template <class T>
inline T min(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline T max(T a, T b) {
return a > b ? a : b;
}
template <int M, class T, T (*f)(T, T)>
struct segtree {
T tr[M * 2];
inline void clear(char x) { memset(tr, x, sizeof(tr)); };
inline void modify(int p, T val) {
tr[p += M] = val;
while (p ^ 1) {
tr[p >> 1] = f(tr[p], tr[p ^ 1]);
p >>= 1;
};
};
inline int delmin(T new_val) {
T mi = tr[1];
int p = 1;
while (p < M) {
p <<= 1;
if (tr[p] != mi) ++p;
};
int ret = p - M;
modify(p - M, new_val);
return ret;
};
inline T getmin() { return tr[1]; };
};
long long h;
int n, m, k;
int cnt;
long long K[25];
segtree<16384, long long, min> S1;
long long dist[10005];
bool visit[10005];
inline void dij() {
S1.clear(0x3f);
memset(visit, 0, sizeof(visit));
visit[1] = 1;
S1.modify(1, 0);
while (1) {
long long mi = S1.getmin();
if (mi == 0x3f3f3f3f3f3f3f3fLL) break;
int p = S1.delmin(0x3f3f3f3f3f3f3f3fLL);
int i;
for (i = 1; i <= cnt; i++) {
long long d = dist[p] + (p + K[i]) / k;
int p1 = (p + K[i]) % k;
if (!visit[p1] || dist[p1] > d) {
visit[p1] = 1;
dist[p1] = d;
S1.modify(p1, d);
};
};
};
};
struct data {
long long q;
int id;
};
inline bool operator<(const data &a, const data &b) { return a.q < b.q; };
std::vector<data> a[10005];
segtree<131072, int, max> S;
bool inS[100005];
int c[100005];
inline void update() {
int i;
for (i = 0; i < k; i++) {
long long d = dist[i];
int sz = a[i].size();
while (sz) {
if (d > a[i][sz - 1].q) break;
int id = a[i][sz - 1].id;
S.modify(id, c[id]);
a[i].pop_back();
--sz;
inS[id] = 1;
};
};
};
int main() {
read(h);
read(n);
read(m);
read(k);
int i;
for (i = 1; i <= n; i++) {
long long x;
read(x);
read(c[i]);
a[x % k].push_back((data){x / k, i});
};
memset(dist, 0x3f, sizeof(dist));
dist[1] = 0;
for (i = 0; i < k; i++) {
std::sort(a[i].begin(), a[i].end());
};
update();
while (m--) {
int op, x, y;
long long X;
read(op);
if (op == 1) {
read(X);
K[++cnt] = X;
dij();
update();
} else if (op == 2) {
read(x);
read(y);
c[x] -= y;
if (inS[x]) S.modify(x, c[x]);
} else {
if (S.getmin() == 0) {
puts("0");
} else {
int pos = S.delmin(0);
inS[pos] = 0;
printf("%d\n", c[pos]);
};
};
};
}
| 17 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:20000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
const int pr = 49999;
const int maxn = 899821;
const int mod = (int)1e9 + 7;
const long double pi = 4 * atan(1);
const long double eps = 1e-7;
const int inf = INT_MAX;
const long long linf = LLONG_MAX;
const unsigned long long ulinf = ULLONG_MAX;
int n, k;
int a[maxn];
map<int, int> cnt;
set<int> more_k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
int l = 1, r = l;
cnt[a[r]]++;
if (cnt[a[r]] >= k) more_k.insert(a[r]);
bool good_break = false;
while (r <= n) {
if (((int)(more_k.size()))) {
good_break = true;
break;
}
if (r == n) break;
++r;
cnt[a[r]]++;
if (cnt[a[r]] >= k) more_k.insert(a[r]);
}
long long ans = 0;
if (good_break)
ans += (n - r) + 1;
else {
cout << 0;
return 0;
}
for (int i = 2; i <= n; ++i) {
cnt[a[l]]--;
if (cnt[a[l]] < k && more_k.count(a[l])) more_k.erase(a[l]);
l = i;
if (!((int)(more_k.size()))) {
good_break = false;
while (r <= n) {
if (((int)(more_k.size()))) {
good_break = true;
break;
}
if (r == n) {
break;
}
++r;
cnt[a[r]]++;
if (cnt[a[r]] >= k) more_k.insert(a[r]);
}
if (good_break) {
ans += (n - r) + 1;
} else {
cout << ans;
return 0;
}
} else {
ans += (n - r) + 1;
}
}
cout << ans;
exit(0);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
priority_queue<int> Q[maxn];
int num[maxn];
int fa[maxn];
inline int Find(int x) { return fa[x] == x ? x : fa[x] = Find(fa[x]); }
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", num + i);
fa[i] = i;
}
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
fa[Find(u)] = Find(v);
}
for (int i = 1; i <= n; i++) {
Find(i);
Q[fa[i]].push(num[i]);
}
for (int i = 1; i <= n; i++) {
printf("%d ", Q[fa[i]].top());
Q[fa[i]].pop();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int MN = 200111;
pair<long double, int> a[MN];
int x[MN], n, l, v1, v2;
long double res[MN];
int main() {
while (scanf("%d%d%d%d", &n, &l, &v1, &v2) == 4) {
int k = 1;
a[k] = make_pair(-1, 0);
int cur = 0;
for (int i = (1), _b = (n); i <= _b; i++) {
scanf("%d", &x[i]);
a[++k] = make_pair(x[i], -1);
long double need = x[i] - l / (v1 / (long double)v2 + 1);
if (need < 0) need += 2 * l;
a[++k] = make_pair(need, 1);
if (x[i] < need) cur++;
}
sort(a + 1, a + k + 1);
memset(res, 0, sizeof res);
for (int i = (1), _b = (k); i <= _b; i++) {
long double range;
if (i == k)
range = 2 * l - a[i].first + a[1].first;
else
range = a[i + 1].first - a[i].first;
cur += a[i].second;
res[cur] += range / (2 * l);
}
for (int i = (0), _b = (n); i <= _b; i++)
printf("%.12lf\n", (double)res[i]);
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
for (i = 1; i < n; i++) {
if (i % 2 == 0) {
cout << "I love that"
<< " ";
} else {
cout << "I hate that"
<< " ";
}
}
if (n % 2 == 0)
cout << "I love it"
<< " ";
else
cout << "I hate it"
<< " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, ans;
unordered_set<string> prefixes;
bool isPrefix(string s) { return prefixes.count(s); }
bool tryToWin(string s) {
bool curr = 0;
for (int i = 0; i < 26; i++) {
s.push_back(char('a' + i));
if (isPrefix(s)) {
if (!tryToWin(s)) curr = 1;
}
s.pop_back();
}
return curr;
}
bool tryToLose(string s) {
bool curr = 0, possibleTransition = 0;
for (int i = 0; i < 26; i++) {
s.push_back(char('a' + i));
if (isPrefix(s)) {
if (!tryToLose(s)) curr = 1;
possibleTransition = 1;
}
s.pop_back();
}
if (!possibleTransition) curr = 1;
return curr;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> k;
prefixes.insert("");
for (int i = 0; i < n; i++) {
string s, t = "";
cin >> s;
for (int i = 0; i < s.size(); i++) {
t.push_back(s[i]);
prefixes.insert(t);
}
}
bool winnerIfWin = tryToWin("");
bool winnerIfLose = tryToLose("");
if (winnerIfWin == 1 && winnerIfLose == 1) cout << "First" << endl;
if (winnerIfWin == 1 && winnerIfLose == 0)
cout << (k % 2 ? "First" : "Second") << endl;
if (winnerIfWin == 0 && winnerIfLose == 1) cout << "Second" << endl;
if (winnerIfWin == 0 && winnerIfLose == 0) cout << "Second" << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long int exp(long long int a, long long int b, long long int m);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int d = 0;
long long int n1 = n;
long long int va = 0;
while (n1) {
n1 /= 10;
d++;
}
long long int te = 1;
long long int oo = 0;
for (long long int i = 0; i < d; i++) {
oo += te;
te *= 10;
}
long long int ans = 0;
for (long long int i = 1; i < 10; i++) {
if (oo * i <= n)
ans++;
else
break;
}
ans += (d - 1) * 9;
cout << ans << "\n";
}
return 0;
}
long long int exp(long long int a, long long int b, long long int m) {
if (b == 0) {
return 1;
}
long long int temp = exp(a, b / 2, m);
temp = (temp * temp) % m;
if (b & 1) {
return (temp * (a % m)) % m;
}
return temp;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5010;
int a[maxn];
int Max_l[maxn][maxn], Min_l[maxn][maxn];
int N;
void read() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) scanf("%d", &a[i]);
}
void getans() {
for (int j = N; j; --j) {
Min_l[j][j] = Max_l[j][j] = 0;
for (int i = j - 1; i; --i) {
Min_l[i][j] = Min_l[i + 1][j], Max_l[i][j] = Max_l[i + 1][j];
if (a[i] < a[j])
++Min_l[i][j];
else if (a[i] > a[j])
++Max_l[i][j];
}
}
long long ans = 0;
for (int i = 1; i <= N; ++i) ans += Max_l[1][i];
long long best = ans, tot = 0;
for (int i = 1; i < N; ++i) {
int Min_r = 0, Max_r = 0;
for (int j = i + 1; j <= N; ++j) {
if (a[j - 1] < a[i])
++Min_r;
else if (a[j - 1] > a[i])
++Max_r;
long long temp = ans - Min_r - Max_l[i + 1][j] + Max_r + Min_l[i + 1][j];
if (a[i] < a[j])
++temp;
else
--temp;
if (temp < best)
best = temp, tot = 1;
else if (temp == best)
++tot;
}
}
cout << best << ' ' << tot << endl;
}
int main() {
read();
getans();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long m, d, w, T;
vector<pair<long long, long long>> pq;
void readInput() {}
void solve() {}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
readInput();
solve();
cin >> T;
while (T--) {
cin >> m >> d >> w;
if (d == 1 || m == 1)
cout << 0 << '\n';
else {
long long m1, d1 = d - 1, w1 = w, res = 1, cnt, ans;
for (long long i = 2; i <= sqrt(w); i++) {
if (w1 % i == 0) {
cnt = 0;
while (w1 % i == 0) {
cnt++;
w1 /= i;
}
pq.push_back({i, cnt});
}
}
if (w1 > 1) pq.push_back({w1, 1});
for (auto v : pq) {
cnt = 0;
if (d1 % v.first == 0) {
while (d1 % v.first == 0) {
cnt++;
d1 /= v.first;
}
}
cnt = max(0ll, v.second - cnt);
for (long long i = 1; i <= cnt; i++) res *= v.first;
}
m1 = min(m, d);
if (m1 % res == 0)
cnt = m1 / res - 1;
else
cnt = m1 / res;
ans = m1 * cnt - (cnt + 1) * cnt / 2 * res;
cout << ans << '\n';
pq.clear();
}
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long x;
long long a = 1, cnt = 0;
cin >> x;
while (1) {
long long tmp = (a + 1) / 2 * a;
x -= tmp;
if (x < 0) break;
cnt++;
a = a * 2 + 1;
}
cout << cnt << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n1, n2 = 0, n3 = 0;
std::cin >> n1;
std::vector<std::vector<char>> v1(n1, std::vector<char>(n1));
for (int i = 0; i < n1; i++)
for (int j = 0; j < n1; j++) std::cin >> v1[i][j];
for (int i = 0; i < n1; i++) {
for (int j = 0; j < n1; j++) {
if (v1[i][j] == 'C') n2++;
}
n3 += n2 * (n2 - 1) / 2;
n2 = 0;
}
for (int i = 0; i < n1; i++) {
for (int j = 0; j < n1; j++) {
if (v1[j][i] == 'C') n2++;
}
if (n2 != 0) n3 += n2 * (n2 - 1) / 2;
n2 = 0;
}
std::cout << n3;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a[4];
char x[3];
while (scanf("%I64d%I64d%I64d%I64d", &a[0], &a[1], &a[2], &a[3]) == 4) {
cin >> x[0] >> x[1] >> x[2];
long long mins = 999999999999999;
long long b[3], c, tmp;
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
if (i == j) continue;
if (x[0] == '*')
b[0] = a[i] * a[j];
else if (x[0] == '+')
b[0] = a[i] + a[j];
int z = 1;
for (int k = 0; k < 4; k++) {
if (k == i || k == j) continue;
b[z] = a[k];
z++;
}
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (i == j) continue;
if (x[1] == '*')
c = b[i] * b[j];
else if (x[1] == '+')
c = b[i] + b[j];
for (int k = 0; k < 3; ++k) {
if (k == i || k == j) continue;
if (x[2] == '*')
tmp = c * b[k];
else if (x[2] == '+')
tmp = c + b[k];
if (tmp < mins) mins = tmp;
}
}
}
}
}
cout << mins << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0;
cin >> n;
map<string, bool> Map;
char s[25], tmp[50];
while (n--) {
cin >> s;
int l = strlen(s);
int index = 0, t = 0;
while (index < l) {
if (s[index] == 'u') {
tmp[t++] = 'o';
tmp[t++] = 'o';
index = index + 1;
} else {
tmp[t++] = s[index];
index++;
}
}
for (int i = 0; i < t; i++) s[i] = tmp[i];
index = t - 1;
while (index >= 0) {
if (s[index] == 'h') {
while (s[index - 1] == 'k' && index - 1 >= 0) {
s[index - 1] = ' ';
index--;
}
index--;
} else
index--;
}
string finalString = "";
for (int i = 0; i < t; i++) {
if (s[i] == ' ') continue;
finalString += s[i];
}
if (Map[finalString]) continue;
sum++;
Map[finalString] = true;
}
cout << sum << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int getint() {
static char c;
while ((c = getchar()) < '0' || c > '9')
;
int res = c - '0';
while ((c = getchar()) >= '0' && c <= '9') res = res * 10 + c - '0';
return res;
}
const int MaxN = 1000;
const int MaxM = 100000;
int n, m;
vector<int> adj[MaxN + 1];
bool vis[MaxN + 1];
int col[MaxN + 1];
int seq_n;
int seq[MaxN + 1];
bool dfs(int u, int now) {
vis[u] = true;
col[u] = now;
seq[++seq_n] = u;
bool ok = true;
for (int i = 0; i < adj[u].size() && ok; ++i) {
int v = adj[u][i];
if (!vis[v])
ok &= dfs(v, !now);
else
ok &= now != col[v];
}
return ok;
}
int q_n, q[MaxN + 1];
int lev[MaxN + 1];
inline int bfs(int sv) {
for (int i = 1; i <= seq_n; ++i) lev[seq[i]] = -1;
lev[sv] = 0, q[q_n = 1] = sv;
for (int i = 1; i <= q_n; ++i) {
int u = q[i];
for (int j = 0; j < adj[u].size(); ++j) {
int v = adj[u][j];
if (!~lev[v]) lev[q[++q_n] = v] = lev[u] + 1;
}
}
int l = 0;
for (int i = 1; i <= seq_n; ++i) l = max(l, lev[seq[i]]);
return l;
}
inline int solve() {
int res = 0;
for (int u = 1; u <= n; ++u)
if (!vis[u]) {
seq_n = 0;
if (!dfs(u, 0)) return -1;
int l = 0;
for (int i = 1; i <= seq_n; ++i) l = max(l, bfs(seq[i]));
res += l;
}
return res;
}
int main() {
n = getint(), m = getint();
for (int i = 0; i < m; ++i) {
int u = getint(), v = getint();
adj[u].push_back(v);
adj[v].push_back(u);
}
printf("%d\n", solve());
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 10;
int n, m, s;
int head[maxn], hcnt = 0;
struct edge {
int v, next;
} e[maxn];
void add(int u, int v) {
e[hcnt] = edge{v, head[u]};
head[u] = hcnt++;
}
int dfn[maxn], low[maxn], suo[maxn], scnt = 0, tcnt = 0, vis[maxn];
stack<int> sta;
void dfs(int u) {
dfn[u] = low[u] = ++tcnt;
sta.push(u);
vis[u] = 1;
for (int i = head[u]; i >= 0; i = e[i].next) {
int v = e[i].v;
if (!dfn[v]) {
dfs(v);
low[u] = min(low[v], low[u]);
} else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
++scnt;
int k = sta.top();
while (k != u) {
vis[k] = 0;
suo[k] = scnt;
sta.pop();
k = sta.top();
}
vis[k] = 0;
suo[k] = scnt;
sta.pop();
}
}
int in[maxn];
int main() {
memset(head, -1, sizeof(head));
scanf("%d%d%d", &n, &m, &s);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i);
for (int i = 1; i <= n; i++) {
for (int j = head[i]; j >= 0; j = e[j].next) {
int v = e[j].v;
if (suo[i] != suo[v]) {
in[suo[v]]++;
}
}
}
int cnt = 0;
for (int i = 1; i <= scnt; i++)
if (in[i] == 0) cnt++;
if (in[suo[s]] == 0) cnt--;
printf("%d\n", cnt);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i;
string x;
cin >> x;
bool f = true;
for (i = 0; i < x.size(); i++) {
if (x[i] == '1' || x[i] == '4')
continue;
else {
f = false;
break;
}
}
int c = 0;
if (x[0] == '4') f = false;
if (f) {
for (i = 0; i < x.size() - 1; i++) {
if (x[i] == '4' && x[i + 1] == '4')
c++;
else
c = 1;
if (c > 2) {
f = false;
break;
}
}
}
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double Pi = 3.14159265359;
const long long MOD = 1000 * 1000 * 1000 + 7;
const long long MAXN = 2e5 + 10;
const long long INF = 1e18;
long long q4;
long long n, m;
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n >> m;
cout << n + m;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
const long long maxn = 1e6 + 10;
long long pref[maxn];
long long c[maxn], d[maxn];
int32_t main() {
long long maxi = 1e18, mini = -1e18;
long long n = in();
for (long long i = 0; i < n; i++) {
c[i] = in(), d[i] = in();
pref[i] = c[i] + (i ? pref[i - 1] : 0);
if (i == 0) {
if (d[i] == 1)
mini = 1900;
else
maxi = 1899;
} else {
if (d[i] == d[i - 1]) {
if (d[i] == 1) {
long long preMinimum = 1900 - pref[i - 1];
mini = max(mini, preMinimum);
} else {
long long preMaximum = 1899 - pref[i - 1];
maxi = min(maxi, preMaximum);
}
} else {
if (d[i - 1] == 2) {
long long preMinimum = 1900 - pref[i - 1];
mini = max(mini, preMinimum);
} else {
long long preMaximum = 1899 - pref[i - 1];
maxi = min(maxi, preMaximum);
}
}
}
}
if (mini <= maxi) {
if (maxi < 1e18)
cout << maxi + pref[n - 1] << "\n";
else
return cout << "Infinity\n", 0;
} else
return cout << "Impossible" << endl, 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n], i, min = 10000, index;
for (i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] < min) {
index = i + 1;
min = arr[i];
}
}
if (n == 1 || (n == 2 && arr[0] == arr[1]))
cout << "-1";
else
cout << "1" << endl << index;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
const vector<string> elem{
"", "H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne", "Na",
"Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca", "Sc", "Ti", "V",
"Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br",
"Kr", "Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag",
"Cd", "In", "Sn", "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr",
"Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu",
"Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi",
"Po", "At", "Rn", "Fr", "Ra", "Ac", "Th", "Pa", "U", "Np", "Pu", "Am",
"Cm", "Bk", "Cf", "Es", "Fm"};
map<string, int> atomic_num;
for (int i = 1; i <= 100; ++i) {
atomic_num[elem[i]] = i;
}
int n, k;
cin >> n >> k;
vector<int> inp(n);
for (int i = 0; i < n; ++i) {
string t;
cin >> t;
inp[i] = atomic_num[t];
}
vector<int> out(k);
for (int i = 0; i < k; ++i) {
string t;
cin >> t;
out[i] = atomic_num[t];
}
int sum[1 << 17];
memset(sum, 0x00, sizeof(sum));
for (int i = 1; i < 1 << n; ++i) {
int x = i & -i;
int y = __builtin_ctz(x);
sum[i] = sum[i ^ x] + inp[y];
}
int dp[1 << 17], from[1 << 17];
memset(dp, 0xff, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < (1 << n); ++i) {
if (dp[i] == -1) continue;
int m = ~i & ((1 << n) - 1);
for (int j = m; j != 0; j = (j - 1) & m) {
if (sum[j] == out[dp[i]]) {
dp[i ^ j] = dp[i] + 1;
from[i ^ j] = i;
}
}
}
if (dp[(1 << n) - 1] == k) {
cout << "YES" << '\n';
for (int i = (1 << n) - 1; i != 0; i = from[i]) {
int step = i ^ from[i];
vector<int> reactants;
for (int x = 0; x < n; ++x) {
if (step & (1 << x)) reactants.push_back(inp[x]);
}
cout << elem[reactants[0]];
for (int j = 1; j < reactants.size(); ++j) {
cout << '+' << elem[reactants[j]];
}
cout << "->" << elem[sum[step]] << '\n';
}
} else {
cout << "NO" << '\n';
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int ar[100000] = {0};
int main() {
int a, b;
cin >> a >> b;
if (a == b) {
cout << 0 << endl;
return 0;
}
int a2 = 0, a3 = 0, a5 = 0;
int acheck = a;
while (acheck % 2 == 0) {
a2++;
acheck /= 2;
}
while (acheck % 3 == 0) {
a3++;
acheck /= 3;
}
while (acheck % 5 == 0) {
a5++;
acheck /= 5;
}
int b2 = 0, b3 = 0, b5 = 0;
int bcheck = b;
while (bcheck % 2 == 0) {
b2++;
bcheck /= 2;
}
while (bcheck % 3 == 0) {
b3++;
bcheck /= 3;
}
while (bcheck % 5 == 0) {
b5++;
bcheck /= 5;
}
if (acheck == bcheck) {
cout << abs(a2 - b2) + abs(a3 - b3) + abs(a5 - b5) << endl;
} else
cout << -1 << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long p[1000100], h[1000100], g[1000100], ans;
int main() {
int m, n, x, y;
cin >> n >> m;
for (int i = 0; i <= n; i++) p[i] = (i ? p[i - 1] * 11 : 1);
while (m--) {
scanf("%d%d", &x, &y);
h[x] += p[y];
h[y] += p[x];
}
for (int i = 1; i <= n; i++) g[i] = h[i] + p[i];
sort(h + 1, h + n + 1);
for (int i = 1, cnt = 0; i <= n; i++)
if (h[i] == h[i - 1])
ans += cnt++;
else
cnt = 1;
sort(g + 1, g + n + 1);
for (int i = 1, cnt = 0; i <= n; i++)
if (g[i] == g[i - 1])
ans += cnt++;
else
cnt = 1;
cout << ans << endl;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
string solve(long long int x, long long int y) {
if (x == 1 && y == 1) {
return "YES";
}
if (x == 2 && (y == 1 || y == 3 || y == 2)) {
return "YES";
}
if (x == 3 && y <= 3) {
return "YES";
}
if (x >= 4) {
return "YES";
}
return "NO";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long int x, y;
cin >> x >> y;
cout << solve(x, y) << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
const int Mod = 1e9 + 7;
int a[2010];
long long init[2010];
long long now[2020], d[2020];
void calc() {
for (int i = 1; i <= n; i++) {
d[i] = now[i];
now[i] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j >= 1; j--) {
now[i] = (now[i] + d[i - j + 1] * init[j]) % Mod;
}
}
}
void mo() {
for (int i = 1; i <= n; i++) {
d[i] = init[i];
init[i] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j >= 1; j--) {
init[i] = (init[i] + d[i - j + 1] * d[j]) % Mod;
}
}
}
void deal(long long k) {
k--;
while (k) {
if (k & 1) calc();
k = k / 2;
mo();
}
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
if (k == 0) {
for (int i = 1; i <= n; i++) cout << a[i] << " ";
cout << endl;
} else {
for (int i = 1; i <= n; i++) init[i] = now[i] = 1;
deal(k);
for (int i = 1; i <= n; i++) {
long long ans = 0;
for (int j = 1; j <= i; j++) {
ans = (ans + a[j] * now[i - j + 1]) % Mod;
}
cout << ans << " ";
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, cnt;
cin >> n;
if (n % 2) return cout << 0 << endl, 0;
n /= 2;
cout << (n - 1) / 2 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using namespace std;
class A {
public:
int a, b, c, d, e;
A(int a, int b, int c, int d, int e) : a(a), b(b), c(c), d(d), e(e) {}
};
double scalar(A a, A b) {
double result = 0.0;
result += a.a * b.a;
result += a.b * b.b;
result += a.c * b.c;
result += a.d * b.d;
result += a.e * b.e;
return result;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
if (n < 3) {
cout << n << endl;
for (int i = 0; i < n; ++i) cout << i + 1 << endl;
return 0;
}
vector<A> points;
for (int i = 0; i < n; ++i) {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
points.push_back(A(a, b, c, d, e));
}
int count = 0;
vector<int> L;
for (int i = 0; i < n; ++i) {
A X = points[i];
bool skip = false;
for (int j = 0; j < n && !skip; ++j) {
if (i == j) continue;
A Y = points[j];
Y.a -= X.a;
Y.b -= X.b;
Y.c -= X.c;
Y.d -= X.d;
Y.e -= X.e;
for (int k = 0; k < n && !skip; ++k) {
if ((k == j) || (k == i)) continue;
A Z = points[k];
Z.a -= X.a;
Z.b -= X.b;
Z.c -= X.c;
Z.d -= X.d;
Z.e -= X.e;
double value =
scalar(Y, Z) / pow(scalar(Y, Y), 0.5) / pow(scalar(Z, Z), 0.5);
if (value > 0.0) {
skip = true;
}
}
}
if (!skip) {
count++;
L.push_back(i + 1);
}
}
cout << count << endl;
for (int i = 0; i < L.size(); ++i) cout << L[i] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000100;
int n, m;
int anum[2 * MAXN], bnum[MAXN];
int loc[MAXN];
int best;
long long poss[2 * MAXN];
int main() {
for (int i = 0; i < MAXN; i++) loc[i] = -1;
best = 0;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &anum[i]);
for (int i = n; i < 2 * n; i++) anum[i] = anum[i - n];
for (int i = 0; i < m; i++) {
scanf("%d", &bnum[i]);
loc[bnum[i]] = i;
}
long long mult = 0;
int ploc = 0, pend = 0;
for (int i = 0; i < 2 * n; i++) {
if (loc[anum[i]] == -1) {
ploc = pend;
continue;
}
if (pend == ploc) {
mult = 0;
poss[pend] = loc[anum[i]];
pend++;
best = max(best, pend - ploc);
continue;
}
long long next = poss[pend - 1] / m * m + loc[anum[i]];
while (next < poss[pend - 1]) next += m;
poss[pend] = next;
pend++;
while (poss[pend - 1] - poss[ploc] >= m) ploc++;
best = max(best, (int)pend - ploc);
}
cout << min(best, n) << "\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
struct node {
long long x, y;
} a[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lld%lld", &a[i].x, &a[i].y);
int flag = 0;
for (int i = 0; i < n; i++) {
if (a[(i + 1) % n].x - a[i].x !=
a[(i + n / 2) % n].x - a[(i + n / 2 + 1) % n].x)
flag = 1;
if (a[(i + 1) % n].y - a[i].y !=
a[(i + n / 2) % n].y - a[(i + n / 2 + 1) % n].y)
flag = 1;
}
if (flag)
printf("NO\n");
else
printf("YES\n");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int HP[2];
int ATK[2];
int DEF[2];
int main() {
for (int i = 0; i < 2; ++i) {
scanf("%d %d %d", HP + i, ATK + i, DEF + i);
}
int hc, ac, dc;
scanf("%d %d %d", &hc, &ac, &dc);
int ans = 1e9;
for (int i = 0; i <= 1000; ++i) {
for (int j = 0; j <= 1000; ++j) {
int cur_ATK = ATK[0] + i, cur_DEF = DEF[0] + j;
int cur_cost = i * ac + j * dc;
int delta_M = max(0, cur_ATK - DEF[1]),
delta_Y = max(0, ATK[1] - cur_DEF);
if (delta_M == 0) {
continue;
}
if (delta_Y != 0) {
int diff =
(HP[1] + delta_M - 1) / delta_M - (HP[0] + delta_Y - 1) / delta_Y;
if (diff >= 0) {
cur_cost += hc * ((delta_Y - HP[0] % delta_Y) % delta_Y + 1);
cur_cost += hc * diff * delta_Y;
}
}
if (cur_cost < ans) {
ans = cur_cost;
}
}
}
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1100;
int n, m;
int a[N][N];
int main() {
scanf("%d%d", &n, &m);
int res, res1, res2;
res = -1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
for (int i = 0; i < n - 1; i++)
for (int j = i + 1; j < n; j++) {
res1 = res2 = -1;
for (int k = 0; k < m; k++) {
if (min(a[i][k], a[j][k]) > res2) {
res1 = res2;
res2 = min(a[i][k], a[j][k]);
} else
res1 = max(res1, min(a[i][k], a[j][k]));
}
res = max(res, res1);
}
printf("%d", res);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
long long a[N];
int main() {
long long ans = 0, n, maxx, minn;
int i;
scanf("%I64d", &n);
for (i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
}
i = 0;
while (i + 1 < n) {
while (i + 1 < n && a[i] <= a[i + 1]) i++;
maxx = a[i];
while (i + 1 < n && a[i] > a[i + 1]) i++;
minn = a[i];
ans += maxx - minn;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
using ll = long long;
int n, m, p, a[N];
struct TNode {
int l, r;
vector<ll> f;
ll sum;
} t[N << 2];
inline int lc(int pos) { return pos << 1; }
inline int rc(int pos) { return pos << 1 | 1; }
void pushup(int pos) {
t[pos].sum = t[lc(pos)].sum + t[rc(pos)].sum;
int ptr = 0;
for (int i = 1; i <= t[pos].r - t[pos].l + 1; i++)
t[pos].f[i] = (LLONG_MAX >> 2);
for (int i = 0; i <= t[lc(pos)].r - t[lc(pos)].l + 1; i++) {
if (ptr > t[rc(pos)].r - t[rc(pos)].l + 1) --ptr;
while (ptr <= t[rc(pos)].r - t[rc(pos)].l + 1) {
ll ret = t[rc(pos)].f[ptr] - (t[lc(pos)].sum - i * 1ll * p);
ll val = t[lc(pos)].f[i + 1] - 1 + (t[lc(pos)].sum - i * 1ll * p);
if (val < t[rc(pos)].f[ptr]) {
if (ptr > 0) --ptr;
break;
}
t[pos].f[i + ptr] = min(t[pos].f[i + ptr], max(t[lc(pos)].f[i], ret));
++ptr;
}
}
}
void build(int pos, int l, int r) {
t[pos].l = l;
t[pos].r = r;
t[pos].f.resize(r - l + 1 + 1);
t[pos].f[0] = LLONG_MIN >> 2;
t[pos].f.push_back(LLONG_MAX >> 2);
if (l == r) {
t[pos].sum = a[l];
t[pos].f[1] = p - a[l];
return;
}
int mid = (l + r) >> 1;
build(lc(pos), l, mid);
build(rc(pos), mid + 1, r);
pushup(pos);
}
ll query(int pos, int l, int r, ll cur = 0) {
if (t[pos].l == l && t[pos].r == r) {
assert(cur < LLONG_MAX / 4);
ll pp = upper_bound(t[pos].f.begin(), t[pos].f.end() - 1, cur) -
t[pos].f.begin() - 1;
return cur + t[pos].sum - p * pp;
}
int mid = (t[pos].l + t[pos].r) >> 1;
if (r <= mid)
return query(lc(pos), l, r, cur);
else if (l > mid)
return query(rc(pos), l, r, cur);
else
return query(rc(pos), mid + 1, r, query(lc(pos), l, mid, cur));
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> p;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
while (m--) {
int l, r;
cin >> l >> r;
cout << query(1, l, r) << endl;
}
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500003;
int n;
vector<int> v[maxn];
vector<int> lv;
void dfs(int root, int pa, int dep) {
if (v[root].size() == 1 && v[root][0] == pa) {
if (pa != 1) lv.push_back(dep);
return;
}
for (int to : v[root]) {
if (to == pa) continue;
dfs(to, root, dep + 1);
}
}
void solve() {
int rt = 1;
int ans = 0, tmp;
for (int to : v[rt]) {
lv.clear();
dfs(to, rt, 0);
tmp = 0;
sort((lv).begin(), (lv).end());
for (int d : lv) {
tmp = max(tmp + 1, d);
}
ans = max(ans, tmp + 1);
}
cout << ans << endl;
}
int main() {
cin >> n;
int x, y;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
solve();
return 0;
}
| 14 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
inline long long input() {
long long n;
cin >> n;
return n;
}
string base2(long long n) {
string a = "";
while (n >= 2) {
a += (char)(n % 2 + '0');
n /= 2;
}
a += (char)(n + '0');
reverse((a).begin(), (a).end());
return a;
}
const int MAXN = 1e6 + 10;
const int MOD = 1e9 + 7;
const int MOD2 = 998244353;
const long long INF = 8e18;
long long pw(long long a, long long b) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % MOD, b / 2)) % MOD
: pw(a * a % MOD, b / 2)));
}
int v[MAXN];
long long dp[MAXN];
long long ps[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, k, d;
cin >> n >> k >> d;
for (int i = 1; i <= n; i++) {
cin >> v[i];
}
sort(v + 1, v + n + 1);
dp[0] = 1;
int last = 0;
for (int i = k; i <= n; i++) {
if (v[i] - v[last + 1] <= d) {
dp[i] = 1;
}
if (dp[i - k + 1]) {
last = i - k + 1;
}
}
if (dp[n]) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long v[100500];
map<long long, long long> mm;
vector<long long> v2;
long long t1[400500];
void add_dp(int v, int tl, int tr, int ind, long long val) {
if (tl == tr) {
t1[v] = val;
return;
}
int tm = (tl + tr) >> 1;
int nv = v << 1;
if (ind <= tm)
add_dp(nv, tl, tm, ind, val);
else
add_dp(nv + 1, tm + 1, tr, ind, val);
t1[v] = max(t1[nv], t1[nv + 1]);
}
long long _get(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r) return t1[v];
int tm = (tl + tr) >> 1;
int nv = v << 1;
return max(_get(nv, tl, tm, l, min(tm, r)),
_get(nv + 1, tm + 1, tr, max(l, tm + 1), r));
}
const long double pi = 3.1415926535897932384626433832795;
long long dp[100500];
int main() {
long long n, i, r, h, x, l, mid, rr = 0;
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long double res = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> r >> h;
v[i] = r * r * h;
}
for (i = 1; i <= n; i++) {
v2.push_back(v[i]);
}
sort(v2.begin(), v2.end());
for (i = 0; i < n; i++) {
if (i && v2[i] == v2[i - 1])
mm[v2[i]] = mm[v2[i - 1]];
else
mm[v2[i]] = i + 1;
}
for (i = 1; i <= n; i++) {
if (i == 1) {
dp[i] = v[i];
add_dp(1, 1, n, mm[v[i]], v[i]);
} else {
dp[i] = _get(1, 1, n, 1, mm[v[i]] - 1) + v[i];
add_dp(1, 1, n, mm[v[i]], dp[i]);
}
}
for (i = 1; i <= n; i++) {
rr = max(rr, dp[i]);
}
res = rr;
res *= pi;
cout << setprecision(20) << res;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int p[1000][1000];
int main() {
int n, k, d;
cin >> n >> k >> d;
k = min(k, 1000);
for (int i = 1; i <= k; i++) {
int flag = 0, tmp = 1;
for (int j = 0; j < d; j++)
if ((tmp *= i) >= n) {
flag = 1;
break;
}
if (flag) {
k = i;
break;
}
if (i == k) {
cout << -1 << endl;
return 0;
}
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < d; j++) p[i][j] = p[i - 1][j];
int t = d - 1;
while (t >= 0 && p[i][t] == k - 1) {
p[i][t] = 0;
t--;
}
p[i][t]++;
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < n; j++) cout << p[j][i] + 1 << " ";
cout << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int64_t M1 = 998244353;
const int64_t M2 = 1000000007;
void solve() {
int64_t n, x;
cin >> n;
vector<int64_t> a(n);
int64_t y = 0;
for (int64_t i = 0; i < n + n; i++) {
cin >> x;
if (x > y) {
a.push_back(0);
y = x;
}
a.back()++;
}
vector<int64_t> dp(n + 1, 0);
dp[0] = 1;
for (int64_t i : a)
for (int64_t l = n; l >= i; l--) dp[l] |= dp[l - i];
cout << (dp[n] ? "YES" : "NO") << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int64_t t;
cin >> t;
while (t--) solve();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
int sum(int a, int b) { return a + b >= MOD ? a + b - MOD : a + b; }
int sub(int a, int b) { return a - b < 0 ? a - b + MOD : a - b; }
int mul(int a, int b) { return (1LL * a * b) % MOD; }
int pw(int a, int b) {
if (!b) return 1;
int r = pw(a, b / 2);
r = mul(r, r);
if (b % 2) r = mul(r, a);
return r;
}
const int MAXN = 3e5 + 7;
int v[MAXN];
int cu[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> v[i];
sort(v + 1, v + n + 1);
for (int i = 1; i <= n; i++) cu[i] = sum(cu[i - 1], v[i]);
int _n = pw(n, MOD - 2);
for (int k = 1; k <= n; k++) {
int ans = 0;
for (int i = n - k, j = 1; i > 0; i -= k, j++) {
int biyog = 0;
if (i - k > 0) biyog = cu[i - k];
ans = sum(ans, mul(j, sub(cu[i], biyog)));
}
cout << mul(ans, _n) << " ";
}
cout << "\n";
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long func(long long n) {
return ((n - 1) * (n)) - (((n - 2) * (n - 1)) / 2) + 1;
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
set<int> adj;
for (int i = 0; i < n; i++)
if (a[i] == -1) {
if (i + 1 < n) adj.insert(a[i + 1]);
if (i - 1 >= 0) adj.insert(a[i - 1]);
}
adj.erase(-1);
if (adj.size() == 0) {
cout << "0 7\n";
continue;
}
double mn = *min_element(adj.begin(), adj.end());
double mx = *max_element(adj.begin(), adj.end());
int k = round((mn + mx) / 2.0);
int m = 0;
for (int i = 0; i < n; i++)
if (a[i] == -1) a[i] = k;
for (int i = 0; i < n - 1; i++) m = max(m, abs(a[i] - a[i + 1]));
cout << m << ' ' << k << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void work() {
int n, s;
scanf("%d%d", &n, &s);
int m = s / n;
if (s % n) m++;
int der = m * n - s;
int x = n / 2;
if (n % 2) x++;
if ((x - 1) * m >= der) {
der = (x - 1) * m - der;
int y = der / (n - x + 1);
printf("%d\n", m + y);
} else {
der = der - (x - 1) * m;
int y = der / (n - x + 1);
if (der % (n - x + 1)) y++;
printf("%d\n", m - y);
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) work();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[100100];
int n;
int kx[100100], ky[100100];
vector<int> first[100100], second[100100];
void read(void) {
cin >> n;
for (int i = 0, x1, y1; i < n; ++i) {
cin >> x1 >> y1;
a[i] = make_pair(x1, y1);
first[x1].push_back(y1);
second[y1].push_back(x1);
}
sort(a, a + n);
for (int i = 0; i < 100100; ++i) {
sort(first[i].begin(), first[i].end());
sort(second[i].begin(), second[i].end());
}
}
void kill(void) {
int ans = 0;
for (int i = 0; i < n; ++i) {
int x1 = a[i].first;
int y1 = a[i].second;
++kx[x1];
++ky[y1];
int d;
if (first[x1].size() < second[y1].size())
for (int j = kx[x1]; j < (int)first[x1].size(); ++j) {
d = first[x1][j] - y1;
if (binary_search(second[y1].begin(), second[y1].end(), x1 + d) &&
binary_search(second[y1 + d].begin(), second[y1 + d].end(), x1 + d))
++ans;
}
else
for (int j = ky[y1]; j < (int)second[y1].size(); ++j) {
d = second[y1][j] - x1;
if (binary_search(first[x1].begin(), first[x1].end(), y1 + d) &&
binary_search(first[x1 + d].begin(), first[x1 + d].end(), y1 + d))
++ans;
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
read();
kill();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long bits[60];
long long ans = 0;
long long s, t;
void dfs(long long a, long long b, int pos, long long c) {
if (a + b == s && (a ^ b) == t) {
ans += c;
return;
} else if (a + b > s) {
return;
}
if ((t & bits[pos]) == bits[pos]) {
if ((a + bits[pos] + b) % bits[pos + 1] == s % bits[pos + 1])
dfs(a + bits[pos], b, pos + 1, c * 2);
} else {
if ((a + b) % bits[pos + 1] == s % bits[pos + 1]) {
dfs(a, b, pos + 1, c);
dfs(a + bits[pos], b + bits[pos], pos + 1, c);
}
}
}
int main() {
bits[0] = 1LL;
for (int i = 1; i < 60; i++) {
bits[i] = bits[i - 1] << 1;
}
cin >> s >> t;
if ((s & 1) != (t & 1)) {
cout << 0 << endl;
return 0;
} else {
if (t % bits[1] == 1) {
dfs(0, 1, 1, 2);
} else {
dfs(0, 0, 1, 1);
dfs(1, 1, 1, 1);
}
}
if (s == t) {
ans -= 2;
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
long long f(long long x) {
if (x % 2)
return x * (x - 1) / 2;
else
return x / 2 + f(x / 2);
}
int main() {
ios_base::sync_with_stdio(false);
long long n;
vector<long long> ans;
cin >> n;
for (int t = 0; t < 1; t++) {
long long sum = 0;
for (int k = 0; sum < 2 * n; k++) {
double l = 0, r = 2 * n;
int ITS = 100;
for (int i = 0; i < ITS; i++) {
double m = (l + r) / 2;
if (m * m + (2 * sum - 1) * m - 2 * n < 0) {
l = m;
} else {
r = m;
}
}
double x = l;
for (long long z = x - 5; z < x + 5; z++) {
if (z % 2 && z * z + (2 * sum - 1) * z == 2 * n && z > 0) {
ans.push_back((z << k));
}
}
sum += (1LL << k);
}
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
}
if (ans.size() == 0) {
cout << -1 << "\n";
}
cout << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:225450978")
#pragma GCC optimize("Ofast")
using namespace std;
const long long Mod = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double Pi = 3.141592653589793116, EPS = 1e-9,
Gold = ((1 + sqrt(5)) / 2);
long long keymod[] = {1000000007LL, 1000000009LL, 1000000021LL, 1000000033LL};
long long keyCount = sizeof(keymod) / sizeof(long long);
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcountll(s);
}
auto TimeStart = chrono::steady_clock::now();
auto TimeEnd = chrono::steady_clock::now();
void ControlIO(int argc, char* argv[]);
void TimerStart();
void TimerStop();
void Exit();
string cppstr_infile = "FILE.IN";
string cppstr_outfile = "FILE.OUT";
long long n, m;
vector<pair<long long, long long> > pts, seg;
vector<long long> Bal;
vector<vector<long long> > A;
void Input() {
cin >> n >> m;
pts.resize(n);
seg.resize(m);
A.resize(n);
Bal.resize(m, 0);
for (long long i = 0; i < n; i++) {
cin >> pts[i].first;
pts[i].second = i;
}
for (auto& x : seg) cin >> x.first >> x.second;
}
void Solve() {
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (seg[j].first <= pts[i].first && pts[i].first <= seg[j].second) {
A[i].push_back(j);
}
}
}
sort(pts.begin(), pts.end());
vector<long long> Col(n, -1);
for (auto z : pts) {
long long x = z.first, id = z.second;
for (auto t : A[id]) {
if (Bal[t] == 0) continue;
if (Bal[t] == -1) {
if (Col[id] == 0) {
cout << "-1";
return;
} else
Col[id] = 1;
} else {
if (Col[id] == 1) {
cout << "-1";
return;
} else
Col[id] = 0;
}
}
if (Col[id] == -1) Col[id] = 0;
for (auto t : A[id]) {
if (Col[id] == 0)
Bal[t]--;
else
Bal[t]++;
}
}
for (auto z : Col) cout << z << " ";
}
int main(int argc, char* argv[]) {
ControlIO(argc, argv);
ios_base::sync_with_stdio(0);
cin.tie(NULL);
Input();
TimerStart();
Solve();
TimerStop();
return 0;
}
void ControlIO(int argc, char* argv[]) {
char* infile = new char[cppstr_infile.size() + 1];
char* outfile = new char[cppstr_outfile.size() + 1];
strcpy(infile, cppstr_infile.c_str());
strcpy(outfile, cppstr_outfile.c_str());
}
void TimerStart() {}
void TimerStop() {}
void Exit() {
TimerStop();
exit(0);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[((int)1e6 + 5)], n, zero, mod, numb[] = {1, 6, 8, 9}, k[4],
perm[] = {0, 1, 2, 3};
string s;
vector<int> v;
int main() {
cin >> s;
n = s.size();
for (int i = 1; i <= n; i++) a[i] = s[i - 1] - '0';
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 3; j++)
if (a[i] == numb[j] and !k[j]) k[j] = i;
sort(k, k + 4);
for (int i = 1; i <= n; i++) {
if (i != k[0] and i != k[1] and i != k[2] and i != k[3] and a[i]) {
v.push_back(a[i]);
mod = (mod * 10 + a[i]) % 7;
}
zero += !a[i];
}
mod = (mod * 10000) % 7;
do {
if (!((mod + numb[perm[0]] * 1000 + numb[perm[1]] * 100 +
numb[perm[2]] * 10 + numb[perm[3]]) %
7))
break;
} while (next_permutation(perm, perm + 4));
for (typeof(v.begin()) it = v.begin(); it != v.end(); it++) cout << *it;
for (int i = 0; i <= 3; i++) cout << numb[perm[i]];
while (zero--) cout << 0;
cout << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int isvowel(char);
int main() {
string s, t;
cin >> s >> t;
int flag = 1;
if (s.size() != t.size()) {
cout << "No";
return 0;
} else {
for (int i = 0; i < s.size(); i++) {
if (isvowel(s[i]) != isvowel(t[i])) flag = 0;
}
}
if (flag)
cout << "Yes";
else
cout << "No";
return 0;
}
int isvowel(char a) {
if (a == 'a' || a == 'e' || a == 'i' || a == 'o' || a == 'u')
return 1;
else
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
string king[n];
long long dp[26][26];
for (long long i = 0; i < 26; i++) {
for (long long j = 0; j < 26; j++) dp[i][j] = 0;
}
for (long long i = 0; i < n; i++) {
long long left, right, len;
string kingi;
cin >> kingi;
king[i] = kingi;
len = kingi.length();
left = kingi[0] - 'a';
right = kingi[len - 1] - 'a';
for (long long j = 0; j < 26; j++) {
if (dp[j][left]) dp[j][right] = max(dp[j][right], dp[j][left] + len);
}
dp[left][right] = max(dp[left][right], len);
}
long long ans = 0;
for (long long i = 0; i < 26; i++) ans = max(ans, dp[i][i]);
cout << ans << endl;
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.