solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, i, mul = 1;
cin >> a >> b;
i = b % 10;
if (b - a == 0) {
cout << "1";
} else if (b - a >= 5) {
cout << "0";
} else if (b - a == 1) {
cout << i;
} else if (b - a == 2) {
mul = (i * (i - 1)) % 10;
cout << mul;
} else if (b - a == 3) {
mul = (i * (i - 1) * (i - 2)) % 10;
cout << mul;
} else if (b - a == 4) {
mul = (i * (i - 1) * (i - 2) * (i - 3)) % 10;
cout << mul;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using nagai = long long;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (auto& x : a) cin >> x;
if (count(a.begin(), a.end(), a[0]) == n) {
if (a[0] == 0) {
cout << "YES\n";
for (int i = 0; i < n; ++i) cout << 1 << ' ';
cout << '\n';
return 0;
}
cout << "NO\n";
return 0;
}
int mem = *max_element(a.begin(), a.end());
vector<nagai> ans(n, -1);
int start = -1;
for (int i = 0; i < n; ++i) {
int j = i == 0 ? n - 1 : i - 1;
if (a[j] < mem && a[i] == mem) {
start = i;
break;
}
}
assert(start != -1);
ans[start] = mem;
int st1 = start == 0 ? n - 1 : start - 1;
ans[st1] = mem * 2 + a[st1];
for (int i = 1; i < n - 1; ++i) {
int ind = (start - i - 1 + n) % n;
int ind1 = ind + 1 == n ? 0 : ind + 1;
ans[ind] = ans[ind1] + a[ind];
}
for (int i = 0; i < n; ++i) {
int i1 = i + 1 == n ? 0 : i + 1;
if (ans[i] % ans[i1] != a[i]) {
cerr << "bad:(\n";
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
for (nagai x : ans) cout << x << ' ';
cout << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma target("avx")
#pragma optimize("O3")
#pragma optimize("unroll-loops")
constexpr int INF = INT_MAX / 2;
constexpr long long LINF = LLONG_MAX / 2;
constexpr double eps = 1e-9;
constexpr double PI = 3.141592653589793238462643383279;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U>
inline bool chmax(T& lhs, const U& rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U>
inline bool chmin(T& lhs, const U& rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline long long gcd(long long a, long long b) {
while (b) {
long long c = a;
a = b;
b = c % b;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
bool isprime(long long n) {
if (n == 1) return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
template <typename T>
T mypow(T a, unsigned int b) {
if (!b) return T(1);
if (b & 1) return mypow(a, b - 1) * a;
T memo = mypow(a, b >> 1);
return memo * memo;
}
long long modpow(long long a, long long b, long long m) {
if (!b) return 1;
if (b & 1) return modpow(a, b - 1, m) * a % m;
long long memo = modpow(a, b >> 1, m);
return memo * memo % m;
}
template <typename T>
void printArray(std::vector<T>& vec) {
for (int i = 0; i < (long long)(vec.size() - 1); i++)
std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T>
void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int n, m, j, k, count[200010];
bool used[2][200010];
std::vector<int> vec[200010], vec2[200010];
int main() {
std::cin >> n >> m;
for (int i = 0; i < (long long)(m); i++) {
std::cin >> j >> k;
vec[j].push_back(k);
vec2[k].push_back(j);
count[k]++;
}
std::queue<int> que;
for (int i = 1; i <= (long long)(n); i++) {
if (!count[i]) que.push(i);
}
int t = 0;
while (!que.empty()) {
int node = que.front();
que.pop();
t++;
for (int i : vec[node]) {
count[i]--;
if (!count[i]) que.push(i);
}
}
if (t != n) {
std::cout << -1 << std::endl;
return 0;
}
std::string ans;
for (int i = 1; i <= (long long)(n); i++) {
if (!used[0][i] && !used[1][i])
ans += 'A';
else
ans += 'E';
que.push(i);
used[0][i] = true;
while (!que.empty()) {
int node = que.front();
que.pop();
for (int i : vec[node]) {
if (!used[0][i]) {
used[0][i] = true;
que.push(i);
}
}
}
que.push(i);
used[1][i] = true;
while (!que.empty()) {
int node = que.front();
que.pop();
for (int i : vec2[node]) {
if (!used[1][i]) {
used[1][i] = true;
que.push(i);
}
}
}
}
std::cout << std::count(ans.begin(), ans.end(), 'A') << std::endl
<< ans << std::endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(long long first) {
return first ? 8 * sizeof(long long) - __builtin_clzll(first) : 0;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();
std::mt19937 rng(seed);
using random_int = std::uniform_int_distribution<int>;
using random_ll = std::uniform_int_distribution<long long>;
struct TimeLimit {
TimeLimit(double seconds) : s(seconds - 0.2), last(clock()), mx(0) {}
operator bool() const {
clock_t cur = clock();
mx = max(mx, cur - last);
last = cur;
return clock() < s * CLOCKS_PER_SEC - 1.5 * mx;
}
double s;
mutable clock_t last, mx;
};
class TaskG {
public:
int N, M;
int simulate(int s, int t) {
while (t > 0) {
if (s < M)
s = (s + t) % N;
else
s = (s + N - t) % N;
--t;
}
return s;
}
void solve(istream& cin, ostream& cout) {
cin >> N >> M;
int S;
long long T;
cin >> S >> T;
--S;
S = simulate(S, T % N);
vector<pair<int, long long>> C(N, {-1, 0LL});
bool quick = true;
for (long long i = T / N - 1; i >= 0; --i) {
if (C[S].first != -1) {
if (quick) {
long long diff = C[S].second - i;
i %= diff;
quick = false;
}
} else {
C[S] = {simulate(S, N - 1), i};
}
S = C[S].first;
}
cout << S + 1 << '\n';
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
TaskG solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int vis[100005];
int fr[100005];
int steps[100005];
int main() {
int n;
cin >> n;
int a1;
bool first = 1;
int x;
memset(vis, 0, sizeof(vis));
memset(steps, 0, sizeof(steps));
memset(fr, 0, sizeof(fr));
int a, b;
for (int i = 1; i <= n; i++) {
cin >> x;
queue<pair<int, int> > q;
q.push(make_pair(x, 0));
while (!q.empty()) {
x = q.front().first;
b = q.front().second;
q.pop();
if (x > 100005) continue;
if (vis[x] == i) continue;
vis[x] = i;
steps[x] += b;
fr[x]++;
q.push(make_pair(x * 2, b + 1));
q.push(make_pair(x / 2, b + 1));
}
}
int res = 1e9;
for (int i = 0; i <= 100000; i++) {
if (fr[i] == n) {
if (res > steps[i]) res = steps[i];
}
}
cout << res;
}
| 5 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const double EPS = 1e-9;
double SQR(double x) { return x * x; }
bool zero(double x) { return abs(x) < EPS; }
int main() {
double x1, y1, r1, x2, y2, r2;
cin >> x1 >> y1 >> r1 >> x2 >> y2 >> r2;
double dis = sqrt(SQR(x1 - x2) + SQR(y1 - y2));
double r = 0;
if (dis > r1 + r2 || zero(dis - r1 - r2)) {
r = (dis - r1 - r2) / 2;
} else if (dis + r1 < r2 || zero(r2 - dis - r1)) {
r = (r2 - dis - r1) / 2;
} else if (dis + r2 < r1 || zero(r1 - dis - r2)) {
r = (r1 - dis - r2) / 2;
} else {
r = 0;
}
printf("%0.7lf\n", r);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
struct node {
node *r, *d;
int v;
} A[maxn][maxn];
int n, m, q, i, j, a, b, c, d, h, w;
int main() {
scanf("%d%d%d", &n, &m, &q);
for (i = 0; i <= n; i++)
for (j = 0; j <= m; j++) {
A[i][j].r = &A[i][j + 1];
A[i][j].d = &A[i + 1][j];
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf("%d", &A[i][j].v);
for (int qq = 1; qq <= q; qq++) {
scanf("%d%d%d%d%d%d", &a, &b, &c, &d, &h, &w);
node *p = &A[0][0], *q = &A[0][0];
while (--a) p = p->d;
while (--b) p = p->r;
while (--c) q = q->d;
while (--d) q = q->r;
node *u = p, *v = q;
for (i = 1; i <= w; i++) {
u = u->r;
v = v->r;
swap(u->d, v->d);
}
for (i = 1; i <= h; i++) {
u = u->d;
v = v->d;
swap(u->r, v->r);
}
u = p, v = q;
for (i = 1; i <= h; i++) {
u = u->d;
v = v->d;
swap(u->r, v->r);
}
for (i = 1; i <= w; i++) {
u = u->r;
v = v->r;
swap(u->d, v->d);
}
}
for (i = 1; i <= n; i++) {
node *a = &A[i][0];
for (j = 1; j <= m; j++) {
a = a->r;
printf("%d%c", a->v, j < m ? ' ' : '\n');
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 3 * 1e4 + 1;
long long int n, k;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
vector<vector<long long int>> divs(N + 1);
for (long long int i = 1; i < N; i++) {
for (long long int j = 1; j * j <= i; ++j) {
if (i % j) continue;
divs[i].push_back(j);
if (j * j != i) divs[i].push_back(i / j);
}
}
long long int tt;
cin >> tt;
for (long long int qq = 1; qq <= tt; ++qq) {
long long int a, b, c;
cin >> a >> b >> c;
long long int res = 1e12;
vector<long long int> sol(3, 0);
for (long long int i = 1; i < N; i++) {
long long int cur = abs(i - b);
long long int t1 = 1e12, t1_id = a;
for (long long int div : divs[i]) {
if (abs(div - a) < t1) {
t1 = abs(div - a);
t1_id = div;
}
}
cur += t1;
long long int up = (c + i - 1) / i, down = c / i;
long long int t2 = abs(up * i - c);
long long int t2_id = up * i;
if (abs(down * i - c) < t2) {
t2 = abs(down * i - c);
t2_id = down * i;
}
cur += t2;
if (cur < res) {
res = cur;
sol[0] = t1_id;
sol[1] = i;
sol[2] = t2_id;
}
}
cout << res << '\n';
for (long long int x : sol) cout << x << ' ';
cout << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* argv[]) {
string pokemons[8] = {"vaporeon", "jolteon", "flareon", "espeon",
"umbreon", "leafeon", "glaceon", "sylveon"};
string s;
int n;
cin >> n >> s;
for (int ip = 0; ip < 8; ++ip) {
string pks = pokemons[ip];
if (pks.length() == s.length()) {
bool isEq = true;
for (int i = 0; i < s.length(); ++i) {
if (s[i] != '.' && s[i] != pks[i]) {
isEq = false;
break;
}
}
if (isEq) {
cout << pks;
break;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Maxk = 1005;
string mul(string a, string b) {
int res[Maxk];
memset(res, 0, sizeof(res));
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
for (int i = 0; i < a.length(); i++) {
for (int j = 0; j < b.length(); j++) {
res[i + j] += (a[i] - '0') * (b[j] - '0');
}
}
for (int i = 0; i < Maxk; i++) {
if (res[i] >= 10) {
res[i + 1] += (res[i] / 10);
res[i] %= 10;
}
}
string ret;
bool flag = false;
for (int i = Maxk - 1; i >= 0; i--) {
if (flag || res[i]) {
flag = true;
ret = ret + (char)(res[i] + '0');
}
}
if (ret == "") ret = "0";
return ret;
}
string add(string a, string b) {
if (a.length() < b.length()) swap(a, b);
while (a.length() != b.length()) {
b = '0' + b;
}
for (int i = a.length() - 1; i >= 0; i--) {
a[i] += (b[i] - '0');
if (a[i] > '9' && i) {
a[i] -= 10;
a[i - 1]++;
}
}
if (a[0] > '9') {
a[0] -= 10;
a = '1' + a;
}
return a;
}
const int Maxn = 100005;
int a[Maxn], c[Maxn], res[Maxn];
int s[Maxn];
int main() {
int n, l, r;
scanf("%d %d %d", &n, &l, &r);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
s[c[i]] = i;
}
int diff = -1e9 - 3;
for (int i = 1; i <= n; i++) {
int val = a[s[i]];
int x1 = diff + 1 + val;
res[s[i]] = max(x1, l);
diff = res[s[i]] - a[s[i]];
if (res[s[i]] > r) {
cout << -1;
return 0;
}
}
for (int i = 1; i <= n; i++) {
printf("%d ", res[i]);
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[51];
int n, i;
cin >> n;
int k = 0;
for (i = 0; i < n; i++) cin >> s[i];
for (i = 0; i < strlen(s); i++) {
if (s[i] == 'R' && s[i + 1] == 'R') k++;
if (s[i] == 'G' && s[i + 1] == 'G') k++;
if (s[i] == 'B' && s[i + 1] == 'B') k++;
}
cout << k;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l, r, x;
cin >> n >> m;
vector<int> A(n);
for (int i = 0; i < n; i++) cin >> A[i];
while (m--) {
cin >> l >> r >> x;
l--, x--, r--;
int j = 0;
for (int i = l; i <= r; i++) j += A[i] < A[x];
cout << (l + j == x ? "Yes\n" : "No\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 10, mod = 1e9 + 7;
int f[N][N][3], g[N][N][2];
int n, k;
char a[N];
int s[N], t[N];
int main() {
scanf("%d%d", &n, &k);
scanf("%s", a + 1);
for (int i = n; i >= 1; i--) s[i] = a[i] - 'a', t[i] = 'z' - a[i];
f[n + 1][0][1] = 1;
for (int i = n; i >= 1; i--) {
for (int j = n - i + 1; j <= k; j++)
f[i][j][2] =
1ll * t[i] *
((f[i + 1][j - (n - i + 1)][0] + f[i + 1][j - n + i - 1][1]) % mod +
f[i + 1][j - n + i - 1][2]) %
mod;
for (int j = 0; j <= k; j++)
f[i][j][0] = 1ll * s[i] *
(1ll * f[i + 1][j][0] + f[i + 1][j][1] + f[i + 1][j][2]) %
mod;
for (int w = 0; w <= k; w++)
g[i][w][0] = (g[i + 1][w][0] + f[i + 1][w][0]) % mod;
for (int w = 0; w <= k; w++) f[i][w][1] = g[i][w][0];
for (int j = i + 1; j <= n; j++)
for (int w = (j - i) * (n - j + 1); w <= k; w++)
f[i][w][1] = (f[i][w][1] + f[j][w - (j - i) * (n - j + 1)][2]) % mod;
f[i][0][1]++;
}
int ans = 0;
ans = ((f[1][k][0] + f[1][k][1]) % mod + f[1][k][2]) % mod;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long readInt() {
bool minus = false;
long long result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
minus = true;
else
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = result * 10 + (ch - '0');
}
if (minus)
return -result;
else
return result;
}
long long exp(long long taban, long long us) {
long long carpan = taban % 1000000007;
long long temp = us;
long long res = 1;
while (temp) {
if (temp % 2) res = (res * carpan) % 1000000007;
temp /= 2;
carpan = (carpan * carpan) % 1000000007;
}
return res;
}
long long ebob(long long a, long long b) {
if (!a) return b;
return ebob(b % a, a);
}
long long ekok(long long a, long long b) { return (a * b) / ebob(a, b); }
int n, m, k;
vector<vector<char>> vec(105, vector<char>(105));
int dp[105][105][15];
bool safe(int r, int c) { return r >= 0 && r < n && c >= 0 && c < m; }
void go(int r, int c, int val, string move, string& ans, int& mx) {
if (dp[r][c][val % (k + 1)] >= val)
return;
else {
dp[r][c][val % (k + 1)] = val;
if (r == 0 && val % (k + 1) == 0) {
if (mx < dp[r][c][0]) {
ans = move;
mx = dp[r][c][0];
}
}
}
if (safe(r - 1, c - 1))
go(r - 1, c - 1, val + vec[r - 1][c - 1] - '0', move + 'L', ans, mx);
if (safe(r - 1, c + 1))
go(r - 1, c + 1, val + vec[r - 1][c + 1] - '0', move + 'R', ans, mx);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
vec.resize(n);
for (int i = 0; i < n; i++) vec[i].resize(m);
for (auto& x : vec)
for (auto& y : x) cin >> y;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int h = 0; h < k; h++) dp[i][j][h] = -1;
int res = -1;
string ans;
int col = -1;
for (int j = 0; j < m; j++) {
string tmp;
int mx = -1;
go(n - 1, j, vec[n - 1][j] - '0', "", tmp, mx);
if (res < mx) {
res = mx;
ans = tmp;
col = j + 1;
}
}
if (res == -1) {
cout << res;
return 0;
}
cout << res << "\n" << col << "\n" << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-16;
const int N = 200009;
const int inf = (int)1e9;
const int mod = (int)1e9 + 7;
struct quest {
int r, t, i;
bool friend operator<(quest a, quest b) {
return a.r == b.r ? a.t < b.t : a.r < b.r;
}
} q[N];
int a[N];
int ans[N];
multiset<int> s;
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &q[i].t, &q[i].r);
q[i].i = i;
}
sort(q + 1, q + m + 1);
for (int i = 1; i <= q[m].r; i++) {
s.insert(a[i]);
}
int pos = q[m].r;
int ind = q[m].i;
int type = q[m].t;
for (int i = m; i >= 1; i--) {
if (q[i].i > ind) {
type = q[i].t;
ind = q[i].i;
}
while ((pos > 0 && i <= 1) || (pos > q[i - 1].r && i >= 2)) {
if (type == 1) {
ans[pos] = *(--s.end());
s.erase(--s.end());
} else {
ans[pos] = *s.begin();
s.erase(s.begin());
}
pos--;
}
}
for (int i = 1; i <= n; i++) {
printf("%d%c", i <= q[m].r ? ans[i] : a[i], " \n"[i == n]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
set<int> v[100005];
int n, m;
int c[100005];
double tt;
int main() {
cin >> n >> m;
tt = clock();
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
v[a].insert(b);
v[b].insert(a);
}
for (int i = 1; i <= n; i++) c[i] = i;
for (int t = 1; t <= 200; t++) {
random_shuffle(c + 1, c + 1 + n);
c[n + 1] = c[1];
int i;
for (i = 1; i <= n; i++)
if (v[c[i]].count(c[i + 1])) break;
if (i >= m + 1) {
for (int j = 1; j <= m; j++) {
cout << c[j] << " " << c[j + 1] << endl;
}
return 0;
}
}
cout << -1;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const long long inf = 1e18;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, k;
cin >> n >> m >> k;
vector<long long> lst(n);
for (long long& x : lst) cin >> x;
vector<long long> a;
for (long long i = 0; i < n - 1; i++) {
a.push_back(lst[i + 1] - lst[i] - 1);
}
sort(a.begin(), a.end());
long long ans = n;
for (long long i = 0; i < n - k; i++) ans += a[i];
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int a = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) {
f = c == '-';
c = getchar();
}
while (isdigit(c)) {
a = a * 10 + c - 48;
c = getchar();
}
return f ? -a : a;
}
const int _ = 200003;
struct line {
long long k, b;
line(long long _k = -1e9, long long _b = -1e18) : k(_k), b(_b) {}
};
long double sect(line a, line b) { return 1.0 * (b.b - a.b) / (a.k - b.k); }
namespace Tree {
line now[_ << 2];
void init(long long x, long long l, long long r) {
if (now[x].k != -1e9 || now[x].b != -1e18) {
now[x] = line();
if (l != r) {
init((x << 1), l, ((l + r) >> 1));
init((x << 1 | 1), ((l + r) >> 1) + 1, r);
}
}
}
void ins(long long x, long long l, long long r, line p) {
line q = now[x];
if (q.k == p.k) {
now[x] = q.b > p.b ? q : p;
return;
}
if (p.k > q.k) swap(p, q);
long double t = sect(p, q);
if (t <= l) {
now[x] = q;
return;
}
if (t >= r) {
now[x] = p;
return;
}
if (t <= ((l + r) >> 1)) {
now[x] = q;
if (l != r) ins((x << 1), l, ((l + r) >> 1), p);
} else {
now[x] = p;
if (l != r) ins((x << 1 | 1), ((l + r) >> 1) + 1, r, q);
}
}
long long calc(line A, long long x) { return A.k * x + A.b; }
long long qry(long long x, long long l, long long r, long long tar) {
if (l == r) return calc(now[x], tar);
return max(calc(now[x], tar),
((l + r) >> 1) >= tar
? qry((x << 1), l, ((l + r) >> 1), tar)
: qry((x << 1 | 1), ((l + r) >> 1) + 1, r, tar));
}
} // namespace Tree
struct Edge {
long long end, upEd;
} Ed[_ << 1];
long long head[_], val[_], cntEd, N, mnsz, mnid, nowsz, ans;
bool vis[_];
void addEd(long long a, long long b) {
Ed[++cntEd] = (Edge){b, head[a]};
head[a] = cntEd;
}
void getsz(long long x) {
vis[x] = 1;
++nowsz;
for (long long i = head[x]; i; i = Ed[i].upEd)
if (!vis[Ed[i].end]) getsz(Ed[i].end);
vis[x] = 0;
}
long long getrt(long long x) {
long long sz = 1, mx = 1;
vis[x] = 1;
for (long long i = head[x]; i; i = Ed[i].upEd)
if (!vis[Ed[i].end]) {
long long t = getrt(Ed[i].end);
mx = max(mx, t);
sz += t;
}
mx = max(mx, nowsz - sz);
if (mx < mnsz) {
mnsz = mx;
mnid = x;
}
vis[x] = 0;
return sz;
}
void dfs1(long long x, long long sum, long long sz, long long v) {
ans = max(ans, Tree::qry(1, 1, N, sz) + sum);
vis[x] = 1;
for (long long i = head[x]; i; i = Ed[i].upEd)
if (!vis[Ed[i].end])
dfs1(Ed[i].end, sum + val[Ed[i].end] + v, sz + 1, val[Ed[i].end] + v);
vis[x] = 0;
}
void dfs2(long long x, long long sum, long long sz, long long v) {
Tree::ins(1, 1, N, line(v, sum));
vis[x] = 1;
for (long long i = head[x]; i; i = Ed[i].upEd)
if (!vis[Ed[i].end])
dfs2(Ed[i].end, sum + (sz + 1) * val[Ed[i].end], sz + 1,
val[Ed[i].end] + v);
vis[x] = 0;
}
void solve(long long x) {
mnsz = 1e9;
nowsz = 0;
getsz(x);
getrt(x);
vis[x = mnid] = 1;
Tree::init(1, 1, N);
Tree::ins(1, 1, N, line(0, 0));
vector<long long> nxt;
for (long long i = head[x]; i; i = Ed[i].upEd)
if (!vis[Ed[i].end]) {
nxt.push_back(Ed[i].end);
dfs1(Ed[i].end, 2 * val[x] + val[Ed[i].end], 2, val[x] + val[Ed[i].end]);
dfs2(Ed[i].end, val[Ed[i].end], 1, val[Ed[i].end]);
}
ans = max(ans, Tree::qry(1, 1, N, 1) + val[x]);
Tree::init(1, 1, N);
reverse(nxt.begin(), nxt.end());
for (auto t : nxt) {
dfs1(t, 2 * val[x] + val[t], 2, val[x] + val[t]);
dfs2(t, val[t], 1, val[t]);
}
for (auto t : nxt) solve(t);
}
signed main() {
N = read();
cntEd = 0;
ans = -1e18;
memset(vis, 0, sizeof(bool) * (N + 1));
memset(head, 0, sizeof(long long) * (N + 1));
for (long long i = 1; i < N; ++i) {
long long a = read(), b = read();
addEd(a, b);
addEd(b, a);
}
for (long long i = 1; i <= N; ++i) val[i] = read();
solve(1);
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int xi, yi, ti;
double pi;
} a[1009];
bool cmp(node x, node y) { return x.ti < y.ti; }
int dist(node x, node y) {
return ceil(sqrt(pow(x.xi - y.xi, 2) + pow(x.yi - y.yi, 2)));
}
int main() {
int i, j, x, y, k, t, n;
scanf("%d", &n);
double p;
for (i = 0; i < n; i++) {
cin >> a[i].xi >> a[i].yi >> a[i].ti >> a[i].pi;
}
sort(a, a + n, cmp);
double ans[1009];
for (i = 0; i < n; i++) {
ans[i] = a[i].pi;
for (j = 0; j < i; j++) {
if ((ans[j] + a[i].pi) > ans[i] &&
dist(a[i], a[j]) <= (a[i].ti - a[j].ti)) {
ans[i] = max(ans[i], ans[j] + a[i].pi);
}
}
}
double anss = 0;
for (i = 0; i < n; i++) {
anss = max(anss, ans[i]);
}
cout << std::setprecision(10) << anss << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x[100], k = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i];
}
sort(x, x + n);
for (int i = 0; i < n - 1; i++) {
if (x[i] != x[i + 1]) {
cout << x[i + 1] << endl;
break;
} else if (x[i + 1] == x[i]) {
k++;
}
}
if (k == n - 1) {
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> seq;
int binarySearch(vector<int>& vec, int value) {
int inf = 0, sup = vec.size() - 1;
while (inf < sup) {
int middle = (inf + sup) / 2;
if (seq[vec[middle]] < value)
inf = middle + 1;
else
sup = middle;
}
return inf;
}
void lis(vector<int>& vec) {
vector<int> path(seq.size());
vec.push_back(0);
for (int i = 1; i < seq.size(); i++) {
if (seq[i] > seq[vec.back()]) {
path[i] = vec.back();
vec.push_back(i);
} else {
int inf = binarySearch(vec, seq[i]);
if (inf > 0) path[i] = vec[inf - 1];
vec[inf] = i;
}
}
for (int i = vec.size() - 2; i >= 0; i--) vec[i] = path[vec[i + 1]];
for (int i = 0; i < vec.size(); i++) vec[i] = seq[vec[i]];
}
int main() {
int n, x;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
seq.push_back(x);
}
vector<int> v;
lis(v);
cout << v.size() << endl;
}
| 3 |
#include <bits/stdc++.h>
const long double eps = 0.00000001;
const long long MOD = 1e9 + 7;
using namespace std;
int ans;
string second[20], need[20], news[20];
int main() {
fflush(stdin);
cout << fixed, cout.precision(18);
ios_base::sync_with_stdio(false);
int i, j, n, m;
cin >> n;
for (i = 0; i < n; ++i) cin >> second[i];
for (i = 0; i < n; ++i) cin >> need[i];
bool fl = true;
for (i = 0; i < n; ++i)
if (second[i] != need[i]) fl = false;
if (fl) return cout << "Yes", 0;
fl = true;
for (i = 0; i < n; ++i) {
if (second[i] != need[n - i - 1]) fl = false;
}
if (fl) return cout << "Yes", 0;
for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j) news[i] += need[j][i];
fl = true;
for (i = 0; i < n; ++i) {
if (second[i] != news[i]) fl = false;
}
if (fl) return cout << "Yes", 0;
fl = true;
for (i = 0; i < n; ++i) {
if (second[i] != news[n - i - 1]) fl = false;
}
if (fl) return cout << "Yes", 0;
fl = true;
for (i = 0; i < n; ++i) {
reverse(need[i].begin(), need[i].end());
if (second[i] != need[i]) fl = false;
reverse(need[i].begin(), need[i].end());
}
if (fl) return cout << "Yes", 0;
fl = true;
for (i = 0; i < n; ++i) {
reverse(need[n - i - 1].begin(), need[n - i - 1].end());
if (second[i] != need[n - i - 1]) fl = false;
reverse(need[n - i - 1].begin(), need[n - i - 1].end());
}
if (fl) return cout << "Yes", 0;
fl = true;
for (i = 0; i < n; ++i) {
reverse(news[i].begin(), news[i].end());
if (second[i] != news[i]) fl = false;
reverse(news[i].begin(), news[i].end());
}
if (fl) return cout << "Yes", 0;
fl = true;
for (i = 0; i < n; ++i) {
reverse(news[n - i - 1].begin(), news[n - i - 1].end());
if (second[i] != news[n - i - 1]) fl = false;
reverse(news[n - i - 1].begin(), news[n - i - 1].end());
}
if (fl) return cout << "Yes", 0;
cout << "No";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100, MOD = 1000 * 1000 * 1000 + 7;
int n, k, ans, a[N], ps[N], fac[N];
string s;
int sum(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
int mul(int a, int b) { return 1LL * a * b % MOD; }
int power(int a, int b) {
if (b == 0) return 1;
if (b == 1) return a;
int res = power(a, b >> 1);
return mul(mul(res, res), power(a, b & 1));
}
int choose(int a, int b) {
if (a > b) return 0;
int A = fac[b], B = mul(fac[a], fac[b - a]);
return mul(A, power(B, MOD - 2));
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> k >> s;
fac[0] = 1;
for (int i = 1; i < N; i++) fac[i] = mul(fac[i - 1], i);
if (k)
for (int i = 1; i < N; i++)
ps[i] = sum(ps[i - 1], mul(power(10, i - 1), choose(k - 1, n - 1 - i)));
for (int i = 0; i < n; i++) a[n - i - 1] = s[i] - '0';
for (int i = 0; i < n; i++) ans = sum(ans, mul(a[i], ps[i]));
memset(ps, 0, sizeof ps);
ps[0] = a[0];
for (int i = 1; i < n; i++) ps[i] = sum(ps[i - 1], mul(power(10, i), a[i]));
if (k)
for (int i = 0; i < n; i++)
ans = sum(ans, mul(ps[i], choose(k - 1, n - i - 1 - 1)));
else
ans = ps[n - 1];
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int x[55][55], a, b, n, m;
int solve() {
int res = 1000000000;
for (int _n((n - a + 1) - 1), i(0); i <= _n; i++)
for (int _n((m - b + 1) - 1), j(0); j <= _n; j++) {
int cnt = 0;
for (int _n((a)-1), k(0); k <= _n; k++)
for (int _n((b)-1), t(0); t <= _n; t++) cnt += x[i + k][j + t];
res = min(res, cnt);
}
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int _n((n)-1), i(0); i <= _n; i++)
for (int _n((m)-1), j(0); j <= _n; j++) scanf("%d", &x[i][j]);
scanf("%d%d", &a, &b);
int r1 = solve();
swap(a, b);
int r2 = solve();
cout << min(r1, r2) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string mario;
cin >> mario;
int ans = 0;
for (int i = 0; i < mario.size() - 1; i++) {
if (mario[i] == 'V' && mario[i + 1] == 'K') {
ans++;
mario[i] = '0';
mario[i + 1] = '0';
}
}
for (int i = 0; i < mario.size() - 1; i++) {
if (mario[i] == 'K' && mario[i + 1] == 'K') {
ans++;
break;
}
if (mario[i] == 'V' && mario[i + 1] == 'V') {
ans++;
break;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
long long n;
int q;
while (scanf("%I64d %d", &n, &q) != EOF) {
for (int i = 1; i <= q; i++) {
long long x;
scanf("%lld", &x);
while (true) {
if (x % 2) break;
x += n - x / 2;
}
printf("%lld\n", x / 2 + 1);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct IO {
inline int read() {
int sum = 0, ff = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') ff = -1;
ch = getchar();
}
while (isdigit(ch)) sum = sum * 10 + (ch ^ 48), ch = getchar();
return sum * ff;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
}
inline void writeln(int x) {
write(x);
putchar('\n');
}
} fast;
const int maxn = 2333333;
map<int, int> c[maxn];
int n, m, ans, cnt, res;
int bo[maxn], x[maxn];
int y[maxn], z[maxn], Bo[maxn];
inline void add(int x, int bl, int val) {
while (x <= 1e9) {
c[bl][x] += val;
x += x & (-x);
}
}
inline int query(int x, int bl) {
int ret = 0;
while (x) {
ret += c[bl][x];
x -= x & (-x);
}
return ret;
}
int main() {
n = fast.read();
for (int i = 1; i <= n; i++) {
x[i] = fast.read();
y[i] = fast.read();
z[i] = fast.read();
Bo[i] = z[i];
}
sort(Bo + 1, Bo + n + 1);
int s = unique(Bo + 1, Bo + n + 1) - Bo - 1;
for (int i = 1; i <= n; i++)
z[i] = lower_bound(Bo + 1, Bo + s + 1, z[i]) - Bo;
for (int i = 1; i <= n; i++) {
if (x[i] == 1) add(y[i], z[i], 1);
if (x[i] == 2) add(y[i], z[i], -1);
if (x[i] == 3) fast.writeln(query(y[i], z[i]));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s, s2;
int i, j, sLen;
int main() {
cin >> s;
i = 0;
sLen = s.size();
for (i = 0; i < sLen; i++) {
if (s[i] != 'a') {
break;
}
}
if (i == sLen) {
s[sLen - 1] = 'z';
cout << s;
} else {
for (j = i; j < sLen; j++) {
if (s[j] == 'a') {
break;
}
}
if (j == sLen) {
for (j = i; j < sLen; j++) {
s[j] = s[j] - 1;
}
} else {
for (int x = i; x < j; x++) {
s[x] = s[x] - 1;
}
}
cout << s;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, m, i, j, k, c = 0, p;
cin >> n;
string s, s1;
cin >> s;
m = s.length();
set<char> v(s.begin(), s.end());
if (n > 26)
cout << -1;
else
cout << s.length() - v.size();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e5 + 7;
const int Max = 4e3 + 7;
const int Mod = 1e9 + 7;
const int Inf = 1e9 + 7;
int n, ans, h[Maxn], dp[Maxn], dp1[Maxn];
int main() {
ios_base::sync_with_stdio(false);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &h[i]);
dp1[1] = 1;
for (int i = 2; i <= n; i++) dp1[i] = min(dp1[i - 1] + 1, h[i]);
dp[n] = 1;
for (int i = n - 1; i > 0; i--) dp[i] = min(dp[i + 1] + 1, h[i]);
for (int i = 0; i <= n; i++) ans = max(ans, min(dp1[i], dp[i]));
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int modInverse(long long int a, long long int m) {
long long int m0 = m;
long long int y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long int q = a / m;
long long int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
bool sortinrev(const pair<int, int>& a, const pair<int, int>& b) {
if (a.first == b.first) return b.second > a.second;
return a.first > b.first;
}
void run(vector<long long int> v) {
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
}
void solve() {
int n;
cin >> n;
string F = "FastestFinger", A = "Ashishgup";
if (n == 1) {
cout << F << endl;
return;
}
if (n == 2) {
cout << A << endl;
return;
} else if ((n & (n - 1)) == 0) {
cout << F << endl;
return;
} else if (n & 1) {
cout << A << endl;
return;
}
int twos = 0, oth = 0;
while (n % 2 == 0) {
n = n / 2;
twos++;
}
for (int i = 3; i * i <= n; i += 2) {
int j = i;
while (n % j == 0) {
n = n / j;
oth++;
}
}
if (n > 2) oth++;
if (twos == 1) {
if (oth == 1) {
cout << F << endl;
return;
} else {
cout << A << endl;
}
} else {
cout << A << endl;
return;
}
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int cnt[105];
int main() {
ios_base::sync_with_stdio(false);
int n, sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
cnt[x]++;
sum += x;
}
int ans = sum;
for (int i = 1; i <= 100; i++) {
for (int j = 1; j <= 100; j++) {
if (cnt[i] and cnt[j]) {
for (int x = 2; x <= 100; x++) {
if (i % x == 0) {
ans = min(ans, sum - i + (i / x) - j + (j * x));
}
}
}
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long n, a[200005], b[200005], idx[200005], k;
bool vis[200005];
signed main() {
long long t;
cin >> t;
while (t--) {
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i];
idx[a[i]] = i;
}
for (long long i = 0; i < k; i++) {
cin >> b[i];
vis[idx[b[i]]] = 1;
}
long long ans = 1;
for (long long i = 0; i < k; i++) {
long long cur = idx[b[i]];
long long cnt = 0;
if (cur && !vis[cur - 1]) cnt++;
if (cur + 1 != n && !vis[cur + 1]) cnt++;
vis[cur] = 0;
ans *= cnt;
ans %= mod;
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = (3e3) + 10, mod = 1e9 + 7, inf = 1e18 + 10;
long long int n, m, x, y, d[maxn][maxn], di[maxn];
pair<long long int, long long int> a[maxn];
vector<pair<long long int, long long int> > v[maxn], g[maxn];
set<pair<long long int, long long int> > s;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
cin >> x >> y;
for (long long int i = 0; i < m; i++) {
long long int u, uu, w;
cin >> u >> uu >> w;
v[u].push_back({uu, w});
v[uu].push_back({u, w});
}
for (long long int i = 1; i <= n; i++) cin >> a[i].first >> a[i].second;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= n; j++) {
if (j == i)
s.insert({0, j});
else
s.insert({inf, j});
d[i][j] = inf;
}
d[i][i] = 0;
while (s.size()) {
pair<long long int, long long int> u = *s.begin();
s.erase(u);
for (long long int k = 0; k < v[u.second].size(); k++) {
if (u.first + v[u.second][k].second < d[i][v[u.second][k].first]) {
s.erase({d[i][v[u.second][k].first], v[u.second][k].first});
d[i][v[u.second][k].first] = u.first + v[u.second][k].second;
s.insert({d[i][v[u.second][k].first], v[u.second][k].first});
}
}
}
}
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= n; j++) {
if (i == j) continue;
if (d[i][j] <= a[i].first) g[i].push_back({j, a[i].second});
}
}
for (long long int i = 1; i <= n; i++) {
if (i == x)
s.insert({0, i});
else
s.insert({inf, i});
di[i] = inf;
}
di[x] = 0;
while (s.size()) {
pair<long long int, long long int> u = *s.begin();
s.erase(u);
for (long long int i = 0; i < g[u.second].size(); i++) {
if (u.first + g[u.second][i].second < di[g[u.second][i].first]) {
s.erase({di[g[u.second][i].first], g[u.second][i].first});
di[g[u.second][i].first] = u.first + g[u.second][i].second;
s.insert({di[g[u.second][i].first], g[u.second][i].first});
}
}
}
if (di[y] == inf)
cout << -1 << endl;
else
cout << di[y] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10, mod = 1e9 + 7;
string s[maxn], ans[maxn];
int cnt[maxn], n, m;
vector<int> dp[maxn];
bool check(int mid) {
int k = 2 * mid + 1;
fill(cnt, cnt + m, 0);
if (k > n || k > m) return 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < m; j++) {
if (dp[i][j] >= k) cnt[j]++;
if (i + k < n && dp[i + k][j] >= k) cnt[j]--;
}
int sm = 0;
for (int j = m - 1; j >= 0; j--) {
sm += cnt[j];
if (j + k < m) sm -= cnt[j + k];
if (s[i][j] == 'X' && sm == 0) return 0;
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie();
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) ans[i] += '.';
dp[i].resize(m);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') {
dp[i][j] = 0;
} else {
dp[i][j] =
1 + min(i == 0 ? 0 : dp[i - 1][j], j == 0 ? 0 : dp[i][j - 1]);
if (s[i - dp[i][j] + 1][j - dp[i][j] + 1] == '.') dp[i][j]--;
}
}
}
int l = 0, r = maxn;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (check(mid))
l = mid;
else
r = mid;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dp[i][j] >= (2 * l + 1)) ans[i - l][j - l] = 'X';
}
}
cout << l << "\n";
for (int i = 0; i < n; i++) cout << ans[i] << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
const int maxm = 2000005;
const int INF = 0x3f3f3f3f;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-18;
const int MOD = 1000000007;
template <class T>
inline void read(T &x) {
x = 0;
T flag = 1;
char c;
do {
c = (char)getchar();
if (c == '-') break;
} while (c < '0' || c > '9');
if (c == '-') c = '0', flag = -1;
do {
x = x * 10 + c - '0';
c = (char)getchar();
} while (c >= '0' && c <= '9');
x *= flag;
}
char str[1100];
string scf() {
scanf("%s", str);
return str;
}
template <class T>
inline void out(T x) {
if (x > 9) out(x / 10);
x = x % 10;
putchar('0' + x);
}
int qpow(int x, int n, int p) {
int ret = 1;
while (n) {
if (n & 1) ret = 1LL * ret * x % p;
x = 1LL * x * x % p;
n >>= 1;
}
return ret;
}
int main() {
int a, b, p;
long long x, c, e;
read(a);
read(b);
read(p);
read(x);
int invbj = qpow(a, p - 2, p);
int invb1 = invbj;
long long ans = 0;
for (int j = 1; j < p && j <= x; ++j) {
c = (x - j) / (p - 1);
e = ((j - 1LL * b * invbj % p) % p + p) % p;
if (c >= e) ans += (c - e) / p + 1;
invbj = 1LL * invbj * invb1 % p;
}
out(ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int ans[N], ma[N];
int t[N], x[N], y[N];
int main() {
int i, j, k;
int n, m, r;
scanf("%d%d", &r, &n);
for (i = 1; i <= n; i++) {
scanf("%d%d%d", &t[i], &x[i], &y[i]);
}
t[0] = 0;
x[0] = 1;
y[0] = 1;
ans[0] = 1;
ma[0] = 1;
for (i = 1; i <= n; i++) {
for (j = i - 1; j >= 0; j--) {
if (t[i] - t[j] > 1000) break;
int step = abs(x[i] - x[j]) + abs(y[i] - y[j]);
if (t[i] - t[j] >= step && ans[j] != 0) ans[i] = max(ans[i], ans[j] + 1);
}
if (j >= 0 && ma[j] > 0) ans[i] = max(ans[i], ma[j] + 1);
ma[i] = max(ma[i - 1], ans[i]);
}
printf("%d\n", max(ma[n] - 1, 0));
}
| 6 |
#include <bits/stdc++.h>
int main() {
char(*a)[9] = new char[3][9], ch = '?';
int index = 4, kol1 = 0, kol2 = 0, kol3 = 0;
scanf("%s%s%s", &a[0], &a[1], &a[2]);
for (int i = 0; i < 4; i++) switch (a[i][0]) {
case 'r':
kol1++;
break;
case 's':
kol2++;
break;
case 'p':
kol3++;
break;
}
if ((kol1 == 1) && (kol2 == 2)) ch = 'r';
if ((kol2 == 1) && (kol3 == 2)) ch = 's';
if ((kol1 == 2) && (kol3 == 1)) ch = 'p';
for (int i = 0; i < 3; i++)
if (a[i][0] == ch) index = i + 1;
switch (index) {
case 1:
printf("F");
break;
case 2:
printf("M");
break;
case 3:
printf("S");
break;
case 4:
printf("?");
break;
}
delete[] a;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int t;
int n, m, k;
vector<int> v[100086];
int x, y;
int deg[100086];
queue<int> q;
bool inq[100086];
vector<int> ans;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) v[i].clear(), deg[i] = inq[i] = 0;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
v[x].push_back(y), v[y].push_back(x);
deg[x]++, deg[y]++;
}
if (1ll * k * (k - 1) / 2 > m) {
puts("-1");
continue;
}
for (int i = 1; i <= n; i++) sort(v[i].begin(), v[i].end());
while (!q.empty()) q.pop();
for (int i = 1; i <= n; i++)
if (deg[i] <= k - 1) q.push(i), inq[i] = true;
bool suc = false;
while (!q.empty()) {
int x = q.front();
q.pop();
if (deg[x] == k - 1) {
vector<int> w;
w.push_back(x);
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i];
if (!deg[to]) continue;
w.push_back(to);
}
bool tag = true;
for (int i = 0; i < w.size() && tag; i++) {
for (int j = 0; j < i && tag; j++) {
tag &= binary_search(v[w[i]].begin(), v[w[i]].end(), w[j]);
}
}
if (tag) {
suc = true;
puts("2");
for (int i = 0; i < w.size(); i++) printf("%d ", w[i]);
puts("");
break;
}
}
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i];
if (!deg[to]) continue;
deg[to]--;
if (deg[to] <= k - 1 && !inq[to]) q.push(to), inq[to] = true;
}
deg[x] = 0;
}
if (suc) continue;
ans.clear();
for (int i = 1; i <= n; i++)
if (deg[i]) ans.push_back(i);
if (ans.empty())
puts("-1");
else {
printf("1 %d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
puts("");
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
typedef pair<pair<int, int>, pair<int, int> > P;
double eps = 1e-6;
set<pair<int, int> > exist;
set<P> fire[31];
int t[31];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t[i];
}
P s = P({0, 0}, {0, 1});
fire[0].insert(s);
for (int i = 0; i < n; i++) {
for (auto p : fire[i]) {
int x = p.first.first, y = p.first.second;
int dx = p.second.first, dy = p.second.second;
exist.insert({x, y});
for (int k = 0; k < t[i] - 1; k++) {
x += dx, y += dy;
exist.insert({x, y});
}
for (int k = -1; k <= 1; k += 2) {
double theta = PI / 4.0 * k;
int ndx = 0, ndy = 0;
double xx = dx * cos(theta) - dy * sin(theta);
double yy = dx * sin(theta) + dy * cos(theta);
if (abs(xx) < eps)
ndx = 0;
else if (xx > 0)
ndx = 1;
else
ndx = -1;
if (abs(yy) < eps)
ndy = 0;
else if (yy > 0)
ndy = 1;
else
ndy = -1;
P ns = P({x + ndx, y + ndy}, {ndx, ndy});
fire[i + 1].insert(ns);
}
}
}
cout << exist.size() << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int n, k;
cin >> n >> k;
vector<long long int> v;
for (long long int i = 1; i <= n; i++) {
v.push_back(i);
}
reverse(v.begin(), v.begin() + k + 1);
for (auto x : v) cout << x << " ";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long select(long long n, long long k) {
if (k == 2) {
return (n * (n - 1)) / 2;
}
if (k == 3) {
return (n * (n - 1) * (n - 2)) / 6;
}
if (k == 4) {
return (n * (n - 1) * (n - 2) * (n - 3)) / 24;
}
return 0;
}
long long d(long long num) {
if (num == 2) {
return 1;
}
if (num == 3) {
return 2;
}
return 9;
}
int main() {
long long n, k;
cin >> n >> k;
if (k == 1) {
cout << 1 << endl;
return 0;
}
long long ans = 0;
while (k != 1) {
long long count = select(n, k);
ans += count * d(k);
--k;
}
++ans;
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int low[222222], dfn[222222];
bool isused[222222];
vector<int> e[222222];
int top, groupnum, countid;
int st[222222], groupid[222222];
void findgroup(int now) {
dfn[now] = low[now] = countid++;
isused[now] = 1;
st[top++] = now;
for (auto &p : e[now]) {
int k = p;
if (isused[k]) {
if (!groupid[k]) low[now] = min(low[now], dfn[k]);
continue;
}
findgroup(k);
low[now] = min(low[now], low[k]);
}
if (low[now] == dfn[now]) {
groupnum++;
while (1) {
int x = st[--top];
groupid[x] = groupnum;
if (x == now) break;
}
}
}
vector<int> e2[222222];
int degree[222222], q[222222], front;
char res[222222];
int num[222222], mmap[222222];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i < n + 1; i++) {
scanf("%d", &num[i]);
if (i > 1) e[num[i - 1]].push_back(num[i]);
}
for (int i = 1; i < n + 1; i++) {
scanf("%d", &num[i]);
if (i > 1) e[num[i - 1]].push_back(num[i]);
}
for (int i = 1; i < n + 1; i++)
if (!isused[i]) findgroup(i);
if (groupnum < k) {
printf("NO\n");
return 0;
};
printf("YES\n");
for (int i = 1; i < n + 1; i++)
for (int k : e[i])
if (groupid[i] != groupid[k])
e2[groupid[i]].push_back(groupid[k]), degree[groupid[k]]++;
top = 0;
for (int i = 1; i < groupnum + 1; i++)
if (!degree[i]) q[top++] = i;
int x = 'a';
while (top != front) {
int k = q[front++];
mmap[k] = x;
x = (x == 'z') ? 'z' : x + 1;
for (int xx : e2[k]) {
degree[xx]--;
if (degree[xx] == 0) q[top++] = xx;
}
}
for (int i = 1; i < n + 1; i++) res[i] = mmap[groupid[i]];
printf("%s\n", res + 1);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long MAXN = 2e5 + 7;
long long len(long long n) {
long long res = 0;
while (n) {
n /= 10;
++res;
}
return res;
}
string to_string_(long long n) {
string res = "";
while (n) {
res += '0' + (n % 10);
n /= 10;
}
reverse(res.begin(), res.end());
return res;
}
long long stoi_(string s) {
long long res = 0;
for (long long i = 0; i < s.size(); ++i) {
res = res * 10 + (s[i] - '0');
}
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cout.precision(40);
long long k, p;
cin >> k >> p;
long long ans = 0;
for (long long i = 1; i <= k; ++i) {
long long add1 = i;
for (long long j = 0; j < len(i); ++j) {
add1 *= 10;
}
ans += add1;
string s = to_string_(i);
reverse(s.begin(), s.end());
ans += stoi_(s);
ans %= p;
}
cout << (ans + p) % p;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int Size, Array[int(2e5 + 10)];
vector<int> MaxPoint;
map<int, int> Mark;
void Read() {
scanf("%d", &Size);
for (int n, i = 0; i < Size; i++) {
scanf("%d", Array + i);
Mark[Array[i]] = true;
}
sort(Array, Array + Size);
for (int i = 0; i < Size; i++) {
for (long long Move = 2; Move <= 2e9 + 10; Move *= 2) {
int Find = Array[i] + Move;
vector<int> Tester;
Tester.push_back(Array[i]);
if (Mark[Find]) {
Tester.push_back(Find);
}
if (Mark[Array[i] + Move / 2]) {
Tester.push_back(Array[i] + Move / 2);
}
if (Tester.size() > MaxPoint.size()) {
MaxPoint = Tester;
}
}
}
}
void Write() {
printf("%d\n", int(MaxPoint.size()));
for (int i = 0; i < MaxPoint.size(); i++) {
printf("%d ", MaxPoint[i]);
}
}
int main() {
Read();
Write();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, k, z, m, pos, q, ans_v, y, root;
vector<long long> g[200500];
long long w[200500], lv[200500];
long long dp[3005][3005];
long long d[3005];
vector<long long> a, b, c;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
string t;
cin >> s >> t;
reverse(s.begin(), s.end());
n = s.size();
m = t.size();
long long ans = 0;
for (int i = 0; i < n - m + 1; i++) {
dp[i][0] = 1;
}
for (int i = 0; i < n; i++) {
for (int l = 0; l <= i; l++) {
int r = l + (n - 1 - i);
if (l >= m || s[i] == t[l]) {
dp[i + 1][l + 1] += dp[i][l];
if (dp[i + 1][l + 1] >= 998244353) {
dp[i + 1][l + 1] -= 998244353;
}
}
if (r >= m || s[i] == t[r]) {
dp[i + 1][l] += dp[i][l];
if (dp[i + 1][l] >= 998244353) {
dp[i + 1][l] -= 998244353;
}
}
}
}
for (int i = 0; i <= n; i++) {
ans += dp[n][i];
}
cout << ans % 998244353 << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
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 fpow(long long n, long long k, long long p = 1000000007) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
long long inv(long long a, long long p = 1000000007) {
return fpow(a, p - 2, p);
}
bool pr[1000007];
void sieve() {
pr[0] = 1;
pr[1] = 1;
for (int i = 2; i < sqrt(1000007); i++) {
for (int j = 2 * i; j <= 1000007; j += i) {
pr[j] = 1;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long temp, temp1, temp2;
long long n, m;
cin >> n;
vector<long long> a;
for (long long i = 0; i < n; i++) {
cin >> temp;
a.push_back(temp);
}
long long dp[n];
memset(dp, 0, sizeof(dp));
for (long long i = n - 2; i >= 0; i--) {
if (a[i + 1] <= a[i] * 2) {
dp[i] = dp[i + 1] + 1;
}
}
long long mx = -1;
for (long long i = 0; i < n; i++) {
mx = max(mx, dp[i]);
}
cout << mx + 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int MOD = 1E9 + 7;
int N, K;
char str[5000];
int dp[4000][4000];
int sum[4000];
int main() {
scanf("%d%d", &N, &K);
scanf("%s", str + 1);
dp[0][0] = 1;
sum[0] = 1;
for (int i = 1; i <= N; ++i)
for (int j = 0; j <= K; ++j) {
dp[i][j] = 1ll * (str[i] - 'a') * sum[j] % MOD;
for (int k = i - 1; k >= 0 && j - 1ll * (i - k) * (N - i + 1) >= 0; --k)
dp[i][j] = (dp[i][j] + 1ll * (25 - (str[i] - 'a')) *
dp[k][j - (i - k) * (N - i + 1)]) %
MOD;
sum[j] = (sum[j] + dp[i][j]) % MOD;
}
int tot = 0;
for (int i = 0; i <= N; ++i) tot = (tot + dp[i][K]) % MOD;
printf("%d\n", tot);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void amax(X& x, const Y& y) {
if (x < y) x = y;
}
template <class X, class Y>
void amin(X& x, const Y& y) {
if (x > y) x = y;
}
const int INF = 1e9 + 10;
const long long INFL = 1e18 + 10;
const int MAX = 1e5 + 10;
struct point {
long long x, y, z;
};
struct equation {
pair<long long, long long> S, a, b, c;
};
int n;
point crd[MAX];
void update(pair<long long, long long>& a,
const pair<long long, long long>& b) {
amax(a.first, b.first);
amin(a.second, b.second);
}
point get_solution(const equation& eq) {
if (eq.S.first > eq.S.second || eq.a.first > eq.a.second ||
eq.b.first > eq.b.second || eq.c.first > eq.c.second)
return point{INT64_MAX, INT64_MAX, INT64_MAX};
if ((eq.a.first + eq.b.first + eq.c.first > eq.S.second) ||
(eq.a.second + eq.b.second + eq.c.second < eq.S.first))
return point{INT64_MAX, INT64_MAX, INT64_MAX};
point res;
res.x = eq.a.first;
res.y = eq.b.first;
res.z = eq.c.first;
long long delta = max(0ll, eq.S.first - res.x - res.y - res.z);
res.x += min(delta, eq.a.second - eq.a.first);
delta -= min(delta, eq.a.second - eq.a.first);
res.y += min(delta, eq.b.second - eq.b.first);
delta -= min(delta, eq.b.second - eq.b.first);
res.z += min(delta, eq.c.second - eq.c.first);
delta -= min(delta, eq.c.second - eq.c.first);
assert(delta == 0);
return res;
}
long long DIV2(long long x) { return (x - (x & 1)) / 2; }
point check(long long D) {
equation eq;
eq.S = eq.a = eq.b = eq.c = make_pair(INT64_MIN, INT64_MAX);
for (int i = 1; i <= n; i++) {
equation nw;
nw.S = make_pair(-D + crd[i].x + crd[i].y + crd[i].z,
D + crd[i].x + crd[i].y + crd[i].z);
nw.a = make_pair(-D - crd[i].x + crd[i].y + crd[i].z,
D - crd[i].x + crd[i].y + crd[i].z);
nw.b = make_pair(-D + crd[i].x - crd[i].y + crd[i].z,
D + crd[i].x - crd[i].y + crd[i].z);
nw.c = make_pair(-D + crd[i].x + crd[i].y - crd[i].z,
D + crd[i].x + crd[i].y - crd[i].z);
update(eq.S, nw.S);
update(eq.a, nw.a);
update(eq.b, nw.b);
update(eq.c, nw.c);
}
for (int r = 0; r < 2; r++) {
equation tr = eq;
tr.S.first = DIV2(tr.S.first - 3 * r + 1);
tr.a.first = DIV2(tr.a.first - r + 1);
tr.b.first = DIV2(tr.b.first - r + 1);
tr.c.first = DIV2(tr.c.first - r + 1);
tr.S.second = DIV2(tr.S.second - 3 * r);
tr.a.second = DIV2(tr.a.second - r);
tr.b.second = DIV2(tr.b.second - r);
tr.c.second = DIV2(tr.c.second - r);
point sol = get_solution(tr);
if (sol.x != INT64_MAX) {
point ans;
ans.x = sol.y + sol.z + r;
ans.y = sol.x + sol.z + r;
ans.z = sol.x + sol.y + r;
return ans;
}
}
return point{INT64_MAX, INT64_MAX, INT64_MAX};
}
point bfind() {
long long l = 0, r = 3e18, i = (l + r) / 2;
while (l != i && i != r) {
if (check(i).x != INT64_MAX)
r = i;
else
l = i;
i = (l + r) / 2;
}
for (long long i = l; i <= r; i++) {
point ret = check(i);
if (ret.x != INT64_MAX) return ret;
}
return point();
}
void process() {
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> crd[i].x >> crd[i].y >> crd[i].z;
point ans = bfind();
cout << ans.x << " " << ans.y << " " << ans.z << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
process();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int inf = 0x3f3f3f3f;
inline long long read() {
long long X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(int x) {
write(x);
putchar('\n');
}
pair<int, int> hero[maxn], que[maxn];
int idx[maxn], monn, heron, cur;
int monster[maxn], st[maxn];
class ST_Class {
private:
static const int maxnlog = 20;
int n, rmq[maxn];
int dp[maxn][maxnlog];
public:
void init() {
rmq[1] = 0;
for (int i = 2; i < maxn; i++) rmq[i] = rmq[i >> 1] + 1;
}
void resize(int siz) {
n = siz;
for (int i = 1; i <= n; i++) dp[i][0] = monster[i];
for (int i = 1, maxlog = rmq[n]; i <= maxlog; i++)
for (int j = 1; j + (1 << i) - 1 <= n; j++)
dp[j][i] = max(dp[j][i - 1], dp[j + (1 << (i - 1))][i - 1]);
}
int query(int l, int r) {
int tmp = rmq[r - l + 1];
return max(dp[l][tmp], dp[r - (1 << tmp) + 1][tmp]);
}
} ST;
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return a.second < b.second;
return a.first < b.first;
}
bool cal(int id) {
int num = idx[id];
if (num == -1)
return false;
else
return que[num].second >= ST.query(cur + 1, min(monn, cur + id));
}
int find() {
int l = 1, r = que[heron].first;
while (l <= r) {
int mid = (l + r) >> 1;
if (l == mid) {
if (cal(r))
return r;
else if (cal(l))
return l;
else
return -1;
}
if (cal(mid))
l = mid;
else
r = mid - 1;
}
return -1;
}
void debug() {
for (int i = 1; i <= heron; i++) cout << que[i].second << " ";
cout << endl;
}
int main() {
ST.init();
int T = read();
while (T--) {
monn = read();
for (int i = 1; i <= monn; i++) monster[i] = read();
ST.resize(monn);
heron = read();
for (int i = 1; i <= heron; i++) {
int p = read(), s = read();
hero[i] = make_pair(s, p);
}
sort(hero + 1, hero + 1 + heron, cmp);
int cnt = 0;
for (int i = 1; i <= heron; i++) {
while (cnt and hero[i].second >= hero[st[cnt]].second) cnt--;
st[++cnt] = i;
}
heron = cnt;
for (int i = 1; i <= heron; i++) que[i] = hero[st[i]];
for (int i = 1, flg = 1; i <= monn; i++) {
while (flg <= heron and que[flg].first < i) flg++;
idx[i] = que[flg].first >= i ? flg : -1;
}
cur = 0;
int ans = 0;
while (cur < monn) {
int num = find();
if (num == -1) {
ans = -1;
break;
} else
cur += num, ans++;
}
writeln(ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 12;
pair<int, int> v[maxn];
map<int, int> mn;
int mx[maxn];
bool b[maxn];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n, q, t, p, x;
cin >> n;
for (int i = 0; i < n; i++) cin >> v[i].second;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> t;
if (t == 1) {
cin >> p >> x;
v[p - 1].first = i;
v[p - 1].second = x;
} else {
cin >> x;
b[i] = 1;
mn[i] = x;
}
}
for (int i = q - 1; i >= 0; i--) {
if (i == q - 1)
mx[i] = -1;
else
mx[i] = mx[i + 1];
if (b[i]) {
mx[i] = max(mx[i], mn[i]);
}
}
for (int i = 0; i < n; i++) {
cout << max(v[i].second, mx[v[i].first]) << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, kk;
cin >> n >> kk;
char t[n];
cin >> t;
char arr[n * kk], sub[n];
int i = 0, c, j = 0;
for (i = 0; i < n; i++) arr[i] = t[i];
i = 1;
c = 1;
while (1) {
int k = 0, p = 1;
while (i + k < n) {
if (arr[i + k] == t[k]) {
k++;
continue;
} else {
p = 0;
break;
}
}
if (p == 0) {
i++;
continue;
}
if (p == 1) {
while (k < n) {
sub[j] = t[k];
j++;
k++;
}
break;
}
}
cout << t;
int y;
for (c = 1; c < kk; c++)
for (y = 0; y < j; y++) cout << sub[y];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double PI = 2 * acos(0.0);
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.ff);
cerr << ",";
_print(p.ss);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long power(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
n = n / 2;
x = x * x % mod;
}
return res % mod;
}
long long modinv(long long n) { return power(n, mod - 2); }
void solve() {
long long n;
cin >> n;
long long i, a[n];
for (i = 0; i < n; i++) cin >> a[i];
long long ins = 0;
if (n & 1) {
for (i = 1; i < n; i++) {
if (a[i - 1] >= a[i]) {
cout << "YES";
return;
}
}
cout << "NO";
} else {
cout << "YES";
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
solve();
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500111;
int n, Q, height[MAXN];
long long a[MAXN];
struct SegmentTree {
int lmx, rmx, ans;
} tr[MAXN << 2];
inline int sign(long long x) {
if (x < 0)
return -1;
else
return x > 0;
}
inline int getnode(int l, int r) { return l + r | l != r; }
inline void update(int k, int l, int r) {
int m = l + r >> 1, lc = getnode(l, m), rc = getnode(m + 1, r);
int lr = sign(a[m]), rl = sign(a[m + 1]), l1 = m - l + 1, l2 = r - m;
SegmentTree &now = tr[k], c1 = tr[lc], c2 = tr[rc];
now.lmx = c1.lmx;
now.rmx = c2.rmx;
now.ans = max(c1.ans, c2.ans);
if (!lr || !rl || lr < rl) return;
if (c1.lmx == l1) now.lmx = l1 + c2.lmx;
if (c2.rmx == l2) now.rmx = l2 + c1.rmx;
now.ans = max(now.ans, c1.rmx + c2.lmx);
}
inline void build_tree(int l, int r) {
int k = getnode(l, r);
if (l == r) {
tr[k].lmx = tr[k].rmx = tr[k].ans = 1;
return;
}
int mid = l + r >> 1;
build_tree(l, mid);
build_tree(mid + 1, r);
update(k, l, r);
}
inline void modify(int x, int l, int r, int d) {
if (l == r) return;
int mid = l + r >> 1;
if (x > mid)
modify(x, mid + 1, r, d);
else
modify(x, l, mid, d);
update(getnode(l, r), l, r);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> height[i];
if (n == 1) {
cin >> Q;
for (; Q; --Q) puts("1");
return 0;
}
for (int i = 1; i < n; ++i) {
a[i] = height[i + 1] - height[i];
}
build_tree(1, n - 1);
cin >> Q;
for (; Q; --Q) {
int l, r, d;
cin >> l >> r >> d;
if (l > 1) {
a[l - 1] += d;
modify(l - 1, 1, n - 1, d);
}
if (r < n) {
a[r] -= d;
modify(r, 1, n - 1, -d);
}
printf("%d\n", tr[getnode(1, n - 1)].ans + 1);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int cnt[27];
char s[5005], t[5005];
bool check(int i) {
for (int x = 25; ~x; x--)
for (int j = 0; j < cnt[x]; j++)
if (x + 'a' != t[i++]) return x + 'a' > t[i - 1];
return false;
}
int main() {
gets(s);
gets(t);
int x = cnt[26] = 1, i;
for (i = 0; s[i]; i++) cnt[s[i] - 'a']++;
for (i = 0; t[i]; i++) {
for (x = t[i] - 'a'; !cnt[x]; x++)
;
if (x == t[i] - 'a') {
s[i] = x + 'a';
cnt[x]--;
if (check(i + 1)) continue;
cnt[x]++;
for (x++; !cnt[x]; x++)
;
}
if (x == 26) return puts("-1") & 0;
cnt[x]--;
s[i++] = x + 'a';
break;
}
while (s[i]) {
for (x = 0; !cnt[x]; x++)
;
cnt[x]--;
s[i++] = x + 'a';
}
puts(s);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int num(char x, char y) { return (x - 48) * 10 + (y - 48); }
char s[1000000];
int main() {
gets(s);
int n = strlen(s), i;
long long int ans = 0;
for (i = 0; i < n; i++) {
if (s[i] == '4' || s[i] == '8' || s[i] == '0') ans++;
}
for (i = 0; i < n - 1; i++) {
if (num(s[i], s[i + 1]) % 4 == 0) {
ans += i + 1;
}
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char p[100100];
int a[5050], b[5050], n, m, primes[10010], pc, gg[5050];
int get(int x) { return binary_search(b, b + m, x) ? -1 : 1; }
int f(int x) {
int res = 0;
for (int i = (0); i < ((pc)); ++i) {
if (primes[i] * primes[i] > x) break;
if (x % primes[i] != 0) continue;
int c = 0;
while (x % primes[i] == 0) ++c, x /= primes[i];
res += c * get(primes[i]);
}
if (x > 1) res += get(x);
return res;
}
int gcd(int a, int b) {
while (a) b %= a, swap(a, b);
return b;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = (0); i < ((n)); ++i) scanf("%d", a + i);
for (int i = (0); i < ((m)); ++i) scanf("%d", b + i);
memset((p), (1), sizeof((p)));
p[0] = p[1] = 0;
for (int i = 2; i * i < 100100; ++i)
if (p[i])
for (int j = i * i; j < 100100; j += i) p[j] = 0;
pc = 0;
for (int i = (0); i < ((100100)); ++i)
if (p[i]) primes[pc++] = i;
int init = 0;
for (int i = (0); i < ((n)); ++i) init += f(a[i]);
int g = -1, res = init;
for (int i = (0); i < ((n)); ++i) {
g = (g == -1 ? a[0] : gcd(g, a[i]));
gg[i] = g;
}
int dv = 1;
for (int i = n - 1; i >= 0; --i) {
int ggg = gg[i] / dv;
int c = f(ggg);
if (c < 0) res -= (i + 1) * c, dv *= ggg;
}
printf("%d\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
long long cub(int a) { return a * 1ll * a * 1ll * a; }
int get(long long x) {
if (x <= 7) return x;
int s = pow(x, 1. / 3), c = s;
for (int a = max(1, s - 1); a < s + 2; a++)
if (cub(a) <= s) c = a;
return 1 + get(x - cub(c));
}
pair<int, long long> solve(long long x) {
if (x <= 7) return make_pair(x, x);
int c = (int)(pow(x, 1. / 3) + 0.00001);
auto ans1 = solve(min(x - cub(c), cub(c + 1) - cub(c) - 1));
auto ans2 = solve(min(x - cub(c - 1), cub(c) - cub(c - 1) - 1));
if (ans1.first > ans2.first)
return make_pair(ans1.first + 1, ans1.second + cub(c));
if (ans1.first < ans2.first)
return make_pair(ans2.first + 1, ans2.second + cub(c - 1));
return make_pair(ans1.first + 1,
max(ans1.second + cub(c), ans2.second + cub(c - 1)));
}
int main() {
long long x;
scanf("%lld", &x);
auto np = solve(x);
printf(
"%d "
"%lld"
"\n",
np.first, np.second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int ans[5000] = {0}, all = 0;
char c;
int Found(int wh) {
while (cin >> c) {
if (c == 'd') {
ans[wh]++;
} else if (c == 'a') {
all++;
Found(all - 1);
} else if (c == '/') {
cin >> c >> c;
if (c == 'a') return 0;
}
}
return 0;
}
int main() {
while (cin >> c) {
if (c == 'a') {
all++;
Found(all - 1);
}
}
sort(ans, ans + all);
for (int i = 0; i < all; i++) printf("%d%c", ans[i], i == all - 1 ? 10 : 32);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 8e5 + 7;
const int C = 30;
template <typename T>
inline T read() {
T res = 0, flag = 1;
char in = getchar();
while (!isdigit(in)) {
if (in == '-') flag = -1;
in = getchar();
}
while (isdigit(in)) {
res = (res << 1) + (res << 3) + in - '0';
in = getchar();
}
return res * flag;
}
template <typename T>
inline void chkmax(T &a, T b) {
if (a < b) a = b;
}
template <typename T>
inline void chkmin(T &a, T b) {
if (a > b) a = b;
}
namespace SGT {
int ls[MAXN << 4], rs[MAXN << 4];
int tot;
void update(int &rt, int l, int r, int x) {
if (!rt) rt = ++tot;
if (l == r) return;
int mid = l + r >> 1;
if (x <= mid)
update(ls[rt], l, mid, x);
else
update(rs[rt], mid + 1, r, x);
}
bool query(int rt, int l, int r, int x, int y) {
if (!rt) return 0;
if (x <= l && r <= y) return 1;
int mid = l + r >> 1;
if (y <= mid) return query(ls[rt], l, mid, x, y);
if (x > mid) return query(rs[rt], mid + 1, r, x, y);
return query(ls[rt], l, mid, x, y) | query(rs[rt], mid + 1, r, x, y);
}
void merge(int &rt, int x, int y) {
if (!x || !y) return (void)(rt = (x | y));
rt = ++tot;
merge(ls[rt], ls[x], ls[y]);
merge(rs[rt], rs[x], rs[y]);
}
void print(int x, int l, int r) {
if (!x) return;
if (l == r) return (void)printf("%d ", l);
int mid = l + r >> 1;
print(ls[x], l, mid);
print(rs[x], mid + 1, r);
}
} // namespace SGT
int rt[MAXN];
namespace SAM {
int mal[MAXN], ch[C][MAXN];
int last = 1, len, tot = 1, pre[MAXN];
int Ht[MAXN], rk[MAXN], pos[MAXN];
int f[MAXN], g[MAXN];
inline void insert(int x, int W) {
int np = ++tot, p = last;
mal[last = np] = mal[p] + 1;
while (!ch[x][p] && p) ch[x][p] = np, p = pre[p];
if (!p)
pre[np] = 1;
else {
int q = ch[x][p];
if (mal[q] == mal[p] + 1)
pre[np] = q;
else {
int nq = ++tot;
pos[nq] = W;
mal[nq] = mal[p] + 1;
pre[nq] = pre[q];
pre[q] = pre[np] = nq;
for (int i = 0; i < C; ++i) ch[i][nq] = ch[i][q];
while (p && ch[x][p] == q) ch[x][p] = nq, p = pre[p];
}
}
SGT::update(rt[np], 1, len, W);
pos[np] = W;
}
inline void init() {
for (int i = 1; i <= tot; ++i) ++Ht[mal[i]];
for (int i = 1; i <= len; ++i) Ht[i] += Ht[i - 1];
for (int i = 1; i <= tot; ++i) rk[Ht[mal[i]]--] = i;
for (int i = tot; i >= 1; --i) {
int u = rk[i];
SGT::merge(rt[pre[u]], rt[u], rt[pre[u]]);
}
}
inline int Work() {
g[1] = 1;
int res = 0;
for (int i = 2; i <= tot; ++i) {
int u = rk[i];
int fa = pre[u];
if (fa == 1) {
g[u] = u;
f[u] = 1;
continue;
}
bool tmp = 0;
tmp = SGT::query(rt[g[fa]], 1, len, pos[u] - mal[u] + mal[pre[g[fa]]] + 1,
pos[u] - 1);
g[u] = tmp ? u : g[fa];
f[u] = f[fa] + tmp;
}
for (int i = 1; i <= tot; ++i) chkmax(res, f[i]);
return res;
}
} // namespace SAM
int n;
char str[MAXN];
inline void init() {
SAM::len = n = read<int>();
scanf("%s", str + 1);
for (int i = 1; i <= n; ++i) SAM::insert(str[i] - 'a' + 1, i);
SAM::init();
}
inline void solve() { printf("%d", SAM::Work()); }
int main() {
init();
solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100007];
int prefix[100007];
int l, r;
int ql, qr;
int main() {
scanf("%d%d%d%d%d", &n, &l, &r, &ql, &qr);
int i;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
prefix[0] = 0;
for (i = 1; i <= n; i++) prefix[i] = prefix[i - 1] + a[i];
int L, R;
int ans = -1;
int cur;
for (i = 0; i <= n; i++) {
L = i;
R = n - i;
cur = prefix[L] * l;
cur += (prefix[n] - prefix[n - R]) * r;
if (L != R) {
if (L > R) {
cur = cur + (L - R - 1) * ql;
} else {
cur = cur + (R - L - 1) * qr;
}
}
if (ans == -1 || cur < ans) ans = cur;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> bs;
vector<int> bx;
long long f[60][2];
int main() {
long long s, x;
cin >> s >> x;
long long ss = s;
long long xx = x;
if (x == 0) {
if (s % 2 == 0) {
cout << 1 << endl;
} else {
cout << 0 << endl;
}
return 0;
}
do {
bs.push_back(s % 2);
s /= 2;
} while (s != 0);
do {
bx.push_back(x % 2);
x /= 2;
} while (x != 0);
f[0][0] = 1;
for (int i = 1; i <= bs.size(); ++i) {
int cur_bit_s = (i <= bs.size() ? bs[i - 1] : 0);
int cur_bit_x = (i <= bx.size() ? bx[i - 1] : 0);
if (cur_bit_x == 0 && cur_bit_s == 0) {
f[i][1] = f[i - 1][0];
f[i][0] = f[i - 1][0];
}
if (cur_bit_x == 1 && cur_bit_s == 1) {
f[i][1] = 0;
f[i][0] = f[i - 1][0] * 2;
}
if (cur_bit_x == 0 && cur_bit_s == 1) {
f[i][0] = f[i - 1][1];
f[i][1] = f[i - 1][1];
}
if (cur_bit_x == 1 && cur_bit_s == 0) {
f[i][1] = f[i - 1][1] * 2;
f[i][0] = 0;
}
}
if (bs.size() > bx.size()) {
cout << f[bs.size() - 1][1] << endl;
} else {
if (xx == ss) {
cout << max(f[bx.size()][0] - 2, 0ll) << endl;
} else {
cout << f[bx.size()][0] << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, f[105], I, g[105];
string nam[105];
string s;
vector<int> v;
void get(string w) {
if (w == "") return;
bool ok = 0;
for (int i = 1; i < I; ++i)
if (w == nam[i]) ok = 1, v.push_back(f[i]), i = I;
if (!ok) v.push_back(3);
}
int solve() {
v.clear();
string w = "";
s += " ";
for (int i = 0; i < s.size(); ++i) {
if (s[i] == ' ') {
get(w);
w = "";
continue;
}
if (s[i] == '+') {
get(w);
w = "";
v.push_back(-1);
continue;
}
if (s[i] == '-') {
get(w);
w = "";
v.push_back(-2);
continue;
}
if (s[i] == '/') {
get(w);
w = "";
v.push_back(-3);
continue;
}
if (s[i] == '*') {
get(w);
w = "";
v.push_back(-4);
continue;
}
if (s[i] == '(') {
get(w);
w = "";
v.push_back(-5);
continue;
}
if (s[i] == ')') {
get(w);
w = "";
v.push_back(-6);
continue;
}
w += s[i];
}
int k = 0;
g[0] = -1;
for (int i = 0; i < v.size(); ++i) {
if (!v[i]) return 0;
if (v[i] == -5) {
g[++k] = -1;
continue;
}
if (v[i] == -6) {
g[--k] = 3;
continue;
}
if (v[i] == 1) {
if (g[k] != -1) return 0;
g[k] = 1;
continue;
}
if (v[i] == 2) {
if (g[k] == -3) return 0;
g[k] = 2;
continue;
}
if (v[i] == 3) {
g[k] = 3;
continue;
}
if (v[i] == -1 || v[i] == -2) {
g[k] = v[i];
continue;
}
if (v[i] == -3 || v[i] == -4) {
if (g[k] == 1) return 0;
g[k] = v[i];
continue;
}
}
k = 0;
int ret = 3;
for (int i = 0; i < v.size(); ++i) {
if (v[i] == -5) {
++k;
continue;
}
if (v[i] == -6) {
--k;
continue;
}
if (k) continue;
if (v[i] == 1 || v[i] == -1 || v[i] == -2) return 1;
if (v[i] == 2 || v[i] == -3 || v[i] == -4) ret = 2;
}
return ret;
}
int main() {
f[0] = 3;
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
I = i;
cin >> nam[i];
if (nam[i] == "#") cin >> nam[i];
cin >> nam[i];
getline(cin, s);
f[i] = solve();
}
getline(cin, s);
I = n + 1;
if (solve())
puts("OK");
else
puts("Suspicious");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int OO = 0x3f3f3f3f, NegOO = -1 * OO, N = 2e5 + 5, mod = 1e9 + 7;
long long dp[N][2], n, a, b;
string x;
long long solve(int i, int pre) {
if (i == n) {
if (pre == 0)
return b;
else
return 1e16;
}
long long &rf = dp[i][pre];
if (~rf) return rf;
if (x[i] == '0') {
if (pre == 0)
rf = min(a + b + solve(i + 1, 0), b + a + a + solve(i + 1, 1));
else
rf = min(b + b + a + solve(i + 1, 1), b + b + a + a + solve(i + 1, 0));
} else {
if (pre == 0)
rf = 1e18;
else
rf = a + b + b + solve(i + 1, 1);
}
return rf;
}
int main() {
int t;
cin >> t;
while (t--) {
memset(dp, -1, sizeof(dp));
cin >> n >> a >> b >> x;
cout << solve(0, 0) << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[50010], b[50010];
bool flag[50010];
struct node {
int v, id;
node(int v = 0, int id = 0) : v(v), id(id) {}
bool operator<(const node& a) const { return v < a.v; }
};
void solve() {
string s;
cin >> s;
int n = 0;
for (int i = 0; i < s.size(); i++)
if (s[i] == '?') n++;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
int cnt = 0, num = 0;
long long ans = 0;
priority_queue<node> que;
memset(flag, 0, sizeof(flag));
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(')
num++;
else {
num--;
if (s[i] == '?') {
ans += (long long)b[cnt];
que.push(node(b[cnt] - a[cnt], cnt));
cnt++;
}
}
if (num < 0) {
if (que.empty()) {
cout << -1 << endl;
return;
}
num += 2;
ans -= (long long)que.top().v;
flag[que.top().id] = 1;
que.pop();
}
}
if (num > 0) {
cout << -1 << endl;
return;
}
cout << ans << endl;
cnt = 0;
for (int i = 0; i < s.size(); i++)
if (s[i] == '?') {
if (flag[cnt])
cout << '(';
else
cout << ')';
cnt++;
} else
cout << s[i];
}
int main() {
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e7;
int n, a[MAXN], h, l[MAXN], ans = 0;
int b[MAXN];
int x;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
b[x] = i;
l[i] = MAXN;
}
l[0] = 0;
for (int i = 0; i < n; i++) {
cin >> x;
a[i] = n - b[x];
h = lower_bound(l, l + n, a[i]) - l;
l[h] = min(l[h], a[i]);
ans = max(ans, h);
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long fix(long long cur) { return ((cur % 1000003) + 1000003) % 1000003; }
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
cout.tie(0);
;
long long n;
cin >> n;
n -= 1;
long long ans = 1;
for (int i = 0; i < n; i++) {
ans *= 3;
ans = fix(ans);
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[111111];
int dp[111111];
int n;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> dp[i];
for (int i = 1; i <= n; ++i) dp[i] = min(dp[i], dp[i - 1] + 1);
for (int i = n; i >= 1; --i) dp[i] = min(dp[i], dp[i + 1] + 1);
int ans = 0;
for (int i = 1; i <= n; ++i) ans = max(ans, dp[i]);
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 310, S = 301, T = 302, M = 51000;
struct Edge {
int y, nex;
long long z;
} g[M * 3];
int n, v, m, dis[N], sz = 1, pos[N], az, ax[M], ay[M], aw[M], que[N], hd, tl,
w[N], a[N], b[N], in[N];
long long sum, p1, p2;
void Init(int x, int y, long long z) {
g[++sz].y = y;
g[sz].nex = pos[x];
g[sz].z = z;
pos[x] = sz;
}
bool Bfs() {
memset(dis, 0, sizeof(dis));
que[hd = tl = 1] = S, dis[S] = 1;
while (hd <= tl) {
int x = que[hd++];
for (int i = pos[x]; i; i = g[i].nex)
if (g[i].z) {
int y = g[i].y;
if (!dis[y]) dis[y] = dis[x] + 1, que[++tl] = y;
}
}
return dis[T];
}
long long Dfs(int x, long long mx) {
if (x == T) return mx;
long long ret = 0;
for (int i = pos[x]; i; i = g[i].nex) {
int y = g[i].y;
long long k;
if (mx && g[i].z && dis[y] == dis[x] + 1 && (k = Dfs(y, min(g[i].z, mx)))) {
g[i].z -= k, g[i ^ 1].z += k, mx -= k, ret += k;
}
}
if (mx) dis[x] = 0;
return ret;
}
void Dinic() {
long long ret = 0;
while (Bfs()) {
while (ret = Dfs(S, (1000000000000000LL))) sum += ret;
}
}
bool Print() {
for (int i = 1; i <= n; i++) in[i] = 0;
for (int x = 1; x <= n; x++) {
for (int i = pos[x]; i; i = g[i].nex)
if (g[i].z < (1000000000000000LL)) in[g[i].y]++;
}
hd = 1, tl = 0;
for (int i = 1; i <= n; i++)
if (!in[i]) que[++tl] = i;
if (tl == n) return 0;
while (hd <= tl) {
int x = que[hd++];
for (int i = pos[x]; i; i = g[i].nex)
if (g[i].y != T && g[i].y != S) {
int y = g[i].y;
long long z = min(((1000000000000000LL) - g[i].z),
(long long)min(v - w[y], w[x]));
if (z > 0) {
ax[++az] = x, ay[az] = y, aw[az] = z;
w[y] += z, w[x] -= z, g[i].z += z;
}
in[y]--;
if (!in[y]) que[++tl] = y;
}
}
return 1;
}
int main() {
scanf("%d%d%d", &n, &v, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), w[i] = a[i];
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
if (a[i] > b[i])
Init(S, i, a[i] - b[i]), Init(i, S, 0), p1 += a[i] - b[i];
else
Init(i, T, b[i] - a[i]), Init(T, i, 0), p2 += b[i] - a[i];
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
Init(x, y, (1000000000000000LL)), Init(y, x, (1000000000000000LL));
}
Dinic();
if (p1 != p2 || sum != p1) {
puts("NO");
return 0;
}
while (Print())
;
printf("%d\n", az);
for (int i = 1; i <= az; i++) printf("%d %d %d\n", ax[i], ay[i], aw[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> used, a;
map<int, vector<int> > g;
vector<pair<int, int> > ans;
bool was = false;
int n;
int main() {
int test;
cin >> test;
for (; test--;) {
cin >> n;
g.clear();
ans.clear();
a.clear();
int t = 0, t1 = 0;
for (int i = 0, x; i < n; i++) {
cin >> x;
g[x].push_back(i);
a.push_back(x);
if (i > 0) {
if (x != a[t]) t1 = i;
}
}
for (int i = 1; i < n; i++) {
if (a[t] != a[i]) {
ans.push_back({t, i});
} else {
ans.push_back({i, t1});
}
}
if (t1 == 0) {
cout << "NO\n";
} else {
cout << "YES\n";
for (int i = 0; i < n - 1; i++) {
cout << ans[i].first + 1 << " " << ans[i].second + 1 << '\n';
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int popcount(long long n) {
int ans = 0;
while (n) ans += n % 2, n /= 2;
return ans;
}
vector<int> bin;
void cut(long long n) {
bin.clear();
while (n) {
bin.push_back(n % 2);
n /= 2;
}
reverse(bin.begin(), bin.end());
}
long long n, t;
long long memo[100][100][2];
long long solve(int idx, int bits, bool less) {
if (idx == (int)bin.size()) return bits == t;
long long &ret = memo[idx][bits][less];
if (ret != -1) return ret;
ret = 0;
for (int i = 0; i < 2; i++) {
if (less) {
ret += solve(idx + 1, bits + (i == 1), less);
} else {
if (i < bin[idx]) {
ret += solve(idx + 1, bits + (i == 1), 1);
} else if (i == bin[idx]) {
ret += solve(idx + 1, bits + (i == 1), 0);
}
}
}
return ret;
}
int main() {
cin >> n >> t;
if (t & (t - 1)) {
cout << 0 << endl;
return 0;
}
int cnt = 0;
while (t) {
t /= 2;
cnt++;
}
t = cnt;
cut(n + 1);
memset(memo, -1, sizeof memo);
long long ans = solve(0, 0, 0);
cut(1);
memset(memo, -1, sizeof memo);
ans -= solve(0, 0, 0);
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
vector<int> eat(n), M(n), A(n), B(n);
int val = 0;
map<int, vector<int>> grp;
for (int i = 0; i < n; ++i) {
scanf("%d%d%d", &A[i], &B[i], &M[i]);
grp[A[i] + B[i] - M[i]].push_back(i);
}
for (auto& g : grp) {
vector<array<int, 3>> ranges;
for (int i : g.second) {
int lb = max(M[i] - B[i], 0);
int ub = min(A[i], M[i]);
assert(lb <= ub);
int l = A[i] - ub, r = A[i] - lb;
ranges.push_back({r, l, i});
}
sort(ranges.begin(), ranges.end());
int las = -1;
for (auto& r : ranges) {
if (las >= r[1]) {
eat[r[2]] = A[r[2]] - las;
continue;
}
++val;
las = r[0];
eat[r[2]] = A[r[2]] - las;
}
}
printf("%d\n", val);
for (int i = 0; i < n; ++i) {
printf("%d %d\n", eat[i], M[i] - eat[i]);
}
}
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
// typedef long l;
// typedef long long ll;
typedef vector<int> vi;
// typedef vector<char> vc;
typedef std::vector<int>::iterator Auto;
// #define PB push_back
#define FOR(i,a,b) for(int i=a;i<b;i++)
#include <vector>
int main()
{
#ifndef ONLINE_JUDGE
freopen("input","r",stdin);
freopen("output","w",stdout);
#endif
int t, x, sum, nn;
cin>>t;
FOR(i, 0, t){
cin>>x;
sum=0;
vector <int> v;
for(int j=9; j>=1; j--){
if(sum+j>x)
nn=0;
else{
v.push_back(j);
sum=sum+j;
}
}
sort(v.begin(), v.end());
if(sum==x){
for(auto &it:v)
cout<<it;
}
else
cout<<-1;
cout<<endl;
}
} | 0 |
#include <bits/stdc++.h>
long long a[200015];
int main() {
long long n, i;
while (~scanf("%lld", &n)) {
long long min = 1111111111;
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
if (a[i] <= min) {
min = a[i];
}
}
for (i = 1; i <= n; i++) {
a[i] -= min;
}
long long s = 0;
long long m = 0;
for (i = 1; i <= n; i++) {
if (a[i])
s++;
else {
if (s > m) m = s;
s = 0;
}
}
if (a[n]) {
i = 1;
while (a[i]) {
s++;
i++;
}
if (s > m) m = s;
}
printf("%lld\n", min * n + m);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
cout << n << " ";
for (int i = 1; i < n; i++) cout << i << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
;
long long sum = 0;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
};
long long mx = *max_element(a, a + n);
;
cout << ((2 * mx) - sum + 1) << endl;
;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
template <typename T>
inline void swap(T &a, T &b) {
T c = a;
a = b;
b = c;
}
template <typename T>
inline const T &min(const T &a, const T &b) {
return a < b ? a : b;
}
template <typename T>
inline const T &min(const T &a, const T &b, const T &c) {
return min(a, min(b, c));
}
template <typename T>
inline const T &max(const T &a, const T &b) {
return b < a ? a : b;
}
template <typename T>
inline const T &max(const T &a, const T &b, const T &c) {
return max(a, max(b, c));
}
template <typename T>
inline T abs(const T &a) {
return a < 0 ? -a : a;
}
template <typename T>
inline T sqr(const T &a) {
return a * a;
}
template <typename T>
inline T lowbit(const T &a) {
return a & -a;
}
const int tmod = 1000000009;
const int maxn = 100000 + 5;
long long pow2(int k) {
if (k <= 60) return (1LL << k) % tmod;
int i = 1;
long long j = 2;
long long ans = 1;
for (i = 1; i <= k; i <<= 1) {
if (k & i) ans = ans * j % tmod;
j = j * j % tmod;
}
return ans;
}
int td = 0;
int father[maxn];
int tnum;
int findfather(int i) {
return i == father[i] ? i : father[i] = findfather(father[i]);
}
int n, m;
long long ans;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) father[i] = i;
for (int i = 1; i <= m; i++) {
int t1, t2;
scanf("%d%d", &t1, &t2);
int tfa = findfather(t1);
int tfb = findfather(t2);
if (tfa != tfb) {
printf("%I64d\n", ans);
father[tfa] = tfb;
} else {
ans = (ans + pow2(td)) % tmod;
printf("%I64d\n", ans);
td++;
}
}
}
| 7 |
#include <bits/stdc++.h>
double eps = 1e-12;
double dist(double ax, double ay, double bx, double by) {
return sqrt((ax - bx) * (ax - bx) + (ay - by) * (ay - by));
}
int main() {
int sx, sy, tx, ty;
scanf("%d%d%d%d", &sx, &sy, &tx, &ty);
int v, t;
scanf("%d%d", &v, &t);
int vx, vy, wx, wy;
scanf("%d%d%d%d", &vx, &vy, &wx, &wy);
double x = sx + t * vx, y = sy + t * vy;
if (dist(x, y, (double)tx, (double)ty) / t < (double)v + eps) {
double l = 0, r = t;
for (int i = 1; i <= 100000; ++i) {
double mid = (l + r) / 2.0;
x = sx + mid * vx, y = sy + mid * vy;
if (dist(x, y, (double)tx, (double)ty) / mid < (double)v + eps)
r = mid;
else
l = mid;
}
printf("%.12f\n", l);
} else {
double l = t, r = 1e9;
for (int i = 1; i <= 100000; ++i) {
double mid = (l + r) / 2.0;
x = sx + t * vx + (mid - t) * wx, y = sy + t * vy + (mid - t) * wy;
if (dist(x, y, (double)tx, (double)ty) / mid < (double)v + eps)
r = mid;
else
l = mid;
}
printf("%.12f\n", l);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int x, y;
int main() {
cin >> x >> y;
if (x == 0 || y == 0) {
printf("black\n");
} else {
int p = 0;
while (p * p < x * x + y * y) p++;
if (p * p == x * x + y * y)
printf("black\n");
else {
if (x * y < 0) p++;
p %= 2;
if (p)
printf("black\n");
else
printf("white\n");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * acos(0.0);
const string DIGITS = "0123456789";
const string ALPH = "abcdefghijklmnopqrstuvwxyz";
template <class T>
ostream &operator<<(ostream &out, vector<T> &a) {
out << "(";
for (auto x : a) out << x << " ";
return out << ")";
}
template <class T>
ostream &operator<<(ostream &out, pair<T, T> &a) {
out << "(";
cout << a.first << ", " << a.second;
return out << ")";
}
void smain();
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
smain();
}
vector<int> di = {1, 1, -1, -1};
vector<int> dj = {1, -1, -1, 1};
vector<pair<int, int> > solve(int n) {
vector<pair<int, int> > ret;
if (n < 16) {
int h = n >> 1;
if (h == 0) h = 100;
for (int i = 0; i < int(n); ++i) ret.push_back({i / h, i % h});
} else {
int l = (n - 1) / 4;
vector<pair<int, int> > a = {{0, 0}};
for (auto x : a) ret.push_back(x), n--;
for (int i = 0; i < int(l); ++i)
ret.push_back({0, i + 1}), ret.push_back({0, -i - 1}), n -= 2;
for (int i = 0; n >= 2; ++i)
ret.push_back({i + 1, 0}), ret.push_back({-i - 1, 0}), n -= 2;
assert(n >= 0);
while (n) ret.push_back({n--, 101100});
}
return ret;
}
bool check(vector<pair<int, int> > ans) {
map<pair<int, int>, int> ret;
vector<int> di = {1, 2, 2, 1, -1, -2, -2, -1};
vector<int> dj = {-2, -1, 1, 2, 2, 1, -1, -2};
queue<pair<int, int> > kek;
for (auto x : ans) {
cout << ("x") << " = " << x << endl;
;
kek.push(x);
if (ret.count(x)) {
cout << ("x.first") << " = " << x.first << endl;
;
cout << ("x.second") << " = " << x.second << endl;
;
assert(0);
}
ret[x] = 4;
}
while (!kek.empty()) {
pair<int, int> cur = kek.front();
kek.pop();
for (int dir = 0; dir < int(((int)(di.size()))); ++dir) {
pair<int, int> nw = cur;
nw.first += di[dir], nw.second += dj[dir];
if (ret[nw] < 4) {
ret[nw]++;
if (ret[nw] == 4) kek.push(nw);
}
}
}
cout << ("ret.size()") << " = " << ret.size() << endl;
;
int n = ans.size();
cout << ("n * n / 10") << " = " << n * n / 10 << endl;
;
cout << ("n") << " = " << n << endl;
;
return ret.size() >= n * n / 10;
}
void smain() {
int n;
cin >> n;
vector<pair<int, int> > ans = solve(n);
for (auto x : ans) cout << x.first << " " << x.second << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e6 + 1;
long long fac[N];
void getFac() {
fac[0] = 1;
for (long long i = 1; i <= N; i++) fac[i] = fac[i - 1] * i % mod;
}
bool check(long long n, long long a, long long b) {
while (n) {
int tmp = n % 10;
if (tmp == a || tmp == b)
n /= 10;
else
return false;
}
return true;
}
long long inv(long long a) {
return a == 1 ? 1 : inv(mod % a) * (mod - mod / a) % mod;
}
long long C(long long n, long long r) {
if (r > n || r == 0) return 1;
long long B = fac[r] * fac[n - r] % mod;
long long ans = fac[n] * inv(B) % mod;
return ans;
}
long long getNum(long long m, long long n, long long a, long long b) {
if ((m - a * n) % (b - a) != 0) return 0;
return C(n, (m - a * n) / (b - a));
}
int main() {
getFac();
long long a, b, n;
while (~scanf("%I64d%I64d%I64d", &a, &b, &n)) {
long long A = a * n, B = b * n;
long long ans = 0;
for (long long i = A; i <= B; i++) {
if (!check(i, a, b)) continue;
ans = (ans + getNum(i, n, a, b)) % mod;
}
printf("%I64d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC diagnostic ignored "-Wmissing-declarations"
int const mod = 1e9 + 7;
inline void safe_add(int& x, const int y) {
x += y;
if (x >= mod) x -= mod;
}
inline int safe_mul(const int x, const int y) { return x * 1LL * y % mod; }
inline int safe_pow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = safe_mul(res, x);
x = safe_mul(x, x);
y >>= 1;
}
return res;
}
inline int safe_inv(const int x) { return safe_pow(x, mod - 2); }
int const maxn = 2005;
int dp[maxn][maxn];
int k, pa, pb, p;
int ka, kb;
inline int func(const int x, const int k = 1) {
int y = x;
safe_add(y, mod - 1);
y = safe_mul(y, y);
return safe_mul(k, safe_mul(x, safe_inv(y)));
}
inline int ssum(const int x, int k = 1) {
int y = 1;
safe_add(y, mod - x);
return safe_mul(k, safe_inv(y));
}
int main() {
ios_base::sync_with_stdio(false);
cin >> k >> pa >> pb;
p = pa + pb;
ka = safe_mul(pa, safe_inv(p));
kb = safe_mul(pb, safe_inv(p));
dp[1][0] = 1;
int ans = 0;
for (int j = 0; j < maxn; ++j)
for (int i = 1; i + 1 < maxn; ++i) {
safe_add(dp[i + 1][j], safe_mul(dp[i][j], ka));
if (i + j < maxn) safe_add(dp[i][j + i], safe_mul(dp[i][j], kb));
if (j >= k)
safe_add(ans, dp[i][j]);
else if (i + j >= k) {
int coef = safe_mul(kb, dp[i][j]);
int tmp1 = ssum(ka, i + j);
int tmp2 = func(ka);
safe_add(ans, safe_mul(coef, tmp1));
safe_add(ans, safe_mul(coef, tmp2));
safe_add(dp[i + 1][j], mod - safe_mul(dp[i][j], ka));
if (i + j < maxn) safe_add(dp[i][j + i], mod - safe_mul(dp[i][j], kb));
}
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, f, k;
cin >> a >> b >> f >> k;
if (b < f) {
cout << -1 << endl;
return 0;
}
int ans = 0;
int t = 0;
bool inverse = 0;
int nowpos = f;
int nowgas = b - f;
while (t != k) {
if (nowpos == f) {
if (inverse == 0) {
if (t + 1 == k && nowgas >= (a - f)) {
nowpos = a;
inverse = 1;
nowgas -= (a - f);
t++;
} else if (t + 1 == k && nowgas < (a - f)) {
if ((a - f) > b) {
cout << -1 << endl;
return 0;
}
ans++;
t++;
nowpos = a;
inverse = 1;
nowgas = b - (a - f);
} else if ((a - f) * 2 > nowgas) {
if ((a - f) * 2 > b) {
cout << -1 << endl;
return 0;
}
ans++;
nowgas = b - (a - f) * 2;
inverse = 1;
t++;
} else if (nowgas >= (a - f) * 2) {
inverse = 1;
nowgas -= (a - f) * 2;
t++;
}
} else if (inverse == 1) {
if (t + 1 == k && nowgas >= f) {
nowpos = 0;
inverse = 0;
nowgas -= f;
t++;
} else if (t + 1 == k && nowgas < f) {
if (f > b) {
cout << -1 << endl;
return 0;
}
ans++;
nowgas = b - f;
nowpos = 0;
inverse = 0;
t++;
} else if (nowgas < f * 2) {
if ((f)*2 > b) {
cout << -1 << endl;
return 0;
}
ans++;
nowgas = b - f * 2;
inverse = 0;
t++;
} else if (nowgas >= (f)*2) {
inverse = 0;
nowgas -= (f)*2;
t++;
}
}
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
unsigned long long n;
cin >> n;
unsigned long long ans = 1;
for (int i = 1; i <= 5; i++) {
ans *= (n * n);
ans /= i;
n--;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[21][21];
int n, m;
long long k, ans;
map<long long, long long> sum[21][21];
void dfs1(long long x, long long y, long long val) {
if (x + y == n + 1) {
sum[x][y][val]++;
return;
}
if (x < n) dfs1(x + 1, y, val ^ a[x + 1][y]);
if (y < m) dfs1(x, y + 1, val ^ a[x][y + 1]);
}
void dfs2(long long x, long long y, long long val) {
if (x + y == n + 1) {
ans += sum[x][y][k ^ val ^ a[x][y]];
return;
}
if (x > 1) dfs2(x - 1, y, val ^ a[x - 1][y]);
if (y > 1) dfs2(x, y - 1, val ^ a[x][y - 1]);
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
if (n == 1) {
long long summ = 0;
for (int i = 1; i <= m; i++) summ ^= a[1][i];
cout << (summ == k) << endl;
return 0;
}
if (m == 1) {
long long summ = 0;
for (int i = 1; i <= n; i++) summ ^= a[i][1];
cout << (summ == k) << endl;
return 0;
}
dfs1(1, 1, a[1][1]);
dfs2(n, m, a[n][m]);
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i]--;
}
vector<int> s(n);
s[0] = min(k + 1, n);
for (int i = 1; i < n; ++i) {
s[i] = min(i, k) + min(k + 1, n - i);
if (a[i] >= 0) {
s[i] += s[a[i]];
int l = max(i - k, 0);
int r = min(a[i] + k, n - 1);
s[i] -= max(0, r - l + 1);
}
}
for (int i = 0; i < n; ++i) printf("%d ", s[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long m, n, i, j, lon[100005], x[100005], c[100005], l[100005], t, voy, a;
bool bol[100005];
long long valor(long long k) {
long long a, b, med;
while (true) {
a = 0;
b = m;
while (a < b) {
med = (a + b) / 2;
if (lon[med] < k)
a = med + 1;
else
b = med;
}
if (bol[b])
return x[b];
else
k = ((k - lon[b - 1] - 1) % l[b] + 1);
}
}
int main() {
cin >> m;
lon[0] = 0;
for (i = 1; i <= m; i++) {
cin >> t;
if (t == 1) {
lon[i] = lon[i - 1] + 1;
bol[i] = true;
cin >> x[i];
} else {
cin >> l[i] >> c[i];
lon[i] = lon[i - 1] + c[i] * l[i];
}
}
cin >> n;
voy = 0;
for (i = 1; i <= n; i++) {
cin >> a;
cout << valor(a);
if (i < n)
cout << " ";
else
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void print(int n) {
if (n == 0) {
putchar('0');
putchar('\n');
} else if (n == -1) {
putchar('-');
putchar('1');
putchar('\n');
} else {
char buf[11];
buf[10] = '\n';
int i = 9;
while (n) {
buf[i--] = n % 10 + '0';
n /= 10;
}
while (buf[i] != '\n') putchar(buf[++i]);
}
}
int read() {
int cc = getc(stdin);
for (; cc < '0' || cc > '9';) cc = getc(stdin);
int ret = 0;
for (; cc >= '0' && cc <= '9';) {
ret = ret * 10 + cc - '0';
cc = getc(stdin);
}
return ret;
}
long long power(long long num, long long g) {
if (g == 0) return 1;
if (g % 2 == 1) return (num * power((num * num), g / 2));
return power((num * num), g / 2);
}
bool check(int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3,
int z3) {
if (min(x1, x2) <= x3 && max(x1, x2) >= x3) {
if (min(y1, y2) <= y3 && max(y1, y2) >= y3) {
if (min(z1, z2) <= z3 && max(z1, z2) >= z3) {
return true;
}
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
pair<pair<int, int>, pair<int, int> > pa[n];
vector<int> vec;
for (int i = 0; i < n; i++) {
cin >> pa[i].first.first >> pa[i].first.second >> pa[i].second.first;
pa[i].second.second = i + 1;
}
bool visit[n];
memset(visit, false, sizeof(visit));
for (int i = 0; i < n; i++) {
if (visit[i]) continue;
bool is = false;
int r = -1;
for (int j = i + 1; j < n; j++) {
if (visit[j]) continue;
if (is == false) {
r = j;
is = true;
continue;
}
if (check(pa[i].first.first, pa[i].first.second, pa[i].second.first,
pa[r].first.first, pa[r].first.second, pa[r].second.first,
pa[j].first.first, pa[j].first.second, pa[j].second.first)) {
r = j;
}
}
cout << pa[i].second.second << " " << pa[r].second.second << endl;
visit[i] = true;
visit[r] = true;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
function<void(void)> ____ = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
const int MAXN = 2e5 + 7;
int n, A[MAXN], f[MAXN], cnt[MAXN], pre[MAXN << 1], c[MAXN];
void solve() {
scanf("%d", &n);
int maxx = 0, appt = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
cnt[A[i]]++;
if (cnt[A[i]] == maxx)
appt++;
else if (cnt[A[i]] > maxx)
maxx = cnt[A[i]], appt = 1;
}
if (appt > 1) {
cout << n << endl;
return;
}
int val = -1;
for (int i = 1; i <= n; i++)
if (cnt[i] == maxx) val = i;
int ret = 0;
auto check = [&](int x, int y) -> int {
for (int i = 1; i <= n; i++) {
if (A[i] == x)
f[i] = 1;
else if (A[i] == y)
f[i] = -1;
else
f[i] = 0;
c[i] = c[i - 1] + (A[i] == x or A[i] == y);
}
memset(pre, 255, sizeof(pre));
pre[MAXN] = 0;
int maxlen = 0, pres = 0;
for (int i = 1; i <= n; i++) {
pres += f[i];
if (pre[pres + MAXN] != -1 and c[i] - c[pre[pres + MAXN]])
maxlen = max(maxlen, i - pre[pres + MAXN]);
if (pre[pres + MAXN] == -1) pre[pres + MAXN] = i;
}
return maxlen;
};
for (int i = 1; i <= min(100, n); i++)
if (i != val) ret = max(ret, check(i, val));
cout << ret << endl;
}
int main() {
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n, m;
cin >> n >> m;
int x = n / m, y = (n + m - 1) / m;
for (int i = 0; i < m - (n % m); i++) {
cout << x << ' ';
}
for (int i = 0; i < n % m; i++) {
cout << y << ' ';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[500005], ra;
vector<pair<long long, long long> > ans;
void solve(long long l, long long r) {
if (l == r) return;
long long mid = (l + r) / 2;
solve(l, mid);
solve(mid + 1, r);
for (int i = l; i <= mid; i++) {
ans.push_back(make_pair(i, mid + 1 + i - l));
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
ra = n;
long long ind = n;
long long rig = n;
long long g = 0;
for (int i = 16; i >= 0; i--) {
if (n & (1 << i)) {
solve(ind - (1 << i) + 1, ind);
solve(1, (1 << i));
break;
}
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, x1, x2;
pair<long long, long long> c[333333];
bool flag, t1, t2;
int main() {
cin >> n >> x1 >> x2;
for (int i = 1; i <= n; i++) {
cin >> c[i].first;
c[i].second = i;
}
sort(c + 1, c + n + 1, greater<pair<int, int> >());
for (int i = 1; i <= n; i++) {
if ((int)ceil(x1 * 1.0 / i) <= c[i].first) {
for (int j = i + 1; j <= n; j++) {
if ((int)ceil(x2 * 1.0 / (j - i) <= c[j].first)) {
vector<int> v1, v2;
for (int k = 1; k <= j; k++) {
if (k <= i)
v1.push_back(c[k].second);
else
v2.push_back(c[k].second);
}
if (flag) swap(v1, v2);
cout << "Yes" << endl;
cout << v1.size() << ' ' << v2.size() << endl;
for (auto u : v1) cout << u << ' ';
cout << endl;
for (auto u : v2) cout << u << ' ';
cout << endl;
return 0;
}
}
break;
}
}
swap(x1, x2);
flag = !flag;
for (int i = 1; i <= n; i++) {
if ((int)ceil(x1 * 1.0 / i) <= c[i].first) {
for (int j = i + 1; j <= n; j++) {
if ((int)ceil(x2 * 1.0 / (j - i) <= c[j].first)) {
vector<int> v1, v2;
for (int k = 1; k <= j; k++) {
if (k <= i)
v1.push_back(c[k].second);
else
v2.push_back(c[k].second);
}
if (flag) swap(v1, v2);
cout << "Yes" << endl;
cout << v1.size() << ' ' << v2.size() << endl;
for (auto u : v1) cout << u << ' ';
cout << endl;
for (auto u : v2) cout << u << ' ';
cout << endl;
return 0;
}
}
break;
}
}
cout << "No" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long modInverse(long long a, long long m);
long long gcd(long long a, long long b);
long long power(long long x, unsigned long long y, unsigned long long m);
long long logint(long long x, long long y);
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long power(long long x, unsigned long long y, unsigned long long m) {
if (y == 0) return 1;
long long p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
long long modInverse(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
void pairsort(long long a[], long long b[], long long n) {
pair<long long, long long> pairt[n];
for (long long i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (long long i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long logint(long long x, long long y) {
long long ans = 0;
long long a = 1;
for (long long i = 0; i < x; i++) {
if (x <= a) {
return ans;
}
ans++;
a *= y;
}
return -1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
long long ar[2 * n + 1];
long long ans = 0;
for (long long j = 1; j < 2 * n + 1; j += 2) {
if (ans >= k) {
ar[j] = j;
ar[j + 1] = j + 1;
} else {
ar[j] = j + 1;
ar[j + 1] = j;
ans++;
}
}
for (long long j = 1; j < 2 * n + 1; j++) {
cout << ar[j] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
int c, n, m, i, j, *a;
long round;
long double t;
scanf("%d %d", &c, &n);
a = (int*)malloc(sizeof(int) * n + 1);
m = c / n;
if (c % n == 0) {
for (i = 0; i < n; i++) {
if (i < n - 1)
printf("%d ", m);
else
printf("%d", m);
}
} else {
t = ceil(c / (long double)n);
round = (long)t;
i = 0;
while (1) {
if (c < round) break;
c = c - round;
a[i++] = round;
}
a[i] = c;
j = 0;
for (i = n - 1; i >= 0; i--) {
if (a[i] && (round - a[i]) < 2)
break;
else {
m = round - a[i];
m--;
a[i] += m;
while (m--) {
a[j] = a[j] - 1;
j++;
}
}
}
for (i = 0; i < n; i++) {
if (i < n - 1)
printf("%d ", a[i]);
else
printf("%d", a[i]);
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n + 1];
vector<int> arr1(n + 1);
bool scan = true;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
int key = n;
for (int i = 1; i <= n; i++) {
if (arr[i] != key) {
cout << endl;
arr1[arr[i]]++;
} else {
cout << arr[i] << " ";
key--;
while (key != 0) {
if (arr1[key] != 0) {
cout << key-- << " ";
} else
break;
}
cout << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
inline int read() {
int data = 0, w = 1;
char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (ch >= '0' && ch <= '9') data = data * 10 + (ch ^ 48), ch = getchar();
return data * w;
}
const int maxn(3e5 + 10);
int q[maxn], top, next[maxn], ok[maxn], n;
struct point {
int x, y, id;
} p[maxn];
double k[maxn];
inline bool operator<(const point &lhs, const point &rhs) {
return lhs.x > rhs.x || (lhs.x == rhs.x && lhs.y > rhs.y);
}
inline double slope(const point &i, const point &j) {
return 1. * i.x * j.x * (j.y - i.y) / (1. * i.y * j.y * (j.x - i.x));
}
int main() {
n = read();
int minx, miny = 0;
for (register int i = 1; i <= n; i++) {
p[i] = (point){read(), read(), i};
if (miny < p[i].y || (miny == p[i].y && minx < p[i].x))
minx = p[i].x, miny = p[i].y;
}
std::sort(p + 1, p + n + 1);
q[top = 1] = 1;
for (register int i = 2; i <= n && minx <= p[i].x; i++) {
if (p[q[top]].x == p[i].x) {
if (p[q[top]].y == p[i].y)
next[p[i].id] = next[p[q[top]].id], next[p[q[top]].id] = p[i].id;
continue;
}
while (top > 1 && k[top] > slope(p[q[top]], p[i])) --top;
q[++top] = i;
k[top] = slope(p[q[top - 1]], p[i]);
}
for (register int i = top; i; --i)
for (register int j = p[q[i]].id; j; j = next[j]) ok[j] = 1;
for (register int i = 1; i <= n; i++)
if (ok[i]) printf("%d ", i);
return 0;
}
| 9 |
#include <bits/stdc++.h>
bool f[99];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
f[a] = 1;
}
int nj = 0, i = 0;
for (i = 1; i < 90; i++) {
if (f[i])
nj = 0;
else {
nj++;
if (nj == 15) break;
}
}
printf("%d", i);
}
| 0 |
#include <bits/stdc++.h>
template <typename T, typename U>
inline void AMIN(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void AMAX(T &x, U y) {
if (x < y) x = y;
}
using namespace std;
int main() {
long long x, y, n;
cin >> x >> y >> n;
pair<double, pair<int, int> > best = {10000000, {1, 1}};
double frac = 1. * x / y;
long long L = 0, M = 1;
while (M <= n) {
double ff = 1. * L / M;
if (abs(ff - frac) < best.first) {
best = {abs(ff - frac), {M, L}};
};
if (ff >= frac) {
++M;
L = 1. * x * M / y - 4;
if (L < 0) L = 0;
} else {
++L;
}
};
printf("%i/%i\n", best.second.second, best.second.first);
};
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long m = 1000000007;
string s = "YORG";
int main() {
long long x, i = 0, ans = 0;
while (cin >> x) {
ans += x * i++;
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20013;
struct Tseg {
int id, l, r;
} seg[maxn];
int n;
namespace Dinit {
vector<int> w;
bool cmp_r(const Tseg &a, const Tseg &b) {
return a.r < b.r || a.r == b.r && a.l > b.l;
}
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int o, r;
scanf("%d%d", &o, &r);
w.push_back(seg[i].l = o - r);
w.push_back(seg[i].r = o + r);
seg[i].id = i;
}
sort(w.begin(), w.end());
w.erase(unique(w.begin(), w.end()), w.end());
for (int i = 1; i <= n; ++i) {
seg[i].l = lower_bound(w.begin(), w.end(), seg[i].l) - w.begin();
seg[i].r = lower_bound(w.begin(), w.end(), seg[i].r) - w.begin();
}
sort(seg + 1, seg + n + 1, cmp_r);
}
} // namespace Dinit
namespace Dsolve {
int f[maxn][2], fin[maxn];
vector<int> son[maxn];
vector<int> inseg;
int w[2 * maxn][2];
bool cmp_r(int a, int b) { return seg[a].r < seg[b].r; }
int work_in(int p) {
inseg.clear();
for (int i = 1; i <= p - 1; ++i)
if (seg[i].l >= seg[p].l && seg[i].r <= seg[p].r) {
inseg.push_back(i);
}
sort(inseg.begin(), inseg.end(), cmp_r);
memset(w, 0, sizeof(w));
vector<int>::iterator iter = inseg.begin();
for (int i = seg[p].l; i <= seg[p].r; ++i) {
if (i > seg[p].l) w[i][0] = w[i - 1][0], w[i][1] = w[i - 1][1];
for (; iter != inseg.end() && i == seg[*iter].r; ++iter) {
if (w[i][0] < w[seg[*iter].l][0] + fin[*iter] + 1) {
w[i][0] = w[seg[*iter].l][0] + fin[*iter] + 1;
w[i][1] = *iter;
}
}
}
for (int i = seg[p].r;; i = seg[w[i][1]].l)
if (w[i][1])
son[p].push_back(w[i][1]);
else
break;
return w[seg[p].r][0];
}
void work() {
int nowseg = 1;
for (int i = 0; i <= seg[n].r; ++i) {
if (i > 0) f[i][0] = f[i - 1][0], f[i][1] = f[i - 1][1];
for (; i == seg[nowseg].r; ++nowseg) {
fin[nowseg] = work_in(nowseg);
if (f[i][0] < f[seg[nowseg].l][0] + fin[nowseg] + 1) {
f[i][0] = f[seg[nowseg].l][0] + fin[nowseg] + 1;
f[i][1] = nowseg;
}
}
}
}
vector<int> use;
void get_in(int p) {
use.push_back(seg[p].id);
for (int i = 0; i < son[p].size(); ++i) {
get_in(son[p][i]);
}
}
void get_use(int x) {
if (!f[x][1]) return;
get_in(f[x][1]);
get_use(seg[f[x][1]].l);
}
void print() {
printf("%d\n", f[seg[n].r][0]);
get_use(seg[n].r);
for (int i = 0; i < use.size(); ++i) printf("%d ", use[i]);
printf("\n");
}
void solve() {
work();
print();
}
} // namespace Dsolve
int main() {
Dinit::init();
Dsolve::solve();
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.