solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline int checkbit(T n, T i) {
return ((n >> i) & T(1));
}
inline int bits_count(int v) {
v = v - ((v >> 1) & 0x55555555);
v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline int bits_count(long long v) {
int t = v >> 32;
int p = (v & ((1LL << 32) - 1));
return bits_count(t) + bits_count(p);
}
unsigned int reverse_bits(register unsigned int x) {
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
return ((x >> 16) | (x << 16));
}
template <typename T>
inline bool isPowerOfTwo(T n) {
return (n != 0 and ((n & (n - 1)) == 0));
}
inline int binlog(int n) {
assert(n > 0);
return 32 - __builtin_clz(n) - 1;
}
inline int binlog(long long n) {
assert(n > 0);
return 64 - __builtin_clzll(n) - 1;
}
void bitprint(int n, int w = 32) {
for (int i = w - 1; i >= 0; i--) {
cout << checkbit(n, i);
}
cout << "\n";
}
void bitprint(long long n, int w = 64) {
for (long long i = w - 1; i >= 0; i--) {
cout << checkbit(n, i);
}
cout << "\n";
}
template <typename T>
inline T sqr(T x) {
T x_ = (x);
return x_ * x_;
}
template <typename T>
inline T qbr(T x) {
T x_ = (x);
return ((x_ * x_) * x_);
}
template <typename T>
inline int sign(T x) {
T x_ = (x);
return ((x_ > T(0)) - (x_ < T(0)));
}
template <typename T>
inline T mod(T x, T m) {
T x_ = (x);
return (((x_) >= 0) ? ((x_) % (m)) : ((((x_) % (m)) + (m)) % (m)));
}
template <typename T>
inline T gcd(T a, T b) {
while (b) {
T t = a % b;
a = b;
b = t;
}
return a;
}
template <typename T>
inline T gcd_ex(T a, T b, T& x, T& y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
T x1, y1;
T d = gcd_ex(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return d;
}
template <typename T>
inline T lcm(T a, T b) {
return (a * (b / gcd(a, b)));
}
template <typename A, typename B, typename C>
function<C(A)> combine(function<B(A)> f, function<C(B)> g) {
return bind(g, bind(f, placeholders::_1));
}
template <typename Collection, typename UnaryOperation>
void foreach (Collection& col, UnaryOperation op) {
for_each(begin(col), end(col), op);
}
template <typename Collection, typename UnaryOperation>
Collection fmap(Collection& col, UnaryOperation op) {
transform(begin(col), end(col), col.begin(), op);
return col;
}
template <typename Collection, typename binop>
Collection zip(Collection& fc, Collection& sc, binop op) {
transform(begin(fc), end(fc), sc.begin(), fc.begin(), op);
return fc;
}
template <typename Collection, typename Condition>
bool exists(Collection& col, Condition con) {
auto exist = find_if(begin(col), end(col), con);
return exist != col.end();
}
template <typename Collection, typename Predicate>
Collection filterNot(Collection& col, Predicate predicate) {
auto returnIterator = remove_if(begin(col), end(col), predicate);
col.erase(returnIterator, end(col));
return col;
}
void fastIO() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
template <class T1, class T2>
istream& operator>>(istream& in, pair<T1, T2>& P) {
in >> P.first >> P.second;
return in;
}
template <class T>
istream& operator>>(istream& in, vector<T>& Col) {
for (auto& el : Col) in >> el;
return in;
}
template <class T>
inline void getarr(T* arr, int l, int r) {
for (long long i = l; i < r; i++) cin >> arr[i];
}
template <class T1, class T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<vector<T>>& v) {
for (auto& row : v) {
for (auto& el : row) os << el << " ";
os << "\n";
}
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& Col) {
for (auto& el : Col) os << el << " ";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& Col) {
for (auto& el : Col) os << el << " ";
return os;
}
template <class T1, class T2>
ostream& operator<<(ostream& os, const map<T1, T2>& Col) {
for (auto& el : Col) os << el << " ";
return os;
}
template <class T>
inline void printarr(T* arr, int l, int r) {
for (long long i = l; i < r; i++) {
cout << arr[i] << " ";
};
cout << "\n";
}
template <typename First>
void read(First& t) {
cin >> t;
}
template <typename First, typename... Args>
void read(First& f, Args&... args) {
cin >> f;
read(forward<Args&>(args)...);
}
template <typename T>
void print(T&& t) {
cout << t << "\n";
}
template <typename First, typename... Args>
void print(First&& f, Args&&... args) {
cout << f << " ";
print(forward<Args&&>(args)...);
}
template <typename T>
void printLn(T&& t) {
cout << t << "\n";
}
template <typename First, typename... Args>
void printLn(First&& f, Args&&... args) {
cout << f << "\n";
printLn(forward<Args&&>(args)...);
}
template <typename T, size_t N>
struct MakeTensor {
template <typename... Args>
static auto tensor(size_t first, Args... sizes)
-> vector<decltype(MakeTensor<T, N - 1>::tensor(sizes...))> {
auto inner = MakeTensor<T, N - 1>::tensor(sizes...);
return vector<decltype(inner)>(first, inner);
}
};
template <typename T>
struct MakeTensor<T, 1> {
static vector<T> tensor(size_t size) { return vector<T>(size); }
};
template <typename T, typename... Args>
auto tensor(Args... args)
-> decltype(MakeTensor<T, sizeof...(Args)>::tensor(args...)) {
return MakeTensor<T, sizeof...(Args)>::tensor(args...);
}
const int MAXN = 1e5;
char X[MAXN + 1];
int S[MAXN + 1], A[MAXN + 1];
int len;
inline void NO() {
puts("0");
exit(0);
}
bool restored() {
int L, R;
for (L = 1, R = len; L <= R;) {
if (S[L] == S[R]) {
L++, R--;
} else if (S[L] == S[R] + 1 || S[L] == S[R] + 11) {
S[L]--, S[L + 1] += 10;
} else if (S[L] == S[R] + 10) {
S[R - 1]--, S[R] += 10;
} else
return false;
}
if (S[1] == 0) return false;
if (L - 1 == R + 1 && (S[L - 1] & 1)) return false;
for (L = 1, R = len; L <= R; L++, R--) {
if (S[L] > 18 || S[L] < 0) return false;
A[L] = (S[L] + 1) >> 1;
A[R] = S[L] - A[L];
}
for (int i = 1; i <= len; i++) printf("%c", A[i] + '0');
return true;
}
int main() {
fastIO();
scanf("%s", X + 1);
for (int i = 1; X[i]; i++) {
S[i] = X[i] - '0';
len++;
}
if (restored()) exit(0);
if (X[1] != '1' || len == 1) NO();
for (int i = 1; X[i]; i++) {
S[i - 1] = X[i] - '0';
}
S[1] += 10;
len--;
if (restored()) exit(0);
NO();
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const double PI = acos(-1);
template <class A, class B>
std::ostream& operator<<(std::ostream& st, const std::pair<A, B> p) {
st << "(" << p.first << ", " << p.second << ")";
return st;
}
using namespace std;
int n;
std::vector<int> E[1 << 20];
int fr[1 << 20], to[1 << 20], W[1 << 20];
int siz[1 << 20];
long long dfs(int u, int p) {
long long mn = 0;
siz[u] = 1;
for (int e : E[u]) {
int v = fr[e] + to[e] - u;
if (v == p) continue;
mn += dfs(v, u);
siz[u] += siz[v];
if (siz[v] & 1) mn += W[e];
}
return mn;
}
long long getMax() {
std::vector<int> ord;
for (int e = 0; e < (n - 1); e++) ord.push_back(e);
sort(ord.begin(), ord.end(),
[](const int& a, const int& b) { return W[a] > W[b]; });
long long ans = 0;
for (int e : ord) {
int s = min(siz[fr[e]], siz[to[e]]);
s = min(s, n - s);
ans += s * (long long)W[e];
}
return ans;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
int k;
scanf("%d", &k);
n = 2 * k;
for (int i = 1; i <= n; i++) E[i].clear();
for (int e = 0; e < (n - 1); e++) {
scanf("%d %d %d", fr + e, to + e, W + e);
E[fr[e]].push_back(e);
E[to[e]].push_back(e);
}
auto mn = dfs(1, 0);
printf("%lld %lld\n", mn, getMax());
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0)
cout << (n * n) / 4 << endl;
else
cout << (n / 2) * (n + 1) / 2 << endl;
for (int i = 1; i <= (n / 2); i++)
for (int j = (n / 2) + 1; j <= n; j++) cout << i << " " << j << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long M;
long long fact[1000005];
void init() {
fact[0] = 1;
for (long long i = 1; i <= 1000000; i++) {
fact[i] = (i * fact[i - 1]) % M;
fact[i] %= M;
}
}
void solve() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n >> M;
init();
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += ((n - i + 1) * ((fact[i] * fact[n - i + 1]) % M)) % M;
ans %= M;
}
ans %= M;
cout << ans << endl;
}
int main() {
int tc = 1;
while (tc--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
long long power(long long a, long long b, long long mod);
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int inf = 0x3f3f3f3f;
const int N = 200 + 5;
int n, m, k;
int a[N][N], b[N][N];
vector<int> e[N];
void INIT() {}
void solve() {
INIT();
for (int i = 1; i <= k; i++) cin >> a[i][0] >> a[i][1];
for (int i = 1; i <= k; i++) cin >> b[i][0] >> b[i][1];
string ans;
for (int i = 1; i <= n - 1; i++) ans += 'U';
for (int i = 1; i <= m - 1; i++) ans += 'L';
int res = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m - 1; j++) {
ans += res == 0 ? 'R' : 'L';
}
if (i < n) {
ans += 'D';
}
res ^= 1;
}
cout << (ans.size()) << '\n';
cout << (ans) << '\n';
}
int main() {
ios::sync_with_stdio(false);
while (cin >> n >> m >> k) {
solve();
}
return 0;
}
long long power(long long a, long long b, long long mod) {
long long ans = 1;
while (b) {
if (b % 2) ans = ans * a % mod;
a = a * a % mod;
b = b / 2;
}
return ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int f(int x, int y, int s, int t, vector<int>& a) {
if (x == s) return abs(y - t);
if (a.size() == 0) return INT_MAX / 2;
if (a.size() == 1) return abs(y - a[0]) + abs(t - a[0]);
if (t < y) {
int p;
p = t;
t = y;
y = p;
}
int ans;
auto it = lower_bound(a.begin(), a.end(), y);
if (it != a.end()) {
int p = *it;
ans = abs(p - y) + abs(t - p);
}
if (it == a.begin()) return ans;
it--;
int p = *it;
ans = min(ans, y + t - 2 * p);
return ans;
}
int main() {
int n, m, cl, ce, v;
cin >> n >> m >> cl >> ce >> v;
vector<int> l, e;
l.resize(cl);
e.resize(ce);
for (int i = 0; i < cl; i++) cin >> l[i];
for (int i = 0; i < ce; i++) cin >> e[i];
int q;
cin >> q;
int x, y, s, t;
while (q > 0) {
cin >> x >> y >> s >> t;
int a = abs(x - s);
cout << min(f(x, y, s, t, l) + a, f(x, y, s, t, e) + a / v + (a % v > 0))
<< endl;
q--;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> M;
vector<pair<long long, long long> > V;
long long a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w,
x, y, z, x1, x2, x3, x4, x5, x6, y11, y2, y3, y4, y5, y6, s1, s2;
pair<long long, long long> P;
string st;
bool cmp(pair<long long, long long> p1, pair<long long, long long> p2) {
return p1.first > p2.first;
}
int main() {
s = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> P.first;
P.second = i;
V.push_back(P);
}
sort(V.begin(), V.end(), cmp);
for (i = 0; i < n; i++) {
s += V[i].first * i;
}
cout << s + n << endl;
for (i = 0; i < n; i++) cout << V[i].second << ' ';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, M = 4005, inf = 1e9;
int nn, s, t, dep[N], hd[N], cur[N], nxt[M], to[M], w[M], tot;
void add(int u, int v, int ww) {
nxt[++tot] = hd[u], to[tot] = v, w[tot] = ww, hd[u] = tot;
nxt[++tot] = hd[v], to[tot] = u, w[tot] = 0, hd[v] = tot;
}
bool bfs() {
memset(dep, 0, sizeof(dep));
dep[s] = 1;
queue<int> q;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = hd[u]; i; i = nxt[i]) {
if (w[i] && !dep[to[i]]) {
dep[to[i]] = dep[u] + 1;
q.push(to[i]);
}
}
}
return dep[t] > 0;
}
int dfs(int u, int f) {
if (u == t) return f;
int ret = 0;
for (int &i = cur[u]; i; i = nxt[i])
if (w[i] && dep[to[i]] == dep[u] + 1) {
int fl = dfs(to[i], min(f, w[i]));
f -= fl, ret += fl;
w[i] -= fl, w[i ^ 1] += fl;
if (!f) break;
}
return ret;
}
int n, m, a[N], ans[N], x[N], y[N], id[N], rd[N], tp[N];
vector<int> g[N], vec;
void solve(int lb, int rb, int l, int r) {
if (l > r) return;
if (lb == rb) {
for (int i = l; i <= r; i++) ans[id[i]] = vec[lb];
return;
}
int mid = (lb + rb) >> 1, lp = l, rp = r;
nn = r - l + 3, tot = 1;
memset(hd, 0, sizeof(hd));
s = nn - 1, t = nn;
for (int i = l; i <= r; i++) {
if (a[id[i]] <= vec[mid])
add(s, i - l + 1, 1);
else
add(i - l + 1, t, 1);
for (auto v : g[id[i]])
if (l <= rd[v] && rd[v] <= r) add(i - l + 1, rd[v] - l + 1, inf);
}
while (bfs()) {
memcpy(cur, hd, sizeof(cur));
dfs(s, inf);
}
for (int i = l; i <= r; i++)
if (dep[i - l + 1])
tp[lp++] = id[i];
else
tp[rp--] = id[i];
for (int i = l; i <= r; i++) rd[id[i] = tp[i]] = i;
solve(lb, mid, l, rp);
solve(mid + 1, rb, lp, r);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
vec.push_back(a[i]);
}
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x[i], &y[i]);
g[y[i]].push_back(x[i]);
}
for (int i = 1; i <= n; i++) rd[id[i] = i] = i;
solve(0, (int)vec.size() - 1, 1, n);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int C[100002], D[100002], maxn = 100002;
int read(int *tree, int i) {
int s = 0;
while (i > 0) {
s = max(s, tree[i]);
i -= i & -i;
}
return s;
}
void add(int *tree, int i, int x) {
while (i <= maxn) {
tree[i] = max(tree[i], x);
i += i & -i;
}
}
int b, p;
char a;
int main() {
int n, c, d, mm, ans = 0;
cin >> n >> c >> d;
for (int i = (0); i < (n); i++) {
cin >> b >> p >> a;
if (a == 'C') {
mm = read(D, d);
if (p > c) continue;
mm = max(mm, read(C, c - p));
add(C, p, b);
} else {
mm = read(C, c);
if (p > d) continue;
mm = max(mm, read(D, d - p));
add(D, p, b);
}
if (mm) {
ans = max(ans, mm + b);
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int d[10020], m, n, sav;
int main() {
cin >> m >> n;
for (int i = 1; i <= n; i++) {
cout << 1 << endl;
cin >> sav;
if (sav == 0) {
return 0;
}
if (sav == 1) d[i] = 1;
if (sav == -1) d[i] = -1;
}
d[0] = d[n];
int l = 1, r = m;
for (int i = 1;; i++) {
int mid = (l + r) >> 1;
cout << mid << endl;
cin >> sav;
if (sav == 0) {
return 0;
}
sav *= d[i % n];
if (sav > 0)
l = mid + 1;
else
r = mid - 1;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000100;
const int MAXN = 5010;
int n;
int main() {
printf("310\n");
n = 310;
printf("0 800000\n");
n--;
int off = 800000;
for (int i = n; i > 1; i--) {
off += 3 * i;
printf("%d %d\n", off, i);
}
printf("1000000 1000000\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const long long int MAX = 1001;
int main() {
int n, m, h;
cin >> n >> m >> h;
int r[m];
for (int i = 0; i < m; i++) {
cin >> r[i];
}
int c[n];
for (int i = 0; i < n; i++) {
cin >> c[i];
}
int a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 1) {
a[i][j] = min(r[j], c[i]);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << a[i][j] << " ";
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000000;
void Search(string pat, string text) {
int M = ((int)(pat.size())), N = ((int)(text.size()));
for (int i = 0; i <= N - M; i++) {
int j;
for (j = 0; j < M; j++)
if (text[i + j] != pat[j]) break;
if (j == M) cout << "Pattern found at index " << i << "\n";
}
}
bool isletter(char f) { return f >= 'a' && f <= 'z'; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k = 0;
cin >> n;
vector<int> primes;
while (n >= 2) {
if (n == 3) {
primes.push_back(n);
n -= 3;
break;
}
n -= 2;
primes.push_back(2);
}
cout << ((int)(primes.size())) << endl;
for (int i = 0; i < (int)((int)(primes.size())); i++)
cout << primes[i] << " ";
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxM = 100;
int n, m, cnt;
int x[maxM], y[maxM], r[maxM];
int p[maxM];
struct State {
int val;
int S, T, i;
State(int v, int S, int T, int i) : val(v), S(S), T(T), i(i) {}
bool operator<(const State &rhs) const { return val < rhs.val; }
bool operator>(const State &rhs) const { return val > rhs.val; }
};
priority_queue<State, vector<State>, std::greater<State> > pq;
bool cmp(int x, int y) { return r[x] < r[y]; }
bool extend(int val, int S, int T, int i) {
if (i < m) {
int SS = S | (1 << x[p[i]]);
int TT = T | (1 << y[p[i]]);
if (SS == S || TT == T) return false;
pq.emplace(val + r[p[i]], SS, TT, i + 1);
return true;
}
return false;
}
int main() {
cin >> n >> m >> cnt;
for (int i = 0; i < m; ++i) {
cin >> x[i] >> y[i] >> r[i];
x[i]--;
y[i]--;
p[i] = i;
}
std::sort(p, p + m, cmp);
pq.emplace(0, 0, 0, 0);
cnt--;
while (cnt--) {
auto u = pq.top();
pq.pop();
int val = u.val, S = u.S, T = u.T, i = u.i;
for (int j = i; j < m; ++j) extend(val, S, T, j);
}
cout << pq.top().val << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double esp = 1e-6;
struct Point {
double x, y;
Point(double _ = 0, double __ = 0) : x(_), y(__) {}
Point operator+(const Point& r) const { return Point(x + r.x, y + r.y); }
Point operator-(const Point& r) const { return Point(x - r.x, y - r.y); }
double operator^(const Point& r) const { return x * r.y - y * r.x; }
bool operator!=(const Point& r) const { return x != r.x || y != r.y; }
friend ostream& operator<<(ostream& o, const Point& v) {
cout << v.x << ' ' << v.y;
return o;
}
};
struct Data {
vector<Point> vct1s;
vector<Point> sup, sdown;
vector<Point> sut, sdt;
vector<Point> ans;
int map[550][550];
} * data;
int n;
char getCH() {
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
return ch;
}
bool CMPx(const Point& l, const Point& r) {
if (l.x == r.x) return l.y < r.y;
return l.x < r.x;
}
void Init() {
data = new Data;
data->vct1s.clear();
data->sup.clear();
data->sdown.clear();
data->sup.clear();
data->sdt.clear();
data->ans.clear();
memset(data->map, 0, sizeof data->map);
}
void work1() {
sort(data->vct1s.begin(), data->vct1s.end(), CMPx);
data->sup.push_back(data->vct1s[0]);
data->sdown.push_back(data->vct1s[0]);
int su, sd;
for (vector<Point>::iterator it = data->vct1s.begin() + 1;
it != data->vct1s.end(); it++) {
su = data->sup.size();
sd = data->sdown.size();
while (su >= 2 && ((data->sup[su - 1] - data->sup[su - 2]) ^
((*it) - data->sup[su - 1])) >= -esp) {
data->sup.pop_back();
su--;
}
data->sup.push_back(*it);
while (sd >= 2 && ((data->sdown[sd - 1] - data->sdown[sd - 2]) ^
((*it) - data->sdown[sd - 1])) <= esp) {
data->sdown.pop_back();
sd--;
}
data->sdown.push_back(*it);
}
}
void work2up() {
data->sut.push_back(data->sup[0] + Point(1, 1));
for (int i = 1; i < data->sup.size() - 1; i++) {
if (data->sup[i].y > data->sup[i - 1].y)
data->sut.push_back(data->sup[i] + Point(1, 0));
if (data->sup[i].y > data->sup[i + 1].y) data->sut.push_back(data->sup[i]);
}
data->sut.push_back(data->sup.back());
}
void work2down() {
data->sdt.push_back(data->sdown[0] + Point(1, 1));
for (int i = 1; i < data->sdown.size() - 1; i++) {
if (data->sdown[i].y < data->sdown[i - 1].y)
data->sdt.push_back(data->sdown[i] + Point(1, 1));
if (data->sdown[i].y < data->sdown[i + 1].y)
data->sdt.push_back(data->sdown[i] + Point(0, 1));
}
data->sdt.push_back(data->sdown.back());
}
int main(void) {
while (scanf("%d", &n) == 1) {
if (!n) break;
Init();
for (int y = n - 1; ~y; y--)
for (int x = 0; x < n; x++) {
data->map[x][y] = getCH() - '0';
if (data->map[x][y] == 1) data->vct1s.push_back(Point(x, y));
}
work1();
work2up();
work2down();
;
data->ans.push_back(data->sut[0]);
for (int i = 1; i < data->sut.size(); i++)
if (data->sut[i] != data->sut[i - 1]) data->ans.push_back(data->sut[i]);
for (int i = data->sdt.size() - 2; i; i--)
if (data->sdt[i] != data->sdt[i + 1]) data->ans.push_back(data->sdt[i]);
if (!(data->ans[0] != data->ans[data->ans.size() - 1]))
data->ans.pop_back();
cout << data->ans.size() << endl;
for_each(data->ans.begin(), data->ans.end(),
[](const Point& r) { cout << r << endl; });
delete data;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 28;
const long long mod = 1LL;
char arr[210][210];
long long par[210];
bool col[210];
vector<long long> adjacency[210];
int main() {
long long n, i, j, k, l;
while (cin >> n) {
for (i = 0; i < n; i++) adjacency[i].clear(), scanf(" %s", arr[i]);
k = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
if (arr[i][j] == '.') {
adjacency[i].push_back(j);
k++;
break;
}
}
if (k == n) {
for (i = 0; i < n; i++)
printf("%I64d %I64d\n", i + 1, adjacency[i][0] + 1);
return 0;
}
k = 0;
for (i = 0; i <= n; i++) adjacency[i].clear();
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
if (arr[j][i] == '.') {
adjacency[i].push_back(j);
k++;
break;
}
}
if (k == n) {
for (i = 0; i < n; i++)
printf("%I64d %I64d\n", adjacency[i][0] + 1, i + 1);
return 0;
}
printf("-1\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int MAXN = 500000;
using namespace std;
int n, k;
char s[2][MAXN];
int q[MAXN], d[MAXN];
void out(string verdict) {
cout << verdict << endl;
exit(0);
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s%s", s[0], s[1]);
q[0] = 0;
memset(d, -1, sizeof(d));
d[0] = 0;
for (int l = 0, r = 1; l < r; l++) {
int u = q[l] >> 1, v = q[l] & 1;
if (d[q[l]] > u) continue;
if (u + k >= n) out("YES");
if (d[(u + 1) * 2 + v] == -1 && s[v][u + 1] != 'X') {
d[(u + 1) * 2 + v] = d[q[l]] + 1;
q[r++] = (u + 1) * 2 + v;
}
if (u && d[(u - 1) * 2 + v] == -1 && s[v][u - 1] != 'X') {
d[(u - 1) * 2 + v] = d[q[l]] + 1;
q[r++] = (u - 1) * 2 + v;
}
if (d[(u + k) * 2 + (v ^ 1)] == -1 && s[v ^ 1][u + k] != 'X') {
d[(u + k) * 2 + (v ^ 1)] = d[q[l]] + 1;
q[r++] = (u + k) * 2 + (v ^ 1);
}
}
out("NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > vec;
long long a[1000000][3], kilk, cnt[1000000];
long long get(string st) {
long long tep = 0;
for (int i = 0; i < st.size(); i++) {
if (a[tep][st[i] - 48] == 0) {
kilk++;
a[tep][st[i] - 48] = kilk;
}
tep = a[tep][st[i] - 48];
}
return (tep);
}
int main() {
long long n;
cin >> n;
while (n--) {
char type;
cin >> type;
if (type == '+') {
string st;
cin >> st;
for (int i = 0; i < st.size(); i++) st[i] = st[i] % 2 + 48;
reverse(st.begin(), st.end());
while (st.size() < 18) st += '0';
cnt[get(st)]++;
}
if (type == '-') {
string st;
cin >> st;
for (int i = 0; i < st.size(); i++) st[i] = st[i] % 2 + 48;
reverse(st.begin(), st.end());
while (st.size() < 18) st += '0';
cnt[get(st)]--;
}
if (type == '?') {
string st;
cin >> st;
for (int i = 0; i < st.size(); i++) st[i] = st[i] % 2 + 48;
reverse(st.begin(), st.end());
while (st.size() < 18) st += '0';
cout << cnt[get(st)] << '\n';
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1005;
int read() {
int x = 0, y = 1;
char ch = getchar();
while (ch < '0' || ch > '9') y = (ch == '-') ? -1 : 1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * y;
}
int n, cnt = 0, a[M], b[M], y[M], Ans[M * M][2];
void solve() {
n = read();
for (int i = 1; i <= n; i++) y[i] = read();
for (int i = 1; i <= n; i++) {
a[i] = 0;
for (int j = 1; j <= n; j++)
a[i] += (y[j] < y[i] || (y[j] == y[i] && j <= i));
b[a[i]] = i;
}
for (int l = 1; l <= n; l++) {
for (int i = 1; i <= n - l; i++) {
if (b[i] > b[i + 1]) {
Ans[++cnt][0] = b[i + 1];
Ans[cnt][1] = b[i];
swap(b[i], b[i + 1]);
}
}
}
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) printf("%d %d\n", Ans[i][0], Ans[i][1]);
}
signed main() { solve(); }
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
char c;
bool nega = 0;
while ((!isdigit(c = getchar())) && (c != '-'))
;
if (c == '-') {
nega = 1;
c = getchar();
}
x = c - 48;
while (isdigit(c = getchar())) x = x * 10 + c - 48;
if (nega) x = -x;
}
template <typename T>
inline void writep(T x) {
if (x > 9) writep(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
writep(x);
}
template <typename T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
int cx[] = {1, -1, 0, 0};
int cy[] = {0, 0, 1, -1};
int n, m, k;
int r[10001];
int c[10001];
map<pair<int, int>, int> M;
vector<pair<int, int> > g[50001];
deque<int> q;
int f[50001];
void bfs(int u) {
for (int i = (1); i <= (50000); i++) f[i] = 1e9;
f[u] = 0;
q.push_back(u);
while (!q.empty()) {
u = q.front();
q.pop_front();
for (pair<int, int> v : g[u]) {
if (f[v.first] > f[u] + v.second) {
f[v.first] = f[u] + v.second;
if (v.second)
q.push_back(v.first);
else
q.push_front(v.first);
}
}
}
}
int main() {
read(n);
read(m);
read(k);
for (int i = (1); i <= (k); i++) {
read(r[i]);
read(c[i]);
M[make_pair(r[i], c[i])] = i;
}
int sz = k;
if (M.find(make_pair(n, m)) == M.end()) k++;
for (int i = (1); i <= (sz); i++) {
g[i].push_back(make_pair(15000 + r[i], 1));
g[15000 + r[i]].push_back(make_pair(i, 0));
if (r[i] > 1) {
g[i].push_back(make_pair(15000 + r[i] - 1, 1));
g[15000 + r[i] - 1].push_back(make_pair(i, 0));
}
if (r[i] < n) {
g[i].push_back(make_pair(15000 + r[i] + 1, 1));
g[15000 + r[i] + 1].push_back(make_pair(i, 0));
}
g[i].push_back(make_pair(30000 + c[i], 1));
g[30000 + c[i]].push_back(make_pair(i, 0));
if (c[i] > 1) {
g[i].push_back(make_pair(30000 + c[i] - 1, 1));
g[30000 + c[i] - 1].push_back(make_pair(i, 0));
}
if (c[i] < m) {
g[i].push_back(make_pair(30000 + c[i] + 1, 1));
g[30000 + c[i] + 1].push_back(make_pair(i, 0));
}
for (int l = (0); l < (4); l++) {
int x = r[i] + cx[l];
int y = c[i] + cy[l];
if (M.find(make_pair(x, y)) != M.end())
g[i].push_back(make_pair(M[make_pair(x, y)], 0));
}
}
if (k > sz) {
M[make_pair(n, m)] = k;
g[15000 + n].push_back(make_pair(k, 0));
g[30000 + m].push_back(make_pair(k, 0));
}
bfs(M[make_pair(1, 1)]);
if (f[M[make_pair(n, m)]] == 1e9) f[M[make_pair(n, m)]] = -1;
write(f[M[make_pair(n, m)]]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll n, m, k, t, a;
list<ll> q;
unordered_map<ll, bool> visited;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> t;
while (t--) {
cin >> n;
ll l = 1;
ll r = n;
q.clear();
visited.clear();
while (l < r) {
ll c = l + (r - l) / 2;
q.push_front(c);
l = c + 1;
}
k = n;
for (ll j : q) {
if (k > j) {
k -= j;
} else {
k += j;
}
}
l = 1;
r = n;
cout << "? " << k << endl;
visited[k] = 1;
cin >> a;
while (l < r) {
ll c = l + (r - l) / 2;
bool aa = false;
while (!aa) {
aa = true;
if (k + c <= n && visited[k + c] != true) {
visited[k + c] = 1;
cout << "? " << k + c << endl;
cin >> a;
if (a == 1) {
r = min(r, c);
} else {
l = max(l, c + 1);
}
k += c;
} else if (k - c >= 1 && visited[k - c] != true) {
visited[k - c] = 1;
cout << "? " << k - c << endl;
cin >> a;
if (a == 1) {
r = min(r, c);
} else {
l = max(l, c + 1);
}
k -= c;
} else {
aa = false;
c--;
}
}
}
cout << "= " << l << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const N = 1000 * 1000 + 16;
int const M = 1000 * 1000 * 1000 + 7;
int n, a, b;
int v[N];
ll chk(int prime) {
vector<vector<ll>> dp(3, vector<ll>(n + 1));
dp[0][0] = 0;
dp[1][0] = 0;
dp[2][0] = 0;
ll inf = 1e16;
auto cost = [inf](int x, int p) {
if (x % p == 0)
return 0ll;
else if ((x + 1) % p && (x - 1) % p)
return inf;
else
return (ll)b;
};
for (int i = 1; i <= n; ++i) {
int z = v[i - 1];
dp[0][i] = dp[0][i - 1] + cost(z, prime);
dp[1][i] = min(dp[0][i - 1], dp[1][i - 1]) + a;
dp[2][i] = min(dp[1][i - 1], dp[2][i - 1]) + cost(z, prime);
dp[0][i] = min(dp[0][i], inf);
dp[1][i] = min(dp[1][i], inf);
dp[2][i] = min(dp[2][i], inf);
}
return min(dp[0][n], min(dp[1][n], dp[2][n]));
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
cin >> n >> a >> b;
for (int i = 0; i < n; ++i) cin >> v[i];
vector<int> p;
for (int x :
{v[0] - 1, v[0], v[0] + 1, v[n - 1] - 1, v[n - 1], v[n - 1] + 1}) {
for (int i = 2; i * i <= x; ++i) {
if (x % i) continue;
while (x % i == 0) x /= i;
p.emplace_back(i);
}
if (x > 1) p.emplace_back(x);
}
sort(p.begin(), p.end());
p.erase(unique(p.begin(), p.end()), p.end());
ll ans = 1e16;
for (int x : p) ans = min(ans, chk(x));
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 123456;
int n;
int a[N];
int fn[N];
int fn2[N];
vector<int> values;
int compress(int x) {
return (int)(lower_bound(values.begin(), values.end(), x) - values.begin()) +
2;
}
void modify(int p, int v) {
for (; p < N; p = (p | (p - 1)) + 1) {
fn[p] += v;
}
}
int findsum(int p) {
int s = 0;
for (; p; p &= (p - 1)) {
s += fn[p];
}
return s;
}
void modify2(int p, int v) {
for (; p < N; p = (p | (p - 1)) + 1) {
fn2[p] += v;
}
}
int findsum2(int p) {
int s = 0;
for (; p; p &= (p - 1)) {
s += fn2[p];
}
return s;
}
int main() {
scanf("%d", &n);
long long k;
scanf("%lld", &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
values.push_back(a[i]);
}
memset(fn, 0, sizeof(fn));
sort(values.begin(), values.end());
values.resize(unique(values.begin(), values.end()) - values.begin());
long long tot_inv = 0;
for (int i = 1; i <= n; i++) {
tot_inv += i - 1 - findsum(compress(a[i]));
modify(compress(a[i]), +1);
}
memset(fn, 0, sizeof(fn));
long long low_inv = 0;
long long high_inv = 0;
long long separated = 0;
long long ans = 0;
int high = n + 1;
for (int i = 1; i <= n; i++) {
low_inv += i - 1 - findsum(compress(a[i]));
modify(compress(a[i]), +1);
}
for (int low = n; low >= 1; low--) {
while (low_inv + high_inv + separated <= k && high > low) {
high_inv += findsum2(compress(a[high - 1]) - 1);
modify2(compress(a[high - 1]), +1);
separated += low - findsum(compress(a[high - 1]));
high--;
}
low_inv -= low - findsum(compress(a[low]));
modify(compress(a[low]), -1);
separated -= findsum2(compress(a[low]) - 1);
ans += max(0, n - (high + 1) + 1);
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void _DBG(const char *s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _DBG(const char *s, _T x, args... a) {
while (*s != ',') cerr << *s++;
cerr << " = " << x << ',';
_DBG(s + 1, a...);
}
const long long P = 998244353;
long long fact[300007];
long long bin_pow(long long n, long long k) {
if (k == 0) {
return 1;
}
if (k & 1) {
return (n * bin_pow(n, k - 1)) % P;
}
long long tmp = bin_pow(n, k / 2);
return (tmp * tmp) % P;
}
long long inv(long long x) { return bin_pow(x, P - 2); }
long long choose(long long n, long long k) {
long long tmp = fact[n] * inv(fact[k]);
tmp %= P;
return (tmp * inv(fact[n - k])) % P;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
n *= 2;
fact[0] = 1;
for (int i = 1; i < n + 3; i++) {
fact[i] = i * fact[i - 1];
fact[i] %= P;
}
vector<long long> A(n);
for (auto &a : A) {
cin >> a;
}
sort((A).begin(), (A).end());
long long total = 0;
for (int i = 0; i < n; i++) {
total += i < n / 2 ? -A[i] : A[i];
total %= P;
}
total *= choose(n, n / 2);
total %= P;
cout << total << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long ar[n + 1], al[n + 1];
long long cnt = 0, mn = 1e18;
for (int i = 0; i < n; i++) {
cin >> ar[i];
mn = min(mn, ar[i]);
al[i] = ar[i];
}
for (int i = 0; i < n - 1; i++) {
if (ar[i] > ar[i + 1]) {
cnt = 1;
break;
}
}
if (cnt == 0) {
cout << "YES" << endl;
continue;
}
sort(al, al + n);
long long f = 0;
for (int i = 0; i < n; i++) {
if (al[i] != ar[i] && ar[i] % mn != 0) {
f = 1;
break;
}
}
if (!f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int par[100010];
long long s[100010];
int n, m, p, q;
void Init() {
for (int i = 1; i <= n; ++i) {
par[i] = i;
}
memset(s, 0, sizeof(s));
}
int Find(int x) {
while (x != par[x]) {
x = par[x];
}
return x;
}
void Union(int x, int y, int len) {
int px = Find(x);
int py = Find(y);
s[px] += len;
if (px == py) return;
par[py] = px;
s[px] += s[py];
}
int main() {
int i, j;
scanf("%d%d%d%d", &n, &m, &p, &q);
Init();
pair<int, int> last;
for (i = 0; i < m; ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
Union(a, b, c);
last.first = a;
last.second = b;
}
vector<pair<long long, int> > roots;
for (i = 1; i <= n; ++i) {
if (par[i] == i) {
roots.push_back(pair<long long, int>(s[i], i));
}
}
int need = roots.size() - q;
if (need > p || need < 0 || (need == 0 && p > 0 && roots.size() == n)) {
printf("NO\n");
return 0;
}
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
priq;
for (i = 0; i < static_cast<int>(roots.size()); ++i) {
priq.push(roots[i]);
}
vector<pair<int, int> > ans;
for (i = 0; i < need; ++i) {
pair<long long, int> a = priq.top();
priq.pop();
pair<long long, int> b = priq.top();
priq.pop();
ans.push_back(pair<int, int>(a.second, b.second));
last.first = a.second;
last.second = b.second;
priq.push(pair<long long, int>(
min(1000000000LL, a.first + b.first + 1 + a.first + b.first),
a.second));
}
if (need < p) {
for (i = 0; i < p - need; ++i) {
ans.push_back(last);
}
}
printf("YES\n");
for (i = 0; i < static_cast<int>(ans.size()); ++i) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, x, y, con[N], tot[N];
int head[N], nxt[N * 2], to[N * 2], cnt;
void addedge(int u, int v) {
to[cnt] = v;
nxt[cnt] = head[u];
head[u] = cnt++;
}
int dfs(int u) {
if (tot[u]) return tot[u];
for (int i = head[u]; ~i; i = nxt[i])
if (to[i] < u) {
tot[u] = max(tot[u], 1 + dfs(to[i]));
}
return tot[u] ? tot[u] : tot[u] = 1;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
memset(head, -1, sizeof(head));
memset(con, 0, sizeof(con));
memset(tot, 0, sizeof(tot));
cnt = 0;
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
if (x < y) swap(x, y);
con[x]++, con[y]++;
addedge(x, y);
}
for (int i = n; i >= 1; i--)
if (!tot[i]) {
dfs(i);
}
long long res = 0;
for (int i = 1; i <= n; i++) res = max(res, (long long)con[i] * tot[i]);
printf("%I64d\n", res);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long base, long long exponent, long long modulus) {
long long result = 1;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % modulus;
exponent = exponent >> 1;
base = (base * base) % modulus;
}
return result;
}
long long gcd(long long u, long long v) { return (v != 0) ? gcd(v, u % v) : u; }
long long mulmod(long long a, long long b, long long c) {
long long x = 0, y = a % c;
while (b > 0) {
if (b % 2 == 1) {
x = (x + y) % c;
}
y = (y * 2) % c;
b /= 2;
}
return x % c;
}
int n, type, x, y;
vector<pair<int, int> > a;
bool vis[101];
void dfs(int idx) {
if (vis[idx]) return;
vis[idx] = 1;
for (int i = 0; i < a.size(); ++i) {
pair<int, int> temp = a[i];
if (idx == i) continue;
if ((temp.first < a[idx].first && temp.second > a[idx].first) ||
(temp.first < a[idx].second && temp.second > a[idx].second))
dfs(i);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
while (n--) {
cin >> type >> x >> y;
if (type == 1) {
a.push_back(make_pair(x, y));
} else {
--x;
--y;
memset(vis, 0, sizeof vis);
dfs(x);
if (!vis[y])
cout << "NO\n";
else
cout << "YES\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, k;
int i, j, temp;
scanf("%d %d", &n, &k);
if (2 * k >= n) {
printf("-1");
return 0;
}
printf("%d\n", n * k);
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= k + i; j++) {
temp = (j > n) ? (j % n) : j;
printf("%d %d\n", i, temp);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const long long inf = 1e17;
int n, qn, a[N];
long long b[N], ans;
inline long long Abs(long long x) { return x > 0 ? x : -x; }
long long cal(int x, int v) {
return (x < 2 || x > n) ? 0 : (Abs(b[x] + v) - Abs(b[x]));
}
struct SegTree {
long long val[N * 5];
void change(int p, long long v, int l, int r, int x) {
if (l == r) {
val[x] = v;
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
change(p, v, l, mid, x << 1);
else
change(p, v, mid + 1, r, x << 1 | 1);
val[x] = min(val[x << 1], val[x << 1 | 1]);
}
long long ask(int L, int R, int l, int r, int x) {
if (L > R) return inf;
if (l >= L && r <= R) return val[x];
int mid = (l + r) >> 1;
long long t = inf;
if (L <= mid) t = min(t, ask(L, R, l, mid, x << 1));
if (R > mid) t = min(t, ask(L, R, mid + 1, r, x << 1 | 1));
return t;
}
} A, B;
void up(int i) {
if (i == 1 || i == n) return;
if (b[i] < 0 && b[i + 1] > 0)
B.change(i, i, 2, n - 1, 1), A.change(i, inf, 2, n - 1, 1);
else
A.change(i, max(0 - b[i], 0LL) + max(b[i + 1], 0LL), 2, n - 1, 1),
B.change(i, inf, 2, n - 1, 1);
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (i = 2; i <= n; ++i) ans += Abs(b[i] = a[i] - a[i - 1]);
for (i = 2; i < n; ++i) up(i);
scanf("%d", &qn);
for (; qn--;) {
int t, l, r, x;
scanf("%d%d%d%d", &t, &l, &r, &x);
if (t == 1) {
long long inc = -inf;
if (l == 1) inc = max(inc, cal(2, -x)), ++l;
if (r == n) inc = max(inc, cal(n, x)), --r;
if (l <= r) {
long long dec = A.ask(l, r, 2, n - 1, 1);
if (dec != inf) inc = max(inc, 2LL * max(x - dec, 0LL));
long long y = B.ask(l, r, 2, n - 1, 1);
if (y != inf) inc = max(inc, cal(y, x) + cal(y + 1, -x));
}
printf("%I64d\n", ans + inc);
} else {
if (l != 1) ans += cal(l, x), b[l] += x, up(l - 1);
if (r != n) ans += cal(r + 1, -x), b[r + 1] -= x, up(r + 1);
up(l);
if (l != r) up(r);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[100005];
int visited[100005];
int l, r;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (visited[a[i]] == 0) cnt++;
visited[a[i]]++;
if (cnt == k) {
for (int j = 0; j <= i; j++) {
visited[a[j]]--;
if (visited[a[j]] == 0) {
cout << j << " ";
break;
}
}
cout << i << endl;
return 0;
}
}
cout << "-1"
<< " "
<< "-1" << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
long long d[maxn], c[maxn], sum[maxn], dp[maxn][101], t;
int q[maxn], head, tail;
long long getans(int i, int j, int k) {
return dp[k][j - 1] + c[i] * (i - k) - (sum[i] - sum[k]);
}
long long Y(int k, int j) { return dp[k][j - 1] + sum[k]; }
int main() {
int N, M, P, i, j, h;
scanf("%d%d%d", &N, &M, &P);
for (i = 2; i <= N; i++) scanf("%d", &d[i]), d[i] += d[i - 1];
for (i = 1; i <= M; i++) {
scanf("%d%d", &h, &t);
c[i] = t - d[h];
}
sort(c + 1, c + M + 1);
for (i = 1; i <= M; i++) sum[i] = sum[i - 1] + c[i];
for (i = 1; i <= M; i++) dp[i][1] = c[i] * (i - 1) - sum[i - 1];
for (j = 2; j <= P; j++) {
head = tail = 0;
for (i = 1; i <= M; i++) {
while (tail > head &&
Y(q[head + 1], j) - Y(q[head], j) < c[i] * (q[head + 1] - q[head]))
head++;
dp[i][j] = getans(i, j, q[head]);
while (tail > head &&
(Y(i, j) - Y(q[tail], j)) * (q[tail] - q[tail - 1]) <
(Y(q[tail], j) - Y(q[tail - 1], j)) * (i - q[tail]))
tail--;
q[++tail] = i;
}
}
printf("%I64d\n", dp[M][P]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, id;
class people {
public:
int cnt, real;
string name, str[210];
bool bad[210];
people() {
cnt = real = 0;
memset(bad, 0, sizeof bad);
}
} p[25];
map<string, int> f;
bool pro(string a, string b) {
if (a.length() > b.length()) return false;
int lenA = a.length();
int lenB = b.length();
for (int i = 0; i < lenA; i++) {
if (b[lenB - 1 - i] == a[lenA - 1 - i])
continue;
else
return false;
}
return true;
}
int main() {
scanf("%d", &n);
for (int tmp, i = 1; i <= n; i++) {
string name;
cin >> name;
int x = f[name];
if (x) {
scanf("%d", &tmp);
for (int j = 1; j <= tmp; j++) {
cin >> p[x].str[++p[x].cnt];
}
} else {
f[name] = ++id;
p[id].name = name;
scanf("%d", &tmp);
for (int j = 1; j <= tmp; j++) {
string s;
cin >> s;
p[id].str[++p[id].cnt] = s;
}
}
}
cout << id << endl;
for (int i = 1; i <= id; i++) {
people &a = p[i];
for (int j = 1; j <= a.cnt; j++) {
if (a.bad[j]) continue;
for (int k = j + 1; k <= a.cnt; k++) {
if (a.bad[k]) continue;
if (pro(a.str[j], a.str[k])) a.bad[j] = true;
if (a.bad[k] || a.bad[j]) continue;
if (pro(a.str[k], a.str[j])) a.bad[k] = true;
}
}
a.real = 0;
for (int j = 1; j <= a.cnt; j++)
if (a.bad[j] == false) a.real++;
cout << a.name << " " << a.real << " ";
for (int j = 1; j <= a.cnt; j++)
if (a.bad[j] == false) cout << a.str[j] << " ";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, x;
int main() {
scanf("%lld%lld", &n, &m);
if (n > m) swap(n, m);
if (n >= 3) {
if ((n % 2) && (m % 2))
printf("%lld\n", n * m - 1);
else
printf("%lld\n", n * m);
} else if (n == 2) {
if (m == 2)
puts("0");
else if (m == 3)
puts("4");
else if (m == 7)
puts("12");
else
printf("%lld\n", n * m);
} else if (n == 1) {
x = m % 6;
if (x == 4)
x = 2;
else if (x == 5)
x = 1;
printf("%lld\n", m - x);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int main() {
cin >> a >> b >> c;
if (a < c * 2 || b < c * 2)
cout << "Second\n";
else
cout << "First\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
long long i, j;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> arr(n);
for (long long i = 0; i < n; ++i) {
cin >> arr[i];
arr[i]--;
}
vector<long long> freq(n * n, 0);
long long ans = 0;
for (long long j = n - 1; j >= 0; --j) {
long long k = j + 1;
for (long long l = k + 1; l < n; ++l) freq[arr[k] * n + arr[l]]++;
for (long long i = 0; i < j; ++i) {
ans += freq[arr[i] * n + arr[j]];
}
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\n";
err(++it, args...);
}
const double PI = acos(-1);
const double eps = (1e-9);
const long long int INF = 1e18;
const int M = (1e9) + 7;
const int N = (2e5) + 5;
const int T = 100;
int sum[N];
int agla[N];
long long int ans = 0;
void add(long long int m) {
ans += ((m * (m - 1)) / 2);
return;
}
int main() {
int n, i, j, a, l, r, p, c, d, k;
string str;
cin >> str;
str = "0" + str;
n = str.size();
for (i = 0; i < n; ++i) sum[i] = str[i] - '0';
for (i = 1; i < n; ++i) sum[i] += sum[i - 1];
vector<int> ar(n);
for (k = 1; k < T + 1; ++k) {
for (i = 0; i < n; ++i) ar[i] = i - k * sum[i];
sort(ar.begin(), ar.end());
i = 0;
while (i < n) {
j = i;
while (j < n && ar[j] == ar[i]) ++j;
add(j - i);
i = j;
}
}
int P;
a = n;
for (i = n - 1; i >= 0; --i) {
agla[i] = a;
if (str[i] == '1') a = i;
}
for (l = 0; l < n; ++l) {
r = agla[l], p = 1, P = (n - l), P /= T;
while (p <= P && r < n) {
a = agla[r];
c = (r - l - 1), c /= p, ++c;
d = (a - l - 1), d /= p, ++d;
c = max(c, T + 1);
if (d > c) ans += (d - c);
r = a, ++p;
}
}
cout << ans << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
vector<vector<long long> > g;
vector<long long> vis, edge, head;
long long fedge(long long v) {
if (edge[v] == v)
return v;
else
edge[v] = fedge(edge[v]);
return edge[v];
}
long long fhead(long long v) {
if (head[v] == v)
return v;
else
head[v] = fhead(head[v]);
return head[v];
}
void dfs(long long v) {
cout << v + 1 << " ";
vis[v] = 1;
for (long long i = 0; i < g[v].size(); i++) {
if (vis[g[v][i]] == 0) dfs(g[v][i]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long a[n];
g.resize(n);
vis.resize(n, 0);
edge.resize(n);
head.resize(n);
for (long long i = 0; i < n; i++) a[i] = 0, edge[i] = i, head[i] = i;
long long b, c;
for (long long i = 0; i < n - 1; i++) {
cin >> b >> c;
fhead(c - 1);
fedge(b - 1);
g[edge[b - 1]].push_back(head[c - 1]);
a[head[c - 1]]++;
edge[edge[b - 1]] = edge[c - 1];
head[head[c - 1]] = head[b - 1];
}
for (long long i = 0; i < n; i++) {
if (a[i] == 0) dfs(i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cin >> x;
if (x % 2 == 0)
cout << "0" << endl;
else
cout << "1" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const long long int N = 1000 + 5;
int32_t main() {
string s;
cin >> s;
long long int n = s.size();
long long int ans = (s[0] % 4 == 0);
for (long long int i = 0; i < n - 1; i++) {
long long int first = s[i] - '0';
long long int second = s[i + 1] - '0';
if (second % 4 == 0) ans++;
if ((first * 10 + second) % 4 == 0) ans += i + 1;
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Face {
int St[4];
bool check(int k) {
if (k == 0)
return St[0] == St[1] && St[2] == St[3];
else
return St[0] == St[2] && St[1] == St[3];
}
bool asame() { return check(0) && check(1); }
} cube[6];
bool check02(int i, int j) { return cube[i].St[0] == cube[j].St[2]; }
bool same02() {
if (!cube[3].check(0)) return false;
if (!cube[1].check(0)) return false;
if (!cube[4].check(0)) return false;
if (!cube[5].check(0)) return false;
if (check02(3, 1) && check02(1, 4) && check02(4, 5) && check02(5, 3))
return true;
if (check02(3, 5) && check02(1, 3) && check02(4, 1) && check02(5, 4))
return true;
return false;
}
bool check01(int i, int j) { return cube[i].St[0] == cube[j].St[1]; }
bool check00(int i, int j) { return cube[i].St[0] == cube[j].St[0]; }
bool check11(int i, int j) { return cube[i].St[1] == cube[j].St[1]; }
bool same34() {
if (!cube[0].check(1)) return false;
if (!cube[1].check(1)) return false;
if (!cube[2].check(1)) return false;
if (!cube[5].check(1)) return false;
if (check01(0, 1) && check01(1, 2) && check00(2, 5) && check11(5, 0))
return true;
if (check00(0, 5) && check01(1, 0) && check01(2, 1) && check11(5, 2))
return true;
return false;
}
bool same15() {
if (!cube[0].check(0)) return false;
if (!cube[3].check(1)) return false;
if (!cube[2].check(0)) return false;
if (!cube[4].check(1)) return false;
if (cube[0].St[3] == cube[3].St[0] && cube[3].St[1] == cube[2].St[2] &&
cube[2].St[0] == cube[4].St[3] && cube[4].St[2] == cube[0].St[1])
return true;
if (cube[0].St[3] == cube[4].St[3] && cube[3].St[1] == cube[0].St[1] &&
cube[2].St[0] == cube[3].St[0] && cube[4].St[2] == cube[2].St[2])
return true;
return false;
}
int main() {
for (int i = 0; i < 6; ++i)
for (int j = 0; j < 4; ++j) cin >> cube[i].St[j];
bool flag = false;
if (cube[0].asame() && cube[2].asame())
flag = same02();
else if (cube[3].asame() && cube[4].asame())
flag = same34();
else if (cube[1].asame() && cube[5].asame())
flag = same15();
if (flag)
cout << "YES";
else
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000;
const int INF = 1 << 28;
int n;
pair<int, int> a[MAX_N];
int solve() {
int r = 0;
for (int i = (0); i < (n); i++) {
int k = a[i].first, m = a[i].second;
int x = (log2(max(m - 1, 1)) / 2.0) + 1;
r = max(r, k + x);
}
return r;
}
int main() {
cin >> n;
for (int i = (0); i < (n); i++) cin >> a[i].first >> a[i].second;
cout << solve() << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
string s;
vector<vector<int> > m(1010), g(1010);
vector<int> u(1010), v(1010);
int c;
bool isPrime(int first) {
for (int i = 2; i * i <= first; i++) {
if (first % i == 0) return false;
}
return true;
}
void dfs(int i) {
u[i] = 1;
g[c].push_back(i);
for (int j = 0; j < m[i].size(); j++) {
if (!u[m[i][j]]) dfs(m[i][j]);
}
}
int main(int argc, char const *argv[]) {
cin.sync_with_stdio(0);
cin.tie(0);
int n;
cin >> s;
n = s.size();
for (int i = 0; i < n; v[s[i] - 'a']++, i++)
;
for (int i = 2; i <= n; i++) {
if (isPrime(i)) {
for (int j = 2 * i; j <= n; m[i].push_back(j), m[j].push_back(i), j += i)
;
}
}
for (int i = 2; i <= n; i++) {
if (!u[i]) {
dfs(i);
c++;
}
}
g[c].push_back(1);
c++;
int i;
int j;
int k;
for (i = 0; i < c; i++) {
for (j = 0; j < 26; j++) {
if (v[j] >= g[i].size()) break;
}
if (j == 26) break;
v[j] -= g[i].size();
for (k = 0; k < g[i].size(); s[g[i][k] - 1] = j + 'a', k++)
;
}
if (i < c)
cout << "NO" << endl;
else
cout << "YES" << endl << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 600005;
const int inf = 1000 * 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
mt19937 myrand(chrono::steady_clock::now().time_since_epoch().count());
int n, x, y;
int a[N];
int q;
vector<int> d[N];
struct cd {
double x, y;
cd(double xx = 0.0, double yy = 0.0) {
x = xx;
y = yy;
}
cd operator+(const cd &a) { return cd(x + a.x, y + a.y); }
cd operator-(const cd &a) { return cd(x - a.x, y - a.y); }
cd operator*(const cd &a) { return cd(x * a.x - y * a.y, x * a.y + y * a.x); }
cd operator/(const double &k) { return cd(x / k, y / k); }
};
int ind[N];
void fft(vector<cd> &a) {
int n = (int)a.size();
int h = 0, _n = n;
while (_n % 2 == 0) {
_n /= 2;
h++;
}
for (int i = 0; i < n; i++) {
if (i < ind[i]) {
swap(a[i], a[ind[i]]);
}
}
for (int i = 1; i <= h; i++) {
int x = (1 << i);
double alfa = 2.0 * acos(-1.0) / x;
cd wn(cos(alfa), sin(alfa));
for (int j = 0; j < n; j += x) {
cd w(1);
for (int h = j; h < j + x / 2; h++) {
cd u = a[h];
cd v = w * a[h + x / 2];
a[h] = u + v;
a[h + x / 2] = u - v;
w = w * wn;
}
}
}
}
void inv(vector<cd> &a) {
fft(a);
for (int i = 0; i < (int)a.size(); i++) {
a[i] = a[i] / (int)a.size();
}
reverse(a.begin() + 1, a.end());
}
void mult(vector<cd> &a, vector<cd> &b) {
int n = 1, h = 0;
int sz = (int)a.size() + (int)b.size() - 1;
while (n < sz) {
n *= 2;
h++;
}
ind[0] = 0;
for (int i = 0; i < h; i++) {
int x = (1 << i);
for (int j = x; j < 2 * x; j++) {
ind[j] = ind[j - x] ^ (1 << (h - i - 1));
}
}
a.resize(n);
b.resize(n);
fft(a);
fft(b);
for (int i = 0; i < n; i++) {
a[i] = a[i] * b[i];
}
inv(a);
vector<int> answ(n);
for (int i = 0; i < n; i++) {
if ((long long)(a[i].x + 0.5) > 0) {
a[i] = 1;
} else {
a[i] = 0;
}
}
}
int main() {
for (int i = 1; i <= 500000; i++) {
for (int j = i; j <= 500000; j += i) {
d[j].push_back(i);
}
}
cin >> n >> x >> y;
vector<cd> A(x + 1), B(x + 1);
for (int i = 1; i <= n + 1; i++) {
scanf("%d", &a[i]);
A[a[i]] = 1;
B[x - a[i]] = 1;
}
mult(A, B);
scanf("%d", &q);
while (q--) {
int xx;
scanf("%d", &xx);
xx /= 2;
bool flag = false;
for (int i = (int)d[xx].size() - 1; i >= 0; i--) {
if (d[xx][i] > y && d[xx][i] - y <= x && A[x + d[xx][i] - y].x > 0.0) {
flag = true;
printf("%d\n", 2 * d[xx][i]);
break;
}
}
if (!flag) printf("-1\n");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
int n, head[N], l, af[N];
bool f[N];
struct re {
int a, b;
} a[N * 2], len[N];
void arr(int x, int y) {
a[++l].a = head[x];
a[l].b = y;
head[x] = l;
}
void dfs(int x, int fa) {
af[x] = fa;
len[x].a = len[fa].a + 1;
len[x].b = x;
if (len[x].a <= 3) f[x] = 1;
for (register int u = head[x]; u; u = a[u].a) {
int v = a[u].b;
if (v != fa) dfs(v, x);
}
}
bool cmp(re x, re y) { return (x.a > y.a); }
void dfs2(int x) {
f[x] = 1;
for (register int u = head[x]; u; u = a[u].a) {
int v = a[u].b;
f[v] = 1;
}
}
int main() {
cin >> n;
for (register int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
arr(x, y);
arr(y, x);
}
dfs(1, 0);
sort(len + 1, len + n + 1, cmp);
int ans = 0;
for (register int i = 1; i <= n; i++)
if (!f[len[i].b]) ans++, dfs2(af[len[i].b]);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[30], ans[2][15];
int main() {
scanf("%s", s);
int x = -1, y = -1;
for (int i = 0; i < 27 && x == -1; i++) {
for (int j = i + 2; j < 27 && x == -1; j++) {
if (s[i] == s[j]) {
x = i, y = j;
break;
}
}
}
if (x == -1) {
printf("Impossible\n");
return 0;
}
int len = y - x - 1;
if (len % 2 == 0) {
int lp = (x + len / 2), rp = lp + 1, rcnt = 13;
while (lp > x) {
rcnt--;
ans[1][rcnt] = s[lp];
ans[0][rcnt] = s[rp];
lp--, rp++;
}
rcnt--;
ans[1][rcnt] = s[x];
x--, y++;
bool rev = false;
int trcnt = rcnt;
while (y < 27) {
ans[rev][rcnt] = s[y];
if (rev) {
rcnt++;
} else
rcnt--;
if (rcnt < 0) {
rev = true;
rcnt = 0;
}
y++;
}
rev = false;
rcnt = trcnt;
while (x >= 0) {
if (rev) {
rcnt++;
} else
rcnt--;
if (rcnt < 0) {
rev = true;
continue;
}
ans[!rev][rcnt] = s[x];
x--;
}
} else {
int lp = (x + len / 2), rp = lp + 1, rcnt = 13;
while (lp > x) {
rcnt--;
ans[1][rcnt] = s[lp];
ans[0][rcnt] = s[rp];
lp--, rp++;
}
rcnt--;
ans[1][rcnt] = s[x], ans[0][rcnt] = s[rp];
x--, y++;
bool rev = false;
int trcnt = rcnt - 1;
rcnt--;
while (y < 27) {
ans[rev][rcnt] = s[y];
if (rev) {
rcnt++;
} else
rcnt--;
if (rcnt < 0) {
rev = true;
rcnt = 0;
}
y++;
}
rev = false;
rcnt = trcnt;
while (x >= 0) {
ans[!rev][rcnt] = s[x];
if (rev) {
rcnt++;
} else
rcnt--;
if (rcnt < 0) {
rev = true;
rcnt = 0;
}
x--;
}
}
ans[0][13] = ans[1][13] = '\0';
printf("%s\n%s\n", ans[0], ans[1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
char a[100000 + 10];
char b[100000 + 10];
char c[100000 + 10];
int vis[100000 + 10];
int main() {
cin >> n >> t;
cin >> a;
cin >> b;
t = n - t;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i]) cnt++;
}
if (cnt == t) {
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
for (char j = 'a'; j <= 'z'; j++)
if (a[i] != j && b[i] != j) {
c[i] = j;
break;
}
} else
c[i] = a[i];
}
printf("%s\n", c);
} else if (cnt > t) {
int m = cnt - t;
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
for (char j = 'a'; j <= 'z'; j++)
if (a[i] != j && b[i] != j) {
c[i] = j;
break;
}
} else {
c[i] = a[i];
for (char j = 'a'; j <= 'z'; j++)
if (a[i] != j && m != 0) {
c[i] = j;
m--;
break;
}
}
}
printf("%s\n", c);
} else {
int m = t - cnt;
int mm = m;
int x = n - cnt;
if (x < m * 2)
printf("-1\n");
else {
for (int i = 0; i < n; i++) {
if (a[i] == b[i])
c[i] = a[i];
else {
if (m != 0) {
c[i] = a[i];
m--;
} else if (mm != 0) {
c[i] = b[i];
mm--;
} else {
for (char j = 'a'; j <= 'z'; j++)
if (a[i] != j && b[i] != j) {
c[i] = j;
break;
}
}
}
}
printf("%s\n", c);
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x, y;
scanf("%lld", &n);
;
scanf("%lld", &x);
;
scanf("%lld", &y);
;
string s;
{
char temp[1000000];
scanf("%s", temp);
s = temp;
};
int count0 = 0;
int i = 0;
int boo = 1;
while (i < n) {
if (boo && s[i] == '0') {
count0++;
boo = 0;
} else if (s[i] == '1') {
boo = 1;
}
i++;
}
long long int min1 = 1000000000000000001;
for (int i = 0; i < count0; i++) {
min1 = min(min1, (i)*x + (count0 - i) * y);
}
if (min1 != 1000000000000000001)
cout << min1 << endl;
else
cout << 0 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int power(long long int x, long long int n) {
if (n == 0) return 1;
if (n % 2) return x * power(x * x, (n - 1) / 2);
return power(x * x, n / 2);
}
int pre[2002000];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int N, K;
cin >> N >> K;
int A[N], mini = 1000001, maxi = 0;
for (int i = 0; i < N; i++) {
cin >> A[i];
pre[A[i]]++;
mini = min(mini, A[i]);
maxi = max(maxi, A[i]);
}
if (mini <= K + 1) {
return cout << mini, 0;
}
for (int i = 1; i <= 2002000; i++) {
pre[i] += pre[i - 1];
}
for (int i = mini; i > K; i--) {
int cnt = 0;
for (int j = i; j <= maxi; j += i) {
cnt += pre[j + K] - pre[j - 1];
}
if (cnt == N) {
cout << i;
return 0;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
string t;
for (int i = 0; i < k - 1; i++) t += "()";
int m = n - 2 * (k - 1);
t += string(m / 2, '(');
t += string(m / 2, ')');
cout << n << "\n";
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
if (t[i] == s[j]) {
reverse(s.begin() + i, s.begin() + j + 1);
cout << i + 1 << " " << j + 1 << "\n";
break;
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
static constexpr int N = (int)2e5 + 1;
int cs[N], ks[N], curr[N];
bool done[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> cs[i];
int total = 0, num_done = 0;
for (int i = 1; i <= m; ++i) {
cin >> ks[i];
total += ks[i];
if (ks[i] == 0) {
done[i] = true;
++num_done;
}
}
int res = INT32_MAX, start = 1;
for (int i = 1; i <= n; ++i) {
++curr[cs[i]];
while (curr[cs[start]] > ks[cs[start]]) {
--curr[cs[start]];
++start;
}
if (curr[cs[i]] == ks[cs[i]] && !done[cs[i]]) {
done[cs[i]] = true;
++num_done;
}
if (num_done == m) res = min(res, i - start + 1 - total);
}
if (res == INT32_MAX)
cout << "-1\n";
else
cout << res << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
const int S = 4;
struct Point {
long long x, y;
Point() {}
Point(long long x, long long y) : x(x), y(y) {}
Point operator*(long long k) { return Point(x * k, y * k); }
Point operator+(Point a) { return Point(x + a.x, y + a.y); }
Point operator/(long long k) { return Point(x / k, y / k); }
friend istream& operator>>(istream& stream, Point& p) {
return stream >> p.x >> p.y;
}
};
Point pt[N];
vector<vector<int>> c(S, vector<int>());
set<int> rm;
int k;
long long ans = LLONG_MAX;
void solve(int d) {
if (d == S) {
int lv[S];
int cnt = 0;
for (int i = 0; i < S; ++i) {
for (int id : c[i]) {
if (rm.count(id) == 0) {
lv[i] = id;
++cnt;
break;
}
}
}
if (cnt == S) {
long long s[2] = {pt[lv[2]].x - pt[lv[0]].x, pt[lv[3]].y - pt[lv[1]].y};
for (int i = 0; i < 2; ++i) {
if (s[i] == 0) {
s[i] = 2;
} else if (s[i] % 2) {
++s[i];
}
}
ans = min(ans, s[0] * s[1]);
} else {
ans = 4;
}
return;
}
solve(d + 1);
set<int> tmp = rm;
for (int id : c[d]) {
if (rm.size() == k) {
break;
}
if (rm.count(id)) {
continue;
}
rm.insert(id);
solve(d + 1);
}
rm = tmp;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
Point p1, p2;
cin >> p1 >> p2;
p1 = p1 * 2;
p2 = p2 * 2;
pt[i] = (p1 + p2) / 2;
}
for (int i = 0; i < n; ++i) {
c[0].push_back(i);
c[1].push_back(i);
}
sort(c[0].begin(), c[0].end(),
[](int i, int j) { return pt[i].x < pt[j].x; });
sort(c[1].begin(), c[1].end(),
[](int i, int j) { return pt[i].y < pt[j].y; });
for (int i = 0; i < 2; ++i) {
c[i + 2] = c[i];
reverse(c[i + 2].begin(), c[i + 2].end());
}
solve(0);
cout << ans / 4 << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2034567891;
const long long int INF64 = 1234567890123456789ll;
const long double pi = 3.1415926535897932384626434;
int dx[] = {1, -1, 0, 0, 1, -1, -1, 1};
int dy[] = {0, 0, 1, -1, -1, -1, 1, 1};
long long int gcd(long long int a, long long int b) {
return (b == 0 ? a : gcd(b, a % b));
}
long long int lcm(long long int a, long long int b) {
return (a * (b / gcd(a, b)));
}
long long int power(long long int x, long long int y) {
long long int ans = 1;
while (y > 0) {
if (y & 1) ans = (ans * x) % 1000000007;
x = (x * x) % 1000000007;
y /= 2;
}
return ans;
}
const int N = 10 + 1e5;
map<long long int, long long int> BIT;
long long int v[N], n;
void update(long long int k, long long int val) {
for (; k <= (1ll << 40); k += k & (-k)) BIT[k] = max(BIT[k], val);
}
long long int query(long long int x) {
long long int ret = 0;
for (; x; x -= x & (-x)) ret = max(BIT[x], ret);
return ret;
}
int main() {
long long int r, h;
cin >> n;
for (long long int i = 0; i < n; i++) {
cin >> r >> h;
v[i] = (r * r * h);
}
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
long long int tm = v[i] + query(v[i] - 1);
ans = max(ans, tm);
update(v[i], tm);
}
cout << fixed << setprecision(8) << ans * pi;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005, INF = 2000000000000000000;
vector<long long> g[N];
long long power(long long a, long long b, long long p) {
if (a == 0) return 0;
long long res = 1;
a %= p;
while (b > 0) {
if (b & 1) res = (res * a) % p;
b >>= 1;
a = (a * a) % p;
}
return res;
}
vector<long long> prime;
bool isprime[N];
void pre() {
for (long long i = 2; i < N; i++) {
if (isprime[i]) {
for (long long j = i * i; j < N; j += i) isprime[j] = false;
prime.push_back(i);
}
}
return;
}
bool isPowerOfTwo(long long n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
long long gcd(long long a, long long b) {
if (a < b)
return gcd(b, a);
else if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long spf[N + 1];
void spfFun() {
for (long long i = 0; i <= N; i++) spf[i] = i;
for (long long i = 2; i * i <= N; i++) {
if (spf[i] == i) {
for (long long j = i * i; j <= N; j += i) {
spf[j] = min(spf[j], i);
}
}
}
}
bool isPerfectSquare(long double x) {
long double sr = sqrt(x);
return ((sr - floor(sr)) == 0);
}
void print(bool n) {
if (n) {
cout << "YES";
} else {
cout << "NO";
}
}
int32_t main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n;
cin >> n;
long long l[n], r[n];
for (long long i = 0; i < n; i++) {
cin >> l[i] >> r[i];
}
long long k;
cin >> k;
k--;
long long ans = n;
for (long long i = 0; i < n; i++) {
if (r[i] > k) {
ans = i;
break;
}
}
cout << n - ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
int a[26], b[26];
for (int i = 0; i < 26; i++) {
a[i] = 0;
b[i] = 0;
}
cin >> s >> t;
for (int i = 0; i < int(s.size()); i++) {
a[int(s[i] - 'a')]++;
}
for (int i = 0; i < int(t.size()); i++) {
b[int(t[i] - 'a')]++;
}
if (s.size() >= t.size()) {
int fl = 0;
for (int i = 0; i < 26; i++) {
if (b[i] > a[i]) {
fl = 1;
break;
}
}
int ff = 0;
int p = 0;
for (int i = 0; i < int(s.size()); i++) {
if (t[p] == s[i]) {
p++;
}
if (p == int(t.size() - 1)) {
break;
}
}
if (p < int(t.size() - 1)) {
ff = 1;
}
if (fl == 0) {
if (ff == 0) {
cout << "automaton";
} else {
if (s.size() == t.size()) {
cout << "array";
} else {
cout << "both";
}
}
} else {
cout << "need tree";
}
} else {
cout << "need tree";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > pairs;
long long arr[102];
int is[100002];
vector<long long> pr;
vector<long long> facts[102];
vector<long long> ids[102];
vector<long long> adj[100002];
int vis[100002];
int p[100002];
void sieve() {
for (long long i = 2; i * i <= 1000000000; i++) {
if (!is[i]) {
pr.push_back(i);
for (long long j = 2 * i; j * j <= 1000000000; j += i) {
is[j]++;
}
}
}
}
int match(int u) {
if (vis[u]) return 0;
vis[u] = 1;
for (int(i) = (0); (i) < (adj[u].size()); (i)++) {
int v = adj[u][i];
if (p[v] == -1 || match(p[v])) {
p[v] = u;
return 1;
}
}
return 0;
}
void add(int u, int v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
sieve();
int n, m;
cin >> n >> m;
for (int(i) = (1); (i) < (n + 1); (i)++) cin >> arr[i];
for (int(i) = (0); (i) < (m); (i)++) {
int x, y;
cin >> x >> y;
pairs.push_back(make_pair(x, y));
}
for (int(i) = (1); (i) < (n + 1); (i)++) {
long long u = arr[i];
for (int(j) = (0); (j) < (((int)pr.size())); (j)++) {
while (u % pr[j] == 0) {
facts[i].push_back(pr[j]);
u /= pr[j];
}
if (u == 1) break;
}
if (u != 1) facts[i].push_back(u);
}
int even = 1, odd = 10001;
for (int(i) = (1); (i) < (n + 1); (i)++) {
if (i % 2 == 0) {
for (int(j) = (0); (j) < (((int)facts[i].size())); (j)++) {
ids[i].push_back(even++);
}
} else {
for (int(j) = (0); (j) < (((int)facts[i].size())); (j)++) {
ids[i].push_back(odd++);
}
}
}
for (int(q) = (0); (q) < (((int)pairs.size())); (q)++) {
int x = pairs[q].first, y = pairs[q].second;
if (x % 2 == 0) swap(x, y);
for (int(i) = (0); (i) < (((int)facts[x].size())); (i)++) {
for (int(j) = (0); (j) < (((int)facts[y].size())); (j)++) {
if (facts[x][i] == facts[y][j]) {
add(ids[x][i], ids[y][j]);
}
}
}
}
int ans = 0;
memset(p, -1, sizeof(p));
for (int(u) = (10001); (u) < (odd); (u)++) {
memset(vis, 0, sizeof(vis));
ans += match(u);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
int a, b, n;
cin >> a >> b >> n;
while (true) {
int tmpa = gcd(a, n);
if (tmpa > n) {
cout << 1;
return 0;
} else {
n -= tmpa;
}
int tmpb = gcd(b, n);
if (tmpb > n) {
cout << 0;
return 0;
} else {
n -= tmpb;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, l[105], a;
bool b;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &l[i]);
}
b = true;
a = l[1] - l[0];
for (int i = 1; i < n; i++) {
if (l[i] != l[i - 1] + a) b = false;
}
if (b)
printf("%d", l[n - 1] + a);
else
printf("%d", l[n - 1]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int cost, earn, want, total = 0;
cin >> cost >> earn >> want;
for (int i = 1; i <= want; i++) {
total += i * cost;
}
if (total <= earn) {
cout << 0 << endl;
} else {
cout << total - earn << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int z;
int x;
int y;
};
int main() {
ios_base::sync_with_stdio(false);
int n, m, k, startx, starty;
cin >> k >> n >> m;
char plate[k][n][m];
for (int i = 0; i < k; i++) {
for (int j = 0; j < n; j++) {
for (int c = 0; c < m; c++) cin >> plate[i][j][c];
}
}
cin >> startx >> starty;
bool visited[k][n][m];
memset(visited, false, sizeof(visited));
stack<Node> stek;
Node temp, top;
temp.z = 0;
temp.x = startx - 1;
temp.y = starty - 1;
stek.push(temp);
visited[0][temp.x][temp.y] = true;
int dz[] = {1, -1, 0, 0, 0, 0}, dx[] = {0, 0, 1, -1, 0, 0},
dy[] = {0, 0, 0, 0, 1, -1};
int r = 1;
while (!stek.empty()) {
top = stek.top();
stek.pop();
for (int i = 0; i < 6; i++) {
int z = top.z + dz[i];
int x = top.x + dx[i];
int y = top.y + dy[i];
if (z >= 0 && z < k && x >= 0 && x < n && y >= 0 && y < m &&
!visited[z][x][y] && plate[z][x][y] == '.') {
visited[z][x][y] = true;
r++;
temp.z = z;
temp.x = x;
temp.y = y;
stek.push(temp);
}
}
}
cout << r;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, x, b, y;
cin >> n;
cin >> a >> x >> b >> y;
int flag = 0;
if (a == b || x == y)
cout << "YES" << endl;
else {
for (int i = a, j = b;; i++, j--) {
int yu1, yu2;
yu1 = (i + n) % n;
yu2 = (j + n) % n;
if (yu1 == 0) yu1 = n;
if (yu2 == 0) yu2 = n;
if (yu1 == yu2) {
flag = 1;
break;
}
if (yu1 == x || yu2 == y) break;
}
if (flag == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
const double EPS = 1e-13;
const double PI = acos(-1.0);
bool ok(int h, int m) {
string hh = toString(h), mm = toString(m);
if (hh.size() == 1) {
hh = "0" + hh;
}
if (mm.size() == 1) {
mm = "0" + mm;
}
reverse((mm).begin(), (mm).end());
return (hh == mm);
}
int main() {
int h, m;
scanf("%d:%d", &h, &m);
while (1) {
m++;
if (m >= 60) {
h++;
m = 0;
if (h >= 24) {
h = 0;
}
}
if (ok(h, m)) break;
}
printf("%02d:%02d", h, m);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > G;
int main() {
int n, k;
cin >> n >> k;
G.resize(n);
for (int i = 0; i < (n - 1); ++i) {
int x, y;
cin >> x >> y;
G[x - 1].push_back(y - 1);
G[y - 1].push_back(x - 1);
}
long long ans = 0;
for (int i = 0; i < n; ++i)
if (G[i].size() == 1) ++ans;
double p = 2.0 * k / ans;
cout.precision(15);
cout << p;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1)
cout << n << ' ' << 1 << endl << 1;
else
cout << (n - 1) * 2 << ' ' << 2 << endl << 1 << ' ' << 2;
}
| 3 |
#include <bits/stdc++.h>
const double EPS = 1e-8;
using namespace std;
int main() {
int n, w, m;
while (cin >> n >> w >> m) {
bool ok = true;
double target = (double)n * w / m;
vector<double> p(m, 0.0);
vector<vector<pair<int, double> > > ans(m);
for (int i = 0; i < (int)n; i++) {
double left = w;
int cnt = 0;
while (left > EPS) {
for (int j = 0; j < (int)m; j++) {
if (p[j] + EPS < target) {
if (target - p[j] > left + EPS) {
p[j] += left;
ans[j].push_back(make_pair(i, left));
left = 0;
break;
} else {
left -= (target - p[j]);
ans[j].push_back(make_pair(i, target - p[j]));
p[j] = target;
break;
}
}
}
cnt++;
if (cnt > 2) break;
}
if (cnt > 2) {
ok = false;
break;
}
}
if (ok) {
puts("YES");
for (int i = 0; i < (int)m; i++) {
for (int j = 0; j < (int)ans[i].size(); j++) {
if (j != 0) putchar(' ');
printf("%d %.8f", ans[i][j].first + 1, ans[i][j].second);
}
cout << endl;
}
} else {
puts("NO");
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pi (3.141592653589)
#define mod 1000000007
#define float double
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(c) c.begin(), c.end()
#define min3(a, b, c) min(c, min(a, b))
#define min4(a, b, c, d) min(d, min(c, min(a, b)))
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define rep(i, n) for (int i = 0; i < n; i++)
#define pii pair<ll, ll>
#define vi vector<ll>
#define mii map<ll, ll>
#define pqb priority_queue<ll>
#define pqs priority_queue<ll, vi, greater<ll>>
#define set_bits __builtin_popcountll
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
void as_fraction(double number, int cycles = 10, double precision = 5e-4)
{
int sign = number > 0 ? 1 : -1;
number = number * sign; //abs(number);
double new_number, whole_part;
double decimal_part = number - (int)number;
int counter = 0;
valarray<double> vec_1{double((int)number), 1}, vec_2{1, 0}, temporary;
while (decimal_part > precision & counter < cycles)
{
new_number = 1 / decimal_part;
whole_part = (int)new_number;
temporary = vec_1;
vec_1 = whole_part * vec_1 + vec_2;
vec_2 = temporary;
decimal_part = new_number - whole_part;
counter += 1;
}
cout << vec_1[1] << endl;
}
int main()
{
fast
ll t;
cin >> t;
while (t--)
{
double k;
cin >> k;
float x = (float)k / 100.0;
as_fraction(x);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (1LL << 60) - 1;
int main() {
int n, m;
cin >> n >> m;
long long A[n], B[m];
int i;
for (i = 0; i < n; i++) cin >> A[i];
for (i = 0; i < m; i++) cin >> B[i];
long long res = INF;
for (i = 0; i < n; i++) {
long long cur = -INF;
for (int j = 0; j < n; j++)
if (j != i)
for (int k = 0; k < m; k++) cur = max(cur, A[j] * B[k]);
res = min(cur, res);
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int p[150000] = {};
void shack(int n) {
for (int i = 2; i <= n; i++)
if (p[i] == 0)
for (int j = 2; j <= n / i; j++) p[i * j] = 1;
}
int main() {
int n;
scanf("%d", &n);
if (n < 3)
printf("1\n");
else
printf("2\n");
shack(n + 1);
for (int i = 2; i <= n + 1; i++) {
if (p[i] == 0)
printf("1 ");
else
printf("2 ");
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e3 + 5;
string a[MAX];
int check[MAX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int tmp = n * 3 - 1;
memset(check, 0, sizeof(check));
string s, temp;
int i = 0;
while (tmp--) {
cin >> s;
if (s != "**") temp += s;
if (s == "**") {
a[i] = temp;
temp = "";
i++;
}
}
a[i] = temp;
int dem = 0;
for (int i = 0; i < n; i++) {
if (!check[i]) {
dem++;
string zd = a[i];
stringstream ss;
ss.str("");
ss << zd[1] << zd[3] << zd[0] << zd[2];
string nid = ss.str();
ss.str("");
ss << nid[1] << nid[3] << nid[0] << nid[2];
string ond = ss.str();
ss.str("");
ss << ond[1] << ond[3] << ond[0] << ond[2];
string twd = ss.str();
check[i] = 1;
for (int j = i + 1; j < n; j++) {
if (zd == a[j] || nid == a[j] || ond == a[j] || twd == a[j]) {
check[j] = 1;
}
}
}
}
cout << dem;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long int> prime;
void sieve(long long int n) {
bool bakh[n + 1];
memset(bakh, true, sizeof(bakh));
for (long long int p = 2; p * p <= n; p++) {
if (bakh[p] == true) {
for (long long int i = p * p; i <= n; i += p) bakh[i] = false;
}
}
for (long long int p = 2; p <= n; p++)
if (bakh[p]) prime.push_back(p);
}
long long int eulertotient(long long int z) {
long long int fac = z;
for (long long int i = 0; prime[i] * prime[i] <= z; i++) {
if (z % prime[i] == 0) {
fac -= (fac / prime[i]);
while (z % prime[i] == 0) z /= prime[i];
}
}
if (z > 1) fac -= (fac / z);
return fac;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
long long int g = gcd(a, b);
long long int ans = (a * b) / g;
return ans;
}
long long int modInverse(long long int a, long long int m) {
long long int hvf = gcd(a, m);
if (hvf == 1) return power(a, m - 2, m);
return -1;
}
void multiply(long long int F[2][2], long long int M[2][2]) {
long long int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
long long int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
long long int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
long long int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
void powermat(long long int F[2][2], long long int n) {
if (n == 0 || n == 1) return;
long long int M[2][2] = {{1, 1}, {1, 0}};
powermat(F, n / 2);
multiply(F, F);
if (n % 2 != 0) multiply(F, M);
}
long long int fib(long long int n) {
long long int F[2][2] = {{1, 1}, {1, 0}};
if (n == 0) return 0;
powermat(F, n - 1);
return F[0][0];
}
vector<long long int> merge(vector<long long int> v1,
vector<long long int> v2) {
vector<long long int> temp;
long long int i = 0, j = 0;
while (i < v1.size() && j < v2.size()) {
if (v1[i] < v2[j])
temp.push_back(v1[i]), i++;
else
temp.push_back(v2[j]), j++;
}
while (i < v1.size()) temp.push_back(v1[i]), i++;
while (j < v2.size()) temp.push_back(v2[j]), j++;
return temp;
}
long long int n, m, k;
char ar[101][101][101];
long long int dp[101][101][101];
long long int check(long long int a, long long int b, long long int c) {
if (a > n || b > m || c > k || a <= 0 || b <= 0 || c <= 0) return 0;
return 1;
}
vector<long long int> back(3), fwd(3), curr(3), papa(3);
long long int fun(long long int i, long long int j, long long int w) {
if (ar[i][j][w] == '1') {
curr = {i, j, w};
for (long long int x = 0; x < 3; x++) {
back = curr;
back[x] -= 1;
if (!check(back[0], back[1], back[2]) ||
ar[back[0]][back[1]][back[2]] == '0')
continue;
for (long long int y = 0; y < 3; y++) {
fwd = curr;
fwd[y] += 1;
papa = back;
papa[y] += 1;
if (check(fwd[0], fwd[1], fwd[2]) &&
ar[fwd[0]][fwd[1]][fwd[2]] == '1') {
if (x == y)
return 1;
else if (check(papa[0], papa[1], papa[2]) and
ar[papa[0]][papa[1]][papa[2]] == '0')
return 1;
}
}
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n >> m >> k;
memset(dp, -1, sizeof(dp));
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
for (long long int p = 1; p <= k; p++) cin >> ar[i][j][p];
}
}
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
for (long long int w = 1; w <= k; w++) {
ans += fun(i, j, w);
}
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
const long long N = 2e3 + 10;
const long long mod = 1e9 + 7;
const long long inf = 0x3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1);
using namespace std;
namespace geo {
long long sgn(double x) {
if (fabs(x) < eps) return 0;
if (x < 0)
return -1;
else
return 1;
}
struct point {
double x, y;
point() {}
point(double xx, double yy) {
x = xx;
y = yy;
}
point operator+(point b) { return point(x + b.x, y + b.y); }
point operator-(point b) { return point(x - b.x, y - b.y); }
double operator^(point b) { return x * b.y - y * b.x; }
double operator*(point b) { return x * b.x + y * b.y; }
point operator*(double b) { return point(x * b, y * b); }
double gettan() { return atan2(y, x); }
void read() { scanf("%lf%lf", &x, &y); }
};
struct line {
point s, e, l;
line() {}
line(point ss, point ee) {
s = ss;
e = ee;
l = e - s;
}
void read() {
s.read(), e.read();
l = e - s;
}
double gettan() { return atan2(e.y - s.y, e.x - s.x); }
};
struct circle {
point o;
double r;
circle() {}
circle(point oo, double rr) {
o = oo;
r = rr;
}
};
double dis2(point a, point b) { return (b - a) * (b - a); }
double dis(point a, point b) { return sqrt(dis2(a, b)); }
bool onseg(line l, point p) {
bool x1 = sgn((l.s - p) ^ (l.e - p)) == 0;
bool x2 = sgn((l.s - p) * (l.e - p)) <= 0;
return x1 && x2;
}
point spin(point p, double a) {
return point(p.x * cos(a) - p.y * sin(a), p.y * cos(a) + p.x * sin(a));
}
double len(point a) { return sqrt(a * a); }
point projection(line l, point p) {
return l.s + l.l * ((l.l * (p - l.s)) / ((l.l) * (l.l)));
}
bool judge(line l1, line l2) {
point a = l1.s, b = l1.e, c = l2.s, d = l2.e;
bool x1 = sgn((c - a) ^ l1.l) * sgn((d - a) ^ l1.l) <= 0;
bool x2 = sgn((a - c) ^ l2.l) * sgn((b - c) ^ l2.l) <= 0;
return x1 && x2 && max(l1.s.x, l1.e.x) >= min(l2.s.x, l2.e.x) &&
max(l2.s.x, l2.e.x) >= min(l1.s.x, l1.e.x) &&
max(l1.s.y, l1.e.y) >= min(l2.s.y, l2.e.y) &&
max(l2.s.y, l2.e.y) >= min(l1.s.y, l1.e.y);
}
point getcross(line l1, line l2) {
double s1 = ((l2.s - l1.s) ^ (l2.e - l1.s));
double s2 = ((l2.e - l1.e) ^ (l2.s - l1.e));
if (s1 + s2 == 0) return point{inf, inf};
return l1.s + l1.l * (s1 / (s1 + s2));
}
double dis_pl(point p, line l) {
point v = p - l.s;
double ans = (v ^ l.l) / sqrt(l.l * l.l);
return fabs(ans);
}
double askarea(point d[], long long n) {
d[n + 1] = d[1];
double area = 0;
for (long long i = 1; i <= n; i++) area += (d[i] ^ d[i + 1]);
area /= 2;
return fabs(area);
}
long long cmp(line a, line b) {
double t1 = a.gettan(), t2 = b.gettan();
if (sgn(t1 - t2) == 0) return (a.l ^ (b.e - a.s)) > 0;
return t1 < t2;
}
long long onright(line a, line b, line c) {
point p = getcross(b, c);
return (a.l ^ (p - a.s)) < 0;
}
void hpi(line li[], long long n) {
line que[N];
sort(li + 1, li + n + 1, cmp);
long long l = 1, r = 1, cnt = 0, i;
for (i = 1; i < n; i++)
if (sgn(li[i].gettan() - li[i + 1].gettan())) li[++cnt] = li[i];
li[++cnt] = li[n];
for (i = 1; i <= cnt; i++) {
while (r - l > 1 && onright(li[i], que[r - 1], que[r - 2])) r--;
while (r - l > 1 && onright(li[i], que[l], que[l + 1])) l++;
que[r++] = li[i];
}
while (r - l > 1 && onright(que[l], que[r - 1], que[r - 2])) r--;
while (r - l > 1 && onright(que[r - 1], que[l], que[l + 1])) l++;
}
} // namespace geo
char a[N][N];
long long sumd[N][N] = {0}, sumr[N][N] = {0}, dp[N][N][2] = {0}, d[N][N] = {0},
r[N][N] = {0};
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, i, j;
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> a[i] + 1;
for (j = 1; j <= m; j++)
if (a[i][j] == 'R') d[i][j] = r[i][j] = 1;
}
for (i = n; i >= 1; i--)
for (j = m; j >= 1; j--) {
d[i][j] += d[i + 1][j];
r[i][j] += r[i][j + 1];
}
dp[n][m][0] = dp[n][m][1] = sumd[n][m] = sumr[n][m] = 1;
if (n == 1 && m == 1) {
cout << 1 << endl;
return 0;
}
for (i = n; i >= 1; i--)
for (j = m; j >= 1; j--) {
if (i == n && j == m) continue;
dp[i][j][0] = (sumd[i][j + 1] - sumd[i][m - r[i][j + 1] + 1] + mod) % mod;
dp[i][j][1] = (sumr[i + 1][j] - sumr[n - d[i + 1][j] + 1][j] + mod) % mod;
sumr[i][j] = (sumr[i + 1][j] + dp[i][j][0]) % mod;
sumd[i][j] = (sumd[i][j + 1] + dp[i][j][1]) % mod;
}
cout << (dp[1][1][0] + dp[1][1][1]) % mod << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int arr[n + 1];
for (long long int i = 1; i < n + 1; i++) {
cin >> arr[i];
}
long long int a = arr[1];
long long int ai = 1;
long long int b, bi = -1;
for (long long int i = 2; i < n + 1; i++) {
if (arr[i] != a) {
b = arr[i];
bi = i;
break;
}
}
if (bi == -1)
cout << "NO" << endl;
else {
cout << "YES" << endl;
cout << ai << " " << bi << endl;
for (long long int i = 2; i < n + 1; i++) {
if (i != bi) {
if (arr[i] != a)
cout << ai << " " << i << endl;
else
cout << bi << " " << i << endl;
}
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int x, y;
cin >> n >> k >> x >> y;
double sum = 0;
for (int i = 1; i < n; i++) {
int xx, yy;
cin >> xx >> yy;
sum += hypot(xx - x, yy - y);
x = xx;
y = yy;
}
printf("%.9lf\n", (k * sum) / 50.0);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, q, mx = 0;
cin >> n >> q;
vector<int> a(n + 2), v;
deque<int> que;
for (int i = 0; i < n; ++i) {
cin >> a[i];
mx = max(mx, a[i]);
que.push_back(a[i]);
}
vector<pair<int, int> > ans;
for (;;) {
int be = que.front();
que.pop_front();
int en = que.front();
que.pop_front();
que.push_front(max(be, en));
que.push_back(min(be, en));
ans.push_back({be, en});
if (max(be, en) == mx) break;
}
que.pop_front();
while (!que.empty()) {
v.push_back(que.front());
que.pop_front();
}
while (q--) {
long long x;
cin >> x;
if (x <= int(ans.size())) {
cout << ans[x - 1].first << " " << ans[x - 1].second << endl;
} else {
x -= int(ans.size());
x = (x - 1) % int(v.size());
cout << mx << " " << v[x] << endl;
}
}
}
int main() {
int _ = 1;
for (int i = 1; i <= _; ++i) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct __timestamper {};
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m;
scanf("%d%d", &n, &m);
vector<string> a(n), b(n);
for (int i = 0; i < n; i++) {
static char buf[(int)1.01e6];
scanf("%s", buf);
a[i] = buf;
}
for (int i = 0; i < n; i++) {
static char buf[(int)1.01e6];
scanf("%s", buf);
b[i] = buf;
}
const vector<int> dx = {1, -1, 0, 0};
const vector<int> dy = {0, 0, 1, -1};
const string ds = "DURL";
vector<vector<int>> c(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
while (ds[c[i][j]] != b[i][j]) c[i][j]++;
}
}
vector<vector<int>> vis(n, vector<int>(m));
vector<vector<int>> cycle(n, vector<int>(m));
vector<vector<int>> rem(n, vector<int>(m));
vector<int> cycle_len;
for (int x = 0; x < n; x++) {
for (int y = 0; y < m; y++) {
if (vis[x][y]) continue;
int cx = x, cy = y;
while (!vis[cx][cy]) {
vis[cx][cy] = 1;
int k = c[cx][cy];
cx += dx[k];
cy += dy[k];
}
if (vis[cx][cy] == 1) {
int clen = 0;
int cycle_id = cycle_len.size();
while (vis[cx][cy] == 1) {
cycle[cx][cy] = cycle_id;
vis[cx][cy] = 2;
rem[cx][cy] = clen;
clen++;
int k = c[cx][cy];
cx += dx[k];
cy += dy[k];
}
cycle_len.push_back(clen);
}
vector<pair<int, int>> vct;
cx = x;
cy = y;
while (vis[cx][cy] == 1) {
vct.push_back({cx, cy});
int k = c[cx][cy];
cx += dx[k];
cy += dy[k];
}
reverse(vct.begin(), vct.end());
for (auto o : vct) {
vis[o.first][o.second] = 2;
int k = c[o.first][o.second];
int nx = o.first + dx[k];
int ny = o.second + dy[k];
cycle[o.first][o.second] = cycle[nx][ny];
rem[o.first][o.second] =
(rem[nx][ny] - 1 + cycle_len[cycle[o.first][o.second]]) %
cycle_len[cycle[o.first][o.second]];
}
}
}
vector<vector<vector<vector<pair<int, int>>>>> cand(cycle_len.size());
for (int i = 0; i < (int)cycle_len.size(); i++) {
cand[i].assign(cycle_len[i], vector<vector<pair<int, int>>>(2));
}
for (int x = 0; x < n; x++) {
for (int y = 0; y < m; y++) {
cand[cycle[x][y]][rem[x][y]][a[x][y] - '0'].push_back({x, y});
}
}
vector<pair<int, int>> ans;
int all = 0;
int black = 0;
for (int i = 0; i < (int)cycle_len.size(); i++) {
for (int j = 0; j < (int)cand[i].size(); j++) {
if (!cand[i][j][0].empty()) {
all++;
black++;
ans.push_back(cand[i][j][0][0]);
} else if (!cand[i][j][1].empty()) {
all++;
ans.push_back(cand[i][j][1][0]);
}
}
}
printf("%d %d\n", all, black);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string str;
int q, l, r, dp[5050][5050];
bool ispali[5050][5050];
int main() {
cin >> str >> q;
int n = str.size();
for (int k = 0; k < n; k++) {
if (k && str[k] == str[k - 1]) {
ispali[k - 1][k] = 1;
dp[k - 1][k] = 3;
} else if (k)
dp[k - 1][k] = 2;
ispali[k][k] = 1;
dp[k][k] = 1;
}
for (int k = 2; k < n; k++)
for (int i = 0; i + k < n; i++) {
if (str[i] == str[i + k] && ispali[i + 1][i + k - 1])
ispali[i][i + k] = 1;
dp[i][i + k] = dp[i + 1][i + k] + dp[i][i + k - 1] -
dp[i + 1][i + k - 1] + ispali[i][i + k];
}
while (q--) {
scanf("%d %d", &l, &r);
printf("%d\n", dp[--l][--r]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long n = 0, k = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') k = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
n = (n << 1) + (n << 3) + (c ^ 48), c = getchar();
return n * k;
}
long long n, m, k;
long long arr[6000];
long long dp[2][6000];
long long qwq[6000 << 1], head, tail;
long long *pre, *now;
signed main() {
n = read(), m = read(), k = read();
for (register long long i = 1; i <= n; ++i) arr[i] = read();
memset(dp, -0x3f, sizeof(dp));
dp[0][0] = 0;
now = dp[0];
pre = dp[1];
long long nower = 0;
for (register long long i = 1; i <= k; ++i) {
memset(qwq, 0, sizeof(qwq));
swap(now, pre);
++nower, nower %= 2;
memset(dp[nower], -0x3f, sizeof(dp[nower]));
head = 1, tail = 0;
for (register long long j = 1; j <= n; ++j) {
while (head <= tail && qwq[head] < j - m) ++head;
while (head <= tail && (pre[j - 1] > pre[qwq[tail]])) --tail;
qwq[++tail] = j - 1;
now[j] = pre[qwq[head]] + arr[j];
}
}
long long ans = -1;
for (register long long i = n - m + 1; i <= n; ++i) ans = max(ans, now[i]);
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const unsigned seed =
std::chrono::system_clock::now().time_since_epoch().count();
mt19937 rnd(seed);
const int MOD = 998244353;
void dp(vector<int> &res, int k, int s, int e, int p) {
if (s > e) return;
int num = e - s + 1;
res[s] = p;
if (num == 1) return;
int a = 1;
if (k <= 1) {
int p = 2;
do {
int b = num - p;
int t = b + 1;
int nlb = (t & (-t)) == t ? 0 : 1;
int cnt = 0;
if (b >= 2 * (p - 1) || p - 1 >= 2 * b) cnt++;
if (cnt + nlb == k) break;
p *= 2;
} while (p < num);
a = p - 1;
} else if (k == 2 && ((num - 1) & (-num + 1)) == num - 1) {
a = 3;
} else if (num == 11 && k == 3) {
a = 3;
}
dp(res, 0, s + 1, s + 1 + a - 1, s);
int b = num - a - 1;
if (a >= 2 * b || a * 2 <= b) {
dp(res, k - 1, s + 1 + a, e, s);
} else
dp(res, k, s + 1 + a, e, s);
}
bool good(int n, int k) {
if (n % 2 == 0) return false;
if (n == 9) return k == 1 || k == 3;
int t = n + 1;
if ((t & -t) == t) {
if (k == 1) return false;
if (k == 0) return true;
}
int d2 = max(0, (n - 3) / 2);
int d1 = 1;
return k >= d1 && k <= d2;
}
void solve() {
int n, k;
cin >> n >> k;
if (!good(n, k)) {
cout << "NO\n";
return;
}
cout << "YES\n";
vector<int> res(n);
dp(res, k, 0, n - 1, -1);
for (int i = 0; i < n; i++) {
if (i > 0) cout << " ";
cout << res[i] + 1;
}
cout << "\n";
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(10);
int T = 1;
for (int i = 1; i <= T; i++) {
solve();
}
cout.flush();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int pebs[n];
for (int i = 0; i < n; i++) {
cin >> pebs[i];
}
bool no = false;
int mi = 10000;
int ma = -1;
for (int i = 0; i < n; i++) {
mi = min(mi, pebs[i]);
ma = max(ma, pebs[i]);
}
if (abs(mi - ma) > k) {
cout << "NO\n";
} else {
cout << "YES\n";
for (int i = 0; i < n; i++) {
for (int j = 0; j < pebs[i]; j++) {
cout << (j % (k)) + 1 << " ";
}
cout << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, t;
const long long Con = 1000000;
cin >> n >> k >> t;
long long res;
long long il = 0;
while (1) {
if ((il * Con + 1 * Con) / n > t * Con / 100) {
break;
}
il++;
}
long long ik = 0;
while ((il * k * Con + ik * Con + Con) / (k * n) <= t * Con / 100 && ik < k) {
ik++;
}
for (int i = 0; i < n; i++) {
if (i < il) {
cout << k;
} else if (i == il)
cout << ik;
else
cout << 0;
cout << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const int MAXM = 4e5 + 5;
struct Edge {
int to, next;
bool cut;
} edge[MAXM];
int head[MAXN], tot;
int Low[MAXN], DFN[MAXN], Stack[MAXN], Belong[MAXN];
int Index, top;
int block;
bool Instack[MAXN];
int bridge;
void addedge(int u, int v) {
edge[tot].to = v;
edge[tot].next = head[u];
edge[tot].cut = false;
head[u] = tot++;
}
void Tarjan(int u, int pre) {
int v;
bool flag = false;
Low[u] = DFN[u] = ++Index;
Stack[top++] = u;
Instack[u] = true;
for (int i = head[u]; ~i; i = edge[i].next) {
v = edge[i].to;
if (v == pre && (!flag)) {
flag = true;
continue;
}
if (!DFN[v]) {
Tarjan(v, u);
if (Low[u] > Low[v]) Low[u] = Low[v];
if (Low[v] > DFN[u]) {
bridge++;
edge[i].cut = true;
edge[i ^ 1].cut = true;
}
} else if (Instack[v] && Low[u] > DFN[v])
Low[u] = DFN[v];
}
if (Low[u] == DFN[u]) {
block++;
do {
v = Stack[--top];
Instack[v] = false;
Belong[v] = block;
} while (v != u);
}
}
void init() {
tot = 0;
memset(head, -1, sizeof(head));
}
void solve(int n) {
memset(DFN, 0, sizeof(DFN));
memset(Instack, false, sizeof(Instack));
memset(Belong, 0, sizeof(Belong));
Index = top = block = 0;
for (int i = 1; i <= n; i++)
if (DFN[i] == 0) Tarjan(i, 0);
}
int w[MAXN], sz[MAXN], fa[MAXN];
bool vis[MAXN];
long long W[MAXN], ans;
vector<int> E[MAXN], G[MAXN];
vector<long long> Lf;
void dfs(int now, int f) {
fa[now] = f;
if (sz[now] > 1 || f == 0) {
int u = now;
while (!vis[u]) {
ans += W[u];
vis[u] = true;
u = fa[u];
}
}
for (int v : E[now]) {
if (v == f) continue;
dfs(v, now);
}
}
void dfs2(int now, int f) {
int u = vis[now] ? 0 : now;
for (int v : E[now]) {
if (v == f) continue;
if (!vis[v]) G[u].push_back(v);
dfs2(v, now);
}
}
void dfs3(int now, int f, long long val, long long &mx) {
mx = max(mx, val);
for (int v : G[now]) {
if (v == f) continue;
dfs3(v, now, val + W[v], mx);
}
}
int main() {
init();
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
int s;
scanf("%d", &s);
solve(n);
for (int i = 1; i <= n; i++) {
sz[Belong[i]]++;
W[Belong[i]] += w[i];
}
for (int u = 1; u <= n; u++) {
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].to;
if (Belong[u] == Belong[v]) continue;
E[Belong[u]].push_back(Belong[v]);
}
}
if (block == 1) return 0 * printf("%lld\n", W[Belong[s]]);
ans = 0;
vis[0] = true;
dfs(Belong[s], 0);
dfs2(Belong[s], 0);
long long mx = 0;
dfs3(0, -1, 0, mx);
cout << ans + mx << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int arr[105];
int main() {
int n, mini = INT_MAX, cost, k;
scanf("%d", &(n));
for (int i = 0; i < n; i++) scanf("%d", &(arr[i]));
for (int i = 0; i < n; i++) {
cost = arr[i] * 15;
for (int j = 0; j < arr[i]; j++) {
scanf("%d", &(k));
cost += k * 5;
}
mini = mini > cost ? cost : mini;
}
cout << mini << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long m, n;
cin >> m >> n;
cout << m * n / 2;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int nCrevenoroddfinder(int n, int r) {
int a = r;
int b = n - r;
for (int i = 0; i < 30; i++) {
int x = 1 << i;
if ((x & a) && (x & b)) {
return 0;
}
}
return 1;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
bool isperfect(long long n) {
long long y = sqrt(n);
if (n % y == 0 && y * y == n) return true;
return false;
}
bool comp(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
}
long long powi(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a);
b = b >> 1;
a = (a * a);
}
return ans;
}
bool isprime(long long n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
bool prime[10000000];
void seive() {
prime[1] = true;
for (int i = 2; i * i < 10000000; i++) {
if (prime[i]) continue;
for (int j = i * i; j < 10000000; j += i) {
prime[j] = true;
}
}
}
map<long long, long long> m;
long long dp[200009];
long long ans;
vector<long long int> v[200009];
long long k;
void dfs(int s, int p) {
for (auto x : v[s]) {
if (x == p) continue;
dfs(x, s);
dp[s] += dp[x];
ans += min(dp[x], 2 * k - dp[x]);
}
if (m[s] > 0) dp[s]++;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n >> k;
for (int i = 0; i < 2 * k; i++) {
long long x;
cin >> x;
m[x]++;
}
for (int i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, 0);
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100][2], d[100][2][2];
char ch[205];
int vis[205];
int main() {
static long long clr[100];
dp[0][1] = dp[1][1] = dp[1][0] = 1;
for (int i = 2; i <= 50; i++)
dp[i][0] = dp[i - 1][1], dp[i][1] = dp[i - 1][1] + dp[i - 1][0];
d[1][1][1] = 1;
d[1][0][0] = 1;
d[2][0][1] = 1;
d[2][1][0] = 1;
d[2][1][1] = 1;
for (int i = 3; i <= 50; i++) {
d[i][0][1] = d[i - 1][0][1] + d[i - 2][0][1];
d[i][0][0] = 0;
d[i][1][0] = d[i - 1][1][1];
d[i][1][1] = d[i - 1][1][1] + d[i - 1][1][0];
}
for (int i = 1; i <= 50; i++)
for (int a = 0; a < 2; a++)
for (int b = 0; b < 2; b++) clr[i] += d[i][a][b];
scanf("%s", ch);
memset(vis, 0, sizeof(vis));
long long ans = 1;
int n = strlen(ch);
for (int i = 0; i < n; i++) ch[n + i] = ch[i];
int s = 0;
if (ch[s] != ch[n - 1])
while (ch[s] != ch[s + 1] && s < n - 1) s++;
for (; s < n;) {
int ed = s;
while (ch[ed] != ch[ed + 1] && ed - s + 1 < n) ed++;
int tmp = ed - s + 1 >> 1;
if (n % 2 == 0 && ed - s + 1 == n) {
ans = clr[n / 2];
break;
}
if (ch[ed] == ch[s])
ans *= dp[tmp][1];
else if (ch[s] == 'A') {
tmp -= 1;
if (tmp == 0) {
ans = 0;
} else if (tmp > 2)
ans *= dp[tmp - 1][1];
} else
ans *= dp[tmp][0] + dp[tmp][1];
s = ed + 1;
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1e3 + 5, M = 3e5 + 5;
int n, m, d;
int a[N], cnt[N], cum[N];
int main() {
scanf("%d%d%d", &n, &m, &d);
for (int i = 0; i < m; ++i) scanf("%d", a + i);
for (int i = m - 1; ~i; --i) cnt[i] = a[i] + cnt[i + 1];
int i = 0;
for (int j = 0; j < m && i <= n; ++j) {
int idx = min(n - cnt[j] + 1, i + d);
++cum[idx];
i = idx + a[j] - 1;
--cum[i + 1];
}
if (i + d <= n) exit(puts("NO"));
puts("YES");
int hna = 1;
int here = 0;
for (int i = 1, j = 0; i <= n; ++i) {
cum[i] += cum[i - 1];
if (cum[i]) {
if (a[j] == here) ++j, ++hna, here = 0;
printf("%d%c", hna, " \n"[i == n]);
++here;
continue;
}
printf("0%c", " \n"[i == n]);
}
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int pr[100000], id;
bool ar[100000];
void init() {
for (int i = 4; i <= 100; i += 2) ar[i] = 1;
for (int i = 3; i <= 100; i += 2) {
if (ar[i] == 0) {
for (int j = min(i * i, 100); j <= 100; j += i) ar[j] = 1;
}
}
for (int i = 2; i <= 100; i++) {
if (ar[i] == 0) pr[id++] = i;
}
}
vector<int> ans;
int main() {
init();
int k;
cin >> k;
int lim = k * k * 2;
for (int i = 0; ans.size() < k && i < id; i++) {
ans.push_back(pr[i]);
for (int j = 0; j < ans.size(); j++) {
if (lim >= ans[j] * pr[i]) ans.push_back(ans[j] * pr[i]);
}
}
for (int i = ans.size() - 1, j = 0; j < k; j++, i--) cout << ans[i] << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mm = 1000000007;
int i, j, k, n, m, ans, f[210001];
int main() {
scanf("%d%d", &n, &m);
if (n < m) swap(n, m);
for (f[1] = 2, f[2] = 4, i = 3; i <= n; i++)
f[i] = (f[i - 1] + f[i - 2]) % mm;
ans = f[n] + f[m] - 2;
ans %= mm;
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, x[2], y[2], val, fen[4][1003][1003];
int check_type(int a, int b) {
long long ans = 0;
if (a & 1) ans++;
if (b & 1) ans += 2;
return ans;
}
void upd(long long x, long long y, long long val) {
int id = check_type(x, y);
for (long long i = x; i <= n; i += i & (-i)) {
for (long long j = y; j <= n; j += j & (-j)) {
fen[id][i][j] ^= val;
}
}
}
long long get(long long x, long long y) {
int id = check_type(x, y), ans = 0;
for (long long i = x; i > 0; i -= i & (-i)) {
for (long long j = y; j > 0; j -= j & (-j)) {
ans ^= fen[id][i][j];
}
}
return ans;
}
void Solve() {
cin >> n >> m;
while (m--) {
long long type;
cin >> type;
if (type == 2) {
cin >> x[0] >> y[0] >> x[1] >> y[1] >> val;
upd(x[0], y[0], val);
upd(x[1] + 1, y[0], val);
upd(x[0], y[1] + 1, val);
upd(x[1] + 1, y[1] + 1, val);
} else {
cin >> x[0] >> y[0] >> x[1] >> y[1];
long long res = 0;
res = get(x[1], y[1]) ^ get(x[1], y[0] - 1) ^ get(x[0] - 1, y[1]) ^
get(x[0] - 1, y[0] - 1);
cout << res << "\n";
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int Test_numbers = 1;
while (Test_numbers--) Solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int s[101][101];
int n;
int main() {
int x1, y1, x2, y2;
scanf("%d", &n);
while (n--) {
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
for (int i = x1; i <= x2; i++) {
for (int j = y1; j <= y2; j++) {
s[i][j]++;
}
}
}
int sum = 0;
for (int i = 1; i <= 100; i++) {
for (int j = 1; j <= 100; j++) {
sum += s[i][j];
}
}
printf("%d\n", sum);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops")
std::pair<int, int> DR[] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {-1, -1}, {1, 1}, {1, -1}};
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
~debug() { cerr << endl; }
template <class c>
typename enable_if<sizeof dud<c>(0) != 1, debug&>::type operator<<(c i) {
cerr << boolalpha << i;
return *this;
}
template <class c>
typename enable_if<sizeof dud<c>(0) == 1, debug&>::type operator<<(c i) {
return *this << range(begin(i), end(i));
}
template <class c, class b>
debug& operator<<(pair<b, c> d) {
return *this << "(" << d.first << ", " << d.second << ")";
}
template <class c>
debug& operator<<(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it) *this << ", " + 2 * (it == d.b) << *it;
return *this << "]";
}
};
int gcd(int a, int b) {
if (b) return gcd(b, a % b);
return a;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, k, a[1 << 18];
vector<int> m[1 << 18];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
for (int j = 0;; j++) {
m[a[i]].push_back(j);
if (a[i] == 0) break;
a[i] /= 2;
}
}
int ans = 1e9;
for (int i = 0; i <= 200000; i++) {
sort(m[i].begin(), m[i].end());
if ((int)((m[i]).size()) < k) continue;
int x = 0;
for (int j = 0; j < k; j++) x += m[i][j];
ans = min(ans, x);
}
return cout << ans, 0;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool endline = false;
template <class T>
istream& operator>>(istream& inp, vector<T>& v) {
for (auto& it : v) inp >> it;
return inp;
}
template <class T>
ostream& operator<<(ostream& out, vector<T>& v) {
for (auto& it : v) out << it << (endline ? "\n" : " ");
return out;
}
template <class T, class U>
istream& operator>>(istream& inp, pair<T, U>& v) {
inp >> v.first >> v.second;
return inp;
}
template <class T, class U>
ostream& operator<<(ostream& out, pair<T, U>& v) {
out << v.first << ' ' << v.second;
return out;
}
void debug() { cout << endl; }
template <typename H, typename... T>
void debug(H a, T... b) {
cout << a << ' ';
debug(b...);
}
void FAST_IO(string filein = "", string fileout = "") {
if (fopen(filein.c_str(), "r")) {
freopen(filein.c_str(), "r", stdin);
freopen(fileout.c_str(), "w", stdout);
}
cin.tie(0), cout.tie(0)->sync_with_stdio(0);
}
void Hollwo_Pelw();
signed main() {
FAST_IO(".inp", ".out");
int testcases = 1;
cin >> testcases;
for (int test = 1; test <= testcases; test++) {
Hollwo_Pelw();
}
return 0;
}
const int allmod[3] = {(int)1e9 + 7, 998244353, (int)1e9 + 9};
const int mod = allmod[1];
const int MAXN = 1e6 + 5;
const int inf = 2e9;
const long long linf = 1e18;
long long nxt[MAXN][25], occ[MAXN], col[MAXN], n, m;
void Hollwo_Pelw() {
cin >> n >> m;
for (long long i = 0; i < n * m; i++) {
occ[i] = 0;
char c;
cin >> c;
col[i] = c == '0';
}
for (long long i = 0; i < n * m; i++) {
char c;
cin >> c;
if (c == 'U') nxt[i][0] = i - m;
if (c == 'D') nxt[i][0] = i + m;
if (c == 'R') nxt[i][0] = i + 1;
if (c == 'L') nxt[i][0] = i - 1;
}
for (long long i = 1; i < 25; i++) {
for (long long j = 0; j < n * m; j++) {
nxt[j][i] = nxt[nxt[j][i - 1]][i - 1];
}
}
for (long long i = 0; i < n * m; i++) occ[nxt[i][24]] |= 2 | col[i];
long long ans = 0, black = 0;
for (long long i = 0; i < n * m; i++) {
ans += occ[i] >> 1 & 1;
black += occ[i] & 1;
}
cout << ans << " " << black << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-10;
double EQ(double a, double b) { return abs(a - b) < EPS; }
void fast_stream() { std::ios_base::sync_with_stdio(0); }
template <class T>
string IntToString(T num) {
string res;
stringstream ss;
ss << num;
return ss.str();
}
long long StringToInt(string &str) {
long long res = 0;
for (int i = 0; i < (int)str.size(); i++) res = (res * 10 + str[i] - '0');
return res;
}
const int dy[] = {-1, 0, 0, 1};
const int dx[] = {0, -1, 1, 0};
int getValueInMask(int mask, int tani, int pos) {
int mul = 1;
int res = 0;
for (int i = 0; i < tani; i++) {
res += ((mask >> (pos * tani + i)) & 1) * mul;
mul *= 2;
}
return res;
}
int setValueInMask(int mask, int tani, int pos, int value) {
int nmask = mask;
for (int i = 0; value != 0; i++) {
int bit = value % 2;
if (bit) nmask |= (1 << (tani * pos + i));
value /= 2;
}
return nmask;
}
int H, W;
char field[20][20];
pair<int, int> pos[10];
int gy, gx;
int d[15][15][1 << 16];
int main() {
memset(d, -1, sizeof(d));
for (int i = 0; i < 10; i++) pos[i] = pair<int, int>(-1, -1);
cin >> H >> W;
for (int i = 0; i < H; i++)
for (int j = 0; j < W; j++) cin >> field[i][j];
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (field[i][j] == '@') {
gy = i;
gx = j;
field[i][j] = '.';
} else if (field[i][j] >= '1' && field[i][j] <= '9') {
int num = field[i][j] - '0';
pos[num] = pair<int, int>(i, j);
field[i][j] = '.';
}
}
}
vector<pair<int, int> > init;
for (int i = 0; i < 10; i++)
if (pos[i].first >= 0) init.push_back(pos[i]);
int initMask = 0;
int sy = init[0].first;
int sx = init[0].second;
int ssz = (int)init.size();
for (int i = 1; i < (int)init.size(); i++) {
for (int j = 0; j < 4; j++) {
if (init[i].first - init[i - 1].first == dy[j] &&
init[i].second - init[i - 1].second == dx[j]) {
int ang = j;
initMask = setValueInMask(initMask, 2, i - 1, ang);
break;
}
}
}
queue<pair<pair<int, int>, int> > q;
d[sy][sx][initMask] = 0;
q.push(make_pair(pair<int, int>(sy, sx), initMask));
while (q.size()) {
pair<pair<int, int>, int> p = q.front();
q.pop();
int cy = p.first.first;
int cx = p.first.second;
int cmask = p.second;
int ccost = d[cy][cx][cmask];
int csy[10];
int csx[10];
csy[0] = cy;
csx[0] = cx;
for (int i = 1; i < ssz; i++) {
int pos = i - 1;
int ang = getValueInMask(cmask, 2, pos);
csy[i] = csy[i - 1] + dy[ang];
csx[i] = csx[i - 1] + dx[ang];
}
for (int i = 0; i < 4; i++) {
int ny = cy + dy[i];
int nx = cx + dx[i];
if (ny >= 0 && nx >= 0 && ny < H && nx < W && field[ny][nx] != '#') {
int nsy[10];
int nsx[10];
nsy[0] = ny;
nsx[0] = nx;
bool ok = true;
for (int j = 1; j < ssz; j++) {
nsy[j] = csy[j - 1];
nsx[j] = csx[j - 1];
if (nsy[j] == ny && nsx[j] == nx) ok = false;
}
if (!ok) continue;
int nmask = 0;
for (int j = 1; j < ssz; j++) {
for (int k = 0; k < 4; k++) {
if (nsy[j] - nsy[j - 1] == dy[k] && nsx[j] - nsx[j - 1] == dx[k]) {
int ang = k;
nmask = setValueInMask(nmask, 2, j - 1, ang);
break;
}
}
}
if (d[ny][nx][nmask] == -1) {
d[ny][nx][nmask] = ccost + 1;
q.push(make_pair(pair<int, int>(ny, nx), nmask));
}
}
}
}
int ans = 1 << 30;
for (int mask = 0; mask < (1 << 16); mask++)
if (d[gy][gx][mask] != -1) ans = min(ans, d[gy][gx][mask]);
if (ans == (1 << 30)) ans = -1;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[65007];
int main() {
int n;
scanf("%d%s", &n, s);
long long cnt = 0;
for (int i = n - 1; i >= 0; --i) {
if ((s[i] - '0') % 2 == 0) cnt += i + 1;
}
printf("%I64d\n", cnt);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10, SQ = 150, inf = 1e9;
template <typename A, typename B>
ostream& operator<<(ostream& out, pair<A, B> p) {
out << "{ " << p.first << ", " << p.second << " }";
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> v) {
out << "[ ";
for (int i = 0; i < int((v).size()); i++) {
out << v[i];
if (i != int((v).size()) - 1) out << " ,";
}
out << " ]";
return out;
}
struct suffix_array {
string s;
int rnk[20][maxn], srt[maxn];
void build(string _s) {
s = _s;
for (int i = 0; i < int((s).size()); i++) {
rnk[0][i] = s[i];
}
iota(srt, srt + int((s).size()), 0);
for (int i = 1; i < 20; i++) {
auto cmp = [&](int a, int b) {
if (rnk[i - 1][a] != rnk[i - 1][b])
return rnk[i - 1][a] < rnk[i - 1][b];
if (b + (1 << (i - 1)) >= int((s).size())) return false;
if (a + (1 << (i - 1)) >= int((s).size())) return true;
return rnk[i - 1][a + (1 << (i - 1))] < rnk[i - 1][b + (1 << (i - 1))];
};
sort(srt, srt + int((s).size()), cmp);
for (int j = 1; j < int((s).size()); j++)
rnk[i][srt[j]] = rnk[i][srt[j - 1]] + cmp(srt[j - 1], srt[j]);
}
}
int lcp(int a, int b) {
int ans = 0;
for (int i = 19; i >= 0; i--)
if (a + (1 << i) <= int((s).size()) && b + (1 << i) <= int((s).size()) &&
rnk[i][a] == rnk[i][b])
a += 1 << i, b += 1 << i, ans += 1 << i;
return ans;
}
};
suffix_array suf;
int srt[maxn], val[maxn];
pair<int, int> ans[maxn];
pair<int, int> sp[20][maxn];
pair<int, int> ask(int l, int r) {
if (l >= r) return {inf, inf};
int id = 31 - __builtin_clz(r - l);
return min(sp[id][l], sp[id][r - (1 << id)]);
}
void add1(int l, int r, int k, int x, int y, int i) {
int blk = l / k;
int pt = min(r, (blk + 1) * k);
ans[i] = min(ans[i], ask(max(blk * k + x, l), min(blk * k + y, pt)));
l = pt;
if (l == r) return;
blk = r / k;
pt = max(l, blk * k);
ans[i] = min(ans[i], ask(max(blk * k + x, pt), min(blk * k + y, r)));
r = pt;
if (l == r) return;
for (l /= k, r /= k; l < r; l++)
ans[i] = min(ans[i], ask(l * k + x, l * k + y));
}
vector<pair<pair<int, int>, int> > tdo[SQ][SQ];
vector<pair<int, int> > TDO[maxn];
void add2(int l, int r, int k, int x, int y, int i) {
for (int rm = x; rm < y; rm++)
tdo[k][rm].push_back(
{{(l / k) + ((l % k) > rm), (r / k) + ((r % k) > rm)}, i});
}
int par[maxn];
void mrg(int a, int b) {
par[a] += par[b];
par[b] = a;
}
int fnd(int u) { return par[u] < 0 ? u : par[u] = fnd(par[u]); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie();
string s, t;
cin >> s >> t;
int n = int((s).size());
s += t;
suf.build(s);
iota(srt, srt + n + 1, 0);
auto chk = [&](int i, int j) {
vector<pair<int, int> > v1 = {{0, i}, {n, int((s).size())}, {i, n}};
vector<pair<int, int> > v2 = {{0, j}, {n, int((s).size())}, {j, n}};
int pt1 = 0, pt2 = 0, L1 = 0, L2 = 0;
while (true) {
while (L1 == v1[pt1].second) {
++pt1;
if (pt1 == int((v1).size())) return false;
L1 = v1[pt1].first;
}
while (L2 == v2[pt2].second) {
++pt2;
if (pt2 == int((v2).size())) return false;
L2 = v2[pt2].first;
}
int mn = min(v1[pt1].second - L1, v2[pt2].second - L2);
int num = suf.lcp(L1, L2);
if (num < mn)
return s[L1 + num] < s[L2 + num];
else
L1 += mn, L2 += mn;
}
return false;
};
int N = n + 1;
sort(srt, srt + N, chk);
for (int i = 1; i < N; i++)
val[srt[i]] = val[srt[i - 1]] + chk(srt[i - 1], srt[i]);
for (int i = 0; i < N; i++) sp[0][i] = {val[i], i};
for (int i = 1; i < 20; i++)
for (int j = 0; j < N; j++)
sp[i][j] = min(sp[i - 1][j], j + (1 << (i - 1)) >= N
? (pair<int, int>){n + 10, n + 10}
: sp[i - 1][j + (1 << (i - 1))]);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
ans[i] = {n + 10, n + 10};
int l, r, k, x, y;
cin >> l >> r >> k >> x >> y;
r++, y++;
if (k >= SQ)
add1(l, r, k, x, y, i);
else
add2(l, r, k, x, y, i);
}
for (int k = 1; k < SQ; k++) {
for (int rm = 0; rm < SQ; rm++) {
if (tdo[k][rm].empty()) continue;
vector<pair<int, int> > vec;
vector<int> vec2;
for (int i = 0; i * k + rm < N; i++) {
vec.push_back({val[i * k + rm], i * k + rm});
}
for (int i = 0; i < int((vec).size()); i++) {
par[i] = -1;
TDO[i].clear();
}
for (auto x : tdo[k][rm]) {
if (x.first.first >= x.first.second) continue;
TDO[x.first.second - 1].push_back({x.first.first, x.second});
}
for (int i = 0; i < int((vec).size()); i++) {
while (int((vec2).size()) && vec[vec2.back()] >= vec[i])
mrg(i, vec2.back()), vec2.pop_back();
vec2.push_back(i);
for (auto [l, id] : TDO[i]) ans[id] = min(ans[id], vec[fnd(l)]);
}
}
}
for (int i = 0; i < q; i++) {
cout << (ans[i].first == n + 10 ? -1 : ans[i].second) << " ";
}
return cout << endl, 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005000;
long long A, B;
long long cnt(long long x) { return x * A + B * x * (x - 1) / 2LL; }
bool can(long long st, long long i, long long m, long long t) {
long long sum = cnt(i) - cnt(st - 1);
return m * t >= sum && t >= A + (i - 1) * B;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> A >> B >> n;
for (int i = 0; i < n; ++i) {
int l, t, m;
cin >> l >> t >> m;
long long lo = l, hi = 1e9;
long long best = -1;
while (lo <= hi) {
long long mid = (lo + hi) >> 1;
if (can(l, mid, m, t))
best = mid, lo = mid + 1;
else
hi = mid - 1;
}
cout << best << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long a, long long b, long long m) {
if (b == 0) return 1 % m;
long long x = bigmod(a, b / 2, m);
x = (x * x) % m;
if (b % 2 == 1) x = (x * a) % m;
return x;
}
const long long inf = 1 << 28;
int main() {
long long n, m, k, i, j;
long long mod = 1000000007ll;
while (cin >> n >> k) {
i = bigmod(k, k - 1, mod);
j = bigmod(n - k, n - k, mod);
i = (i * j) % mod;
cout << i << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 200200;
int a[M], n, b[M], ds[M], m = 0, h[M];
long long f[M];
int bad[M], sz;
void read() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
}
void build(int d) {
for (int i = 0; i < d; ++i) b[i] = a[i];
for (int i = 0; i < n; ++i) b[i % d] = max(b[i % d], a[i]);
for (int i = 0; i < n; ++i) b[i] = b[i % d];
}
void recount(int t) {
fill(bad, bad + t + 1, 0);
for (int i = 2; i <= t; ++i)
if (t % i == 0)
for (int j = i; j <= t; j += i) bad[j] = 1;
for (int i = 1; i <= t; ++i) bad[i] += bad[i - 1];
}
int cnt(int k) { return k - bad[k]; }
long long run(int d) {
for (int i = 3 * n; i >= 0; --i) {
int x = i % n;
if (b[x] != a[x])
h[x] = 0;
else
h[x] = 1 + h[(x + 1) % n];
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
h[i] = min(n - 1, h[i]);
ans += cnt(h[i] / d);
}
return ans;
}
void kill() {
long long ans = 0;
for (int d = 1; d < n; ++d)
if (n % d == 0) {
build(d);
recount(n / d);
ans += run(d);
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
read();
kill();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 30;
struct node {
int u, v, next;
long long w, p, c;
} edge[maxn << 1];
int Next[maxn], cnt = 0;
long long sum[maxn] = {0};
void link(int u, int v, long long w, long long p) {
edge[cnt] = {u, v, Next[u], w, p, 0};
Next[u] = cnt++;
}
void dfs(int u) {
for (int i = Next[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
dfs(v);
sum[u] += sum[v];
long long tmp = min({edge[i].w - 1, edge[i].p, edge[i].p - sum[v]});
if (tmp < 0) {
puts("-1");
exit(0);
}
edge[i].w -= tmp;
edge[i].p -= tmp;
edge[i].c = tmp;
sum[u] += edge[i].w;
}
}
long long dfs2(int u, long long x) {
long long use = 0;
for (int i = Next[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
long long tmp = min(edge[i].c, x);
edge[i].w += tmp;
edge[i].p += tmp;
x -= tmp;
use += tmp;
long long val = dfs2(v, min(x, edge[i].p - sum[v]));
x -= val;
use += val;
}
return use;
}
int main() {
int n, a, b;
long long c, d;
scanf("%d", &n);
memset(Next, -1, sizeof(Next));
for (int i = 1; i < n; ++i) {
scanf("%d%d%lld%lld", &a, &b, &c, &d);
link(a, b, c, d);
}
dfs(1);
dfs2(1, 1LL << 60);
printf("%d\n", n);
for (int i = 0; i < cnt; ++i)
printf("%d %d %lld %lld\n", edge[i].u, edge[i].v, edge[i].w, edge[i].p);
return 0;
};
| 9 |
#include <bits/stdc++.h>
using namespace std;
int x = 1000001;
bool prime[1000001];
void sev() {
for (int i = 2; i * i <= x; i++) {
for (int j = i * 2; j <= x; j += i) {
prime[j] = true;
}
}
}
bool sq(long long n) { return (n == pow(sqrt(n), 2)); }
int main() {
string second;
int n, x = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> second;
if (second == "X++") {
x++;
}
if (second == "++X") {
++x;
}
if (second == "X--") {
x--;
}
if (second == "--X") {
--x;
}
}
cout << x << endl;
return 0;
}
| 0 |
Subsets and Splits