solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
struct Node {
int V, Id;
bool operator<(const Node &B) const { return V < B.V; }
} A[MAXN];
int N, Ans;
bool Vis[MAXN];
vector<int> V[MAXN];
int main() {
cin >> N;
for (int I = 1; I <= N; ++I) scanf("%d", &A[I].V), A[I].Id = I;
sort(A + 1, A + N + 1);
for (int I = 1, Now; I <= N; ++I) {
if (Vis[I]) continue;
Now = I;
++Ans;
while (!Vis[Now]) {
V[Ans].push_back(Now);
Vis[Now] = true;
Now = A[Now].Id;
}
}
cout << Ans << "\n";
for (int I = 1; I <= Ans; ++I) {
printf("%d ", V[I].size());
for (vector<int>::iterator It = V[I].begin(); It != V[I].end(); ++It) {
printf("%d ", *It);
}
puts("");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int binaryExponentiation(long long int x, long long int n) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return binaryExponentiation(x * x, n / 2);
else
return x * binaryExponentiation(x * x, (n - 1) / 2);
}
long long int modularExponentiation(long long int x, long long int n,
long long int M) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return modularExponentiation((x * x) % M, n / 2, M);
else
return (x * modularExponentiation((x * x) % M, (n - 1) / 2, M)) % M;
}
bool prime_check(long long x) {
bool prime = (x >= 2);
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
prime = false;
break;
}
}
return prime;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long int> v(n);
vector<long long int> a(n);
for (long long int i = 1; i < n + 1; i++) {
cin >> v[i - 1];
}
sort(v.begin(), v.end());
for (long long int i = 0; i < n / 2; i++) {
a[i] = v[2 * i];
a[n - i - 1] = v[2 * i + 1];
}
if (n % 2 == 1) {
a[n / 2] = v[n - 1];
}
for (long long int i = 0; i < n; i++) {
cout << a[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
vector<pair<int, int> > G[N];
long long res = 0LL, dp[N][4];
void dfs(int u, int parent) {
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i].first;
int w = G[u][i].second;
if (v == parent) continue;
dfs(v, u);
long long cnt[4] = {0};
if (w == 0) {
cnt[0] += dp[v][0] + 1;
cnt[2] += dp[v][2] + dp[v][3];
} else {
cnt[1] += dp[v][0] + dp[v][1];
cnt[3] += dp[v][3] + 1;
}
res += (cnt[0] + cnt[3]) * 2 + cnt[1] + cnt[2];
res += dp[u][0] * cnt[0] + dp[u][0] * cnt[2] + dp[u][0] * cnt[3];
res += dp[u][1] * cnt[3];
res += dp[u][3] * cnt[3];
res += cnt[0] * dp[u][0] + cnt[0] * dp[u][2] + cnt[0] * dp[u][3];
res += cnt[1] * dp[u][3];
res += cnt[3] * dp[u][3];
for (int j = 0; j < 4; ++j) {
dp[u][j] += cnt[j];
}
}
}
int main() {
int n;
cin >> n;
int a, b, w;
for (int i = 0; i < n - 1; ++i) {
cin >> a >> b >> w;
--a;
--b;
G[a].push_back(make_pair(b, w));
G[b].push_back(make_pair(a, w));
}
memset(dp, 0, sizeof(dp));
dfs(0, -1);
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using ull = uint64_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using pii = pair<int, int>;
using ld = double;
namespace io {
const int BUFSIZE = 1 << 20;
int isize, osize;
char ibuf[BUFSIZE + 10], obuf[BUFSIZE + 10];
char *is, *it, *os = obuf, *ot = obuf + BUFSIZE;
char getchar() {
if (is == it) {
is = ibuf;
it = ibuf + fread(ibuf, 1, BUFSIZE, stdin);
if (is == it) return EOF;
}
return *is++;
}
char getalpha() {
char c = getchar();
while (!isalpha(c)) c = getchar();
return c;
}
void putchar(char c) {
*os++ = c;
if (os == ot) {
fwrite(obuf, 1, BUFSIZE, stdout);
os = obuf;
}
}
int inp() {
int x = 0, f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar()) {
if (ch == '-') f = 1;
}
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return f ? -x : x;
}
ll inp_ll() {
ll x = 0;
int f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return f ? -x : x;
}
template <class T>
bool read(T& x) {
x = 0;
char ch = getchar();
if (ch == EOF) return 0;
for (; !isdigit(ch);) {
ch = getchar();
if (ch == EOF) return 0;
}
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return 1;
}
template <class T>
void write(T x) {
static char s[22];
static char* it = s + 20;
static char* end = s + 20;
if (x < 0) {
putchar('-');
x = -x;
}
do {
*--it = x % 10 + '0';
x /= 10;
} while (x);
for (; it < end; ++it) putchar(*it);
}
template <>
void write(const char* s) {
for (; *s; ++s) putchar(*s);
}
template <>
void write(char c) {
putchar(c);
}
template <class T, class V>
void write(T x, V y) {
write(x);
write(y);
}
template <class T>
void writeln(T x) {
write(x);
putchar('\n');
}
struct ender {
~ender() {
if (os != obuf) fwrite(obuf, 1, os - obuf, stdout);
}
} __ender;
} // namespace io
template <class T>
void print(const T& a) {
for (auto x : a) printf("%d ", x);
puts("");
}
int64_t power(int64_t a, int64_t b, int64_t p) {
if (!b) return 1;
int64_t t = power(a, b >> 1, p);
t = t * t % p;
if (b & 1) t = t * a % p;
return t;
}
mt19937_64 rd(chrono::steady_clock::now().time_since_epoch().count());
using namespace io;
template <class T>
inline void freshmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
inline void freshmax(T& a, const T& b) {
if (a < b) a = b;
}
template <class data_type>
struct segment_tree {
using T = data_type;
int n;
vector<T> a;
using initialize_type = function<void(T&, int)>;
using merge_type = function<void(T&, const T&, const T&)>;
using pushdown_type = function<void(T&, int, int, T&, T&)>;
initialize_type initialize;
merge_type merge;
pushdown_type pushdown;
void clear(int k, int L, int R) {
pushdown(a[k], L, R, a[k << 1], a[k << 1 | 1]);
}
void update(int k) { merge(a[k], a[k << 1], a[k << 1 | 1]); }
void build(int k, int L, int R) {
if (L == R) {
initialize(a[k], L);
return;
}
int m = (L + R) >> 1;
build(k << 1, L, m);
build(k << 1 | 1, m + 1, R);
update(k);
}
segment_tree(int n, const initialize_type& initialize,
const merge_type& merge, const pushdown_type& pushdown) {
assert(n >= 1);
this->n = n;
this->initialize = initialize;
this->merge = merge;
this->pushdown = pushdown;
a = vector<T>(4 * n + 1);
build(1, 1, n);
}
using modifier_type = function<void(T&, int, int)>;
void modify(int k, int L, int R, int x, int y,
const modifier_type& modifier) {
if (L == x && R == y) {
modifier(a[k], L, R);
return;
}
int m = (L + R) >> 1;
clear(k, L, R);
if (y <= m)
modify(k << 1, L, m, x, y, modifier);
else if (x > m)
modify(k << 1 | 1, m + 1, R, x, y, modifier);
else {
modify(k << 1, L, m, x, m, modifier);
modify(k << 1 | 1, m + 1, R, m + 1, y, modifier);
}
update(k);
}
void modify(int x, int y, const modifier_type& modifier) {
assert(1 <= x && x <= y && y <= n);
modify(1, 1, n, x, y, modifier);
}
template <class result_type,
class convert_type = function<result_type(const T&)>,
class calculate_type =
function<result_type(const result_type&, const result_type&)>>
result_type query(int k, int L, int R, int x, int y,
const convert_type& convert,
const calculate_type& calculate) {
if (L == x && R == y) return convert(a[k]);
int m = (L + R) >> 1;
clear(k, L, R);
if (y <= m)
return query<result_type>(k << 1, L, m, x, y, convert, calculate);
if (x > m)
return query<result_type>(k << 1 | 1, m + 1, R, x, y, convert, calculate);
return calculate(
query<result_type>(k << 1, L, m, x, m, convert, calculate),
query<result_type>(k << 1 | 1, m + 1, R, m + 1, y, convert, calculate));
}
template <class result_type,
class convert_type = function<result_type(const T&)>,
class calculate_type =
function<result_type(const result_type&, const result_type&)>>
result_type query(int x, int y, const convert_type& convert,
const calculate_type& calculate) {
assert(1 <= x && x <= y && y <= n);
return query<result_type>(1, 1, n, x, y, convert, calculate);
}
T query(int x, int y) {
assert(1 <= x && x <= y && y <= n);
function<T(const T&)> convert = [](const T& it) -> T { return it; };
function<T(const T&, const T&)> calculate = [&](const T& Lc,
const T& Rc) -> T {
T ret;
merge(ret, Lc, Rc);
return ret;
};
return query<T>(x, y, convert, calculate);
}
};
const ll MOD = 998244353;
const int MAXN = 100010;
int x[MAXN], v[MAXN], p[MAXN];
void solve() {
int n = inp();
if (n == 1) {
writeln(0);
return;
}
const ll INV100 = power(100, MOD - 2, MOD);
for (int i = 1; i <= n; ++i) {
x[i] = inp();
v[i] = inp();
p[i] = inp();
p[i] = p[i] * INV100 % MOD;
}
struct event {
int x, v, id, s, t;
};
vector<event> stamp;
for (int i = 1; i < n; ++i) {
for (int s = 0; s < 2; ++s)
for (int t = 0; t < 2; ++t) {
if (s == 1 && t == 0) continue;
if (s == 0 && t == 0) {
if (v[i] > v[i + 1]) {
stamp.push_back({x[i + 1] - x[i], v[i] - v[i + 1], i, s, t});
}
} else if (s == 1 && t == 1) {
if (v[i] < v[i + 1]) {
stamp.push_back({x[i + 1] - x[i], v[i + 1] - v[i], i, s, t});
}
} else if (s == 0 && t == 1) {
stamp.push_back({x[i + 1] - x[i], v[i + 1] + v[i], i, s, t});
}
}
}
sort(stamp.begin(), stamp.end(), [](const event& a, const event& b) {
return (ll)a.x * b.v < (ll)b.x * a.v;
});
struct node {
ll a[2][2];
};
vector<node> A(n);
for (int i = 1; i < n; ++i) {
A[i].a[0][0] = p[i + 1];
A[i].a[0][1] = p[i + 1];
A[i].a[1][0] = (1 - p[i + 1] + MOD) % MOD;
A[i].a[1][1] = (1 - p[i + 1] + MOD) % MOD;
}
auto initialize = [&](node& it, int id) -> void { it = A[id]; };
auto merge = [&](node& it, const node& Lc, const node& Rc) -> void {
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) {
it.a[i][j] = 0;
for (int k = 0; k < 2; ++k) it.a[i][j] += Rc.a[i][k] * Lc.a[k][j];
it.a[i][j] %= MOD;
}
};
auto pushdown = [&](node& it, int L, int R, node& Lc, node& Rc) -> void {};
segment_tree<node> H(n - 1, initialize, merge, pushdown);
ll ans = 0;
for (auto [x, v, id, s, t] : stamp) {
node tmp;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) tmp.a[i][j] = 0;
tmp.a[t][s] = A[id].a[t][s];
H.modify(id, id, [&](node& it, int L, int R) -> void { it = tmp; });
tmp = H.query(1, n - 1);
ll cur = (tmp.a[0][0] * p[1] % MOD + tmp.a[0][1] * (1 - p[1] + MOD) % MOD +
tmp.a[1][0] * p[1] % MOD + tmp.a[1][1] * (1 - p[1] + MOD) % MOD) %
MOD;
ans = (ans + cur * x % MOD * power(v, MOD - 2, MOD)) % MOD;
A[id].a[t][s] = 0;
tmp = A[id];
H.modify(id, id, [&](node& it, int L, int R) -> void { it = tmp; });
}
writeln(ans);
}
int main() {
solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a[100][100];
int main() {
memset(a, 0, sizeof(a));
int K;
scanf("%d", &K);
int n = 100;
while (n * (n - 1) * (n - 2) > 6 * K) n--;
K -= n * (n - 1) * (n - 2) / 6;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i != j) a[i][j] = 1;
int ret = 0;
while (K) {
int tmp = n;
while (tmp * (tmp - 1) > 2 * K) tmp--;
K -= (tmp) * (tmp - 1) / 2;
for (int i = 0; i < tmp; i++) {
a[n + ret][i] = 1;
a[i][n + ret] = 1;
}
ret++;
}
printf("%d\n", n + ret);
for (int i = 0; i < n + ret; i++) {
for (int j = 0; j < n + ret; j++) printf("%d", a[i][j]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string inttostring(int n) {
stringstream a;
a << n;
return a.str();
}
int stringtoint(string A) {
istringstream a(A);
int p;
a >> p;
return p;
}
int n;
int A[200001];
long long dp[200001][2];
bool mark[200001][2];
long long x, y;
int g;
long long run(int i, int p) {
if (i <= 0 || i > n) return 0;
long long &res = dp[i][p % 2];
if (res != 0) return res;
if (mark[i][p % 2]) {
return res = -1;
}
mark[i][p % 2] = true;
if (p % 2)
x -= A[i];
else
x += A[i];
res = run(x, p + 1);
if (res == -1) {
return res = -1;
} else
return res = res + A[i];
}
int main() {
cin >> n;
for (int i = 2; i < n + 1; i++) cin >> A[i];
for (int i = 1; i < n; i++) {
A[1] = i;
x = 1;
g = 0;
long long ans = run(1, 0);
cout << ans << "\n";
dp[1][0] = 0;
mark[1][0] = false;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int int_inf = 0x3f3f3f3f;
const long long int ll_inf = 0x3f3f3f3f3f3f3f3f;
const int max_n = 1e5 + 5;
int num[max_n];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int i, j;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> num[i];
}
bool flag = true;
int a = num[1], b = 0;
for (int i = 1; i <= n; i++) {
if (b > num[i]) {
flag = false;
break;
}
int k = num[i] - b;
if (k >= a) {
b = num[i] - a;
} else {
a = k;
b = num[i] - a;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double m[6], w[6], h, h2;
double sum = 0;
int main() {
for (int i = 1; i <= 5; i++) {
cin >> m[i];
}
for (int i = 1; i <= 5; i++) {
cin >> w[i];
}
cin >> h >> h2;
sum += max((500 * 0.3),
(((1 - ((m[1] * 1.0 / 250.0) * 1.0)) * 500) - (50 * w[1])));
sum += max((1000 * 0.3),
(((1 - ((m[2] * 1.0 / 250.0) * 1.0)) * 1000) - (50 * w[2])));
sum += max((1500 * 0.3),
(((1 - ((m[3] * 1.0 / 250.0) * 1.0)) * 1500) - (50 * w[3])));
sum += max((2000 * 0.3),
(((1 - ((m[4] * 1.0 / 250.0) * 1.0)) * 2000) - (50 * w[4])));
sum += max((2500 * 0.3),
(((1 - ((m[5] * 1.0 / 250.0) * 1.0)) * 2500) - (50 * w[5])));
cout << sum + (h * 100) - (h2 * 50);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int64_t INF = 1e18 + 7;
ostream& operator<<(ostream& o, const string& s) {
for (auto c : s) o << c;
return o;
}
template <typename F, typename S>
ostream& operator<<(ostream& o, const pair<F, S>& p) {
o << "[" << p.first << "," << p.second << "]";
return o;
}
template <typename... T, template <class...> class C>
ostream& operator<<(ostream& o, const C<T...>& v) {
o << "[";
long long tot = 0;
for (auto x : v) {
o << x;
if (tot < v.size() - 1) o << ",";
tot++;
}
o << "]";
return o;
}
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) long long idx,
__attribute__((unused)) long long LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, long long idx, long long LINE_NUM, Head H,
Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
void init() {}
void solve() {
long long n, m;
cin >> n >> m;
long long l = 1, r = n;
vector<pair<long long, long long> > ans;
while (l <= r) {
if (l == r) {
for (long long i = 1; i <= m; i++) {
if (i % 2)
ans.push_back({l, (i + 1) / 2});
else
ans.push_back({l, m - (i - 1) / 2});
}
} else {
for (long long i = 1; i <= m; i++) {
ans.push_back({l, i});
ans.push_back({r, m - i + 1});
}
}
l++;
r--;
}
for (auto p : ans) cout << p.first << " " << p.second << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie();
init();
long long T = 1;
while (T--) {
solve();
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, c;
int a[105];
int b[105];
int d[105];
int main() {
cin >> n >> m;
int i;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 1; i <= m; i++) {
cin >> b[i];
c += b[i];
}
int e = 0;
for (i = 1; i <= c; i++) {
d[a[i]]++;
}
for (int j = 1; j <= m; j++) {
if (d[j] == b[j]) {
e++;
}
}
for (; e != m && i <= n; i++) {
if (a[i] == a[i - c]) {
continue;
}
d[a[i]]++;
d[a[i - c]]--;
if (d[a[i]] == b[a[i]] + 1) {
e--;
}
if (d[a[i]] == b[a[i]]) {
e++;
}
if (d[a[i - c]] == b[a[i - c]]) {
e++;
}
if (d[a[i - c]] == b[a[i - c]] - 1) {
e--;
}
}
cout << (e == m ? "YES" : "NO") << endl;
return (0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename P>
P dectobin(P a) {
if (a == 0)
return 0;
else
return (a % 2 + 10 * dectobin(a / 2));
}
template <typename Y>
Y bintodec(Y a) {
long long ans = 0, b = 1, t = a;
while (t) {
long long ld = t % 10;
t /= 10;
ans += ld * b;
b = b * 2;
}
return ans;
}
template <typename H>
H modExp(H x, H n) {
long long r = 1;
while (n > 0) {
if (n % 2 == 1) {
r = (r * x) % 1000000007;
}
x = (x * x) % 1000000007;
n /= 2;
}
return r;
}
template <typename T>
T isPowerOfTwo(T x) {
return x && (!(x & (x - 1)));
}
template <typename T>
T lcm(T a, T b) {
return a * b / gcd(a, b);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ostream_iterator<long long> output(cout, " ");
long long t;
cin >> t;
while (t--) {
long long n, cnt1 = 0, cnt2 = 0;
cin >> n;
string second;
cin >> second;
for (long long(i) = (0); i < (n); i++) {
if (second[i] != '>')
cnt1++;
else
break;
}
for (long long i = n - 1; i >= 0; i--) {
if (second[i] != '<')
cnt2++;
else
break;
}
if (n == 2) {
if (cnt1 == 1 && cnt2 == 1) {
cout << 1 << '\n';
} else {
cout << 0 << '\n';
}
} else if (n == 1) {
cout << 0 << '\n';
} else {
if (cnt1 == 0 || cnt2 == 0)
cout << 0 << '\n';
else
cout << min(cnt1, cnt2) << '\n';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const int MOD = 1000000007;
int a[128];
char s[N];
int quick_mod(int a, int b) {
long long ans = 1;
while (b != 0) {
if (b % 2 == 1) {
ans = (ans * a) % MOD;
}
a = ((long long)a * a) % MOD;
b /= 2;
}
return ans;
}
int main(void) {
int n;
scanf("%d", &n);
scanf("%s", s);
for (int i = 0; i < n; ++i) {
a[s[i]]++;
}
int maxval = 0, sum = 0;
for (int i = 0; i < 128; ++i) {
if (a[i] > maxval) {
maxval = a[i];
sum = 1;
} else if (a[i] == maxval) {
sum++;
}
}
cout << quick_mod(sum, n) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct cmp {
bool operator()(pair<int, pair<int, int> > a, pair<int, pair<int, int> > b) {
if (a.first != b.first) {
return a.first < b.first;
} else
return a.second.first > b.second.first;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
set<pair<int, pair<int, int> >, cmp> s;
s.insert({n, {0, n - 1}});
int cnt = 1;
vector<int> ans(n, -1);
while (!s.empty()) {
int a, b;
a = ((*(s.rbegin())).second).first;
b = ((*(s.rbegin())).second).second;
int m = (a + b) / 2;
ans[m] = cnt;
cnt++;
s.erase({b - a + 1, {a, b}});
if (a <= m - 1) {
s.insert({m - 1 - a + 1, {a, m - 1}});
}
if (m + 1 <= b) {
s.insert({b - m - 1 + 1, {m + 1, b}});
}
}
for (auto& i : ans) {
cout << i << ' ';
}
cout << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int power(int x, int p, int MOD) {
if (p == 0) return 1 % MOD;
if (p == 1) return x % MOD;
int res = power(x, p / 2, MOD);
res = (long long)res * res % MOD;
if (p & 1) res = (long long)res * x % MOD;
return res;
}
const int N = 2e6 + 10;
bool vis[N];
int a[N], ans[N];
void relax(int x) {
if (vis[x]) return;
for (int i = x; i < N; i += x) vis[i] = 1;
}
void relax_factors(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) relax(i);
while (n % i == 0) n /= i;
}
if (n > 1) relax(n);
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
bool flag = false;
for (int i = 0; i < n; i++) {
ans[i] = a[i];
while (vis[ans[i]]) ans[i]++;
if (!flag && ans[i] > a[i])
a[i + 1] = 2;
else if (flag)
a[i + 1] = ans[i];
flag |= ans[i] > a[i];
relax_factors(ans[i]);
cout << ans[i] << " ";
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long INF = 100000000000000000;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long modularExp(long long x, long long n, long long mod) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % mod;
x = ((x % mod) * (x % mod)) % mod;
n = n / 2;
}
return (result) % mod;
}
long long fastExp(long long x, long long n) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x);
x = ((x) * (x));
n = n / 2;
}
return (result);
}
bool isPrime(long long n) {
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
void solve() {
long long n;
cin >> n;
long long k = log2(n);
k = k / 2;
vector<long long> v(n);
long long i, j;
long long res = 0;
for (i = 0; i < n; i++) cin >> v[i];
sort(v.rbegin(), v.rend());
long long prev = 0;
long long cidx = 0;
for (j = k; j >= 0; j--) {
long long d = fastExp(4, j);
long long cnt = n / d - prev;
for (i = cidx; i < cidx + cnt; i++) res += v[i] * (j + 1);
prev += cnt;
cidx = cidx + cnt;
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
struct node {
int v, flag, id;
} nd[maxn];
bool cmp(node a, node b) {
if (a.v == b.v) return a.flag > b.flag;
return a.v < b.v;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<pair<int, int> > a;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
nd[i] = {x, y, i};
}
sort(nd, nd + m, cmp);
long long lim = 0;
int cnt = 0, l = 2, r = 3;
vector<pair<int, int> > ans(m);
for (int i = 0; i < m; i++) {
if (nd[i].flag == 0) {
if (lim == 0) return cout << -1 << '\n', 0;
ans[nd[i].id] = {l, r};
l++;
if (l == r) r++, l = 2;
} else {
cnt++;
lim += cnt;
ans[nd[i].id] = {1, cnt + 1};
}
lim--;
}
for (auto &x : ans) cout << x.first << ' ' << x.second << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace ioput {
template <typename T>
T read() {
T x = 0, f = 1;
char c = getchar_unlocked();
while ((c < '0') || (c > '9')) {
if (c == '-') f = -1;
c = getchar_unlocked();
}
while ((c >= '0') && (c <= '9'))
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar_unlocked();
return x * f;
}
template <typename T>
void write(T x, char c) {
static char t[20];
static int tlen;
t[tlen = 1] = c;
if (x < 0) putchar_unlocked('-'), x = -x;
do t[++tlen] = x % 10 + '0', x /= 10;
while (x);
while (tlen) putchar_unlocked(t[tlen--]);
}
} // namespace ioput
using namespace ioput;
const int maxn = 100005;
struct seg {
int id, pos, t;
bool operator<(const seg &A) const {
return pos - t == A.pos - A.t ? pos < A.pos : pos - t < A.pos - A.t;
}
} a[maxn], b[maxn], tmp[maxn];
int a_cnt, b_cnt;
int p[maxn], n, W, H;
pair<int, int> ans[maxn];
int main() {
n = read<int>(), W = read<int>(), H = read<int>();
int type, pos, t;
for (int i = 1, iend = n; i <= iend; ++i) {
type = read<int>(), pos = read<int>(), t = read<int>();
if (type == 1)
a[++a_cnt] = (seg){i, pos, t};
else
b[++b_cnt] = (seg){i, pos, t};
}
sort(a + 1, a + 1 + a_cnt);
sort(b + 1, b + 1 + b_cnt);
int cur = 1;
for (int i = 1, iend = a_cnt; i <= iend; ++i) {
static stack<int> stk;
int j = i;
while ((j < a_cnt) && (a[j + 1].pos - a[j + 1].t == a[i].pos - a[i].t)) ++j;
int pos = j, tmpcur;
while ((cur <= b_cnt) && (b[cur].pos - b[cur].t < a[i].pos - a[i].t)) ++cur;
tmpcur = cur;
for (int k = j, kend = i; k >= kend; --k) stk.push(a[k].id);
while ((cur <= b_cnt) && (b[cur].pos - b[cur].t == a[i].pos - a[i].t))
stk.push(b[cur].id), ++cur;
for (int k = i, kend = j; k <= kend; ++k) a[k].id = stk.top(), stk.pop();
for (int k = cur - 1, kend = tmpcur; k >= kend; --k)
b[k].id = stk.top(), stk.pop();
i = j;
}
for (int i = 1, iend = a_cnt; i <= iend; ++i)
ans[a[i].id] = make_pair(a[i].pos, H);
for (int i = 1, iend = b_cnt; i <= iend; ++i)
ans[b[i].id] = make_pair(W, b[i].pos);
for (int i = 1, iend = n; i <= iend; ++i)
printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int N = 1024;
using namespace std;
int n, k, bs, L[N + 5], R[N + 5], blo[N + 5], ans, vis[N + 5];
char ch[2];
int main() {
scanf("%d%d", &n, &k);
bs = max(1, k / 2);
for (int i = 1; i <= n; i++) {
blo[i] = (i - 1) / bs + 1;
if (!L[blo[i]]) L[blo[i]] = i;
R[blo[i]] = i;
}
for (int i = 1; i <= n / bs; i++) {
for (int st = 1; st <= i; st++) {
if (st + i > blo[n]) break;
for (int j = L[st]; j <= R[st]; j++) {
printf("? %d\n", j);
fflush(stdout);
scanf("%s", ch + 1);
if (ch[1] == 'Y') vis[j] = 1;
}
for (int x = st + i; x <= blo[n]; x += i) {
for (int j = L[x]; j <= R[x]; j++) {
printf("? %d\n", j);
fflush(stdout);
scanf("%s", ch + 1);
if (ch[1] == 'Y') vis[j] = 1;
}
}
printf("R\n");
fflush(stdout);
}
}
for (int i = 1; i <= n; i++) ans += !vis[i];
printf("! %d\n", ans);
fflush(stdout);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
long long ans, G[1000005], g[1000005], S;
int n;
long double Gu[1000005];
struct N {
long long x, y;
} a[1000005], B[1000005];
N operator+(N a, N b) { return (N){(a.x + b.x) % mo, (a.y + b.y) % mo}; }
N operator-(N a, N b) { return (N){(a.x - b.x) % mo, (a.y - b.y) % mo}; }
long long operator*(N a, N b) { return a.x * b.y - a.y * b.x; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld%lld", &a[i].x, &a[i].y);
for (int i = 1; i <= n >> 1; ++i) swap(a[i], a[n - i + 1]);
for (int i = n + 1; i <= n + n; ++i) a[i] = a[i - n];
S = a[n] * a[1];
for (int i = 2; i <= n; ++i) S += a[i - 1] * a[i];
G[1] = a[n] * a[1] % mo;
Gu[1] = a[n] * a[1];
for (int i = 2; i <= n + n; ++i) {
G[i] = (G[i - 1] + a[i - 1] * a[i]) % mo;
Gu[i] = Gu[i - 1] + a[i - 1] * a[i];
}
for (int i = 1; i <= n + n; ++i) g[i] = (g[i - 1] + G[i]) % mo;
for (int i = 1; i <= n + n; ++i) B[i] = B[i - 1] + a[i];
for (int i = 1, j = 0; i <= n; ++i) {
j = max(j, i + 2);
while (1) {
long long X = (G[j] - G[i] + a[j] * a[i]) % mo;
long double Y = Gu[j] - Gu[i] + a[j] * a[i];
X = (long long)(Y - X) / mo * mo + X;
while (Y - X > 1000) X += mo;
while (X - Y > 1000) X -= mo;
if (j <= n && (unsigned long long)X * 2llu <= (unsigned long long)S)
++j;
else if (j > n && (unsigned long long)X * 2llu < (unsigned long long)S)
++j;
else
break;
}
(ans += g[j - 1] - g[i + 1] - G[i] * (j - i - 2) +
(B[j - 1] - B[i + 1]) * a[i] % mo) %= mo;
}
printf("%lld\n",
((1ll * n * (n - 3) / 2 % mo * G[n] - ans * 2) % mo + mo) % mo);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 100000000;
long long a, b, ta, tb, dp[101][101][2];
int main() {
cin >> a >> b >> ta >> tb;
for (int i = 0; i <= ta; i++) {
dp[i][0][0] = 1;
}
for (int i = 0; i <= tb; i++) {
dp[0][i][1] = 1;
}
for (int i = 1; i <= a; i++) {
for (int j = 1; j <= b; j++) {
dp[i][j][0] = (dp[i - 1][j][0] + dp[i - 1][j][1]) % Mod;
if ((i - ta - 1) >= 0)
dp[i][j][0] = ((dp[i][j][0] + Mod) - dp[i - ta - 1][j][1]) % Mod;
dp[i][j][1] = (dp[i][j - 1][1] + dp[i][j - 1][0]) % Mod;
if ((j - tb - 1) >= 0)
dp[i][j][1] = ((dp[i][j][1] + Mod) - dp[i][j - tb - 1][0]) % Mod;
}
}
cout << (dp[a][b][1] + dp[a][b][0]) % Mod;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx[8] = {-1, 1, 0, 0, 1, 1, -1, -1}, dy[8] = {0, 0, 1, -1, 1, 1, -1, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int tot = 0;
while (n--) {
int x;
cin >> x;
tot += x;
}
tot = abs(tot);
int ans = 0;
while (tot > 0) tot -= m, ans++;
cout << ans << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[101];
cin >> str;
int len = strlen(str);
for (int i = 0; i < len; i++) {
if (str[i] < 'a') str[i] += 32;
if (str[i] != 'a' && str[i] != 'e' && str[i] != 'i' && str[i] != 'o' &&
str[i] != 'u' && str[i] != 'y')
cout << "." << str[i];
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
scanf("%d%d", &n, &m);
if (n > m) swap(n, m);
if (n == 1)
printf("%d", max(m - m % 6, m - (6 - m % 6)));
else if (n == 2 && m == 2)
printf("0");
else if (n == 2 && m == 3)
printf("4");
else if (n == 2 && m == 7)
printf("12");
else if (n % 2 == 1 && m % 2 == 1)
printf("%lld", 1ll * n * m - 1);
else
printf("%lld", 1ll * n * m);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int tab[10000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
unsigned long long odp = 1;
int po = n / 2;
n--;
while (n > po) {
odp *= n;
n--;
}
n--;
while (n) {
odp *= n;
n--;
}
cout << odp << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
vector<pair<int, int> > act, fake;
multimap<pair<int, int>, pair<int, int> > final;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m, cycle1, cycle2, temp;
multimap<pair<int, int>, pair<int, int> >::iterator it;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
act.push_back(make_pair(a, b));
fake.push_back(make_pair(a, (b + 1) % 2));
}
sort(fake.begin(), fake.end());
if (fake[0].second == 1 || fake[1].second == 1) {
cout << "-1";
return 0;
}
final.insert(make_pair(make_pair(fake[0].first, (fake[0].second + 1) % 2),
make_pair(1, 2)));
final.insert(make_pair(make_pair(fake[1].first, (fake[1].second + 1) % 2),
make_pair(2, 3)));
cycle1 = 3;
cycle2 = 1;
temp = 3;
for (int i = 2; i < (int)(fake.size()); i++) {
if (fake[i].second == 1) {
if (cycle1 > temp) {
cout << "-1";
return 0;
}
final.insert(make_pair(make_pair(fake[i].first, (fake[i].second + 1) % 2),
make_pair(cycle1, cycle2)));
if (cycle2 + 1 <= cycle1 - 2)
cycle2++;
else {
cycle1++;
cycle2 = 1;
}
} else {
final.insert(make_pair(make_pair(fake[i].first, (fake[i].second + 1) % 2),
make_pair(temp, temp + 1)));
temp++;
}
}
for (int i = 0; i < (int)(act.size()); i++) {
it = final.find(act[i]);
cout << it->second.first << " " << it->second.second << "\n";
final.erase(it);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, u[200001], ar[200001], a[200001], x, y;
vector<int> vec[200001], w[200001], pr[200001];
vector<long long> ans[200001];
inline int dfs(int v) {
int y = 0;
for (int i = 0; i < vec[v].size(); i++) y += dfs(vec[v][i]);
a[v] = y;
y = y - u[v];
return y + 1;
}
inline void f(int v, int p, int ww) {
if (p != -1) {
int a = 0, b = p;
ans[v].push_back(ww);
pr[v].push_back(b);
while (ans[b].size() > a && b != 1) {
ans[v].push_back(ans[v][a] + ans[b][a]);
b = pr[b][a];
pr[v].push_back(b);
a++;
}
}
pr[v].push_back(1);
if (p != -1)
ans[v].push_back(ans[p][ans[p].size() - 1] + ww);
else
ans[v].push_back(0);
for (int i = 0; i < vec[v].size(); i++) f(vec[v][i], v, w[v][i]);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &ar[i]);
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &x, &y);
vec[x].push_back(i + 2);
w[x].push_back(y);
}
f(1, -1, -1);
for (int i = 1; i <= n; i++) {
int a = i, b = 0, c = ar[i];
while (a != 1 && ans[a][0] + b <= c) {
int t = 1;
for (int i = 1; i < ans[a].size(); i++) {
if (b + ans[a][i] > c) {
t = 0;
b = b + ans[a][i - 1];
a = pr[a][i - 1];
break;
}
}
if (t == 1) {
b = b + ans[a][ans[a].size() - 1];
a = pr[a][ans[a].size() - 1];
}
}
u[a]++;
}
dfs(1);
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int mod = 1000000007;
const int mask = 1;
const int maxp = 30;
long long dp[2][22][3];
long long p2[maxp];
long long p3[maxp];
long long zz[maxp][maxp];
int zml(int a2, int a3, int n) {
memset(dp, 0, sizeof(dp));
for (int j = 0; j < maxp; j++)
for (int k = 0; k < maxp; k++) {
zz[j][k] = n / (p2[j] * p3[k]);
}
dp[0][a2][a3] = zz[a2][a3];
for (int i = 1; i < n; i++) {
for (int j = 0; j <= a2; j++)
for (int k = 0; k <= a3; k++) {
dp[i & mask][j][k] = 0;
long long &z0 = zz[j][k];
long long &z1 = zz[j + 1][k];
long long &z2 = zz[j][k + 1];
if (z0 <= i) continue;
dp[i & mask][j][k] += dp[(i - 1) & mask][j][k] * max(z0 - i, 0LL);
dp[i & mask][j][k] += dp[(i - 1) & mask][j + 1][k] * (z0 - z1);
dp[i & mask][j][k] += dp[(i - 1) & mask][j][k + 1] * (z0 - z2);
dp[i & mask][j][k] %= mod;
}
}
return dp[(n - 1) & mask][0][0];
}
void getfac() {
p2[0] = p3[0] = 1;
for (int i = 1; i < maxp; i++) {
p2[i] = p2[i - 1] * 2;
p3[i] = p3[i - 1] * 3;
}
}
int main() {
ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
getfac();
int n;
cin >> n;
int a2;
for (a2 = 0; p2[a2] <= n; a2++)
;
a2--;
long long ans = 0;
ans += zml(a2, 0, n);
if (p2[a2 - 1] * 3 <= n) ans += zml(a2 - 1, 1, n);
ans %= mod;
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int ds(int x) {
int res = 0;
while (x) {
res += x % 10;
x /= 10;
}
return res;
}
int main(int argc, char** argv) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(15);
if (argc == 2 && atoi(argv[1]) == 123456789)
freopen("d:\\code\\cpp\\contests\\stdin", "r", stdin);
int T;
cin >> T;
for (int(t) = 0; (t) < (T); (t)++) {
int n, k;
cin >> n >> k;
string ans = string(n + 1, '9');
for (int(a) = 0; (a) < (100); (a)++) {
int s = 0;
for (int(x) = 0; (x) < (k + 1); (x)++) s += ds(a + x);
string str = to_string(a);
if (s == n)
if (str.length() < ans.length() ||
str.length() == ans.length() && str < ans)
ans = str;
}
for (int(a) = 0; (a) < (10); (a)++) {
for (int(tt) = 0; (tt) < ((n + 8) / 9); (tt)++) {
for (int(c) = 0; (c) < (10); (c)++) {
int s = 0;
for (int(x) = 0; (x) < (k + 1); (x)++) {
if (x + c < 10)
s += a + tt * 9 + c + x;
else
s += ds(a + 1) + c + x - 10;
}
if (s == n) {
string str =
string(1, a + '0') + string(tt, '9') + string(1, c + '0');
if (str.length() < ans.length() ||
str.length() == ans.length() && str < ans)
ans = str;
}
}
for (int c = 10; c < 100; c++) {
int s = 0;
for (int(x) = 0; (x) < (k + 1); (x)++) {
if (x + c < 100)
s += a + tt * 9 + ds(c + x);
else
s += ds(a + 1) + ds(c + x - 100);
}
if (s == n) {
string str = string(1, a + '0') + string(tt, '9') + to_string(c);
if (str.length() < ans.length() ||
str.length() == ans.length() && str < ans)
ans = str;
}
}
}
}
if (ans[0] == '0' && ans.length() > 1) ans = ans.substr(1);
if (ans.length() == n + 1)
cout << -1 << endl;
else
cout << ans << endl;
}
if (argc == 2 && atoi(argv[1]) == 123456789)
cout << clock() * 1.0 / CLOCKS_PER_SEC << " sec\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int qq = 1;
cin >> qq;
for (int qqq = 0; qqq < qq; qqq++) {
int n, first, v;
cin >> n >> first;
int maxx = 0;
int maxxd = 0;
for (int i = 0; i < n; i++) {
cin >> v;
maxx = max(maxx, v);
if (v <= first) {
maxxd = max(maxxd, v);
}
}
if (maxxd == 0)
cout << 2 << "\n";
else if (maxx == maxxd) {
cout << first / maxx + (first % maxx > 0) << "\n";
} else if (maxxd == first) {
cout << 1 << "\n";
} else
cout << 2 << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
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 {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const long long maxn = 100005;
long long cfc[maxn];
long long cnt[maxn];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a(n + 1);
long long ans = 1;
long long mx_cnt = 0;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
cfc[cnt[a[i]]]--;
cnt[a[i]]++;
cfc[cnt[a[i]]]++;
mx_cnt = max(mx_cnt, cnt[a[i]]);
if (cnt[a[i]] == i) {
ans = i;
}
if (cfc[mx_cnt] * mx_cnt == i - 1 && cfc[1] == 1) {
ans = i;
}
if ((cfc[mx_cnt - 1] * (mx_cnt - 1) == i - mx_cnt) && cfc[mx_cnt] == 1) {
ans = i;
}
if (cfc[1] == i) ans = i;
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
double x, y;
} p1, p2, w1, w2, m1, m2;
Point operator-(const Point &i, const Point &j) {
Point ret = {i.x - j.x, i.y - j.y};
return ret;
}
void Init() {
scanf("%lf %lf", &p1.x, &p1.y);
scanf("%lf %lf", &p2.x, &p2.y);
scanf("%lf %lf", &w1.x, &w1.y);
scanf("%lf %lf", &w2.x, &w2.y);
scanf("%lf %lf", &m1.x, &m1.y);
scanf("%lf %lf", &m2.x, &m2.y);
}
double det(const Point &i, const Point &j) { return i.x * j.y - i.y * j.x; }
bool Solve() {
if (det(w1 - p1, p2 - p1) * det(w2 - p1, p2 - p1) > 0 ||
det(p1 - w1, w2 - w1) * det(p2 - w1, w2 - w1) > 0 ||
max(p1.x, p2.x) < min(w1.x, w2.x) || min(p1.x, p2.x) > max(w1.x, w2.x)) {
if (det(m1 - p1, p2 - p1) * det(m2 - p1, p2 - p1) > 0 ||
det(p1 - m1, m2 - m1) * det(p2 - m1, m2 - m1) > 0 ||
(fabs(det(m1 - p1, p2 - p1)) < 1e-10 &&
fabs(det(m2 - p1, p2 - p1)) < 1e-10))
return 1;
else
return 0;
}
double s1 = det(m1 - m2, p1 - m2), s2 = det(m1 - m2, p2 - m2);
if (s1 * s2 < 1e-10) return 0;
double r = s1 / s2, A = m2.y - m1.y, B = m1.x - m2.x;
Point q = {p2.x * r / (1 + r) + p1.x / (1 + r),
p2.y * r / (1 + r) + p1.y / (1 + r)},
D = {A, B};
if (det(D, m1 - q) * det(D, m2 - q) > 1e-10) return 0;
double t = det(m2 - m1, q - m1) / det(D, m2 - m1);
Point h = {q.x + D.x * t, q.y + D.y * t};
if (det(h - p1, w1 - p1) * det(h - p1, w2 - p1) < 1e-10 &&
det(w2 - w1, h - w1) * det(w2 - w1, p1 - w1) < 1e-10)
return 0;
if (det(h - p2, w1 - p2) * det(h - p2, w2 - p2) < 1e-10 &&
det(w2 - w1, h - w1) * det(w2 - w1, p2 - w1) < 1e-10)
return 0;
return 1;
}
int main() {
Init();
printf("%s\n", Solve() ? "YES" : "NO");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
int t;
cin >> t;
while (t--) {
cin >> a >> b;
long long d = abs(a - b);
if (!d) {
cout << "0\n";
continue;
}
int cnt = 1;
while (1) {
long long sum = cnt * (cnt + 1) / 2;
if (sum >= d) {
if ((sum % 2) == (d % 2)) break;
}
cnt++;
}
cout << cnt << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int md = 998244353;
inline void add(int &a, int b) {
a += b;
if (a >= md) a -= md;
}
inline void sub(int &a, int b) {
a -= b;
if (a < 0) a += md;
}
inline int mul(int a, int b) { return (int)((long long)a * b % md); }
inline int power(int a, long long b) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res;
}
inline int inv(int a) {
a %= md;
if (a < 0) a += md;
int b = md, u = 0, v = 1;
while (a) {
int t = b / a;
b -= t * a;
swap(a, b);
u -= t * v;
swap(u, v);
}
assert(b == 1);
if (u < 0) u += md;
return u;
}
namespace ntt {
int base = 1;
vector<int> roots = {0, 1};
vector<int> rev = {0, 1};
int max_base = -1;
int root = -1;
void init() {
int tmp = md - 1;
max_base = 0;
while (tmp % 2 == 0) {
tmp /= 2;
max_base++;
}
root = 2;
while (true) {
if (power(root, 1 << max_base) == 1) {
if (power(root, 1 << (max_base - 1)) != 1) {
break;
}
}
root++;
}
}
void ensure_base(int nbase) {
if (max_base == -1) {
init();
}
if (nbase <= base) {
return;
}
assert(nbase <= max_base);
rev.resize(1 << nbase);
for (int i = 0; i < (1 << nbase); i++) {
rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (nbase - 1));
}
roots.resize(1 << nbase);
while (base < nbase) {
int z = power(root, 1 << (max_base - 1 - base));
for (int i = 1 << (base - 1); i < (1 << base); i++) {
roots[i << 1] = roots[i];
roots[(i << 1) + 1] = mul(roots[i], z);
}
base++;
}
}
void fft(vector<int> &a) {
int n = a.size();
assert((n & (n - 1)) == 0);
int zeros = __builtin_ctz(n);
ensure_base(zeros);
int shift = base - zeros;
for (int i = 0; i < n; i++) {
if (i < (rev[i] >> shift)) {
swap(a[i], a[rev[i] >> shift]);
}
}
for (int k = 1; k < n; k <<= 1) {
for (int i = 0; i < n; i += 2 * k) {
for (int j = 0; j < k; j++) {
int x = a[i + j];
int y = mul(a[i + j + k], roots[j + k]);
a[i + j] = x + y - md;
if (a[i + j] < 0) a[i + j] += md;
a[i + j + k] = x - y + md;
if (a[i + j + k] >= md) a[i + j + k] -= md;
}
}
}
}
vector<int> multiply(vector<int> a, vector<int> b, int eq = 0) {
int need = a.size() + b.size() - 1;
int nbase = 0;
while ((1 << nbase) < need) nbase++;
ensure_base(nbase);
int sz = 1 << nbase;
a.resize(sz);
b.resize(sz);
fft(a);
if (eq)
b = a;
else
fft(b);
int inv_sz = inv(sz);
for (int i = 0; i < sz; i++) {
a[i] = mul(mul(a[i], b[i]), inv_sz);
}
reverse(a.begin() + 1, a.end());
fft(a);
a.resize(need);
return a;
}
vector<int> square(vector<int> a) { return multiply(a, a, 1); }
}; // namespace ntt
long long modpow(long long x, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * x % 998244353;
x = x * x % 998244353;
n >>= 1;
}
return res;
}
long long F[4005], R[4005];
void make() {
F[0] = 1;
for (int i = 1; i < 4005; i++) F[i] = F[i - 1] * i % 998244353;
for (int i = 0; i < 4005; i++) R[i] = modpow(F[i], 998244353 - 2);
}
long long C[2005][2005];
long long t[2005][2005];
int n, a[2005][2005];
struct BIT {
int bit[(1 << 12) + 5];
void init() { memset(bit, 0, sizeof(bit)); }
int f(int x) { return x & -x; }
void add(int i, int x) {
for (int s = i; s <= (1 << 12); s += f(s)) bit[s] += x;
}
int query(int i) {
int res = 0;
for (int s = i; s > 0; s -= f(s)) res += bit[s];
return res;
}
} B[2];
int main() {
make();
for (int i = 0; i < 2005; i++)
for (int j = 0; j < i + 1; j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 998244353;
}
for (int b = 0; b <= 2000; b++) {
vector<int> c, d;
for (int j = 0; j <= b; j++) {
int q = C[b][j];
if (j % 2 == 1) q *= -1;
if (q < 0) q += 998244353;
c.push_back(q);
}
for (int j = 0; j <= 2000; j++) {
d.push_back(F[j]);
}
vector<int> e = ntt::multiply(c, d);
for (int a = 0; a <= 2000 - b; a++) {
t[b][a] = e[a + b];
}
}
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
}
long long ans = 0;
int used[2005] = {};
for (int j = 1; j <= n; j++) {
int C = 0;
for (int i = 1; i < a[1][j]; i++) {
if (!used[i]) {
C++;
}
}
ans += 1LL * C * F[n - j] % 998244353;
used[a[1][j]] = 1;
}
ans = ans % 998244353 * modpow(t[n][0], n - 1) % 998244353;
for (int i = 2; i <= n; i++) {
bool x[2005][2] = {};
bool y[2005][2] = {};
int cnt = 0;
long long add = 0;
B[0].init();
B[1].init();
for (int j = n; j >= 1; j--) {
x[a[i - 1][j]][0] = 1;
if (x[a[i - 1][j]][0] && x[a[i - 1][j]][1]) B[1].add(a[i - 1][j], 1);
x[a[i][j]][1] = 1;
if (x[a[i][j]][0] && x[a[i][j]][1]) B[1].add(a[i][j], 1);
B[0].add(a[i][j], 1);
if (j < n) {
y[a[i - 1][j + 1]][0] = 1;
if (y[a[i - 1][j + 1]][0] && y[a[i - 1][j + 1]][1]) cnt++;
}
y[a[i][j]][1] = 1;
if (y[a[i][j]][0] && y[a[i][j]][1]) cnt++;
int p[2] = {};
p[1] = B[1].query(a[i][j] - 1);
p[0] = B[0].query(a[i][j] - 1) - p[1];
if (a[i - 1][j] < a[i][j]) {
if (x[a[i - 1][j]][1]) {
p[x[a[i - 1][j]][0]]--;
}
}
if (cnt) add += p[1] * t[cnt - 1][n - j - cnt + 1];
add += p[0] * t[cnt][n - j - cnt];
}
add %= 998244353;
add = add * modpow(t[n][0], n - i) % 998244353;
ans += add;
}
cout << (ans % 998244353 + 998244353) % 998244353 << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline void inp(int &n) {
n = 0;
int ch = getchar();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar();
n = n * sign;
}
long long gcd(long long A, long long B) {
return A > B ? gcd(B, A) : A ? gcd(B % A, A) : B;
}
long long lcm(long long A, long long B) { return A / gcd(A, B) * B; }
long long pow(long long A, long long B, long long P) {
if (!B) return 1 % P;
long long h = pow(A, B / 2, P);
h *= h;
h %= P;
if (B % 2) h *= A;
return h % P;
}
vector<int> z_function(string s) {
int n = (int)s.length();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
int tst;
void get_ready() { tst = 1; }
bool f[262145];
vector<int> g[262145], c[262145];
vector<int> ans1, ans2, ans3;
string s, q, s1, s2;
pair<int, int> P[262145];
int a[262145], b[262145];
char D[2555][2555];
int n, m, i, j, k, l, r, x, y, u, v;
long long ans, res, cur;
bool READ() {
cin >> n >> k;
for (i = 1; i <= n - k; i++) cout << i << " ";
r = n;
l = n - k + 1;
i = 0;
for (;;) {
i++;
if (l > r) break;
if (i % 2)
cout << r << " ", r--;
else
cout << l << " ", l++;
}
cout << endl;
return 1;
}
bool SOLVE() { return 1; }
bool PRINT() { return 1; }
bool CLEAR() { return 1; }
int main() {
get_ready();
while (tst--) {
if (!READ()) {
return 0;
}
if (!SOLVE()) {
return 0;
}
if (!PRINT()) {
return 0;
}
if (!CLEAR()) {
return 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<long long> s;
long long n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
if (s.find(n % i) != s.end()) break;
s.insert(n % i);
}
if (s.size() == k)
cout << "YES";
else
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
char lin[2000086];
int main() {
int i, j, k, len, ans = 1, tpan;
while (gets(lin) != NULL) {
len = strlen(lin);
for (i = 0; i < len; i++) {
if (lin[i] != ' ') break;
}
if (lin[i] == '#') {
tpan = 0;
if (ans != 1) {
printf("\n");
}
ans = 1;
printf("%s\n", lin);
continue;
}
ans = 0;
tpan = 1;
for (i = 0; i < len; i++) {
if (lin[i] != ' ') {
printf("%c", lin[i]);
}
}
}
if (tpan == 1) {
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
set<int> v[200007];
int indeg[200003];
int num_leaf[200003];
int rem[200003];
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
std::vector<int> leaves;
for (int i = 1; i <= n; ++i) {
v[i].clear();
indeg[i] = 0;
rem[i] = 0;
}
for (int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
v[x].insert(y);
v[y].insert(x);
indeg[x]++;
indeg[y]++;
}
for (int i = 1; i <= n; ++i) {
if (v[i].size() == 1) {
leaves.push_back(i);
}
}
int ans = 0;
for (int i = 0; i < leaves.size(); ++i) {
int val = leaves[i];
if (indeg[val] < 1 || v[val].size() == 0) continue;
for (auto e : v[val]) {
rem[e]++;
v[e].erase(val);
if (rem[e] == k) {
ans++;
indeg[e] -= k;
rem[e] = 0;
}
if (indeg[e] == 1 && rem[e] == 0) {
leaves.push_back(e);
}
}
v[val].clear();
}
cout << ans << endl;
}
}
| 7 |
#include <bits/stdc++.h>
const int INF = 1e9;
const int maxm = 1000000;
const int maxn = 10000;
using namespace std;
struct edge {
int to, next, cap, flow, cost;
} edge[maxm];
int head[maxn];
int tol;
int pre[maxn], dis[maxn];
bool vis[maxn];
int n;
int cnt_node;
void addedge(int u, int v, int cap, int cost) {
edge[tol].to = v;
edge[tol].cap = cap;
edge[tol].cost = cost;
edge[tol].flow = 0;
edge[tol].next = head[u];
head[u] = tol++;
edge[tol].to = u;
edge[tol].cap = 0;
edge[tol].cost = -cost;
edge[tol].flow = 0;
edge[tol].next = head[v];
head[v] = tol++;
}
bool spfa(int s, int t) {
queue<int> q;
for (int i = 0; i <= 2 * n + 1; i++) {
dis[i] = INF;
vis[i] = false;
pre[i] = -1;
}
dis[s] = 0;
vis[s] = true;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = false;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (edge[i].cap > edge[i].flow && dis[v] > dis[u] + edge[i].cost) {
dis[v] = dis[u] + edge[i].cost;
pre[v] = i;
if (!vis[v]) {
vis[v] = true;
q.push(v);
}
}
}
}
if (pre[t] == -1)
return false;
else
return true;
}
int minCostMaxflow(int s, int t, int &cost) {
int flow = 0;
cost = 0;
while (spfa(s, t)) {
int Min = INF;
for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to]) {
if (Min > edge[i].cap - edge[i].flow) {
Min = edge[i].cap - edge[i].flow;
}
}
for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to]) {
edge[i].flow += Min;
edge[i ^ 1].flow -= Min;
cost += edge[i].cost * Min;
}
flow += Min;
}
return flow;
}
int min_limit[100];
int max_limit[100];
int main() {
int q;
scanf("%d%d", &n, &q);
tol = 0;
memset(head, -1, sizeof(head));
int t, l, r, v;
for (int i = 1; i <= n; i++) {
min_limit[i] = 1;
max_limit[i] = n;
}
for (int i = 1; i <= q; i++) {
scanf("%d%d%d%d", &t, &l, &r, &v);
if (t == 1) {
for (int j = l; j <= r; j++) {
min_limit[j] = max(min_limit[j], v);
}
} else {
for (int j = l; j <= r; j++) {
max_limit[j] = min(max_limit[j], v);
}
}
}
for (int i = 1; i <= n; i++) {
addedge(0, i, 1, 0);
}
for (int i = 1; i <= n; i++) {
for (int k = min_limit[i]; k <= max_limit[i]; k++) {
addedge(i, n + k, 1, 0);
}
}
for (int i = n + 1; i <= n + n; i++) {
for (int v = 1; v <= 2 * n - 1; v += 2) {
addedge(i, 2 * n + 1, 1, v);
}
}
int ans = 0;
int flow = minCostMaxflow(0, 2 * n + 1, ans);
if (flow != n) {
printf("-1\n");
} else {
printf("%d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int sum = 0;
for (int i = 1; sum <= n; i++) {
sum += i;
if (sum == n) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long maxi = LLONG_MAX;
long long mini = LLONG_MIN;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
pair<long double, long double> norm(pair<long double, long double> p) {
long double lenp = (sqrt(((p.first) * (p.first) + (p.second) * (p.second))));
return {p.first / lenp, p.second / lenp};
}
pair<long double, long double> rotate(pair<long double, long double> p, int a) {
return {cos(a) * p.first - sin(a) * p.second,
cos(a) * p.second + sin(a) * p.first};
}
long double dot(pair<long double, long double> p,
pair<long double, long double> q) {
return p.first * q.first + p.second * q.second;
}
long double cross(pair<long double, long double> p,
pair<long double, long double> q) {
return p.first * q.second - p.second * q.first;
}
long double cosv(pair<long double, long double> p,
pair<long double, long double> q) {
return dot(p, q) /
((sqrt(((p.first) * (p.first) + (p.second) * (p.second)))) *
(sqrt(((q.first) * (q.first) + (q.second) * (q.second)))));
}
long double sinv(pair<long double, long double> p,
pair<long double, long double> q) {
return sqrt(1 - cosv(p, q) * cosv(p, q));
}
long double dist2(pair<int, int> p, pair<int, int> q) {
return (p.first - q.first) * (p.first - q.first) +
(p.second - q.second) * (p.second - q.second);
}
long double dist(pair<int, int> p, pair<int, int> q) {
return sqrt(dist2(p, q));
}
long long gcd(long long a, long long b) {
if (b > a) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
int sti(string s) {
int n = 0;
for (int i = 0; i < s.size(); i++) {
n *= 10;
n += (s[i] - '0');
}
return n;
}
long long power(long long x, long long y) {
long long p = 1000000007;
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res % p;
}
long long modInverse(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = (x - q * y);
x = t;
}
if (x < 0) x += m0;
return x;
}
long long C[205][205];
void nCr() {
for (int i = 0; i < 205; i++) {
C[i][i] = 1;
C[i][0] = 1;
}
for (int i = 1; i < 205; i++) {
C[i][1] = i;
}
for (int r = 1; r < 204; r++) {
for (int n = r + 1; n < 203; n++) {
C[n][r] = ((C[n - 1][r - 1] % 1000000007) + (C[n - 1][r] % 1000000007)) %
1000000007;
}
}
}
bool isPal(string s) {
string s1 = s.substr(0, s.size() / 2);
string s2 = s.substr((s.size() + 1) / 2, s.size() / 2);
reverse(s2.begin(), s2.end());
if (s1 == s2)
return 1;
else
return 0;
}
vector<bool> prm(100005, 1);
void sieve() {
prm[0] = prm[1] = 0;
for (int i = 2; i * i <= prm.size(); i++) {
if (prm[i])
for (int j = i * 2; j < prm.size(); j += i) {
prm[j] = 0;
}
}
}
struct line {
int a, b, c;
};
pair<long double, long double> insc(line l1, line l2) {
pair<long double, long double> p;
long double a = l1.b * l2.c - l2.b * l1.c;
long double b = l1.c * l2.a - l2.c * l1.a;
long double c = l1.a * l2.b - l2.a * l1.b;
p.first = a / c;
p.second = b / c;
return p;
}
line twoPline(pair<long double, long double> A,
pair<long double, long double> B) {
line l;
l.a = B.second - A.second;
l.b = A.first - B.first;
l.c = l.a * A.first + l.b * A.second;
l.c = -(l.c);
return l;
}
int main() {
fast();
string s;
cin >> s;
int fg = 1;
for (int i = 0; i < s.size(); i++) {
if (!(s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u')) {
if (s[i] == 'n')
;
else {
if (i == s.size() - 1 ||
(!(s[i + 1] == 'a' || s[i + 1] == 'e' || s[i + 1] == 'i' ||
s[i + 1] == 'o' || s[i + 1] == 'u'))) {
fg = 0;
}
}
}
}
if (fg == 1)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 0.000000000000001;
void transoo(char *s) {
int i, j, l = strlen(s);
char t[200] = {0};
int p = 0;
for (i = 0; i < l; i++) {
if (!(s[i] == 'u')) {
t[p++] = s[i];
} else {
t[p++] = 'o';
t[p++] = 'o';
}
}
t[p] = 0;
strcpy(s, t);
}
void transkh(char *s) {
int i, j, l = strlen(s);
char t[200] = {0};
int p = 0;
for (i = 0; i < l; i++) {
if (!(i + 1 < l && s[i] == 'k')) {
t[p++] = s[i];
} else {
for (j = i; j < l; j++) {
if (s[j] != 'k') break;
}
if (j < l && s[j] == 'h') {
t[p++] = 'h';
i = j;
} else {
t[p++] = s[i];
}
}
}
t[p] = 0;
strcpy(s, t);
}
int main() {
int n, i, j;
scanf("%d", &n);
char str[100];
map<string, int> ma;
for (i = 0; i < n; i++) {
scanf("%s", str);
transoo(str);
transkh(str);
ma[str]++;
}
printf("%d\n", (int)ma.size());
return 0;
}
| 2 |
#include <bits/stdc++.h>
namespace XX {
template <int MOD>
long long int powmod(long long int a, long long int b) {
long long int ret = 1;
while (b) {
if (b & 1) ret = ret * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ret;
}
} // namespace XX
namespace XX {
template <template <typename> class Compare, typename T>
inline T& UP(T& x, const T& y) {
Compare<T>()(y, x) && (x = y);
return x;
}
template <typename Compare, typename T>
inline T& UP(T& x, const T& y, Compare comp) {
comp(y, x) && (x = y);
return x;
}
template <typename T>
inline T& GT(T& x, const T& y) {
return UP<std::greater>(x, y);
}
template <typename T>
inline T& LS(T& x, const T& y) {
return UP<std::less>(x, y);
}
template <typename T, typename... Args>
std::array<std::reference_wrapper<T>, sizeof...(Args) + 1> MAKEV(
T& arg1, Args&... args) {
return {arg1, args...};
}
struct Range {
struct It {
int num, step;
int operator*() { return num; }
void operator++() { num += step; }
bool operator!=(const It& other) { return num != other.num; }
};
Range(int ee) : b(0), e(ee) {}
Range(int bb, int ee) : b(bb), e(ee) {}
It begin() { return {b, (b < e ? 1 : -1)}; }
It end() { return {e}; }
int b, e;
};
} // namespace XX
template <typename T>
struct ScanfSpecifier {};
template <>
struct ScanfSpecifier<int> {
static constexpr const char* value = "%d";
};
template <>
struct ScanfSpecifier<double> {
static constexpr const char* value = "%lf";
};
template <>
struct ScanfSpecifier<float> {
static constexpr const char* value = "%f";
};
template <>
struct ScanfSpecifier<char> {
static constexpr const char* value = " %c";
};
template <>
struct ScanfSpecifier<const char*> {
static constexpr const char* value = "%s";
};
template <>
struct ScanfSpecifier<unsigned long> {
static constexpr const char* value = "%lu";
};
template <>
struct ScanfSpecifier<long long int> {
static constexpr const char* value = "%lld";
};
template <typename T>
int RD(T& arg) {
return std::scanf(ScanfSpecifier<T>::value, &arg);
}
template <int S>
int RD(char (&arg)[S]) {
return std::scanf("%s", arg);
}
template <>
int RD<char*>(char*& arg) {
return std::scanf("%s", arg);
}
template <typename T, typename... Args>
int RD(T& arg1, Args&... args) {
return RD(arg1) + RD(args...);
}
template <typename It>
void RDV(It begin, It end) {
while (begin != end) RD(*begin++);
}
template <typename C>
void RDV(C& c) {
RDV(std::begin(c), std::end(c));
}
template <typename... Args>
void WT(Args... args) {
int alc = 0;
int dummy[] = {((alc++ ? std::printf(" ") : 0),
std::printf(ScanfSpecifier<Args>::value, args), 0)...};
}
template <typename... Args>
void WTL(Args... args) {
WT(args...);
std::printf("\n");
}
template <typename It>
void WTV(It begin, It end) {
int alc = 0;
while (begin != end) (alc++ ? std::printf(" ") : 0), WT(*begin++);
}
template <typename C>
void WTV(const C& c) {
WTV(std::begin(c), std::end(c));
}
template <typename It>
void WTVL(It begin, It end) {
WTV(begin, end);
std::printf("\n");
}
template <typename C>
void WTVL(const C& c) {
WTVL(std::begin(c), std::end(c));
}
const int MOD = 1e9 + 7;
auto POW = XX::powmod<MOD>;
using XX::GT;
using XX::LS;
using XX::UP;
using RG = XX::Range;
using XX::MAKEV;
using namespace std;
int h[1000009];
int n;
int main() {
RD(n);
RDV(h, h + n);
int ans = 0;
ans = h[0] - 1;
int last = h[0] - 1;
int m = 0;
for (int i : RG(1, n)) {
(ans += h[i] - 1) %= MOD;
int now = min(h[i], h[i - 1]) - 1;
(ans += now * 1ll * now % MOD) %= MOD;
m = m * 1ll * POW(last, MOD - 2) % MOD * (min(h[i] - 1, last)) % MOD * now %
MOD;
(ans += m) %= MOD;
(m += now * 1ll * now % MOD) %= MOD;
last = now;
}
WTL(ans);
}
| 7 |
#include<bits/stdc++.h>
#define ll long long int
#define f0n for(ll i=0; i<n; i++)
using namespace std;
const int MAX=2e3+5;
ll dp[MAX][MAX];
ll a[MAX];
ll call(ll l,ll r)
{
if(l==r) return 0;
if(dp[l][r]!=-1) return dp[l][r];
else return dp[l][r]=min(a[r]-a[l]+call(l+1,r),a[r]-a[l]+call(l,r-1));
}
int main()
{
ll n;
cin>>n;
//ll a[i];
f0n cin>>a[i];
sort(a,a+n);
memset(dp,-1,sizeof(dp));
cout<<call(0,n-1)<<endl;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> divs[100100];
void gen_divs(int n) {
for (int i = 2; i <= n; ++i) {
for (int j = i; j <= n; j += i) {
divs[j].push_back(i);
}
}
}
bool on[1001000];
int used[101000], ans[101000];
int chk(int n) {
if (on[n] == 1) return -2;
for (auto el : divs[n])
if (used[el]) return ans[el];
for (auto el : divs[n]) used[el] = 1, ans[el] = n;
on[n] = 1;
return -1;
}
int rem(int n) {
if (on[n] == 0) return -1;
for (auto el : divs[n]) used[el] = 0, ans[el] = n;
on[n] = 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
gen_divs(1e5);
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
char op;
int x;
cin >> op >> x;
if (op == '+') {
int flag = chk(x);
if (flag == -2)
cout << "Already on\n";
else if (flag == -1)
cout << "Success\n";
else
cout << "Conflict with " << flag << "\n";
} else if (op == '-') {
int flag = rem(x);
if (flag == -1)
cout << "Already off\n";
else
cout << "Success\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int md = 998244353;
inline void add(int &a, int b) {
a += b;
if (a >= md) a -= md;
}
inline void sub(int &a, int b) {
a -= b;
if (a < 0) a += md;
}
inline int mul(int a, int b) {
return (int)((long long)a * b % md);
unsigned long long x = (long long)a * b;
unsigned xh = (unsigned)(x >> 32), xl = (unsigned)x, d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(md));
return m;
}
inline int power(int a, long long b) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res;
}
inline int inv(int a) {
a %= md;
if (a < 0) a += md;
int b = md, u = 0, v = 1;
while (a) {
int t = b / a;
b -= t * a;
swap(a, b);
u -= t * v;
swap(u, v);
}
assert(b == 1);
if (u < 0) u += md;
return u;
}
namespace ntt {
int base = 1;
vector<int> roots = {0, 1};
vector<int> rev = {0, 1};
int max_base = -1;
int root = -1;
void init() {
int tmp = md - 1;
max_base = 0;
while (tmp % 2 == 0) {
tmp /= 2;
max_base++;
}
root = 2;
while (true) {
if (power(root, 1 << max_base) == 1) {
if (power(root, 1 << (max_base - 1)) != 1) {
break;
}
}
root++;
}
}
void ensure_base(int nbase) {
if (max_base == -1) {
init();
}
if (nbase <= base) {
return;
}
assert(nbase <= max_base);
rev.resize(1 << nbase);
for (int i = 0; i < (1 << nbase); i++) {
rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (nbase - 1));
}
roots.resize(1 << nbase);
while (base < nbase) {
int z = power(root, 1 << (max_base - 1 - base));
for (int i = 1 << (base - 1); i < (1 << base); i++) {
roots[i << 1] = roots[i];
roots[(i << 1) + 1] = mul(roots[i], z);
}
base++;
}
}
void fft(vector<int> &a) {
int n = (int)a.size();
assert((n & (n - 1)) == 0);
int zeros = __builtin_ctz(n);
ensure_base(zeros);
int shift = base - zeros;
for (int i = 0; i < n; i++) {
if (i < (rev[i] >> shift)) {
swap(a[i], a[rev[i] >> shift]);
}
}
for (int k = 1; k < n; k <<= 1) {
for (int i = 0; i < n; i += 2 * k) {
for (int j = 0; j < k; j++) {
int x = a[i + j];
int y = mul(a[i + j + k], roots[j + k]);
a[i + j] = x + y - md;
if (a[i + j] < 0) a[i + j] += md;
a[i + j + k] = x - y + md;
if (a[i + j + k] >= md) a[i + j + k] -= md;
}
}
}
}
vector<int> multiply(vector<int> a, vector<int> b, int eq = 0) {
int need = (int)(a.size() + b.size() - 1);
int nbase = 0;
while ((1 << nbase) < need) nbase++;
ensure_base(nbase);
int sz = 1 << nbase;
a.resize(sz);
b.resize(sz);
fft(a);
if (eq)
b = a;
else
fft(b);
int inv_sz = inv(sz);
for (int i = 0; i < sz; i++) {
a[i] = mul(mul(a[i], b[i]), inv_sz);
}
reverse(a.begin() + 1, a.end());
fft(a);
a.resize(need);
return a;
}
vector<int> square(vector<int> a) { return multiply(a, a, 1); }
} // namespace ntt
vector<int> adjList[100000];
int parent[100000], size[100000];
int doDFS(int u, int p) {
int i;
parent[u] = p, size[u] = 1;
for (i = 0; i < adjList[u].size(); i++) {
int v = adjList[u][i];
if (v != p) size[u] += doDFS(v, u);
}
return size[u];
}
int down[100000], up[100000];
vector<int> mult(vector<vector<int> > &v, int l, int r) {
if (l == r)
return v[l];
else if (l > r)
return vector<int>(1, 1);
int i;
int mid = (l + r) / 2;
vector<int> ll = mult(v, l, mid), rr = mult(v, mid + 1, r), ans;
vector<int> temp = ntt::multiply(ll, rr);
for (i = 0; i < temp.size(); i++) ans.push_back(temp[i] % 998244353);
return ans;
}
vector<int> p[100000];
int ans = 0;
int doDFS2(int u, int p) {
int i;
int s = 0;
for (i = 0; i < adjList[u].size(); i++) {
int v = adjList[u][i];
if (v != p) {
doDFS2(v, u);
down[u] += down[v], down[u] %= 998244353;
ans += ((long long int)down[v] * up[v]) % 998244353, ans %= 998244353;
ans += ((long long int)s * down[v]) % 998244353, ans %= 998244353;
s += down[v], s %= 998244353;
}
}
return 0;
}
int main() {
int i;
int n, k, a, b;
scanf("%d %d", &n, &k);
for (i = 0; i < n - 1; i++) {
scanf("%d %d", &a, &b);
a--, b--;
adjList[a].push_back(b);
adjList[b].push_back(a);
}
if (k == 1) {
printf("%d\n", ((long long int)n * (n - 1) / 2) % 998244353);
return 0;
}
int j, l;
doDFS(0, -1);
for (i = 0; i < n; i++) {
vector<vector<int> > vv;
for (j = 0; j < adjList[i].size(); j++) {
int v = adjList[i][j];
if (v != parent[i]) {
vector<int> vvv(2);
vvv[0] = size[v], vvv[1] = 1;
vv.push_back(vvv);
} else {
vector<int> vvv(2);
vvv[0] = n - size[i], vvv[1] = 1;
vv.push_back(vvv);
}
}
p[i] = mult(vv, 0, (int)vv.size() - 1);
}
for (i = 0; i < n; i++) {
map<int, int> M;
vector<int> poly = p[i];
if (i > 0) {
for (j = poly.size() - 1; j >= 1; j--)
poly[j - 1] +=
998244353 - (((long long int)(n - size[i]) * poly[j]) % 998244353),
poly[j - 1] %= 998244353;
for (j = 0; j < poly.size() - 1; j++) poly[j] = poly[j + 1];
poly.pop_back();
}
long long int c = 1;
for (j = 0; j < poly.size(); j++) {
down[i] += (poly[poly.size() - j - 1] * c) % 998244353,
down[i] %= 998244353;
c *= k - j, c %= 998244353;
}
M[n - size[i]] = down[i];
for (j = 0; j < adjList[i].size(); j++) {
int v = adjList[i][j];
if (v != parent[i]) {
if (M.count(size[v]))
up[v] = M[size[v]];
else {
vector<int> poly = p[i];
for (l = poly.size() - 1; l >= 1; l--)
poly[l - 1] +=
998244353 - (((long long int)size[v] * poly[l]) % 998244353),
poly[l - 1] %= 998244353;
for (l = 0; l < poly.size() - 1; l++) poly[l] = poly[l + 1];
poly.pop_back();
long long int c = 1;
for (l = 0; l < poly.size(); l++) {
up[v] += (poly[poly.size() - l - 1] * c) % 998244353,
up[v] %= 998244353;
c *= k - l, c %= 998244353;
}
M[size[v]] = up[v];
}
}
}
}
doDFS2(0, -1);
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline bool isvowel(char c) {
c = tolower(c);
if (c == 'a' || c == 'e' || c == 'i' || c == 'y' || c == 'o' || c == 'u')
return 1;
return 0;
}
const double eps = 0.000001;
const long double pi = acos(-1);
const int maxn = 1e7 + 9;
const int mod = 1e9 + 7;
const long long MOD = 1e18 + 9;
const long long INF = 1e18 + 123;
const int inf = 2e9 + 11;
const int mxn = 1e6 + 9;
const int N = 6e5 + 123;
const int M = 22;
const int pri = 997;
const int Magic = 2101;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int n, m, k;
int a[N];
int pr[N][6];
int dp[N][6];
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (int j = 1; j <= 5; j++) dp[1][j] = 1;
for (long long i = 2; i <= n; i++) {
for (int j = 1; j <= 5; j++) {
if (!dp[i - 1][j]) continue;
for (int l = 1; l <= 5; l++) {
if (dp[i][l]) continue;
if (a[i - 1] < a[i] && j < l) {
dp[i][l] = 1;
pr[i][l] = j;
}
if (a[i - 1] > a[i] && j > l) {
dp[i][l] = 1;
pr[i][l] = j;
}
if (a[i - 1] == a[i] && j != l) {
dp[i][l] = 1;
pr[i][l] = j;
}
}
}
}
for (long long j = 1; j <= 5; j++) {
if (dp[n][j]) {
int l = n, last = j;
vector<int> ans;
while (l > 0) {
ans.push_back(last);
last = pr[l][last];
l--;
}
reverse(ans.begin(), ans.end());
for (auto it : ans) cout << it << ' ';
exit(0);
}
}
cout << -1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int maxint = 0x3f3f3f3f;
const int mod = 1e9 + 7;
struct mmp {
int x, y, p;
mmp() {}
mmp(int xx, int yy) { x = xx, y = yy; }
} p[100010];
int n, m, k, sum[100010], l, r, sn, pos[100010];
long long res[1000010], ans, num[2000010];
bool cmp(mmp x, mmp y) {
if (pos[x.x] == pos[y.x])
return x.y < y.y;
else
return pos[x.x] < pos[y.x];
}
int main() {
int i, j, l, r;
cin >> n >> m >> k;
sn = sqrt(n);
for (i = 1; i <= n; i++) {
scanf("%d", &j);
sum[i] = sum[i - 1] ^ j;
pos[i] = (i - 1) / sn + 1;
}
for (i = 1; i <= m; i++) {
scanf("%d%d", &p[i].x, &p[i].y);
p[i].p = i;
}
sort(p + 1, p + m + 1, cmp);
l = 0;
r = 0;
for (i = 1; i <= m; i++) {
while (l < p[i].x - 1) {
num[sum[l]]--;
ans -= num[sum[l] ^ k];
l++;
}
while (l >= p[i].x) {
l--;
ans += num[sum[l] ^ k];
num[sum[l]]++;
}
while (r <= p[i].y) {
ans += num[sum[r] ^ k];
num[sum[r]]++;
r++;
}
while (r > p[i].y + 1) {
r--;
num[sum[r]]--;
ans -= num[sum[r] ^ k];
}
res[p[i].p] = ans;
}
for (i = 1; i <= m; i++) {
printf("%I64d\n", res[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
long long t = 1;
while (t--) {
long long n;
cin >> n;
vector<long long> ar(n), br(n);
for (long long i = 0; i < n; i++) {
cin >> ar[i];
br[i] = ar[i];
}
sort(br.begin(), br.end(), greater<long long>());
long long m;
cin >> m;
while (m--) {
long long k, pos;
cin >> k >> pos;
vector<long long> seq, arr;
arr = ar;
for (long long i = 0; i < k; i++) {
for (long long j = 0; j < n; j++) {
if (arr[j] == br[i]) {
seq.push_back(j);
arr[j] = -1;
break;
}
}
}
sort(seq.begin(), seq.end());
cout << ar[seq[pos - 1]] << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
void input() {
cin >> n;
while (n--) {
int x;
cin >> x;
x == 2 ? a++ : b++;
}
}
void solve() {
int ans = min(a, b);
a -= ans, b -= ans;
cout << (max(a, b) / 3) * (b > 0) + ans << endl;
}
int main() {
input(), solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
int n, l, r;
cin >> n >> l >> r;
int arr1[n];
int arr2[n];
int a[r - l];
int b[r - l];
int index = 0;
for (int i = 0; i < n; i++) {
cin >> arr1[i];
if (i + 1 >= l && i + 1 <= r) {
a[index] = arr1[i];
index++;
}
}
index = 0;
for (int i = 0; i < n; i++) {
cin >> arr2[i];
if (i + 1 >= l && i + 1 <= r) {
b[index] = arr2[i];
index++;
}
}
sort(a, a + (r - l) + 1);
sort(b, b + (r - l) + 1);
for (int i = 0; i <= (r - l); i++) {
if (a[i] != b[i]) {
cout << "LIE" << endl;
return 0;
}
}
for (int i = 0; i < n; i++) {
if (i + 1 < l || i + 1 > r) {
if (arr1[i] != arr2[i]) {
cout << "LIE" << endl;
return 0;
}
}
}
cout << "TRUTH" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
string as, at;
int ls, lt, ss[32], kk, s[5555], t[5555];
void go(int x) {
if (ss[t[x]] == 0 || x == kk && ls <= lt) {
int yy = -1;
for (int i = t[x] + 1; i < 26; ++i)
if (ss[i] > 0) {
yy = i;
break;
}
if (yy < 0) return;
--ss[yy];
for (int i = 0; i < x; ++i) putchar(t[i] + 97);
putchar(yy + 97);
for (int i = 0; i < 26; ++i)
for (int j = 0; j < ss[i]; ++j) putchar(i + 97);
exit(0);
}
--ss[t[x]];
if (x == kk) {
for (int i = 0; i <= x; ++i) putchar(t[i] + 97);
for (int i = 0; i < 26; ++i)
for (int j = 0; j < ss[i]; ++j) putchar(i + 97);
exit(0);
}
go(x + 1);
++ss[t[x]];
int yy = -1;
for (int i = t[x] + 1; i < 26; ++i)
if (ss[i] > 0) {
yy = i;
break;
}
if (yy < 0) return;
--ss[yy];
for (int i = 0; i < x; ++i) putchar(t[i] + 97);
putchar(yy + 97);
for (int i = 0; i < 26; ++i)
for (int j = 0; j < ss[i]; ++j) putchar(i + 97);
exit(0);
}
int main() {
getline(cin, as);
getline(cin, at);
ls = as.length();
lt = at.length();
kk = min(ls, lt) - 1;
memset(ss, 0, sizeof(ss));
for (int i = 0; i < ls; ++i) {
s[i] = as[i] - 97;
++ss[s[i]];
}
for (int i = 0; i < lt; ++i) t[i] = at[i] - 97;
go(0);
printf("-1");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int toI(string s) { return (s[0] - '0') * 256 + (s[1] - '0'); }
string toS(int i) {
string result(1, '0' + i / 256);
result += (char)('0' + i % 256);
return result;
}
pair<int, int> getNodes(string s) {
return pair<int, int>{toI(s.substr(0, 2)), toI(s.substr(1, 2))};
}
int main() {
int n;
cin >> n;
string temp;
getline(cin, temp);
vector<vector<int>> aL(256 * 256);
map<int, int> C;
set<int> V;
for (int i = 0; i < n; i++) {
getline(cin, temp);
pair<int, int> nodes = getNodes(temp);
aL[nodes.first].push_back(nodes.second);
C[nodes.second]++;
}
int start = -1;
vector<int> cType(3);
bool valid = true;
for (int i = 0; i < aL.size(); i++) {
if (aL[i].empty()) continue;
if (start == -1 or aL[i].size() - C[i] == 1) start = i;
int diff = aL[i].size() - C[i];
if (diff < -1 or diff > 1) {
valid = false;
break;
}
cType[diff + 1]++;
}
if (cType[0] > 1 or cType[2] > 1) valid = false;
deque<int> Q{start};
V.insert(start);
while (!Q.empty()) {
int curr = Q.front();
Q.pop_front();
for (int j : aL[curr]) {
if (V.count(j)) continue;
V.insert(j);
Q.push_back(j);
}
}
for (int i = 0; i < aL.size(); i++) {
if (!aL[i].empty() and !V.count(i)) valid = false;
}
if (!valid) {
cout << "NO" << endl;
return 0;
}
vector<int> P, revP;
P.push_back(start);
while (!P.empty()) {
int curr = P.back();
if (!aL[curr].empty()) {
int next = aL[curr].back();
aL[curr].pop_back();
P.push_back(next);
} else {
revP.push_back(curr);
P.pop_back();
}
}
reverse(revP.begin(), revP.end());
cout << "YES" << endl;
string result = toS(revP[0]);
for (int i = 1; i < revP.size(); i++) result += toS(revP[i])[1];
cout << result << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long Bin_expo(long long n, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res *= n;
n *= n;
b /= 2;
}
return res;
}
const long long Mod = 998244353;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tc;
cin >> tc;
while (tc--) {
long long n;
cin >> n;
vector<long long> v(n);
long long m = 0;
map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
cin >> v[i];
mp[v[i]]++;
}
long long cnt = 0;
vector<long long> res;
while (1) {
while (mp[m] > 0) {
m++;
}
long long ind = -1;
if (m >= n - 1) {
ind = n - 1;
if (v[ind] == n) {
long long k = 0;
while (v[k] == k) k++;
ind = k;
}
} else {
ind = m;
}
if (ind != -1 && ind < n) {
res.push_back(ind + 1);
mp[v[ind]]--;
v[ind] = m;
mp[m]++;
}
m = 0;
long long f = 0;
for (long long i = 0; i + 1 < n; i++) {
if (v[i] > v[i + 1]) {
f = 1;
break;
}
}
if (f == 0) break;
}
cout << res.size() << "\n";
for (long long i = 0; i < res.size(); i++) cout << res[i] << " ";
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000;
long long t, n, k, kol[5];
string s;
bool f;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
for (long long o = 1; o <= t; ++o) {
cin >> n >> k;
cin >> s;
kol[0] = kol[1] = 0;
for (long long i = 0; i < k; ++i)
if (s[i] != '?') ++kol[s[i] - '0'];
f = true;
if (kol[0] > k / 2 || kol[1] > k / 2) {
cout << "NO\n";
continue;
}
if (kol[0] == k / 2) {
for (long long i = 0; i < k; ++i)
if (s[i] == '?') s[i] = '1';
} else if (kol[1] == k / 2) {
for (long long i = 0; i < k; ++i)
if (s[i] == '?') s[i] = '0';
}
for (long long i = k; i < n; ++i) {
if (s[i - k] != '?') --kol[s[i - k] - '0'];
if (s[i] != '?') ++kol[s[i] - '0'];
if (s[i - k] == '1' && s[i] == '?') {
++kol[1];
s[i] = '1';
}
if (s[i - k] == '0' && s[i] == '?') {
++kol[0];
s[i] = '0';
}
if (kol[0] > k / 2 || kol[1] > k / 2 ||
(s[i - k] == '0' && s[i] == '1') ||
(s[i - k] == '1' && s[i] == '0')) {
f = false;
break;
}
}
if (f)
cout << "YES";
else
cout << "NO";
cout << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int MAXN = 100;
const int INF = 0x3f3f3f3f;
using namespace std;
inline int read() {
int x = 0, w = 1;
char c = ' ';
while (c < '0' || c > '9') {
c = getchar();
if (c == '-') w = -1;
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * w;
}
struct Node {
int to, w, nxt;
} edge[MAXN * MAXN + 5];
bool flag;
class Graph {
public:
Graph() {
memset(head, -1, sizeof(head)), tot = 0;
memset(dp, -1, sizeof(dp));
}
void add(int u, int v, int w);
bool dfs(int x, int y, int turn, int last);
private:
int tot, head[MAXN + 5], dp[MAXN + 5][MAXN + 5][3][27];
} G;
void Graph ::add(int u, int v, int w) {
edge[tot] = (Node){v, w, head[u]}, head[u] = tot++;
}
bool Graph ::dfs(int x, int y, int turn, int last) {
if (dp[x][y][turn][last] != -1) return dp[x][y][turn][last];
int flag = false;
if (!turn)
for (int i = head[x]; ~i; i = edge[i].nxt) {
int v = edge[i].to, w = edge[i].w;
if (w >= last) flag |= !dfs(v, y, !turn, w);
}
else
for (int i = head[y]; ~i; i = edge[i].nxt) {
int v = edge[i].to, w = edge[i].w;
if (w >= last) flag |= !dfs(x, v, !turn, w);
}
dp[x][y][turn][last] = flag;
return dp[x][y][turn][last];
}
int main() {
int n = read(), e = read();
for (int i = 1; i <= e; ++i) {
int u = read(), v = read();
char c;
cin >> c;
G.add(u, v, c - 'a');
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
flag = G.dfs(i, j, 0, -1);
if (flag)
cout << 'A';
else
cout << 'B';
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MAX_N = (int)1e5 + 123;
const double eps = 1e-6;
const int inf = (int)1e9 + 123;
using namespace std;
struct P {
int x, l, r;
P() {}
P(int x, int l, int r) : x(x), l(l), r(r) {}
};
vector<P> T;
int n, k;
string second;
bool d[105][5];
int moves[3][2] = {{0, 1}, {1, 1}, {-1, 1}};
bool check(int x, int y, int t) {
for (auto i : T) {
if (i.x != x) continue;
int l = i.l - t * 2, r = i.r - t * 2;
if (y >= l && y <= r) return 0;
}
return 1;
}
void solve() {
T.clear();
cin >> n >> k;
memset(d, 0, sizeof d);
for (int i = 0; i < 3; i++) {
cin >> second;
for (int j = 0; j < n;) {
if (second[j] == 's') {
d[0][i] = 1;
j++;
continue;
}
if (second[j] != '.') {
int k = j;
while (k + 1 < n && second[k + 1] == second[j]) k++;
T.push_back(P(i, j, k));
j = k + 1;
} else {
j++;
}
}
}
for (int i = 0; i + 1 < n; i++) {
for (int j = 0; j < 3; j++) {
if (!d[i][j]) continue;
for (int k = 0; k < 3; k++) {
int x = j + moves[k][0], y = i + moves[k][1];
if (x >= 0 && x < 3 && y >= 0 && y < n && check(x, y, y - 1) &&
check(j, y, y - 1) && check(x, y, y))
d[y][x] = 1;
}
}
}
if (d[n - 1][0] || d[n - 1][1] || d[n - 1][2])
printf("YES\n");
else
printf("NO\n");
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(NULL);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
ll mtr[600][600];
ll n,m,k;
int main()
{
int n,m;
cin>>n>>m;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
cin>>mtr[i][j];
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
if((i+j)&1)
{
cout<<720720+mtr[i][j]*mtr[i][j]*mtr[i][j]*mtr[i][j]<<" ";
}else
cout<<720720<<" ";
}
cout<<endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const int NMAX = 3e5 + 3;
int n;
int arr[NMAX];
vector<vector<int>> adj;
pair<int, int> cnt[NMAX];
int ans = 0;
pair<int, int> dfs1(int u, int par) {
if (arr[u] == 1)
cnt[u] = {1, 0};
else if (arr[u] == 2)
cnt[u] = {0, 1};
for (auto it : adj[u]) {
if (it != par) {
pair<int, int> tmp = dfs1(it, u);
cnt[u] = {tmp.first + cnt[u].first, tmp.second + cnt[u].second};
}
}
return cnt[u];
}
void dfs(int u, int par) {
for (auto it : adj[u]) {
if (it != par) {
dfs(it, u);
pair<int, int> tmp = {cnt[0].first - cnt[it].first,
cnt[0].second - cnt[it].second};
if ((!tmp.first or !tmp.second) and (!cnt[it].first or !cnt[it].second))
ans++;
}
}
}
void solve() {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
adj = vector<vector<int>>(n);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs1(0, 0);
dfs(0, 0);
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 11;
int dp[N][N][N];
pair<pair<int, int>, pair<int, int> > pr[N][N][N];
vector<pair<int, pair<int, int> > > vv;
int n, m;
void up(int l, int r, int k, int ans, int c1, int c2, int c3, int c4) {
if (k < 0 || k > max(n, m)) return;
if (dp[l][r][k] != -1) return;
dp[l][r][k] = ans;
pr[l][r][k] = make_pair(make_pair(c1, c2), make_pair(c3, c4));
vv.push_back(make_pair(l, make_pair(r, k)));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, t;
cin >> s >> t;
n = s.size();
m = t.size();
s = "." + s;
t = "." + t;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++)
for (int bal = 0; bal <= max(n, m); bal++) dp[i][j][bal] = -1;
dp[0][0][0] = 0;
vv.push_back(make_pair(0, make_pair(0, 0)));
for (int j = 0; j < vv.size(); j++) {
int l = vv[j].first;
int r = vv[j].second.first;
int k = vv[j].second.second;
int ans = dp[l][r][k] + 1;
up(l, r, k + 1, ans, 1, l, r, k);
up(l, r, k - 1, ans, -1, l, r, k);
if (l < n && r < m && s[l + 1] == '(' && t[r + 1] == '(')
up(l + 1, r + 1, k + 1, ans, 1, l, r, k);
if (l < n && r < m && s[l + 1] == ')' && t[r + 1] == ')')
up(l + 1, r + 1, k - 1, ans, -1, l, r, k);
if (l < n && s[l + 1] == '(') up(l + 1, r, k + 1, ans, 1, l, r, k);
if (l < n && s[l + 1] == ')') up(l + 1, r, k - 1, ans, -1, l, r, k);
if (r < m && t[r + 1] == '(') up(l, r + 1, k + 1, ans, 1, l, r, k);
if (r < m && t[r + 1] == ')') up(l, r + 1, k - 1, ans, -1, l, r, k);
}
string ans = "";
int k = 0;
while (n != 0 || m != 0 || k != 0) {
pair<pair<int, int>, pair<int, int> > p = pr[n][m][k];
if (p.first.first == 1)
ans += "(";
else
ans += ")";
n = p.first.second;
m = p.second.first;
k = p.second.second;
}
reverse(ans.begin(), ans.end());
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a, b;
using item = pair<int, vector<char>>;
item f(long long a, long long b) {
if (a > b) return {1e9, vector<char>()};
if (a == b) return {0, vector<char>()};
item val = f(a * 2, b);
item val2 = f((10 * a) + 1, b);
if (val.first < val2.first) {
val.first++;
val.second.push_back('*');
return val;
} else {
val2.first++;
val2.second.push_back('+');
return val2;
}
}
int main() {
cin >> a >> b;
item ans = f(a, b);
reverse(ans.second.begin(), ans.second.end());
if (ans.first >= 1e9) {
cout << "NO\n";
} else {
cout << "YES\n";
cout << ans.first + 1 << endl;
cout << a << " ";
for (int i = 0; i < ans.first; i++) {
if (ans.second[i] == '*')
a *= 2;
else
a = (10 * a) + 1;
cout << a << " ";
}
}
cout << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, cnt = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 1) {
cnt++;
} else if (a[i] % 2 == -1) {
cnt--;
}
}
cnt /= 2;
if (cnt > 0) {
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 1) {
a[i] += 1;
cnt--;
}
if (!cnt) {
break;
}
}
for (int i = 0; i < n; i++) {
cout << a[i] / 2 << "\n";
}
} else if (cnt < 0) {
for (int i = 0; i < n; i++) {
if (a[i] % 2 == -1) {
a[i] -= 1;
cnt++;
}
if (!cnt) {
break;
}
}
for (int i = 0; i < n; i++) {
cout << a[i] / 2 << "\n";
}
} else {
for (int i = 0; i < n; i++) {
cout << a[i] / 2 << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int c[333];
char s[111111];
long long r;
int main() {
gets(s);
for (int i = r = 0; s[i]; i++) c[s[i]]++;
for (int i = 1; i < 200; i++) r += 1LL * c[i] * c[i];
printf("%I64d\n", r);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void dfs(vector<vector<long double> > &graph, vector<long double> &vis,
long long n) {
for (long long i = 0; i < graph[n].size(); i++) {
if (!vis[graph[n][i]]) {
vis[graph[n][i]] = 1;
dfs(graph, vis, graph[n][i]);
}
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
string na, ma;
cin >> na >> ma;
vector<vector<long double> > graph(n * m);
for (long long i = 0; i < n * m; i++) {
long long r = i / m, c = i % m;
if (na[r] == '>') {
if (c + 1 < m) graph[i].push_back(i + 1);
} else {
if (c > 0) graph[i].push_back(i - 1);
}
if (ma[c] == '^') {
if (r > 0) graph[i].push_back(i - m);
} else {
if (r < n - 1) graph[i].push_back(i + m);
}
}
for (long long i = 0; i < n * m; i++) {
vector<long double> vis(n * m, 0);
vis[i] = 1;
dfs(graph, vis, i);
for (long long j = 0; j < n * m; j++) {
if (vis[j] == 0) {
cout << "NO";
return 0;
}
}
}
cout << "YES";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void File() {
freopen("output.txt", "w", stdout);
freopen("input.txt", "r", stdin);
}
void fast() {
ios::sync_with_stdio(NULL);
cout.tie(NULL);
cin.tie(NULL);
}
const double pi = 2 * acos(0.0);
const int oo = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int nn = 1e2 + 15;
int dx[8] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[8] = {0, 0, 1, -1, -1, 1, 1, -1};
int n, m;
char arr[nn][nn];
int vis[nn][nn];
bool valid(int r, int c) {
if (r >= 0 && r < n && c >= 0 && c < m) return 1;
return 0;
}
void connectedComponent(int r, int c) {
if (!valid(r, c) || vis[r][c] || arr[r][c] != '#') return;
vis[r][c] = 1;
for (int i = 0; i < 4; i++) connectedComponent(r + dx[i], c + dy[i]);
}
int solve() {
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == '#' && !vis[i][j]) {
cnt++;
connectedComponent(i, j);
}
}
}
return cnt;
}
int main() {
fast();
cin >> n >> m;
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
if (arr[i][j] == '#') cnt++;
}
}
if (cnt < 3) return cout << -1 << "\n", 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == '#') {
arr[i][j] = '.';
memset(vis, 0, sizeof vis);
if (solve() > 1) return cout << 1 << "\n", 0;
arr[i][j] = '#';
}
}
}
cout << 2 << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
long long T[101000];
int F[101000];
vector<set<int> > V;
long long Gr[101000];
long long In[101000];
struct Com1 {
bool operator()(int a, int b) const;
};
struct Com2 {
bool operator()(int a, int b) const;
};
struct Com3 {
bool operator()(int a, int b) const;
};
vector<set<int, Com1> > Rank;
set<int, Com2> Rankg;
set<int, Com3> Rankgmin;
bool Com1::operator()(int a, int b) const {
if (In[a] == In[b]) return a < b;
return In[a] > In[b];
}
long long getMax(int a) {
return (Rank[a].size() == 0 ? 0 : Gr[a] + In[*(Rank[a].begin())]);
}
long long getMin(int a) {
return (Rank[a].size() == 0 ? 1000000000000000000ll
: Gr[a] + In[*(Rank[a].rbegin())]);
}
bool Com2::operator()(int a, int b) const {
long long gma = getMax(a);
long long gmb = getMax(b);
if (gma == gmb) return a < b;
return gma > gmb;
}
bool Com3::operator()(int a, int b) const {
long long gma = getMin(a);
long long gmb = getMin(b);
if (gma == gmb) return a < b;
return gma < gmb;
}
void wywal(int x) {
Rankg.erase(F[x]);
Rankgmin.erase(F[x]);
Rankg.erase(x);
Rankgmin.erase(x);
Rank[F[x]].erase(x);
}
void wstaw(int x) {
Rankg.erase(F[x]);
Rankgmin.erase(F[x]);
Rank[F[x]].insert(x);
Rankg.insert(F[x]);
Rankgmin.insert(F[x]);
Rankg.insert(x);
Rankgmin.insert(x);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> q;
V.resize(n + 100);
Rank.resize(n + 100);
for (int i = 1; i <= n; ++i) cin >> T[i];
int f;
for (int i = 1; i <= n; ++i) {
cin >> f;
F[i] = f;
V[f].insert(i);
}
for (int i = 1; i <= n; ++i) {
long long k = V[i].size();
Gr[i] = T[i] / (k + 2);
In[F[i]] += Gr[i];
In[i] += T[i] - (k + 1) * Gr[i];
}
for (int i = 1; i <= n; ++i) Rank[F[i]].insert(i);
for (int i = 1; i <= n; ++i) {
Rankg.insert(i);
Rankgmin.insert(i);
}
int type;
for (int i = 0; i < q; ++i) {
cin >> type;
if (type == 1) {
int c, newf, oldf;
cin >> c >> newf;
oldf = F[c];
int newff = F[newf];
int oldff = F[oldf];
long long ko = Rank[oldf].size();
long long kn = Rank[newf].size();
wywal(c);
wywal(oldf);
wywal(oldff);
wywal(newf);
wywal(newff);
In[oldf] -= Gr[c];
In[oldff] -= Gr[oldf];
In[newff] -= Gr[newf];
In[newf] += Gr[c];
In[oldf] -= T[oldf] - (ko + 1) * Gr[oldf];
Gr[oldf] = T[oldf] / (ko + 1);
In[newf] -= T[newf] - (kn + 1) * Gr[newf];
Gr[newf] = T[newf] / (kn + 3);
In[oldff] += Gr[oldf];
In[oldf] += T[oldf] - ko * Gr[oldf];
In[newff] += Gr[newf];
In[newf] += T[newf] - (kn + 2) * Gr[newf];
F[c] = newf;
wstaw(c);
wstaw(oldf);
wstaw(oldff);
wstaw(newf);
wstaw(newff);
Rankg.insert(oldf);
Rankgmin.insert(oldf);
}
if (type == 2) {
int x;
cin >> x;
cout << In[x] + Gr[F[x]] << endl;
}
if (type == 3) {
int grupa = *Rankg.begin();
int grupa2 = *Rankgmin.begin();
cout << In[(*Rank[grupa2].rbegin())] + Gr[grupa2] << ' ';
cout << In[(*Rank[grupa].begin())] + Gr[grupa] << endl;
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1003;
bool a[maxn], b[maxn];
inline int get() {
int f = 0, v = 0;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') break;
if (ch == '-')
f = 1;
else
v = ch - 48;
while (isdigit(ch = getchar())) v = v * 10 + ch - 48;
if (f == 1)
return -v;
else
return v;
}
inline double getd() {
double d = 0, d2 = 0, d3 = 1;
char ch;
bool flag = 0;
while (!isdigit(ch = getchar()))
if (ch == '-') break;
if (ch == '-')
flag = true;
else
d = ch - 48;
while (isdigit(ch = getchar())) d = d * 10 + ch - 48;
if (ch == '.') {
while (isdigit(ch = getchar())) d2 = d2 * 10 + ch - 48, d3 = d3 * 0.1;
d += d3 * d2;
}
if (flag)
return -d;
else
return d;
}
inline void write(int x) {
int _ = x, len = 0, p[20];
if (_ < 0) putchar('-'), _ = -_;
while (_) p[++len] = _ % 10, _ /= 10;
if (!x) p[++len] = 0;
while (len) putchar(p[len--] + '0');
}
inline void writeln(int x) {
write(x);
puts("");
}
int main() {
int n = get(), m = get();
for (int i = 1; i <= m; i++) a[get()] = 1, b[get()] = 1;
int ans = 0;
for (int i = 2; i < n; i++) ans += !a[i], ans += !b[i];
m = n / 2 + 1;
if (n % 2 == 1 && !a[m] && !b[m]) ans--;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d;
scanf("%I64d%I64d%I64d%I64d", &a, &b, &c, &d);
char x, y, z;
cin >> x >> y >> z;
int s1 = 0, s2 = 0;
if (x == '+')
s1++;
else
s2++;
if (y == '+')
s1++;
else
s2++;
if (z == '+')
s1++;
else
s2++;
if (s1 == 3) {
printf("%I64d\n", a + b + c + d);
}
if (s2 == 3) {
printf("%I64d\n", a * b * c * d);
}
if (s1 == 1 && s2 == 2) {
long long mm = 3000000000000;
long long a1 = 0;
if (x == '*' && y == '*' && z == '+') {
a1 = a * b + c * d;
if (a1 < mm) mm = a1;
a1 = a * c + b * d;
if (a1 < mm) mm = a1;
a1 = a * d + c * b;
if (a1 < mm) mm = a1;
a1 = a * b * c + d;
if (a1 < mm) mm = a1;
a1 = a * c * d + b;
if (a1 < mm) mm = a1;
a1 = a * b * d + c;
if (a1 < mm) mm = a1;
a1 = b * c * d + a;
if (a1 < mm) mm = a1;
}
if (x == '+' && y == '*' && z == '*') {
a1 = (a + b) * c * d;
if (a1 < mm) mm = a1;
a1 = (a + c) * b * d;
if (a1 < mm) mm = a1;
a1 = (a + d) * c * b;
if (a1 < mm) mm = a1;
a1 = (b + c) * a * d;
if (a1 < mm) mm = a1;
a1 = (b + d) * a * c;
if (a1 < mm) mm = a1;
a1 = (c + d) * a * b;
if (a1 < mm) mm = a1;
}
if (x == '*' && y == '+' && z == '*') {
a1 = (a * b + c) * d;
if (a1 < mm) mm = a1;
a1 = (a * b + d) * c;
if (a1 < mm) mm = a1;
a1 = (a * b) * (c + d);
if (a1 < mm) mm = a1;
a1 = (a * c + b) * d;
if (a1 < mm) mm = a1;
a1 = (a * c + d) * b;
if (a1 < mm) mm = a1;
a1 = (a * c) * (b + d);
if (a1 < mm) mm = a1;
a1 = (a * d + c) * b;
if (a1 < mm) mm = a1;
a1 = (a * d + b) * c;
if (a1 < mm) mm = a1;
a1 = (a * d) * (b + c);
if (a1 < mm) mm = a1;
a1 = (b * c + a) * d;
if (a1 < mm) mm = a1;
a1 = (b * c + d) * a;
if (a1 < mm) mm = a1;
a1 = (b * c) * (a + d);
if (a1 < mm) mm = a1;
a1 = (b * d + c) * a;
if (a1 < mm) mm = a1;
a1 = (b * d + a) * c;
if (a1 < mm) mm = a1;
a1 = (b * d) * (a + c);
if (a1 < mm) mm = a1;
a1 = (c * d + a) * b;
if (a1 < mm) mm = a1;
a1 = (c * d + b) * a;
if (a1 < mm) mm = a1;
a1 = (c * d) * (a + b);
if (a1 < mm) mm = a1;
}
printf("%I64d\n", mm);
}
if (s1 == 2 && s2 == 1) {
long long mm = 3000000000000;
long long a1 = 0;
if (x == '*' && y == '+' && z == '+') {
a1 = c * d + a + b;
if (a1 < mm) mm = a1;
a1 = b * c + a + d;
if (a1 < mm) mm = a1;
a1 = b * d + a + c;
if (a1 < mm) mm = a1;
a1 = a * b + c + d;
if (a1 < mm) mm = a1;
a1 = a * c + b + d;
if (a1 < mm) mm = a1;
a1 = a * d + b + c;
if (a1 < mm) mm = a1;
}
if (x == '+' && y == '+' && z == '*') {
a1 = (a + b + c) * d;
if (a1 < mm) mm = a1;
a1 = (a + c + d) * b;
if (a1 < mm) mm = a1;
a1 = (a + b + d) * c;
if (a1 < mm) mm = a1;
a1 = (b + c + d) * a;
if (a1 < mm) mm = a1;
}
if (x == '+' && y == '*' && z == '+') {
a1 = (a + b) * c + d;
if (a1 < mm) mm = a1;
a1 = (a + b) + c * d;
if (a1 < mm) mm = a1;
a1 = (a + b) * d + c;
if (a1 < mm) mm = a1;
a1 = (a + c) * d + b;
if (a1 < mm) mm = a1;
a1 = (a + c) * b + d;
if (a1 < mm) mm = a1;
a1 = (a + c) + b * d;
if (a1 < mm) mm = a1;
a1 = (a + d) * b + c;
if (a1 < mm) mm = a1;
a1 = (a + d) * c + b;
if (a1 < mm) mm = a1;
a1 = (a + d) + c * b;
if (a1 < mm) mm = a1;
a1 = (b + c) * a + d;
if (a1 < mm) mm = a1;
a1 = (b + c) * d + a;
if (a1 < mm) mm = a1;
a1 = (b + c) + a * d;
a1 = (b + d) * a + c;
if (a1 < mm) mm = a1;
a1 = (b + d) * c + a;
if (a1 < mm) mm = a1;
a1 = (b + d) + a * c;
if (a1 < mm) mm = a1;
a1 = (c + d) * a + b;
if (a1 < mm) mm = a1;
a1 = (c + d) * b + a;
if (a1 < mm) mm = a1;
a1 = (c + d) + b * a;
if (a1 < mm) mm = a1;
}
printf("%I64d\n", mm);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int t, f, w;
bool operator<(const edge& e) const { return w > e.w; }
edge(int from, int to, int weight) {
t = to;
f = from;
w = weight;
}
};
const double EPS = (1e-5);
struct line {
double a, b, c;
};
struct point {
double x, y;
point() { x = y = 0.0; }
point(double _x, double _y) : x(_x), y(_y) {}
bool operator==(point other) const {
return (fabs(x - other.x) < EPS && (fabs(y - other.y) < EPS));
}
};
double dist(point p1, point p2) {
return fabs(p1.x - p2.x) * fabs(p1.x - p2.x) +
fabs(p1.y - p2.y) * fabs(p1.y - p2.y);
}
void pointsToLine(point p1, point p2, line& l) {
if (fabs(p1.x - p2.x) < EPS) {
l.a = 1.0;
l.b = 0.0;
l.c = -p1.x;
} else {
l.a = -(double)(p1.y - p2.y) / (p1.x - p2.x);
l.b = 1.0;
l.c = -(double)(l.a * p1.x) - p1.y;
}
}
bool areParallel(line l1, line l2) {
return (fabs(l1.a - l2.a) < EPS) && (fabs(l1.b - l2.b) < EPS);
}
bool areSame(line l1, line l2) {
return areParallel(l1, l2) && (fabs(l1.c - l2.c) < EPS);
}
bool areIntersect(line l1, line l2, point& p) {
if (areParallel(l1, l2)) return false;
p.x = (l2.b * l1.c - l1.b * l2.c) / (l2.a * l1.b - l1.a * l2.b);
if (fabs(l1.b) > EPS)
p.y = -(l1.a * p.x + l1.c);
else
p.y = -(l2.a * p.x + l2.c);
return true;
}
long long binpowmod(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
int findXOR(int n) {
switch (n % 4) {
case 0:
return n;
case 1:
return 1;
case 2:
return n + 1;
case 3:
return 0;
}
}
int rangeXOR(int l, int r) { return (findXOR(l - 1) ^ findXOR(r)); }
int getbit(int mask, int bit) { return (mask & (1 << bit)); }
void setbit(int& mask, int bit, int val) {
if (val)
mask |= (1 << bit);
else
mask &= ~(1 << bit);
}
const int N = 1e5 + 10;
const int M = 2e5 + 10;
const long long INF = 9999999;
int BIT[N];
void update(int x, int val) {
++x;
while (x <= N) {
BIT[x] += val;
x += (x & -x);
}
}
int query(int x) {
++x;
int res = 0;
while (x > 0) {
res += BIT[x];
x -= (x & -x);
}
return res;
}
void solve() {
int n;
cin >> n;
cout << setprecision(10) << fixed << 1 / (2 * sin(acos(-1) / 4 / n)) << endl;
}
int main(void) {
int tc = 1;
cin >> tc;
while (tc--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2, s;
cin >> s1 >> s2;
int i = 0;
int k = 0;
while (i < s1.size()) {
if (s1[i] != s2[i]) {
k++;
if (k & 1)
if (s1[i] == '1')
s += "0";
else
s += "1";
else if (s2[i] == '1')
s += "0";
else
s += "1";
} else
s += s1[i];
i++;
}
if (k % 2 != 0)
cout << "impossible";
else
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int N, K, L;
int A[10005];
int Pos[25];
struct E {
int V, Next;
} Edge[2500005];
int EdgeTop;
int Head[10005];
void Add(int U, int V) {
Edge[++EdgeTop] = (E){V, Head[U]};
Head[U] = EdgeTop;
}
void Init() {
int X;
Get(N);
Get(K);
Get(L);
for (int i = 1; i <= K; i++) {
Get(X);
A[X] = 1;
}
N++;
for (int i = N; i >= 1; i--) {
A[i] = (A[i] != A[i - 1]);
}
K = 0;
for (int i = 1; i <= N; i++) {
if (A[i] == 1) {
K++;
Pos[K] = i;
}
}
for (int k = 1, W; k <= L; k++) {
Get(W);
for (int i = 1, j = W + 1; j <= N; i++, j++) {
Add(i, j);
Add(j, i);
}
}
}
int F[10005];
int Visited[10005];
int Queue[15005];
void SPFA(int X) {
memset(F, 0x2f, sizeof F);
int L, R;
Queue[L = R = 1] = X;
F[X] = 0;
Visited[X] = 1;
for (;;) {
for (int i = Head[Queue[L]]; i; i = Edge[i].Next) {
if (F[Edge[i].V] > F[Queue[L]] + 1) {
F[Edge[i].V] = F[Queue[L]] + 1;
if (!Visited[Edge[i].V]) {
Visited[Edge[i].V] = 1;
R++;
if (R > 15000) R = 1;
Queue[R] = Edge[i].V;
}
}
}
Visited[Queue[L]] = 0;
if (L == R) break;
L++;
if (L > 15000) L = 1;
}
}
int W[25][25];
int G[1048605];
int DP(int i) {
if (G[i] != -1) return G[i];
G[i] = 0x2f2f2f2f;
int Min = 0;
for (int k = K; k >= 1; k--) {
if ((((i) >> (k - 1)) & 1)) Min = k;
}
for (int k = K; k >= 1; k--)
if (((((i) >> (k - 1)) & 1)) && k != Min) {
int Ans0 = DP(i & ~((1) << (k - 1)) & ~((1) << (Min - 1))) + W[Min][k];
if (G[i] > Ans0) G[i] = Ans0;
}
return G[i];
}
int Ans;
void Work() {
for (int k = 1; k <= K; k++) {
SPFA(Pos[k]);
for (int p = 1; p <= K; p++) W[k][p] = F[Pos[p]];
}
memset(G, 0xff, sizeof G);
G[0] = 0;
Ans = DP((1 << K) - 1);
}
void Output() {
if (Ans >= 0x2f2f2f2f)
puts("-1");
else
printf("%d\n", Ans);
}
int main() {
Init();
Work();
Output();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int modpow(int b, int e) {
int a = 1;
while (e) {
if (e & 1) a = 1LL * a * b % MOD;
b = 1LL * b * b % MOD;
e >>= 1;
}
return a;
}
int dp[5000001];
int sieve[5000001];
void precompute() {
for (int i = 2; i <= 5000000; ++i) {
if (sieve[i]) continue;
for (int j = i; j <= 5000000; j += i) {
if (sieve[j]) continue;
sieve[j] = i;
}
}
dp[1] = 0;
for (int i = 2; i <= 5000000; ++i)
dp[i] = (1LL * i * (sieve[i] - 1) / 2 + dp[i / sieve[i]]) % MOD;
}
void solve() {
precompute();
int t, l, r;
cin >> t >> l >> r;
int ans = 0;
for (int i = l; i <= r; ++i)
ans = (ans + 1LL * modpow(t, i - l) * dp[i]) % MOD;
cout << ans << '\n';
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int oo = 0x7fffffff;
const long long OO = 0x7fffffffffffffff;
template <class T>
std::ostream& operator<<(std::ostream& O, const std::vector<T>& V) {
for (const T& x : V) O << x << " ";
O << "\n";
return O;
}
template <class T1, class T2>
std::ostream& operator<<(std::ostream& O, const std::pair<T1, T2>& P) {
return O << "(" << P.first << ", " << P.second << ")";
}
std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
using namespace std;
const int M = 'z' - 'a' + 1;
void sum(string& A, const string& B, int r = 0) {
int l = A.size();
for (int i = 0, x; i < l; ++i) {
x = (A[i] + B[i] - 'a' - 'a' + r);
r = x / M;
x %= M;
A[i] = x + 'a';
}
if (r) A += char(r + 'a');
}
void div2(string& A) {
reverse(A.begin(), A.end());
string B;
int r = 0, l = A.size();
for (int i = 0, x; i < l; ++i) {
x = A[i] + r * M - 'a';
r = x % 2;
x /= 2;
B += char('a' + x);
}
A = B;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
;
int n;
cin >> n;
string A, B;
cin >> A >> B;
reverse(A.begin(), A.end());
reverse(B.begin(), B.end());
;
;
sum(A, B);
;
div2(A);
;
if (A.size() > n) A.erase(0, 1);
cout << A << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, p = 0, n = 0, x, t;
cin >> N;
t = N;
while (t--) {
cin >> x;
if (x > 0)
p++;
else if (x < 0)
n++;
}
if (p >= (N + 1) / 2)
cout << 1;
else if (n >= (N + 1) / 2)
cout << -1;
else
cout << 0;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define fo(i,n) for(int i=0;i<n;i++)
#define Fo(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define int long long
#define pqb priority_queue<int>
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define vi vector<int>
#define vvi vector<vi>
#define mii map<int,int>
#define pqs priority_queue<int,vi,greater<int> >
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x,y) fixed<<setprecision(y)<<x
#define mk(arr,n,type) type *arr=new type[n];
#define w(x) int x; cin>>x; while(x--)
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
int mod_add(int x, int y, int m) {x = x % m; y = y % m; return (((x + y) % m) + m) % m;}
int mod_mul(int x, int y, int m) {x = x % m; y = y % m; return (((x * y) % m) + m) % m;}
int mod_sub(int x, int y, int m) {x = x % m; y = y % m; return (((x - y) % m) + m) % m;}
int fact(int n);
int mpow(int base, int exp);
void addEdge(vvi& g,int n, int m);
void c_p_c()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
//===================================== MAIN ======================================================
//===================================== MAIN ======================================================
bool check(string str,int n){
vi freq(26,0);
for(int i=0;i<n;i++){
char ch = str[i];
if(freq[ch-'a'] == 1 || (ch - 'a') >= n)return false;
freq[ch-'a']++;
}
return true;
}
void solve(){
int i,j,n=0,m;
string str="";
cin >> str;
n = str.size();
if(!check(str, n)){
cout <<"NO\n";
return;
}
int idx=0;
for(int i=0;i<n;i++){
if(str[i]=='a'){
idx = i;
break;
}
}
bool ans=true;
i=0;
while(i!=idx){
if(i-1>=0 && str[i-1]<str[i]){
ans = false;
break;
}
i++;
}
if(!ans){
cout << "NO\n";
return;
}
idx++;
while(idx<n){
if(str[idx] < str[idx-1]){
ans = false;
break;
}
idx++;
}
if(!ans){
cout << "NO\n";
return;
}
cout<<"YES\n";
}
int32_t main()
{
c_p_c();
w(x){
solve();
}
// solve();
return 0;
}
//=============================================================================================
int fact(int n)
{
if (n == 0) return 1;
return n * fact(n - 1);
}
int mpow(int base, int exp) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % mod;
base = ((base) * base) % mod;
exp >>= 1;
}
return result;
}
void addEdge(vvi &g, int u, int v){
g[u].pb(v);
g[v].pb(u);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[1001], k = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n - 1; i++) {
if (a[i] > a[i - 1] && a[i] > a[i + 1])
++k;
else if (a[i] < a[i - 1] && a[i] < a[i + 1])
++k;
}
cout << k;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:20000000")
using namespace std;
const int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
const int SIZE = 2048;
const int RAD = 3;
const double BLACK_THRES = 0.5;
const int COMP_SIZE_THRES = 100;
int n;
int matr[SIZE][SIZE];
double smooth[SIZE][SIZE];
inline bool good(int x, int y) { return !(x < 0 || x >= n || y < 0 || y >= n); }
inline bool isblack(int x, int y) { return smooth[x][y] >= BLACK_THRES; }
int k;
vector<vector<pair<int, int> > > comps;
bool used[SIZE][SIZE];
void DFS(int x, int y) {
used[x][y] = true;
comps[k].push_back(pair<int, int>(x, y));
for (int d = 0; d < 4; d++) {
int nx = x + dir[d][0];
int ny = y + dir[d][1];
if (!good(nx, ny) || used[nx][ny] || !isblack(nx, ny)) continue;
DFS(nx, ny);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", &matr[i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
int cnt = 0;
int sum = 0;
for (int di = -RAD; di <= RAD; di++)
for (int dj = -RAD; dj <= RAD; dj++) {
int qi = i + di;
int qj = j + dj;
if (!good(qi, qj)) continue;
cnt++;
sum += matr[qi][qj];
}
smooth[i][j] = double(sum) / cnt;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (isblack(i, j) && !used[i][j]) {
comps.push_back(vector<pair<int, int> >());
DFS(i, j);
k++;
}
int circles = 0, rects = 0;
for (int i = 0; i < k; i++) {
const vector<pair<int, int> > &shape = comps[i];
if (shape.size() < COMP_SIZE_THRES) continue;
double cx = 0.0, cy = 0.0;
for (int j = 0; j < shape.size(); j++) {
cx += shape[j].first;
cy += shape[j].second;
}
cx /= shape.size();
cy /= shape.size();
double radius = sqrt(shape.size() / (2.0 * acos(0.0)));
static const int HISTO_RES = 2;
double histo[HISTO_RES * 2 + 1] = {0.0};
for (int j = 0; j < shape.size(); j++) {
double dx = shape[j].first - cx;
double dy = shape[j].second - cy;
double dist = sqrt(dx * dx + dy * dy);
dist /= radius;
int cell = int(dist * HISTO_RES);
if (cell > HISTO_RES * 2) continue;
histo[cell] += 1.0;
}
for (int i = 0; i <= HISTO_RES * 2; i++) {
double avgrad = radius * (i + 0.5) / HISTO_RES;
double deltarad = radius / HISTO_RES;
double sq = 2.0 * acos(0.0) * avgrad * deltarad;
histo[i] /= sq;
}
if (histo[2] < 0.05)
circles++;
else
rects++;
}
printf("%d %d\n", circles, rects);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int l = 0, u = 0;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] > 90)
l++;
else
u++;
}
if (l >= u) {
transform(s.begin(), s.end(), s.begin(), ::tolower);
cout << s << endl;
} else {
transform(s.begin(), s.end(), s.begin(), ::toupper);
cout << s << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
const int inf = 0x3f3f3f3f;
int n;
struct SegmentTree {
int mn, id, col;
} tree[maxn << 2];
void up(int p) {
if (tree[p * 2].mn < tree[p * 2 + 1].mn) {
tree[p].mn = tree[p * 2].mn;
tree[p].id = tree[p * 2].id;
} else {
tree[p].mn = tree[p * 2 + 1].mn;
tree[p].id = tree[p * 2 + 1].id;
}
}
void down(int p) {
if (tree[p].col) {
tree[p * 2].mn += tree[p].col;
tree[p * 2 + 1].mn += tree[p].col;
tree[p * 2].col += tree[p].col;
tree[p * 2 + 1].col += tree[p].col;
tree[p].col = 0;
}
}
void build(int p, int l, int r) {
tree[p].col = 0;
if (l == r) {
tree[p].id = l;
tree[p].mn = 0;
return;
}
int mid = (l + r) / 2;
build(p * 2, l, mid);
build(p * 2 + 1, mid + 1, r);
up(p);
}
void add(int p, int l, int r, int L, int R, int d) {
if (L > R || L < 0 || R > n) return;
if (L <= l && r <= R) {
tree[p].col += d;
tree[p].mn += d;
return;
}
down(p);
int mid = (l + r) / 2;
if (L <= mid) add(p * 2, l, mid, L, R, d);
if (R > mid) add(p * 2 + 1, mid + 1, r, L, R, d);
up(p);
}
void change(int p, int l, int r, int x, int d) {
if (x == 0 || x > n) return;
if (l == r) {
tree[p].mn = d;
return;
}
down(p);
int mid = (l + r) / 2;
if (x <= mid)
change(p * 2, l, mid, x, d);
else
change(p * 2 + 1, mid + 1, r, x, d);
up(p);
}
pair<int, int> ask(int p, int l, int r, int L, int R) {
if (L <= l && r <= R) {
return make_pair(tree[p].mn, tree[p].id);
}
down(p);
int mid = (l + r) / 2;
pair<int, int> ret = make_pair(inf, 0);
if (L <= mid) ret = min(ret, ask(p * 2, l, mid, L, R));
if (R > mid) ret = min(ret, ask(p * 2 + 1, mid + 1, r, L, R));
up(p);
return ret;
}
int nxt[maxn];
int L[maxn], R[maxn];
vector<int> G[maxn];
void init() {
for (int i = 0; i <= n; i++) G[i].clear();
}
int ans[maxn];
bool topo() {
for (int i = 1; i <= n; i++) ans[i] = 0;
int now = n;
pair<int, int> s = ask(1, 1, n, 1, n);
if (s.first > 0) return 0;
while (s.first == 0) {
ans[s.second] = now--;
change(1, 1, n, s.second, inf);
if (L[s.second] && R[s.second]) add(1, 1, n, L[s.second], R[s.second], -1);
for (int v : G[s.second]) {
add(1, 1, n, v, v, -1);
}
s = ask(1, 1, n, 1, n);
}
if (s.first != inf) return 0;
return 1;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
build(1, 1, n);
init();
for (int i = 1; i <= n; i++) scanf("%d", nxt + i);
for (int i = 1; i <= n; i++) L[i] = R[i] = 0;
for (int i = 1; i <= n; i++)
if (nxt[i] != -1 && nxt[i] != n + 1) {
G[nxt[i]].push_back(i);
L[i] = i + 1;
R[i] = nxt[i] - 1;
add(1, 1, n, L[i], R[i], 1);
add(1, 1, n, i, i, 1);
}
for (int i = 1; i <= n; i++)
if (nxt[i] == n + 1) {
L[i] = i + 1;
R[i] = n;
add(1, 1, n, L[i], R[i], 1);
}
if (!topo())
puts("-1");
else {
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, ans;
multiset<int> setik;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
setik.insert(x);
}
while (setik.size()) {
int cur = 0;
while (true) {
auto it = setik.lower_bound(cur);
if (it == setik.end()) break;
setik.erase(it);
++cur;
}
++ans;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int m = *max_element(a.begin(), a.end());
bool flag = true, ans = true;
if (m == a[0]) flag = false;
for (int i = 1; i < n; i++) {
if (a[i] < a[i - 1] && flag) {
ans = false;
} else if (a[i] > a[i - 1] && !flag) {
ans = false;
}
if (a[i] == m) {
flag = false;
}
}
if (ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323846;
void rw() {}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, p = 0;
cin >> n >> m;
cout << min(n, m) + 1 << "\n";
while (n >= 0 && p <= m) {
cout << n << " " << p << "\n";
n--, p++;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
char s[1000010], t[1000010];
int ans;
int main() {
int i, j, x = 0, y = 0;
scanf("%s%s", s + 1, t + 1);
for (i = 1; t[i]; i++) y ^= t[i] - '0';
for (i = 1; t[i]; i++) x ^= s[i] - '0';
ans += x ^ y ^ 1;
for (j = 1; s[i]; i++, j++) {
x ^= s[i] - '0';
x ^= s[j] - '0';
ans += x ^ y ^ 1;
}
printf("%d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool f1(int x, int y, int** a) {
if (x < 0 || y < 0 || x >= n || y >= m) return false;
if (x == n - 1 && y == m - 1) return true;
if (a[x][y] == -1) return false;
a[x][y] = 1;
if (f1(x + 1, y, a)) return true;
if (f1(x, y + 1, a)) return true;
a[x][y] = -1;
return false;
}
bool f2(int x, int y, int** b) {
if (x < 0 || y < 0 || x >= n || y >= m) return false;
if (x == n - 1 && y == m - 1) return true;
if (b[x][y] == -1) return false;
b[x][y] = 1;
if (f2(x, y + 1, b)) return true;
if (f2(x + 1, y, b)) return true;
b[x][y] = -1;
return false;
}
int main() {
cin >> n >> m;
int** a = new int*[n];
for (int i = 0; i < n; i++) a[i] = new int[m + 1];
char x;
int** b = new int*[n];
for (int i = 0; i < n; i++) b[i] = new int[m + 1];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> x;
if (x == '.')
b[i][j] = 0;
else
b[i][j] = -1;
a[i][j] = b[i][j];
}
}
if (!f1(0, 0, a) && !f2(0, 0, b)) {
cout << 0;
cin >> n;
return 0;
}
f2(0, 0, b);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0 && j == 0) continue;
if (a[i][j] == 1 && b[i][j] == 1) {
cout << 1;
cin >> n;
return 0;
}
}
}
cout << 2;
cin >> n;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Splay {
int l, r, fa, maxdep, mindep, dep, sign;
} t[220000];
vector<int> E[220000];
int tim, dfn[220000], dfn2[220000], qn, q[220000], root, n, m, i, x, y, k, j,
type, ans, pos[220000], cnt;
void dfs(int x, int dep) {
dfn[x] = ++tim;
pos[tim] = x;
t[tim].dep = dep;
for (int i = 0; i < E[x].size(); ++i) dfs(E[x][i], dep + 1);
dfn2[x] = ++tim;
pos[tim] = x;
t[tim].dep = dep;
}
void renew(int p) {
int x = t[p].l, y = t[p].r;
t[p].maxdep = max(t[p].dep, max(t[x].maxdep, t[y].maxdep));
t[p].mindep = min(t[p].dep, min(t[x].mindep, t[y].mindep));
}
void modify(int p, int v) {
if (!p) return;
t[p].sign += v;
t[p].maxdep += v;
t[p].mindep += v;
t[p].dep += v;
}
void updata(int p) {
int x = t[p].l, y = t[p].r;
if (t[p].sign) {
modify(x, t[p].sign);
modify(y, t[p].sign);
t[p].sign = 0;
}
}
void left(int p) {
int y = t[p].fa, x = t[y].fa;
t[p].fa = x;
t[y].fa = p;
t[t[p].l].fa = y;
t[y].r = t[p].l;
t[p].l = y;
renew(y);
renew(p);
if (t[x].l == y) t[x].l = p;
if (t[x].r == y) t[x].r = p;
}
void right(int p) {
int y = t[p].fa, x = t[y].fa;
t[p].fa = x;
t[y].fa = p;
t[t[p].r].fa = y;
t[y].l = t[p].r;
t[p].r = y;
renew(y);
renew(p);
if (t[x].l == y) t[x].l = p;
if (t[x].r == y) t[x].r = p;
}
void splay(int p, int rt) {
int x, y;
qn = 0;
for (x = p; x != rt; x = t[x].fa) q[++qn] = x;
for (x = qn; x >= 1; --x) updata(q[x]);
while (t[p].fa != rt) {
y = t[p].fa;
x = t[y].fa;
if (x == rt) {
if (t[y].l == p)
right(p);
else
left(p);
break;
}
if (t[x].l == y) {
if (t[y].l == p)
right(y), right(p);
else
left(p), right(p);
} else {
if (t[y].l == p)
right(p), left(p);
else
left(y), left(p);
}
}
if (!rt) root = p;
}
int Find(int p, int x) {
updata(p);
if (t[t[p].r].maxdep >= x && t[t[p].r].mindep <= x) return Find(t[p].r, x);
if (t[p].dep == x) return p;
return Find(t[p].l, x);
}
void debug(int p) {
updata(p);
if (t[p].l) debug(t[p].l);
printf("%d ", t[p].dep);
if (t[p].r) debug(t[p].r);
}
int main() {
t[0].mindep = 1 << 30;
t[0].maxdep = -1 << 30;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) {
scanf("%d", &k);
for (j = 1; j <= k; ++j) scanf("%d", &x), E[i].push_back(x);
}
dfs(1, 0);
root = 1;
for (i = 1; i < tim; ++i) t[i].r = i + 1, t[i + 1].fa = i;
for (i = tim; i >= 1; --i) renew(i);
for (i = max(1, tim / 2); i <= tim; ++i) splay(i, 0);
for (i = 1; i <= m; ++i) {
scanf("%d", &type);
if (type == 1) {
scanf("%d%d", &x, &y);
if (x == y) {
ans = 0;
} else {
x = dfn[x];
y = dfn[y];
splay(x, 0);
splay(y, x);
int xx = t[x].dep, yy = t[y].dep, dd;
if (t[x].l == y) dd = t[t[y].r].mindep;
if (t[x].r == y) dd = t[t[y].l].mindep;
dd = min(dd - 1, min(xx, yy));
ans = xx + yy - 2 * dd;
}
}
if (type == 2) {
scanf("%d%d", &x, &y);
int ll, rr;
splay(dfn[x], 0);
ll = t[root].l;
while (t[ll].r) ll = t[ll].r;
splay(dfn2[x], 0);
rr = t[root].r;
while (t[rr].l) rr = t[rr].l;
splay(dfn[x], 0);
int p = Find(t[dfn[x]].l, t[dfn[x]].dep - y);
splay(ll, 0);
splay(rr, ll);
int u = t[rr].l;
t[u].fa = 0;
t[rr].l = 0;
renew(rr);
renew(ll);
modify(u, -y + 1);
p = dfn2[pos[p]];
splay(p, 0);
int tmp = t[p].l;
while (t[tmp].r) tmp = t[tmp].r;
splay(tmp, p);
t[u].fa = tmp;
t[tmp].r = u;
renew(tmp);
renew(p);
}
if (type == 3) {
scanf("%d", &x);
ans = pos[Find(root, x)];
}
if (type != 2) printf("%d\n", ans);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 1e5 * 2 + 5;
const int INF = 0x3f3f3f3f;
int main() {
int n;
scanf("%d", &n);
vector<int> a(n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a.begin(), a.end());
int ans = 1;
for (int i = 1; i < n; i++)
if (a[i] == a[i - 1]) ans++;
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int MAXN = 100005;
int x1[MAXN], x2[MAXN];
std::map<int, int> cnt;
int main() {
int n, y1;
scanf("%d %d", &n, &y1);
for (int i = 0; i < n; i++) scanf("%d", &x1[i]);
int m, y2;
scanf("%d %d", &m, &y2);
for (int i = 0; i < m; i++) scanf("%d", &x2[i]);
int ans = 2;
for (int l = 1; l <= 1000000000; l <<= 1) {
cnt.clear();
for (int i = 0; i < n; i++) ++cnt[x1[i] % (l << 1)];
for (int i = 0; i < m; i++) ++cnt[(x2[i] + l) % (l << 1)];
for (auto i : cnt) ans = std::max(ans, i.second);
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
string a, b;
cin >> a >> b;
int cnt1, cnt2, cnt3, cnt4;
cnt1 = cnt2 = cnt3 = cnt4 = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i]) {
if (a[i] == '0') {
cnt1++;
} else {
cnt2++;
}
} else {
if (a[i] == '0') {
cnt3++;
} else {
cnt4++;
}
}
}
int ans = n + 1;
if (cnt1 + cnt2 == n) {
ans = 0;
}
if (cnt1 + 1 == cnt2) {
ans = min(ans, cnt1 + cnt2);
}
if (cnt3 && cnt3 == cnt4) {
ans = min(ans, cnt3 + cnt4);
}
ans = ans == n + 1 ? -1 : ans;
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma,sse2")
#pragma GCC optimization("unroll-loops")
using namespace std;
int64_t t, n, l, r, a[1000005];
string s;
bool prime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) return 0;
}
return 1;
}
void solve() {
int vt = -1;
for (int i = 0; i < n; i++) {
if (int(s[i]) % 2 == 0 && s[i] != '2') vt = int(s[i]) - 48;
}
if (vt > -1)
cout << 1 << "\n" << vt << "\n";
else {
for (int i = 0; i < n; i++) {
if (s[i] == '9') vt = 9;
if (s[i] == '1') vt = 1;
}
if (vt > 0)
cout << 1 << "\n" << vt << "\n";
else {
if (n <= 5) {
bool b[6];
int ans = 99999;
for (int i = 1; i <= n; i++) b[i] = 0;
b[n] = 1;
while (1) {
int sum = 0, num = 1;
vector<int> v;
for (int i = n; i >= 1; i--) {
if (b[i]) v.push_back(int(s[i - 1]) - 48);
}
for (auto i : v) {
sum += i * num;
num *= 10;
}
if (!prime(sum)) ans = min(ans, sum);
bool f = 0;
for (int i = n; i >= 1; i--) {
if (!b[i]) {
f = 1;
b[i] = 1;
for (int j = i + 1; j <= n; j++) b[j] = 0;
break;
}
}
if (!f) break;
}
if (10 <= ans && ans <= 99)
cout << 2 << "\n" << ans << "\n";
else if (100 <= ans && ans <= 999)
cout << 3 << "\n" << ans << "\n";
else if (1000 <= ans && ans <= 9999)
cout << 4 << "\n" << ans << "\n";
else
cout << 5 << "\n" << ans << "\n";
} else {
int ans = 999;
for (int i = 0; i < s.size() - 1; i++) {
for (int j = i + 1; j < s.size(); j++) {
int num = (int(s[i]) - 48) * 10 + int(s[j]) - 48;
if (!prime(num)) ans = min(ans, num);
}
}
for (int i = 0; i < s.size() - 2; i++) {
for (int j = i + 1; j < s.size() - 1; j++) {
for (int k = j + 1; k < s.size(); k++) {
int num = (int(s[i]) - 48) * 100 + (int(s[j]) - 48) * 10 +
int(s[k]) - 48;
if (!prime(num)) ans = min(ans, num);
}
}
}
if (10 <= ans && ans <= 99)
cout << 2 << "\n" << ans << "\n";
else
cout << 3 << "\n" << ans << "\n";
}
}
}
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> t;
while (t--) {
cin >> n >> s;
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int maps[1005][1005];
int main() {
int n, a, b;
scanf("%d%d%d", &n, &a, &b);
if (n == 1 && a == 1 && b == 1) {
printf("YES\n");
printf("0\n");
} else if ((n <= 3 && a == 1 && b == 1) || min(a, b) != 1)
printf("NO\n");
else {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (i == j)
maps[i][j] = 0;
else
maps[i][j] = 1;
}
int x = max(a, b);
int y = n;
int c = 1, d = 2;
while (1) {
if (y == x) break;
y--;
maps[c][d] = 0;
maps[d][c] = 0;
c++;
d++;
}
printf("YES\n");
if (a == 1) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) printf("%d", maps[i][j]);
printf("\n");
}
} else if (b == 1) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j)
printf("0");
else
printf("%d", (maps[i][j] ^ 1));
}
printf("\n");
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1100005;
const long long MOD = 998244353;
int n, cnt, tot;
int a[MAXN];
int sum[MAXN];
long long ans;
long long fac[MAXN];
long long inv[MAXN];
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) (res *= a) %= MOD;
(a *= a) %= MOD;
b >>= 1;
}
return res;
}
void init() {
fac[0] = 1;
for (int i = 1; i <= n + tot; i++) fac[i] = fac[i - 1] * i % MOD;
inv[n + tot] = power(fac[n + tot], MOD - 2);
for (int i = n + tot; i >= 1; i--) inv[i - 1] = inv[i] * i % MOD;
}
long long C(int x, int y) { return fac[x] * inv[y] % MOD * inv[x - y] % MOD; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
tot += a[i];
}
init();
sort(a + 1, a + n + 1);
int MIN = -1;
for (int i = 1; i < n; i++)
if (a[i + 1] < i) {
MIN = i - 1;
break;
}
if (~MIN) {
for (int i = 0, j = 0; i <= MIN; i++) {
while (j + 1 <= n && a[j + 1] < i) j++;
(ans += C(i + n - j - 1, n - 1)) %= MOD;
}
printf("%lld\n", ans);
return 0;
}
for (int i = 1; i <= n; i++) {
a[i] %= n;
sum[0] += a[i];
sum[n - a[i]] -= n;
}
for (int i = 0; i < n; i++) {
cnt += sum[i];
(ans += C((tot - cnt) / n + n - 1, n - 1)) %= MOD;
cnt += n;
}
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long l[200001];
long long r[200001];
vector<pair<long long, pair<int, int> > > P;
int ans[200001];
set<pair<long long, int> > ms;
int main() {
int N, M;
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++) {
scanf("%lld%lld", &l[i], &r[i]);
if (i > 0) {
P.push_back(make_pair(l[i] - r[i - 1], make_pair(-1, i)));
P.push_back(make_pair(r[i] - l[i - 1], make_pair(1, i)));
}
}
for (int i = 0; i < M; i++) {
long long b;
scanf("%lld", &b);
P.push_back(make_pair(b, make_pair(0, i + 1)));
}
sort(P.begin(), P.end());
for (int i = 0; i < P.size(); i++) {
int cmd = P[i].second.first;
int idx = P[i].second.second;
if (cmd == -1)
ms.insert(make_pair(r[idx] - l[idx - 1], idx));
else if (cmd == 1)
ms.erase(make_pair(r[idx] - l[idx - 1], idx));
else {
if (!ms.empty()) {
ans[ms.begin()->second] = idx;
ms.erase(ms.begin());
}
}
}
for (int i = 1; i < N; i++) {
if (ans[i] == 0) {
printf("No\n");
return 0;
}
}
printf("Yes\n");
for (int i = 1; i < N; i++) {
printf("%d ", ans[i]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s, good;
cin >> s >> good;
int k, lens = s.length(), bad = 0;
cin >> k;
long long pow31[1500], pow37[1500];
pow31[0] = 1;
pow37[0] = 1;
set<pair<long long, long long>> st;
for (int i = 1; i < 1500; i++) {
pow31[i] = (pow31[i - 1] * 31) % 1000000007;
pow37[i] = (pow37[i - 1] * 37) % 1000000007;
}
for (int i = 0; i < lens; i++) {
long long hash1 = 0, hash2 = 0, bad = 0;
for (int j = i; j < lens; j++) {
hash1 += (s[j] - 'a' + 1) * pow31[j - i];
hash2 += (s[j] - 'a' + 1) * pow37[j - i];
bad += (good[s[j] - 'a'] == '0');
if (bad <= k) st.insert({hash1, hash2});
}
}
cout << st.size() << "\n";
}
int main() { solve(); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
const int maxn = 110;
int n;
int a[maxn][maxn];
int res[maxn][maxn];
bool vis[maxn];
int ans, cnt;
void dfs(int u) {
vis[u] = 1;
cnt++;
ans = max(ans, cnt);
for (int i = 0; i < n; i++) {
if (!res[u][i] && !vis[i]) {
dfs(i);
}
}
}
void solve() {
memset(res, 0, sizeof(res));
memset(vis, 0, sizeof(vis));
scanf("%d", &n);
char s[maxn];
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < n; j++) a[i][j] = s[j] - '0';
res[i][i] = 1;
}
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (a[i][k] != a[j][k]) res[i][j] = res[j][i] = 1;
ans = INT_MIN;
for (int i = 0; i < n; i++) {
cnt = 0;
if (!vis[i]) dfs(i);
}
printf("%d", ans);
}
int main() {
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
int a[N], b[N];
vector<int> vec;
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> b[i];
sort(b, b + n);
for (int i = 0; i < n; i++) {
a[i] = b[n - i - 1];
}
while (k > 0) {
for (int i = vec.size(); i < n && k > 0; i++) {
cout << vec.size() + 1 << " ";
for (int i = 0; i < vec.size(); i++) cout << a[vec[i]] << " ";
cout << a[i] << endl;
k--;
}
vec.push_back(vec.size());
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long inv_euclid(long long a, long long m = 998244353) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
long long ssum(long long n) { return (n * (n + 1)) / 2; }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / (gcd(a, b)); }
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
while (v.size() && v[v.size() - 1] == 0) v.pop_back();
reverse(v.begin(), v.end());
while (v.size() && v[v.size() - 1] == 0) v.pop_back();
long long ans = 0;
for (auto i : v) ans += (i == 0);
cout << ans << "\n";
}
int main() {
long long tttt;
cin >> tttt;
while (tttt--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[300005];
int main() {
int n, sum = 0, x, y;
cin >> n;
map<int, int> mp, mp1;
if (n > 36) {
cout << -1;
return 0;
}
while (n >= 2) {
cout << 8;
n -= 2;
}
if (n == 1) {
cout << 4;
}
}
| 2 |
#include <bits/stdc++.h>
const int N = 200005;
const int cIz = 1000000007;
inline int Pow(int a, int b) {
int ans = 1;
for (; b; b >>= 1) {
if (b & 1) ans = (long long)ans * a % cIz;
a = (long long)a * a % cIz;
}
return ans;
}
inline int Inv(int a) { return Pow(a, cIz - 2); }
template <typename T>
inline void add(int &a, T b) {
a = (a + b) % cIz;
}
int n, l[N], r[N], inv_len[N];
inline int len(int i) { return r[i] - l[i] + 1; }
void get_inv() {
static int mul[N];
mul[0] = 1;
for (int i = 1; i <= n; ++i) {
mul[i] = (long long)mul[i - 1] * len(i) % cIz;
}
int tmp = Inv(mul[n]);
for (int i = n; i; --i) {
inv_len[i] = (long long)tmp * mul[i - 1] % cIz;
tmp = (long long)tmp * len(i) % cIz;
}
}
inline int calc(int x, int p = 1) {
int L = l[x], R = r[x], div = inv_len[x];
while (p--) {
--x;
L = std::max(L, l[x]);
R = std::min(R, r[x]);
div = (long long)div * inv_len[x] % cIz;
}
return L <= R ? (R - L + 1ll) * div % cIz : 0;
}
int f[N], sumf[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", l + i);
for (int i = 1; i <= n; ++i) scanf("%d", r + i);
get_inv();
int ans = 1;
for (int i = 2; i <= n; ++i) {
f[i] = 1 - calc(i);
add(sumf[i] = sumf[i - 1], f[i]);
add(ans, 3ll * f[i]);
add(ans, 2ll * f[i] * sumf[i - 2]);
if (i > 2) add(ans, 2 * (f[i - 1] + f[i] - 1ll + calc(i, 2)));
}
add(ans, cIz);
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0)
cout << 0;
else
cout << 1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, A1, B, x, A[100004];
long long int Snap(int, int);
int pow1(int, int);
int CalcAv(int, int);
int main() {
int i;
cin >> n >> k >> A1 >> B;
for (i = 0; i < k; ++i) {
cin >> A[i];
}
sort(A, A + k);
n = pow1(2, n);
long long int ans;
ans = Snap(1, n);
cout << ans << '\n';
return 0;
}
int CalcAv(int a, int b) {
int z1, z2;
z1 = (int)(upper_bound(A, A + k, b) - A);
z2 = (int)(lower_bound(A, A + k, a) - A);
return z1 - z2;
}
long long int Snap(int a, int b) {
long long int z = CalcAv(a, b);
long long int maxim;
if (z == 0) return A1;
if (a == b) {
return B * z;
}
maxim = z * B * (b - a + 1);
z = Snap(a, (a + (b - a) / 2)) + Snap((a + (b - a) / 2) + 1, b);
if (maxim > z) maxim = z;
;
return maxim;
}
int pow1(int x, int n) {
int p = 1;
while (n > 0) {
if (n % 2) {
p *= x;
n--;
}
x = x * x;
n /= 2;
}
return p;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void doit(int& a, int b) {
if (a == -1)
a = b;
else
a = min(a, b);
}
vector<vector<int>> getCost(vector<vector<int>> A, int idx) {
int n = A.size();
int m = A[0].size();
vector<vector<int>> D(n, vector<int>(m, -1));
vector<vector<int>> V(n, vector<int>(m, 0));
deque<pair<int, int>> q;
for (int i = 0; i < n; i++) {
for (int k = 0; k < m; k++) {
if (A[i][k] == idx) {
D[i][k] = 0;
q.push_back(make_pair(i, k));
}
}
}
while (!q.empty()) {
int r = q.front().first;
int c = q.front().second;
q.pop_front();
if (V[r][c]) {
continue;
}
V[r][c] = true;
int dr[4] = {0, 1, 0, -1};
int dc[4] = {1, 0, -1, 0};
for (int d = 0; d < 4; d++) {
int tr = r + dr[d];
int tc = c + dc[d];
if (tr < 0 || tc < 0 || tr >= n || tc >= m) {
continue;
}
if (A[tr][tc] == 0) {
continue;
}
if (A[r][c] == 4) {
doit(D[tr][tc], D[r][c] + 1);
q.push_back(make_pair(tr, tc));
} else {
doit(D[tr][tc], D[r][c]);
q.push_front(make_pair(tr, tc));
}
}
}
return D;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> A;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
vector<int> vec;
for (int i = 0; i < m; i++) {
int temp = 0;
if (s[i] == '#') {
temp = 0;
} else if (s[i] == '.') {
temp = 4;
} else {
temp = (s[i] - '0');
}
vec.push_back(temp);
}
A.push_back(vec);
}
vector<vector<int>> DS[3];
for (int i = 0; i < 3; i++) {
DS[i] = getCost(A, i + 1);
}
int res = -1;
for (int i = 0; i < n; i++) {
for (int k = 0; k < m; k++) {
bool ok = true;
int cost = (A[i][k] == 4 ? 1 : 0);
for (int j = 0; j < 3; j++) {
int temp = DS[j][i][k];
if (temp == -1) {
ok = false;
}
cost += temp;
}
if (ok) {
doit(res, cost);
}
}
}
cout << res << endl;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.