solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int mod = 1e9 + 7;
void init() {
ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
}
void solve() {
long long n;
cin >> n;
long long cn = 1;
long long arr[n][n];
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
for (int j = 0; j < n; j++) {
arr[i][j] = cn;
cn++;
}
} else {
for (int j = n - 1; j >= 0; j--) {
arr[i][j] = cn;
cn++;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << arr[j][i] << " ";
}
cout << endl;
}
}
int main() {
init();
long long t = 1;
clock_t launch = clock();
while (t--) {
solve();
}
clog << ((long double)(clock() - launch) / CLOCKS_PER_SEC) << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
const int M = 1048577;
const double eps = 1e-10;
int n, k, cnt;
double p[N], ans[N], f[M];
int check(int x) {
int ret = 0;
for (int i = 0; i < n; ++i)
if (x & (1 << i)) ++ret;
return ret;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%lf", &p[i]);
if (p[i] < eps) ++cnt;
}
k = min(k, n - cnt);
f[0] = 1;
for (int i = 0; i < (1 << n); ++i) {
double tmp = 1;
for (int j = 0; j < n; ++j) {
if (i & (1 << j)) {
tmp -= p[j];
if (check(i) == k) ans[j] += f[i];
}
}
for (int j = 0; j < n; ++j)
if (!(i & (1 << j))) f[i | (1 << j)] += f[i] * p[j] / tmp;
}
for (int i = 0; i < n; ++i) printf("%.10lf ", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
if (n == 1) {
cout << 2;
return 0;
}
if (n == 2) {
cout << 3;
return 0;
}
long long int curr = 2, line = 3, to = 2;
while (to < n) {
line++;
to += curr;
if (to >= n) {
cout << line;
return 0;
}
line++;
to += (curr);
curr++;
if (to >= n) {
cout << line;
return 0;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int N;
char op[maxn];
int vis[maxn * 2];
int solve_0() {
int pos = 0;
vis[maxn + pos] = 1;
for (int i = 1; i <= N; ++i) {
if (op[i] == 'R')
++pos;
else
--pos;
++vis[maxn + pos];
}
return vis[maxn + pos] > 1 ? 0 : 1;
}
int check_at_least(int mid) {
if (0) printf("checking at least %d\n", mid);
memset(vis, 0, sizeof(vis));
int pos = 0;
vis[maxn + pos] = 1;
for (int i = 1; i <= N; ++i) {
if (op[i] == 'R')
++pos, ++vis[maxn + pos];
else {
if (pos - 1 > mid) --pos, ++vis[maxn + pos];
}
}
if (0) {
for (int i = -N; i <= N; ++i) printf("%d (%d) ", vis[maxn + i], i);
printf("\n");
}
return vis[maxn + pos] > 1 ? 0 : 1;
}
int check_at_most(int mid) {
memset(vis, 0, sizeof(vis));
int pos = 0;
vis[maxn + pos] = 1;
for (int i = 1; i <= N; ++i) {
if (op[i] == 'R') {
if (pos + 1 < mid) ++pos, ++vis[maxn + pos];
} else {
--pos, ++vis[maxn + pos];
}
}
return vis[maxn + pos] > 1 ? 0 : 1;
}
int main() {
scanf("%s", op + 1);
N = strlen(op + 1);
if (solve_0()) {
printf("1\n");
} else {
int ret = 0;
int l = -1, r = -N, L = 0, R = 0;
while (l >= r) {
int mid = (l + r) >> 1;
if (check_at_least(mid)) {
L = mid;
l = mid - 1;
} else {
r = mid + 1;
}
}
l = 1, r = N;
while (l <= r) {
int mid = (l + r) >> 1;
if (check_at_most(mid)) {
R = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
if (0) printf("L = %d , R = %d\n", L, R);
ret += -L + R;
printf("%d\n", ret);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int t, a, b, c;
int main() {
cin >> t;
for (; t; t--) {
cin >> a >> b >> c;
int res = 0;
if (c >= b) {
swap(b, c);
}
if (b >= a) {
swap(a, b);
}
if (c > 0) {
c--;
res++;
}
if (b > 0) {
b--;
res++;
}
if (a > 0) {
a--;
res++;
}
if ((a > 0) && (b > 0)) {
a--;
b--;
res++;
}
if ((c > 0) && (a > 0)) {
a--;
c--;
res++;
}
if ((c > 0) && (b > 0)) {
c--;
b--;
res++;
}
if ((c > 0) && (b > 0) && (a > 0)) {
a--;
b--;
c--;
res++;
}
cout << res << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 5e5 + 5;
int n, m, x;
map<int, int> a;
struct cinema {
int cnt, sum1, sum2;
} ans[M];
bool cmp(cinema a, cinema b) {
if (a.sum1 == b.sum1)
return a.sum2 > b.sum2;
else
return a.sum1 > b.sum1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
a[x]++;
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &x);
ans[i].sum1 = a[x];
ans[i].cnt = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d", &x);
ans[i].sum2 = a[x];
}
sort(ans + 1, ans + m + 1, cmp);
printf("%d", ans[1].cnt);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y;
void solve(int val) {
val %= x + y;
long long lb = 0, rb = (long long)x * y;
while (lb <= rb) {
long long mid = (rb - lb) / 2 + lb;
long long hit = mid / x + mid / y;
if (hit >= val)
rb = mid - 1;
else
lb = mid + 1;
}
int flag = (lb % x == 0) << 1 | (lb % y == 0);
switch (flag) {
case 1:
puts("Vanya");
break;
case 2:
puts("Vova");
break;
case 3:
puts("Both");
break;
}
}
int main() {
scanf("%d%d%d", &n, &x, &y);
for (int i = 0; i < n; ++i) {
int val;
scanf("%d", &val);
solve(val);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, m;
int add;
scanf("%d:%d%d", &h, &m, &add);
int tm = (h * 60 + m + add) % (24 * 60);
printf("%02d:%02d\n", tm / 60, tm % 60);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
const int M = 1e5 + 2;
const int mod = 1e9 + 7;
const int inf = 1e9;
const long long INF = 1e18;
void data() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); }
int n, m, p[2 * N], ans[2 * N], t[8 * N];
pair<pair<int, int>, int> k[2 * N];
pair<int, int> a[2 * N];
void add(int val, int v = 1, int l = 1, int r = n) {
if (l == r) {
t[v] = 1;
return;
}
int m = (l + r) >> 1;
if (val <= m)
add(val, v << 1, l, m);
else
add(val, v << 1 | 1, m + 1, r);
t[v] = t[v << 1] + t[v << 1 | 1];
}
int get(int pos, int v = 1, int l = 1, int r = n) {
if (l == r) return p[l];
int m = (l + r) >> 1;
if (t[v << 1] >= pos)
return get(pos, v << 1, l, m);
else
return get(pos - t[v << 1], v << 1 | 1, m + 1, r);
}
bool mysort(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
}
int main() {
data();
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].first);
p[i] = a[i].first;
a[i].second = i;
}
sort(a + 1, a + n + 1, mysort);
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &k[i].first.first, &k[i].first.second);
k[i].second = i;
}
sort(k + 1, k + m + 1);
int cnt = n;
for (int i = 1; i <= m; ++i) {
for (int j = k[i - 1].first.first; j < k[i].first.first; ++j)
add(a[cnt--].second);
ans[k[i].second] = get(k[i].first.second);
cerr << "OK\n";
;
}
for (int i = 1; i <= m; ++i) {
printf("%d\n", ans[i]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, c[10];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
int a[m], b[m];
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i];
if (c[b[i] - 1] == 0) {
c[b[i] - 1] = i + 1;
} else {
a[c[b[i] - 1] - 1] += a[i];
}
}
sort(b, b + m, greater<int>());
for (int i = 0; i < m && b[i] && n > 0; i++) {
while (a[c[b[i] - 1] - 1]-- > 0 && n-- > 0) {
ans += b[i];
}
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const deque<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const deque<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T, typename OP>
vector<T> prefixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = 0; i < (int((v).size())); i++) r[i + 1] = op(r[i], v[i]);
return r;
}
template <typename C, typename T, typename OP>
vector<T> suffixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = (int((v).size())) - 1; i >= 0; i--) r[i] = op(v[i], r[i + 1]);
return r;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
int main() {
setIO();
int N, M, K;
re(N, M, K);
vi cost(N), type(N);
re(cost);
int A;
re(A);
for (int i = 0; i < (A); i++) {
int x;
re(x);
type[x - 1] |= 1;
}
int B;
re(B);
for (int i = 0; i < (B); i++) {
int x;
re(x);
type[x - 1] |= 2;
}
vi c3;
priority_queue<int> c1, c2, c0l;
priority_queue<int, vi, greater<int>> c0h;
ll s0 = 0, s1 = 0, s2 = 0, s3 = 0;
for (int i = 0; i < (N); i++) switch (type[i]) {
case 0:
c0h.push(cost[i]);
break;
case 1:
c1.push(cost[i]);
s1 += cost[i];
break;
case 2:
c2.push(cost[i]);
s2 += cost[i];
break;
case 3:
c3.push_back(cost[i]);
break;
default:
assert(false);
}
sort((c3).begin(), (c3).end());
ll ans = LLONG_MAX;
for (int lower_bound = 0; lower_bound < (int((c3).size()) + 1);
lower_bound++) {
if (lower_bound) s3 += c3[lower_bound - 1];
while (int((c1).size()) > max(0, K - lower_bound)) {
s1 -= c1.top();
c0h.push(c1.top());
c1.pop();
}
while (int((c2).size()) > max(0, K - lower_bound)) {
s2 -= c2.top();
c0h.push(c2.top());
c2.pop();
}
if (min(int((c1).size()), int((c2).size())) < max(0, K - lower_bound))
continue;
int rest = M - lower_bound - 2 * max(0, K - lower_bound);
if (rest < 0 || rest > int((c0l).size()) + int((c0h).size())) continue;
while (int((c0l).size()) > rest) {
s0 -= c0l.top();
c0h.push(c0l.top());
c0l.pop();
}
while (int((c0l).size()) < rest) {
s0 += c0h.top();
c0l.push(c0h.top());
c0h.pop();
}
while (int((c0l).size()) && int((c0h).size()) && c0l.top() > c0h.top()) {
int vl = c0l.top();
c0l.pop();
int vh = c0h.top();
c0h.pop();
s0 += vh - vl;
c0l.push(vh);
c0h.push(vl);
}
ckmin(ans, s0 + s1 + s2 + s3);
}
ps(ans < LLONG_MAX ? ans : -1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma G++ optimize(2)
using namespace std;
const int maxn = 1e4 + 5;
int n, a[maxn];
bool check(int x) {
bitset<2005> dp, tmp;
for (int i = 0; i <= x; ++i) dp[i] = 1;
tmp = dp;
for (int i = 1; i <= n; ++i) {
dp = (dp << a[i]) | (dp >> a[i]);
dp &= tmp;
}
return dp.any();
}
void test_case() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
int l = 0, r = 2001;
while (l < r) {
int mid = l + r >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
cout << l << "\n";
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0);
int _;
cin >> _;
for (int i = 1; i <= _; ++i) test_case();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int tt(int n) {
int c = 0;
while (n) {
n >>= 1;
c++;
}
return c;
}
int main() {
int n;
cin >> n;
cout << tt(n) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int color[1000000];
bool flag = true;
vector<vector<int> > g;
void dfs(int v, int prevColor) {
int curColor = 3 - prevColor;
color[v] = curColor;
for (int i = 0; i < g[v].size(); i++) {
if (color[g[v][i]] == curColor) {
flag = false;
} else {
if (color[g[v][i]] == 0) {
dfs(g[v][i], curColor);
}
}
}
}
int main(int argc, const char* argv[]) {
int n, m;
cin >> n >> m;
g.resize(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 0; i < n; i++) {
if (color[i] == 0) dfs(i, 2);
}
if (!flag) {
cout << "-1";
return 0;
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (color[i] == 1) {
cnt++;
}
}
cout << cnt << endl;
for (int i = 0; i < n; i++) {
if (color[i] == 1) {
cout << i + 1 << " ";
}
}
cout << endl << n - cnt << endl;
for (int i = 0; i < n; i++) {
if (color[i] == 2) cout << i + 1 << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
char c;
cin >> c;
while (1) {
if (c == '1') {
if (!(cin >> c)) break;
if (c == '4') {
if (!(cin >> c)) break;
if (c == '4') {
if (!(cin >> c)) break;
}
}
} else {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct op {
int id, t;
long long b;
bool operator<(const op &o) const { return b > o.b; }
};
struct ov {
double delta;
int id;
bool operator<(const ov &o) const { return delta > o.delta; }
};
vector<op> v[100005];
long long oval[100005];
int k, n, m;
vector<ov> r;
void addops(int i) {
long long b = oval[i];
op *bop;
for (op &o : v[i])
if (o.t == 1 && o.b > b) {
b = o.b;
bop = &o;
}
if (b != oval[i]) {
bop->t = 2;
bop->b -= oval[i];
}
sort(v[i].begin(), v[i].end());
long long val = oval[i];
for (op o : v[i]) {
ov x;
x.id = o.id;
if (o.t == 3) {
x.delta = o.b;
r.push_back(x);
} else if (o.t == 2) {
x.delta = (val + o.b) / 1. / val;
val += o.b;
r.push_back(x);
}
}
}
int TV[100005];
bool cmp(int i, int j) { return TV[i] < TV[j]; }
int main() {
scanf("%d %d %d", &k, &n, &m);
for (int i = (0); i < (k); i++) scanf("%lld", &oval[i]);
for (int i = (0); i < (n); i++) {
int T, I;
long long B;
scanf("%d %d %lld", &T, &I, &B);
I--;
TV[i + 1] = T;
v[I].push_back({i + 1, T, B});
}
for (int i = (0); i < (k); i++) addops(i);
sort(r.begin(), r.end());
vector<int> res;
for (int i = (0); i < (min(m, int(r.size()))); i++) res.push_back(r[i].id);
sort(res.begin(), res.end(), cmp);
printf("%d\n", int(res.size()));
for (int i = (0); i < (int(res.size())); i++) printf("%d ", res[i]);
printf("\n");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const int maxN = 1e5 + 69;
struct segment {
int l, r, p;
bool operator<(const segment& oth) const { return l < oth.l; }
};
int n, m, k;
vector<segment> vec;
struct PersistentSegmentTree {
static const int maxNodes = maxN * 19;
struct Node {
int v, lc, rc;
};
int n;
vector<Node> st;
vector<int> ver;
PersistentSegmentTree(int n) {
this->n = n;
st.reserve(maxNodes);
}
PersistentSegmentTree() {}
int create(Node a) {
st.push_back(a);
return st.size() - 1;
}
int build(int l, int r) {
if (l == r) {
return create({INF});
}
int mid = (l + r) / 2;
int id = create({INF, build(l, mid), build(mid + 1, r)});
return id;
}
int update(int i, int v, int oldId, int l, int r) {
if (l == r) {
return create({min(v, st[oldId].v)});
}
int mid = (l + r) / 2;
int id = create(st[oldId]);
if (i <= mid)
st[id].lc = update(i, v, st[oldId].lc, l, mid);
else
st[id].rc = update(i, v, st[oldId].rc, mid + 1, r);
st[id].v = max(st[st[id].lc].v, st[st[id].rc].v);
return id;
}
int get(int L, int R, int id, int l, int r) {
if (R < l || r < L) return -1;
if (L <= l && r <= R) return st[id].v;
int mid = (l + r) / 2;
int lv = get(L, R, st[id].lc, l, mid);
int rv = get(L, R, st[id].rc, mid + 1, r);
return max(lv, rv);
}
void build() {
ver.push_back(0);
build(1, n);
}
void update(int i, int v) { ver.push_back(update(i, v, ver.back(), 1, n)); }
int get(int L, int R, int k) { return get(L, R, ver[k], 1, n); }
} pst;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
int l, r, p;
cin >> l >> r >> p;
vec.push_back({l, r, p});
}
sort(vec.begin(), vec.end());
pst = PersistentSegmentTree(n);
pst.build();
for (int i = (int)vec.size() - 1; i >= 0; i--) {
pst.update(vec[i].p, vec[i].r);
}
while (m--) {
int a, b, x, y;
cin >> a >> b >> x >> y;
int pos = lower_bound(vec.begin(), vec.end(), segment{x}) - vec.begin();
int ver = vec.size() - pos;
if (pst.get(a, b, ver) <= y)
cout << "yes" << endl;
else
cout << "no" << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
const int K = 1e4;
const int INF = 0x3f3f3f3f;
int n, st, k, f[N + 10][K + 10];
char s[N + 10];
struct data {
int va, x;
} a[N + 10];
bool cmp(data p, data q) { return p.va < q.va; }
int Abs(int x) { return (x < 0) ? (-x) : x; }
int main() {
scanf("%d%d%d", &n, &st, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].va);
a[i].x = i;
}
scanf("%s", s + 1);
sort(a + 1, a + n + 1, cmp);
a[0].x = st;
memset(f, 0x3f, sizeof(f));
f[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= k; j++) {
if (f[i][j] == INF) continue;
for (int i2 = i + 1; i2 <= n; i2++) {
if (i && (s[a[i2].x] == s[a[i].x] || a[i].va == a[i2].va)) continue;
f[i2][min(j + a[i2].va, k)] =
min(f[i2][min(j + a[i2].va, k)], f[i][j] + Abs(a[i].x - a[i2].x));
}
}
}
int min0 = INF;
for (int i = 1; i <= n; i++) min0 = min(min0, f[i][k]);
if (min0 == INF)
printf("-1\n");
else
printf("%d\n", min0);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int markk[200000], n, len[200000];
char mapp[200000];
int fin(int i) {
int x;
if (i >= n || i < 0) {
return 0;
}
if (markk[i] == 1) {
return 1;
}
markk[i] = 1;
if (mapp[i] == '>') {
return fin(i + len[i]);
}
if (mapp[i] == '<') {
return fin(i - len[i]);
}
}
int main() {
int i, j, k;
scanf("%d", &n);
scanf("%s", mapp);
for (i = 0; i < n; i++) {
scanf("%d", &len[i]);
}
k = fin(0);
if (k == 0) {
printf("FINITE\n");
} else {
printf("INFINITE\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 119 << 23 | 1;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int)1e9 + 23111992;
const long long LINF = (long long)1e18 + 23111992;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline unsigned long long isqrt(unsigned long long k) {
unsigned long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() { return abs((int)mt()); }
void chemthan() {
int n;
cin >> n;
vector<vector<int> > adj(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);
}
vector<vector<int> > dp(n, vector<int>(5));
function<void(int, int)> dfs = [&](int u, int p) {
dp[u][0] = 1;
vector<int> x, y, z;
x.push_back(1);
for (int v : adj[u]) {
if (v ^ p) {
dfs(v, u);
dp[u][0] = mult(dp[u][0], dp[v][1] + dp[v][2]);
x.push_back((dp[v][1] + dp[v][2]) % MOD);
y.push_back(((long long)dp[v][0] + dp[v][1] + dp[v][4]) % MOD);
z.push_back((dp[v][1] + dp[v][2]) % MOD);
}
}
y.push_back(1), z.push_back(1);
for (int i = (1); i < (int((x).size())); ++i) x[i] = mult(x[i], x[i - 1]);
for (int i = (int((y).size()) - 1) - 1; i >= (0); --i)
y[i] = mult(y[i], y[i + 1]);
for (int i = (int((z).size()) - 1) - 1; i >= (0); --i)
z[i] = mult(z[i], z[i + 1]);
int ptr = 0, flag = 0;
for (int v : adj[u]) {
if (v ^ p) {
ptr++;
if (!flag) {
addmod(dp[u][1], mult(x[ptr - 1], mult(y[ptr], dp[v][3])));
} else {
addmod(dp[u][3], mult(x[ptr - 1], mult(y[ptr], dp[v][3])));
addmod(dp[u][4], mult(x[ptr - 1], mult(y[ptr], dp[v][3])));
}
} else {
flag = 1;
addmod(dp[u][2], mult(x[ptr], y[ptr]));
addmod(dp[u][3], mult(x[ptr], z[ptr]));
}
}
};
dfs(0, -1);
int res = 0;
addmod(res, dp[0][0]);
addmod(res, dp[0][1]);
cout << res << "\n";
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
chemthan();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const double eps = 1e-8;
const int maxn = 205;
int x[maxn], y[maxn];
struct Matrix {
double a[maxn][maxn];
void init() {
memset(a, 0, sizeof(a));
for (int i = 0; i < maxn; ++i) {
a[i][i] = 1;
}
}
} P[14];
Matrix mul(Matrix a, Matrix b) {
Matrix ans;
memset(ans.a, 0, sizeof(ans.a));
for (int i = 0; i < maxn; ++i) {
for (int k = 0; k < maxn; ++k) {
if (a.a[i][k] != 0)
for (int j = 0; j < maxn; ++j) {
ans.a[i][j] += a.a[i][k] * b.a[k][j];
}
}
}
return ans;
}
vector<pair<double, int> > v;
double d[maxn], e[maxn];
int main() {
int n, q;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d %d", x + i, y + i);
for (int i = 1; i <= n; ++i) {
v.clear();
for (int j = 1; j <= n; ++j) {
if (j == i) continue;
double theta = atan2(x[j] - x[i], y[j] - y[i]);
while (theta < 0) theta += pi;
while (theta >= pi) theta -= pi;
v.push_back(pair<double, int>(theta, j));
}
sort(v.begin(), v.end());
int line = 0;
for (int j = 0, k; j < n - 1;) {
for (k = j; k < n - 1 && fabs(v[k].first - v[j].first) < eps; ++k)
;
j = k, line++;
}
for (int j = 0, k; j < n - 1;) {
for (k = j; k < n - 1 && fabs(v[k].first - v[j].first) < eps; ++k)
;
for (int p = j; p < k; ++p)
P[0].a[v[p].second][i] += 1.0 / line / (k - j + 1);
P[0].a[i][i] += 1.0 / line / (k - j + 1);
j = k;
}
}
for (int i = 1; i < 14; ++i) P[i] = mul(P[i - 1], P[i - 1]);
scanf("%d", &q);
while (q--) {
int t, m;
scanf("%d %d", &t, &m);
m--;
memset(d, 0, sizeof(d));
d[t] = 1;
for (int i = 0; i < 14; ++i) {
if (m & (1 << i)) {
memset(e, 0, sizeof(e));
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= n; ++k) e[j] += P[i].a[k][j] * d[k];
memcpy(d, e, sizeof(d));
}
}
double ans = 0;
for (int i = 1; i <= n; ++i) {
v.clear();
for (int j = 1; j <= n; ++j) {
if (j == i) continue;
double theta = atan2(x[j] - x[i], y[j] - y[i]);
while (theta < 0) theta += pi;
while (theta >= pi) theta -= pi;
v.push_back(pair<double, int>(theta, j));
}
sort(v.begin(), v.end());
for (int j = 0, k; j < n - 1;) {
double tmp = 0;
for (k = j; k < n - 1 && fabs(v[k].first - v[j].first) < eps; ++k)
;
for (int p = j; p < k; ++p) tmp += d[v[p].second] / (k - j + 1);
tmp += d[i] / (k - j + 1);
ans = max(ans, tmp);
j = k;
}
}
printf("%.10f\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e6 + 6;
const int P1 = 792924877;
const int P2 = 1017450191;
const int P3 = 614677073;
const int P4 = 809880751;
const int P5 = 1061596561;
const int DIGIT = 401016061;
struct HASH {
const int MOD;
long long p[MAX_N], h[MAX_N], rh[MAX_N];
HASH() = delete;
HASH(const int x) : MOD(x) {
p[0] = 1;
for (int i = 1; i < MAX_N; i++) p[i] = (p[i - 1] * DIGIT) % MOD;
}
void calc_h(char *s, int n) {
h[0] = rh[n + 1] = 0;
for (int i = 1; i <= n; i++)
h[i] = (h[i - 1] * DIGIT + s[i] - 'a' + 1) % MOD;
for (int i = n; i >= 1; i--)
rh[i] = (rh[i + 1] * DIGIT + s[i] - 'a' + 1) % MOD;
}
long long H(int l, int r) {
return ((h[r] - h[l - 1] * p[r - l + 1] % MOD) % MOD + MOD) % MOD;
}
long long RH(int l, int r) {
return ((rh[l] - rh[r + 1] * p[r - l + 1] % MOD) % MOD + MOD) % MOD;
}
bool same(int l, int r) { return H(l, r) == RH(l, r); }
} h1(P1), h2(P2), h3(P3), h4(P4), h5(P5);
int t;
char s[MAX_N];
int n;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%s", s + 1);
n = strlen(s + 1);
h1.calc_h(s, n);
h2.calc_h(s, n);
int same = 0;
for (int i = 1, j = n; i < j && s[i] == s[j]; i++, j--) same++;
int L = same, R = n - same + 1;
for (int i = L + 1, l = i; i <= n - same; i++)
if (h1.same(l, i) && h2.same(l, i) && h3.same(l, i) && h4.same(l, i) &&
h5.same(l, i))
L = i;
for (int i = R - 1, r = i; i >= same + 1; i--)
if (h1.same(i, r) && h2.same(i, r) && h3.same(i, r) && h4.same(i, r) &&
h5.same(i, r))
R = i;
for (int i = 1; i <= same; i++) putchar(s[i]);
if (L > n - R + 1)
for (int i = same + 1; i <= L; i++) putchar(s[i]);
else
for (int i = R; i <= n - same; i++) putchar(s[i]);
for (int i = n - same + 1; i <= n; i++) putchar(s[i]);
puts("");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long int lxt() {
long long int aaa;
scanf("%lld", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
int ar[1000010];
int main() {
int n = nxt();
cout << n << endl;
for (int i = 1; i <= n; i++) {
printf("1 ");
}
printf("\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << (b == a || c != 0 && (b - a) % c == 0 && (b - a) / c >= 0 ? "YES"
: "NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
int A[200];
int inside[200], outside[200];
int main(int argc, char** argv) {
std::ios::sync_with_stdio(false);
cin >> N >> K;
int mx = -100000;
for (int i = 0; i < N; i++) {
cin >> A[i];
mx = max(mx, A[i]);
}
int ans;
if (mx <= 0) {
ans = mx;
} else {
ans = 0;
for (int i = 0; i < N; i++) {
for (int j = i; j < N; j++) {
if (i == 2 && j == 7) {
cout << "";
}
int sum = 0;
for (int k = i; k <= j; k++) sum += A[k];
int in = 0, ou = 0;
for (int k = 0; k < N; k++) {
if (i <= k && k <= j)
inside[in++] = A[k];
else
outside[ou++] = A[k];
}
sort(inside, inside + in);
sort(outside, outside + ou, greater<int>());
for (int k = 0; k < min(K, min(in, ou)); k++) {
if (outside[k] <= inside[k]) break;
sum += outside[k] - inside[k];
}
ans = max(ans, sum);
}
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 100;
const int mod = (int)1e9 + 7;
const int P = (int)1e6 + 7;
int n, cnt[33], dp[2666][2666];
pair<int, int> par[2666][2666];
char second[maxn];
int calc(int l, int r) {
if (l > r) return 0;
if (l == r) return 1;
int &res = dp[l][r];
if (res != -1) return res;
res = -mod;
if (second[l] == second[r]) {
res = calc(l + 1, r - 1) + 2;
par[l][r] = make_pair(l + 1, r - 1);
}
if (calc(l + 1, r) > res) {
res = calc(l + 1, r);
par[l][r] = make_pair(l + 1, r);
}
if (res < calc(l, r - 1)) {
res = calc(l, r - 1);
par[l][r] = make_pair(l, r - 1);
}
return res;
}
string path(int l, int r) {
if (l > r) return "";
if (l == r) {
string cur = "";
cur += second[l];
return cur;
}
pair<int, int> p = par[l][r];
int pl = p.first, pr = p.second;
string ans = "";
if (l != pl && r != pr) {
ans = second[l] + path(pl, pr) + second[r];
} else {
ans = path(pl, pr);
}
return ans;
}
int main() {
scanf("%s", second + 1);
n = strlen(second + 1);
for (int i = (1); i <= (n); ++i) {
cnt[second[i] - 'a']++;
if (cnt[second[i] - 'a'] == 100) {
while (cnt[second[i] - 'a']--) cout << second[i];
return 0;
}
}
memset(dp, -1, sizeof(dp));
calc(1, n);
string ans = path(1, n);
if (((int)(ans).size()) <= 100)
cout << ans;
else {
int m = ((int)(ans).size());
string ss = "";
for (int i = (0); i <= (49); ++i) ss += ans[i];
cout << ss;
reverse((ss).begin(), (ss).end());
cout << ss;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x1fffffffffffffff;
const double INFD = 1e20;
const double EPS = 1e-9;
const double PI = atan(1) * 4;
const long long M = 1000000007;
long long scan() {
long long r;
scanf("%lld", &r);
return r;
}
void scanstr(char *buf) { scanf("%s", buf); }
void dumpVI(vector<long long> &x) {
for (auto v : x) {
cerr << v << ",";
}
cerr << endl;
}
void tarjan_dfs(long long current, long long parent, long long &timer,
long long &cn, vector<long long> &vtime,
vector<long long> &rtime, vector<long long> &v2e0,
vector<long long> &e2t, vector<long long> &e2n,
vector<long long> &v2c, stack<long long> &stk) {
stk.push(current);
rtime[current] = vtime[current] = timer++;
for (long long e = v2e0[current]; e >= 0; e = e2n[e]) {
long long next = e2t[e];
if (next == parent) continue;
if (vtime[next] == -1) {
tarjan_dfs(next, current, timer, cn, vtime, rtime, v2e0, e2t, e2n, v2c,
stk);
rtime[current] = min(rtime[current], rtime[next]);
} else if (v2c[next] == -1)
rtime[current] = min(rtime[current], vtime[next]);
}
if (vtime[current] == rtime[current]) {
while (true) {
long long v = stk.top();
v2c[v] = cn;
stk.pop();
if (v == current) break;
}
cn++;
}
}
void work(const vector<long long> &v2e0, const vector<long long> &e2t,
const vector<long long> &e2c, const vector<long long> &e2n,
vector<long long> &score, vector<long long> &isSp, long long spn,
long long current, long long parent, vector<long long> &spCount,
vector<long long> &fio, vector<long long> &fore) {
fio[current] = score[current];
spCount[current] = (isSp[current]) ? 1 : 0;
for (long long e = v2e0[current]; e >= 0; e = e2n[e]) {
long long next = e2t[e];
if (next == parent) continue;
work(v2e0, e2t, e2c, e2n, score, isSp, spn, next, current, spCount, fio,
fore);
spCount[current] += spCount[next];
fore[next] = (spCount[next] > 0 && spCount[next] < spn)
? max(0LL, fio[next] - e2c[e])
: fio[next];
fio[current] += fore[next];
}
}
void calc(vector<long long> &v2e0, vector<long long> &e2t,
vector<long long> &e2c, vector<long long> &e2n, long long spn,
long long current, long long parent, vector<long long> &spCount,
vector<long long> &fio, vector<long long> &fore,
vector<long long> &ans, long long fioParent, long long srcEdge) {
long long parentScore = (spCount[current] > 0 && spCount[current] < spn)
? max(0LL, fioParent - e2c[srcEdge])
: fioParent;
ans[current] = fio[current] + parentScore;
for (long long e = v2e0[current]; e >= 0; e = e2n[e]) {
long long next = e2t[e];
if (next == parent) continue;
long long fioAsChild = fio[current] - fore[next] + parentScore;
calc(v2e0, e2t, e2c, e2n, spn, next, current, spCount, fio, fore, ans,
fioAsChild, e);
}
}
int main() {
long long n = scan();
long long m = scan();
long long k = scan();
vector<long long> c(n);
vector<long long> w(m);
vector<long long> isSp0(n);
for (long long i = 0; i < k; ++i) isSp0[scan() - 1] = 1;
for (long long i = 0; i < n; ++i) c[i] = scan();
for (long long i = 0; i < m; ++i) w[i] = scan();
vector<long long> _v2e0(n, -1);
vector<long long> _e2f;
vector<long long> _e2t;
vector<long long> _e2c;
vector<long long> _e2n;
for (long long i = 0; i < m; ++i) {
long long x = scan() - 1;
long long y = scan() - 1;
_e2f.push_back(x);
_e2t.push_back(y);
_e2c.push_back(w[i]);
_e2n.push_back(_v2e0[x]);
_v2e0[x] = _e2f.size() - 1;
_e2f.push_back(y);
_e2t.push_back(x);
_e2c.push_back(w[i]);
_e2n.push_back(_v2e0[y]);
_v2e0[y] = _e2f.size() - 1;
}
long long timer = 0;
long long cn = 0;
vector<long long> vtime(n, -1);
vector<long long> rtime(n, -1);
vector<long long> _v2c(n, -1);
stack<long long> stk;
tarjan_dfs(0, -1, timer, cn, vtime, rtime, _v2e0, _e2t, _e2n, _v2c, stk);
vector<long long> v2e0(cn, -1);
vector<long long> e2n;
vector<long long> e2c;
vector<long long> e2t;
vector<long long> e2f;
set<tuple<long long, long long>> eset;
for (long long i = 0; i < m; ++i) {
long long cx = _v2c[_e2f[i * 2]], cy = _v2c[_e2t[i * 2]];
if (cx == cy) continue;
if (cx > cy) swap(cx, cy);
if (eset.find(make_tuple(cx, cy)) != eset.end()) continue;
e2n.push_back(v2e0[cx]);
e2c.push_back(_e2c[i * 2]);
e2f.push_back(cx);
e2t.push_back(cy);
v2e0[cx] = e2n.size() - 1;
e2n.push_back(v2e0[cy]);
e2c.push_back(_e2c[i * 2]);
e2t.push_back(cx);
e2f.push_back(cy);
v2e0[cy] = e2n.size() - 1;
}
vector<long long> score(cn);
vector<long long> isSp(cn);
for (long long i = 0; i < n; ++i) {
score[_v2c[i]] += c[i];
isSp[_v2c[i]] |= isSp0[i];
}
long long spn = 0;
for (long long i = 0; i < cn; ++i)
if (isSp[i]) spn++;
vector<long long> spCount(cn);
vector<long long> fio(cn);
vector<long long> fore(cn);
work(v2e0, e2t, e2c, e2n, score, isSp, spn, 0, -1, spCount, fio, fore);
vector<long long> ans(cn);
calc(v2e0, e2t, e2c, e2n, spn, 0, -1, spCount, fio, fore, ans, 0, -1);
for (long long i = 0; i < n - 1; ++i) {
cout << ans[_v2c[i]] << " ";
}
cout << ans[_v2c[n - 1]] << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
int a[N], L[N], R[N], f[N];
bool st[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (!L[a[i]]) L[a[i]] = i;
R[a[i]] = i;
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= N - 1; ++j) st[j] = 0;
f[i] = f[i - 1];
int minv = L[a[i]], sum = 0;
for (int j = i; j >= 1; --j) {
if (R[a[j]] > i) break;
minv = min(minv, L[a[j]]);
if (!st[a[j]]) st[a[j]] = 1, sum ^= a[j];
if (minv >= j) f[i] = max(f[i], f[j - 1] + sum);
}
}
printf("%d\n", f[n]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
struct node {
int banfcc;
int t;
};
queue<node> q;
vector<int> v;
map<pair<int, int>, int> mp;
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
v.push_back(x);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
node now, nxt;
now.banfcc = now.t = 0;
q.push(now);
int cnt = 0;
if (n == 0) {
if (v[0] == 0)
printf("1\n");
else
printf("-1\n");
return 0;
}
int t = 0;
while (!q.empty()) {
now = q.front();
q.pop();
nxt.t = now.t + 1;
for (int i = 0; i < v.size(); i++) {
nxt.banfcc = now.banfcc + v[i];
if (nxt.banfcc / n < nxt.t) continue;
if (mp[make_pair(nxt.banfcc, nxt.t)]) continue;
mp[make_pair(nxt.banfcc, nxt.t)] = 1;
if (nxt.banfcc / n == nxt.t && nxt.banfcc % n == 0) {
printf("%d\n", nxt.t);
return 0;
}
q.push(nxt);
}
t++;
if (t > 1000000) break;
}
cout << -1 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
const int MAXP = 2000100;
const long long MOD = 1e9 + 7;
int N;
int pprime[MAXP];
int arr[MAXN];
int pord[MAXN];
map<int, int> pv;
map<int, int> nd;
int nvp[MAXP];
int nf[MAXP];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> N;
for (int i = 2; i < MAXP; i++) {
if (!pprime[i]) {
pprime[i] = i;
for (int j = i; j < MAXP; j += i) pprime[j] = i;
}
}
for (int i = 0; i < N; i++) cin >> arr[i];
sort(arr, arr + N);
reverse(arr, arr + N);
int r = 0;
for (int i = 0; i < N; i++) {
int cp = arr[i];
bool gadd = false;
if (pv.find(cp) != pv.end()) {
cp--;
while (cp > 1) {
int np = pprime[cp], nc = 0;
while (cp % np == 0) {
cp /= np;
nc++;
}
pv[np];
if (pv[np] < nc) {
pv[np] = nc;
nd[np] = 1;
gadd = true;
} else if (pv[np] == nc)
nd[np]++;
}
pord[i] = arr[i] - 1;
} else {
pv[cp] = 1;
nd[cp] = 1;
gadd = true;
pord[i] = arr[i];
}
if (!gadd) r = 1;
}
for (pair<int, int> ppair : pv) {
nvp[ppair.first] = ppair.second;
}
for (int i = 0; i < N; i++) {
int cp = pord[i];
bool gadd = false;
while (cp > 1) {
int np = pprime[cp], nc = 0;
while (cp % np == 0) {
cp /= np;
nc++;
}
if (pv[np] == nc && nd[np] == 1) gadd = true;
}
if (!gadd) r = 1;
}
long long res = 1;
for (pair<int, int> ppair : pv) {
for (int i = 0; i < ppair.second; i++) res = (res * ppair.first) % MOD;
}
cout << (res + r) % MOD << "\n";
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pi = pair<int, int>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
if (n % 2 == 0) {
cout << "home" << endl;
} else {
cout << "contest" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
struct Modint {
int val;
Modint(int new_val = 0) { val = new_val; }
Modint operator+(Modint r) { return (val + r.val) % MOD; }
Modint operator-(Modint r) { return (val + MOD - r.val) % MOD; }
Modint operator*(Modint r) { return 1LL * val * r.val % MOD; }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> m >> n;
vector<string> ts(n);
for (int i = 0; i < n; i++) {
cin >> ts[i];
}
vector<long long> descriptors;
for (int j = 0; j < m; j++) {
long long val = 0;
for (int i = 0; i < n; i++) {
val = val * 2 + (ts[i][j] == '1');
}
descriptors.push_back(val);
}
sort(descriptors.begin(), descriptors.end());
static Modint dp[1001][1001];
dp[0][0] = 1;
for (int i = 0; i < m; i++) {
for (int j = 0; j <= i; j++) {
dp[i + 1][j] = dp[i + 1][j] + dp[i][j] * j;
dp[i + 1][j + 1] = dp[i + 1][j + 1] + dp[i][j];
}
}
Modint result = 1;
for (int i = 0, j = 0; i < m; i = j) {
while (j < m && descriptors[i] == descriptors[j]) {
j++;
}
Modint to_mult = 0;
for (int k = 0; k <= j - i; k++) {
to_mult = to_mult + dp[j - i][k];
}
result = result * to_mult;
}
cout << result.val << '\n';
return 0;
}
| 8 |
//#include <bits/stdc++.h>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#define ll long long
#define LL long long
using namespace std;
int main() {
// ios::sync_with_stdio(0);
// cin.tie(0);
// cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin>>n;
string s;
cin>>s;
string ans="";
int len = s.length(),la=-1;
for(int i=0;i<len;i++){
if(s[i]=='1'){
if(la==2){
ans+='0';
la=1;
}else{
ans+='1';
la=2;
}
}else{
if(la==1){
ans+='0';
la=0;
}else{
ans+='1';
la=1;
}
}
//cout<<la<<'-';
}
cout<<ans<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
void setmin(T& a, T val) {
if (a > val) a = val;
}
template <class T>
void setmax(T& a, T val) {
if (a < val) a = val;
}
void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
const int N = 100005;
vector<pair<long long, long long> > a, b;
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
long long l, r;
cin >> l >> r;
long long in1 = 0, p = 1, sum = 1;
while (r > sum) {
p = p * 2;
sum += p;
in1++;
}
sum = 0;
long long s1 = 0, s2 = 0;
for (int i = 0; i <= in1; i++) {
long long p = 1;
for (int j = 0; j < i; j++) p = p * 2;
if (sum + p <= r) {
if (i % 2 == 0)
s1 += p;
else
s2 += p;
} else {
if (i % 2 == 0)
s1 += r - sum;
else
s2 += r - sum;
}
sum += p;
}
s1 %= MOD;
s2 %= MOD;
long long tot = (s1 * s1) % MOD + ((s2 + 1) * s2) % MOD;
tot %= MOD;
in1 = 0, p = 1, sum = 1;
while ((l - 1) > sum) {
p = p * 2;
sum += p;
in1++;
}
sum = 0;
long long l1 = 0, l2 = 0;
for (int i = 0; i <= in1; i++) {
long long p = 1;
for (int j = 0; j < i; j++) p = p * 2;
if (sum + p <= l - 1) {
if (i % 2 == 0)
l1 += p;
else
l2 += p;
l1 %= MOD;
l2 %= MOD;
} else {
if (i % 2 == 0)
l1 += l - 1 - sum;
else
l2 += l - 1 - sum;
}
sum += p;
}
l1 %= MOD;
l2 %= MOD;
long long res = (l1 * l1) % MOD + ((l2 + 1) * (l2)) % MOD;
res %= MOD;
cout << (tot - res + MOD) % MOD << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long in[100005];
set<long long> S;
int n, k;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%I64d", &in[i]);
}
int ans = 0;
sort(in, in + n);
for (int i = 0; i < n; i++) {
if (in[i] % k != 0 || (in[i] % k == 0 && S.find(in[i] / k) == S.end())) {
ans++;
S.insert(in[i]);
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int num;
long long int temp;
vector<long long int> vi;
scanf("%d", &num);
set<int> st;
for (int i = 0; i < num; i++) {
scanf("%lld", &temp);
st.insert(temp);
}
for (set<int>::iterator it = st.begin(); it != st.end(); it++)
vi.push_back(*it);
sort(vi.begin(), vi.end());
for (int i = 0; i < vi.size() - 1; i++) {
if (vi[i + 1] != 1 && vi[i + 1] < vi[i] * 2) {
printf("YES\n");
return 0;
}
}
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int k;
cin >> s >> k;
vector<int> B(26, 0);
vector<pair<int, int> > A(26, make_pair(0, 0));
for (int i = 0; i < 26; i++) {
A[i].first = 0;
A[i].second = -1;
}
for (int i = 0; i < s.length(); i++) {
A[s[i] - 'a'].first++;
A[s[i] - 'a'].second = s[i] - 'a';
B[s[i] - 'a']++;
}
sort(A.begin(), A.end());
int cnt = 0;
for (int i = 0; i < 26; i++) {
if (k >= A[i].first && A[i].second != -1) {
B[A[i].second] = -1;
k -= A[i].first;
}
}
for (int i = 0; i < 26; i++) {
if (B[i] > 0) cnt++;
}
cout << endl << cnt << endl;
string ret;
for (int i = 0; i < s.length(); i++) {
if (B[s[i] - 'a'] > 0) cout << s[i];
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
stack<vector<string> > st;
char inp[200];
string modify() {
int j = 0, len = strlen(inp);
string ret = "";
for (j = 0; j < len; j++) {
if (inp[j] == '(' || inp[j] == ')' || inp[j] == ',' || inp[j] == '\"') {
ret += " ";
} else
ret += inp[j];
}
return ret;
}
int main() {
int n;
gets(inp);
sscanf(inp, "%d", &n);
for (int i = 0; i < n; i++) {
gets(inp);
int len = strlen(inp);
stringstream ss(stringstream::in | stringstream::out);
ss << modify();
vector<string> tmp;
string take;
while (ss >> take) {
tmp.push_back(take);
}
if (tmp.size() == 0) continue;
if (tmp[0] == "catch") {
string message = "";
int len = strlen(inp);
int freq = 0;
for (int j = len - 1; j >= 0; j--) {
if (inp[j] == '\"') {
freq++;
if (freq == 2) break;
} else if (freq == 1) {
message = inp[j] + message;
}
}
tmp.push_back(message);
}
if (tmp[0] == "try" || tmp[0] == "throw") {
st.push(tmp);
} else {
vector<string> take = st.top();
if (take[0] == "throw") {
if (take[1] == tmp[1]) {
cout << tmp[tmp.size() - 1] << endl;
return 0;
} else {
st.pop();
st.pop();
st.push(take);
}
} else {
st.pop();
}
}
}
cout << "Unhandled Exception" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
const int M = 55;
const int K = 26;
const int Inf = 1e8;
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;
}
};
int Dp1[N][K];
int Dp2[N][K];
void KMP(string t, int Type) {
int m = t.size();
vector<int> LongestPrefix(m);
for (int i = 1, k = 0; i < m; i++) {
while (k > 0 && t[i] != t[k]) k = LongestPrefix[k - 1];
if (t[i] == t[k])
LongestPrefix[i] = ++k;
else
LongestPrefix[i] = k;
}
for (int i = 0; i < m; i++)
for (char c = 'a'; c <= 'z'; c++)
if (Type == 1)
Dp1[i][c - 'a'] =
((t[i] == c) ? i + 1
: (i ? Dp1[LongestPrefix[i - 1]][c - 'a'] : 0));
else
Dp2[i][c - 'a'] =
((t[i] == c) ? i + 1
: (i ? Dp2[LongestPrefix[i - 1]][c - 'a'] : 0));
for (char c = 'a'; c <= 'z'; c++)
if (Type == 1)
Dp1[m][c - 'a'] = Dp1[LongestPrefix[m - 1]][c - 'a'];
else
Dp2[m][c - 'a'] = Dp2[LongestPrefix[m - 1]][c - 'a'];
}
int n;
char s[N];
int Dp[N][M][M];
string t1, t2;
int Rec(int i, int k1, int k2) {
if (i == n) return 0;
if (Dp[i][k1][k2] != Inf) return Dp[i][k1][k2];
int Res = -Inf;
for (char j = 'a'; j <= 'z'; j++)
if (s[i] == '*' || s[i] == j) {
int z1 = Dp1[k1][j - 'a'];
int z2 = Dp2[k2][j - 'a'];
int Res1 = (z1 == t1.size());
int Res2 = (z2 == t2.size());
Res = max(Res, Res1 - Res2 + Rec(i + 1, z1, z2));
}
return Dp[i][k1][k2] = Res;
}
int main() {
scanf("%s", s);
n = strlen(s);
cin >> t1 >> t2;
KMP(t1, 1);
KMP(t2, 2);
for (int i = 0; i < N; i++)
for (int k1 = 0; k1 < M; k1++)
for (int k2 = 0; k2 < M; k2++) Dp[i][k1][k2] = -Inf;
for (int k1 = 0; k1 < M; k1++)
for (int k2 = 0; k2 < M; k2++) Dp[n][k1][k2] = 0;
for (int i = n - 1; ~i; i--)
for (int k1 = 0; k1 <= t1.size(); k1++)
for (int k2 = 0; k2 <= t2.size(); k2++) {
int& Res = Dp[i][k1][k2];
for (char j = 'a'; j <= 'z'; j++)
if (s[i] == '*' || s[i] == j) {
int z1 = Dp1[k1][j - 'a'];
int z2 = Dp2[k2][j - 'a'];
int Res1 = (z1 == t1.size());
int Res2 = (z2 == t2.size());
Res = max(Res, Res1 - Res2 + Dp[i + 1][z1][z2]);
}
}
cout << Dp[0][0][0];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool A[2010][2010];
bool B[2010][2010];
int C1[2010], C2[2010];
int C11[2010], C22[2010];
int D[2010];
int S, S1;
void load() {
cin >> n;
string T;
for (int i = 1; i <= n; ++i) {
cin >> T;
for (size_t j = 0; j < T.size(); ++j)
if (T[j] == '1') A[i][j + 1] = 1;
}
}
void algo1() {
for (int i = 1; i <= n; ++i)
for (int j = n; j > i; j--)
if ((C1[j] + C2[i]) % 2 != A[i][j]) {
C1[j]++, C2[i]++, S1++, D[i]++, D[j]++;
}
for (int i = n; i >= 1; i--)
for (int j = 1; j < i; ++j)
if ((C11[j] + C22[i]) % 2 != A[i][j]) {
C11[j]++, C22[i]++, S1++, D[i]++, D[j]++;
}
for (int i = 1; i <= n; ++i)
if (D[i] % 2 != A[i][i]) D[i]++, S1++;
}
void write() { cout << S1 << endl; }
int main() {
load();
algo1();
write();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, m, len, a, b, ans, ansa = 0, ansb = 0;
char s[200005];
scanf("%d", &n);
scanf("%s", s);
len = strlen(s);
for (auto i = 0; i < len; i++) {
if (s[i] == '<')
ansa++;
else
break;
}
for (auto i = len - 1; i > -1; i--) {
if (s[i] == '>') {
ansb++;
} else
break;
}
printf("%d\n", min(len, ansa + ansb));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
int a1 = 0;
int a2 = 0;
int flag1 = 0;
int flag2 = 0;
cin >> n;
int h[101];
memset(h, 0, sizeof(h));
for (int i = 0; i < n; i++) {
cin >> x;
h[x]++;
}
for (int i = 0; i <= 100; i++) {
if (flag1 == 1 && flag2 == 1) break;
if (h[i] == 0) {
if (flag1 == 0) {
a1 = i;
flag1 = 1;
}
if (flag2 == 0) {
a2 = i;
flag2 = 1;
}
}
if (h[i] == 1) {
if (flag1 == 0) {
a1 = i;
flag1 = 1;
} else if (flag2 == 0) {
a2 = i;
}
}
}
int ans = a1 + a2;
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int cnt;
int v[1000001];
int siz[1000001];
vector<int> e[1000001];
int dp[1000001];
void get_siz(int u) {
if (e[u].empty()) siz[u] = 1;
for (int i = 0; i < e[u].size(); i++) {
get_siz(e[u][i]);
siz[u] += siz[e[u][i]];
}
}
int dfs(int u) {
if (e[u].empty()) return 0;
for (int i = 0; i < e[u].size(); i++) dfs(e[u][i]);
int ans = 0;
if (v[u] == 1) {
ans = 999999999;
for (int i = 0; i < e[u].size(); i++) {
int to = e[u][i];
ans = min(ans, dp[to]);
}
return dp[u] = ans;
} else {
for (int i = 0; i < e[u].size(); i++) {
int to = e[u][i];
ans += dp[to] + 1;
}
return dp[u] = ans - 1;
}
}
signed main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
for (int i = 2; i <= n; i++) {
int fa;
scanf("%d", &fa);
e[fa].push_back(i);
}
cnt = n;
get_siz(1);
dfs(1);
printf("%d", siz[1] - dp[1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
int i, a, num = 0;
cin >> a;
cin >> str;
for (i = 1; i < a - 1; i++) {
if (str[i] == 'x') {
if ((str[i + 1] == 'x') && (str[i - 1] == 'x')) {
num++;
}
}
}
cout << num << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int m, n, c[40];
int main() {
scanf("%d%d", &m, &n);
for (int i = 1; i <= n; i++) {
puts("1");
fflush(stdout);
int t;
scanf("%d", &t);
if (t == 0) return 0;
if (t == -1)
c[i] = -1;
else
c[i] = 1;
}
int low = 1, up = m, mid;
int i = 1;
while (1) {
mid = low + up >> 1;
printf("%d\n", mid);
fflush(stdout);
int t;
scanf("%d", &t);
if (t == 0) return 0;
t *= c[i++];
if (i == n + 1) i = 1;
if (t == 1)
low = mid + 1;
else
up = mid - 1;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 105, MMAX = 1e4 + 5;
int n, m;
string table[NMAX];
int idx[NMAX][MMAX];
int main() {
cin >> n >> m;
for (int r = 0; r < n; ++r) {
cin >> table[r];
memset(idx[r], MMAX, sizeof(idx[r]));
int c;
for (c = 0; c < m; ++c) {
if (table[r][c] == '1') {
break;
}
}
if (c == m) {
puts("-1");
return 0;
}
for (int i = 1; i <= 2 * m; ++i) {
if (table[r][((c + i) % m + m) % m] == '1')
idx[r][((c + i) % m + m) % m] = 0;
else
idx[r][((c + i) % m + m) % m] =
min(idx[r][((c + i) % m + m) % m],
idx[r][((c + i - 1) % m + m) % m] + 1);
}
for (int i = 1; i <= 2 * m; ++i) {
if (table[r][((c - i) % m + m) % m] == '1')
idx[r][((c - i) % m + m) % m] = 0;
else
idx[r][((c - i) % m + m) % m] =
min(idx[r][((c - i) % m + m) % m],
idx[r][((c - i + 1) % m + m) % m] + 1);
}
}
int ans = NMAX * MMAX;
for (int c = 0; c < m; ++c) {
int res = 0;
for (int r = 0; r < n; ++r) res += idx[r][c];
ans = min(ans, res);
}
cout << ans << '\n';
}
| 3 |
#include <bits/stdc++.h>
int min(int a, int b) { return a < b ? a : b; }
int *ej[100000], eo[100000], *ej_[100000], eo_[100000], *dp[100000],
deg[100000], n;
void append(int i, int j) {
int o = eo[i]++;
if (o >= 2 && (o & o - 1) == 0)
ej[i] = (int *)realloc(ej[i], o * 2 * sizeof *ej[i]);
ej[i][o] = j;
}
char used[100000];
int cc[100000], jj[100000], kkb[100000], kkr[100000];
int tt[100000], kk[100000], ii[100000], cc_[100000];
void dfs1(int p, int i) {
int o, j_, k;
memset(dp[i], 0, deg[i] * 2 * sizeof *dp[i]);
j_ = -1;
for (o = eo[i]; o--;) {
int j = ej[i][o];
if (j != p) {
dfs1(i, j);
if (jj[j] == -1) {
dp[i][0]++;
if (kkr[j] <= -deg[i])
dp[i][0] -= 2;
else if (kkr[j] <= deg[i])
dp[i][deg[i] - 1 + kkr[j]] -= 2;
} else if (j_ == -1)
j_ = j;
else
j_ = -2;
}
}
for (k = 1; k < deg[i] * 2; k++) dp[i][k] += dp[i][k - 1];
if (j_ == -1 && !used[i]) {
jj[i] = -1;
if (deg[i] == 0)
kkr[i] = cc[i] == 0 ? -0x3f3f3f3f : 0x3f3f3f3f;
else {
k = -(deg[i] - 1);
while (k <= deg[i] && dp[i][k + deg[i] - 1] >= k) k++;
kkr[i] = k;
}
} else if (j_ != -2 && !used[i]) {
jj[i] = jj[j_];
k = -(deg[i] - 1);
while (k <= deg[i] && dp[i][k + deg[i] - 1] + (k <= kkb[j_] ? 1 : -1) >= k)
k++;
kkb[i] = k - 1;
while (k <= deg[i] && dp[i][k + deg[i] - 1] + (k < kkr[j_] ? 1 : -1) >= k)
k++;
kkr[i] = k;
} else {
jj[i] = i, kkb[i] = -0x3f3f3f3f, kkr[i] = 0x3f3f3f3f, used[i] = 1;
for (o = eo[i]; o--;) {
int j = ej[i][o];
if (j != p && jj[j] != -1) ej_[i][eo_[i]++] = j;
}
}
}
int dfs2(int i, int k_) {
int o, k;
if (deg[i] == 0) return cc[i];
if (k_ <= -deg[i]) return 1;
if (k_ > deg[i]) return 0;
k = 0;
for (o = eo_[i]; o--;) {
int j = ej_[i][o], c = dfs2(jj[j], k_);
if (k_ <= kkb[j])
c = 1;
else if (k_ >= kkr[j])
c = 0;
if (c == 1)
k++;
else
k--;
}
k += dp[i][deg[i] - 1 + k_];
return k >= k_;
}
void solve(int hl, int hr) {
int h;
memset(used, 0, n * sizeof *used);
for (h = hl; h < hr; h++)
if (tt[h] != 3) used[ii[h]] = 1;
memset(eo_, 0, n * sizeof *eo_);
dfs1(-1, 0);
for (h = hl; h < hr; h++)
if (tt[h] == 1)
printf("%d\n", dfs2(ii[h], kk[h]));
else if (tt[h] == 2)
cc[ii[h]] = cc_[h];
}
int main() {
int q, k, h, i, j;
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) ej[i] = (int *)malloc(2 * sizeof *ej[i]);
for (h = 0; h < n - 1; h++) {
scanf("%d%d", &i, &j), i--, j--;
append(i, j), append(j, i);
}
for (i = 0; i < n; i++) {
scanf("%d", &cc[i]);
deg[i] = i == 0 ? eo[i] : eo[i] - 1;
ej_[i] = (int *)malloc(deg[i] * sizeof *ej_[i]);
dp[i] = (int *)malloc(deg[i] * 2 * sizeof *dp[i]);
}
scanf("%d", &q);
for (h = 0; h < q; h++) {
int x;
scanf("%d%d", &tt[h], &x);
if (tt[h] == 1)
ii[h] = x - 1;
else if (tt[h] == 2)
scanf("%d", &cc_[h]), ii[h] = x - 1;
else
k = x;
kk[h] = k;
}
for (h = 0; h < q; h += 3000) solve(h, min(h + 3000, q));
return 0;
}
| 13 |
#include <bits/stdc++.h>
const long long M = 1e9 + 7;
const double pi = 3.14159265358979323846;
using namespace std;
vector<long long> adj[100005];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a, b, c;
cin >> a >> b >> c;
string s;
cin >> s;
vector<char> v;
long long h = n / 2;
if (n % 2 != 0) h++;
long long flag = 0, cnt = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == 'R') {
if (b > 0) {
v.push_back('P');
b--;
cnt++;
} else {
v.push_back('%');
}
}
if (s[i] == 'P') {
if (c > 0) {
v.push_back('S');
c--;
cnt++;
} else
v.push_back('%');
}
if (s[i] == 'S') {
if (a > 0) {
v.push_back('R');
a--;
cnt++;
} else
v.push_back('%');
}
}
for (long long i = 0; i < n; i++) {
if (v[i] == '%') {
if (b > 0) {
v[i] = 'P';
b--;
} else if (c > 0) {
v[i] = 'S';
c--;
} else if (a > 0) {
v[i] = 'R';
a--;
}
}
}
if (cnt >= h) {
cout << ("YES") << "\n";
for (long long i = 0; i < v.size(); i++) cout << v[i];
cout << "\n";
} else
cout << ("NO") << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
#pragma GCC target("avx2")
using namespace std;
template <class T, class U>
inline void checkmin(T& x, U y) {
if (y < x) x = y;
}
template <class T, class U>
inline void checkmax(T& x, U y) {
if (y > x) x = y;
}
template <class T, class U>
inline bool ifmax(T& x, U y) {
if (y > x) return x = y, true;
return false;
}
template <class T, class U>
inline bool ifmin(T& x, U y) {
if (y < x) return x = y, true;
return false;
}
template <class T>
inline void sort(T& a) {
sort(a.begin(), a.end());
}
template <class T>
inline void rsort(T& a) {
sort(a.rbegin(), a.rend());
}
template <class T>
inline void reverse(T& a) {
reverse(a.begin(), a.end());
}
template <class T, class U>
inline istream& operator>>(istream& str, pair<T, U>& p) {
return str >> p.first >> p.second;
}
template <class T>
inline istream& operator>>(istream& str, vector<T>& a) {
for (auto& i : a) str >> i;
return str;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(12);
srand(94385);
long long t, a, b, n;
cin >> t;
while (t--) {
cin >> a >> b >> n;
if (n % 3 == 0)
cout << a;
else if (n % 3 == 1)
cout << b;
else
cout << (a ^ b);
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int a[101001];
vector<int> positions[101010];
int tr[404040];
int b[101010];
int dp[404040];
long long getSum(int* b, int* dp, int n) {
long long res = 0;
for (int j = 0; j < n; ++j) {
res += b[j] > 0 ? 0 : dp[j];
}
return res;
}
const int fftmod = 998244353;
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < (n); ++i) {
b[i] -= k;
}
for (int i = 0; i < (n); ++i) {
cin >> a[i];
--a[i];
positions[i].push_back(-1);
positions[i].push_back(-1);
}
dp[0] = 1;
for (int i = 0; i < n; ++i) {
int x = a[i];
{
int to = positions[x].back();
int from = *++positions[x].rbegin() + 1;
for (int j = from; j <= to; ++j) {
b[j]--;
}
}
int from = positions[x].back() + 1;
for (int j = from; j <= i; ++j) {
b[j]++;
}
long long res = 0;
for (int j = 0; j < i + 1; ++j) res += b[j] > 0 ? 0 : dp[j];
dp[i + 1] = res % fftmod;
positions[x].push_back(i);
}
cout << dp[n] << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
float l, d, v, g, r, t = 0, x, y, z, z2;
cin >> l >> d >> v >> g >> r;
if (d == l)
t = t + (l / v);
else {
t = t + (d / v);
l = l - d;
x = t;
while (x > 0) {
y = x;
x = x - g;
if (x > 0) {
y = x;
x = x - r;
if (x > 0)
y = x;
else {
t = t + r;
t = t - y;
break;
}
} else if (x == 0) {
t = t + r;
break;
} else
break;
}
t = t + (l / v);
}
cout << setprecision(8) << t;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
void ioi(string name) {
freopen((name + ".in").c_str(), "r", stdin);
freopen((name + ".out").c_str(), "w", stdout);
}
int n, c[10], d[10][10];
void solve() {
cin >> n;
for (int i = 1; i <= 5; i++)
for (int j = 1; j <= 5; j++) c[i] = d[i][j] = 0;
for (int i = 1; i <= n; i++) {
vector<int> v;
for (int j = 1; j <= 5; j++) {
int x;
cin >> x;
if (x) v.push_back(j);
}
for (int j = 0; j < (int)v.size(); j++) {
c[v[j]]++;
for (int k = j + 1; k < (int)v.size(); k++) {
d[v[j]][v[k]]++;
d[v[k]][v[j]]++;
}
}
}
for (int i = 1; i <= 5; i++) {
if (n / 2 <= c[i]) {
for (int j = i + 1; j <= 5; j++) {
if (n / 2 <= c[j] && c[i] + c[j] - d[i][j] >= n) {
cout << "YES\n";
return;
}
}
}
}
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cout.precision(30);
cerr.precision(10);
;
int T;
cin >> T;
while (T--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int flag = 0, counter = 0;
int a[20] = {2, 4, 3, 9, 5, 25, 7, 49, 11, 13,
17, 19, 23, 29, 31, 37, 41, 43, 47, 53};
for (int i = 0; i < 20; i++) {
cout << a[i] << endl;
fflush(stdout);
cin >> s;
if (s == "yes") {
counter++;
}
}
if (counter < 2) {
cout << "prime" << endl;
} else {
cout << "composite" << endl;
}
fflush(stdout);
exit(0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 1;
while (t--) {
int k = 0;
cin >> k;
if (k > 36)
cout << -1 << endl;
else {
while (k > 1) {
cout << 8;
k -= 2;
}
if (k == 1) cout << 4;
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
set<int> v[200005];
int x[200005];
int y[200005];
int an[200005];
set<pair<int, int> > s;
void r(int i, int k) {
if (v[x[i]].size() >= k && v[y[i]].size() >= k) {
s.erase(pair<int, int>(v[x[i]].size(), x[i]));
s.erase(pair<int, int>(v[y[i]].size(), y[i]));
v[x[i]].erase(y[i]);
v[y[i]].erase(x[i]);
s.insert(pair<int, int>(v[x[i]].size(), x[i]));
s.insert(pair<int, int>(v[y[i]].size(), y[i]));
}
}
void solve(int k) {
if (s.empty() || s.begin()->first >= k) return;
int x = s.begin()->second;
s.erase(s.begin());
for (auto it = v[x].begin(); it != v[x].end(); it++)
if (v[*it].size() >= k) {
s.erase(pair<int, int>(v[*it].size(), *it));
v[*it].erase(x);
s.insert(pair<int, int>(v[*it].size(), *it));
}
solve(k);
}
int main() {
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i];
v[x[i]].insert(y[i]);
v[y[i]].insert(x[i]);
}
for (int i = 0; i < n; i++) {
s.insert(pair<int, int>(v[i + 1].size(), i + 1));
}
for (int i = m - 1; i >= 0; i--) {
solve(k);
an[i] = s.size();
r(i, k);
}
for (int i = 0; i < m; i++) cout << an[i] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
struct node {
int n4, n7, n47, n74, lazy;
};
node it[N << 2];
int n, m;
string s;
void build(int k, int l, int r) {
if (l == r) {
if (s[l - 1] == '4') it[k].n4 = 1;
if (s[l - 1] == '7') it[k].n7 = 1;
it[k].n47 = it[k].n74 = 1;
return;
}
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
it[k].n4 = it[k << 1].n4 + it[k << 1 | 1].n4;
it[k].n7 = it[k << 1].n7 + it[k << 1 | 1].n7;
it[k].n47 = max(max(it[k << 1].n4 + it[k << 1 | 1].n47,
it[k << 1].n47 + it[k << 1 | 1].n7),
it[k << 1].n4 + it[k << 1 | 1].n7);
it[k].n74 = max(max(it[k << 1].n7 + it[k << 1 | 1].n74,
it[k << 1].n74 + it[k << 1 | 1].n4),
it[k << 1].n7 + it[k << 1 | 1].n4);
}
void update(int k) {
it[k].lazy = (!it[k].lazy);
swap(it[k].n47, it[k].n74);
swap(it[k].n4, it[k].n7);
}
void update(int k, int l, int r, const int &ll, const int &rr) {
if (l > rr || r < ll) return;
if (ll <= l && r <= rr) {
update(k);
return;
}
int mid = l + r >> 1;
if (it[k].lazy) {
it[k].lazy = 0;
update(k << 1);
update(k << 1 | 1);
}
update(k << 1, l, mid, ll, rr);
update(k << 1 | 1, mid + 1, r, ll, rr);
it[k].n4 = it[k << 1].n4 + it[k << 1 | 1].n4;
it[k].n7 = it[k << 1].n7 + it[k << 1 | 1].n7;
it[k].n47 = max(max(it[k << 1].n4 + it[k << 1 | 1].n47,
it[k << 1].n47 + it[k << 1 | 1].n7),
it[k << 1].n4 + it[k << 1 | 1].n7);
it[k].n74 = max(max(it[k << 1].n7 + it[k << 1 | 1].n74,
it[k << 1].n74 + it[k << 1 | 1].n4),
it[k << 1].n7 + it[k << 1 | 1].n4);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
cin >> s;
build(1, 1, n);
int l, r;
while (m--) {
cin >> s;
if (s == "switch") {
cin >> l >> r;
update(1, 1, n, l, r);
}
if (s == "count") cout << it[1].n47 << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long x1, y1, x2, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
for (int i = 0; i < 4; i++) {
long long dx = x2 - x1;
long long dy = y2 - y1;
long long u = dx * x3 + dy * y3;
long long v = dx * y3 - dy * x3;
long long w = x3 * x3 + y3 * y3;
if (dx == 0 && dy == 0) {
cout << "YES" << endl;
return 0;
}
if (w != 0 && u % w == 0 && v % w == 0) {
cout << "YES" << endl;
return 0;
}
x1 = -x1;
swap(x1, y1);
}
cout << "NO" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> zeroes;
int binarySearch(int p, int low, int high) {
int ans = INT_MAX;
while (low <= high) {
int mid = (low + high) >> 1;
ans = min(ans, abs(p - zeroes[mid]));
if (zeroes[mid] > p) {
high = mid - 1;
} else if (zeroes[mid] < p) {
low = mid + 1;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<long long int> v(n), result(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
if (v[i] == 0) {
zeroes.emplace_back(i);
result[i] = 0;
} else {
result[i] = -1;
}
}
sort((zeroes).begin(), (zeroes).end());
int len = (int)zeroes.size();
for (int i = 0; i < n; i++) {
if (result[i] == -1) {
result[i] = binarySearch(i, 0, len - 1);
}
}
for (int x : result) {
cout << x << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100000];
long long sum, suffsum, prefsum, ans;
int suff[100001];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i], sum += a[i];
if (sum % 3) return !printf("0\n");
sum /= 3;
for (int i = n - 1; i > -1; --i) {
suffsum += a[i];
suff[i] = suff[i + 1];
if (suffsum == sum) ++suff[i];
}
for (int i = 0; i < n - 2; ++i) {
prefsum += a[i];
if (prefsum == sum) {
ans += suff[i + 2];
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int q;
int n;
int idx[300005];
int l[300005];
int ans[300005];
int main() {
scanf("%d", &q);
while (q--) {
scanf("%d", &n);
int t;
for (int i = 0; i <= n; i++) idx[i] = ans[i] = l[i] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &t);
l[t] = max(l[t], i - idx[t]);
idx[t] = i;
}
for (int i = 1; i <= n; i++) l[i] = max(l[i], n + 1 - idx[i]);
for (int i = n; i > 0; i--) {
if (!l[i]) continue;
ans[l[i]] = i;
}
for (int i = 1; i <= n; i++) {
if (ans[i - 1] && ans[i])
ans[i] = min(ans[i], ans[i - 1]);
else
ans[i] = max(ans[i], ans[i - 1]);
printf("%d ", ans[i] ? ans[i] : -1);
}
printf("\n");
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
const int M=998244353;
const long long inf=101010101010101ll;
const int N=1000005;
int n,i,j,k,f[N],m,u,x[N],y[N],p[N],id[N];
struct str{
int u,v;
};
vector<str> ans;
int Find(int x)
{
return f[x]?f[x]=Find(f[x]):x;
}
void uniot(int x,int y)
{
int u=Find(x),v=Find(y);
if(u!=v)
f[u]=v;
}
bool cmp(int a,int b)
{
return 1ll*(x[a]-x[u])*(y[b]-y[u])-1ll*(y[a]-y[u])*(x[b]-x[u])<0;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
scanf("%d",&n);
for(i=1;i<=n;++i)
{
scanf("%d %d %d",&x[i],&y[i],&p[i]);
if(p[i]!=i)
if(u==0||x[u]>x[i])
u=i;
}
if(u!=0)
{
for(i=1;i<=n;++i)
if(p[i]!=i&&i!=u)
id[++k]=i;
for(i=1;i<=n;++i)
for(j=p[i];j!=i;j=p[j])
uniot(i,j);
sort(id+1,id+1+k,cmp);
for(i=1;i<k;++i)
if(Find(id[i])!=Find(id[i+1]))
{
uniot(id[i],id[i+1]);
ans.push_back({id[i],id[i+1]});
swap(p[id[i]],p[id[i+1]]);
}
while(p[u]!=u)
{
ans.push_back({p[u],u});
swap(p[p[u]],p[u]);
}
}
printf("%d\n",ans.size());
for(auto it:ans)
printf("%d %d\n",it.u,it.v);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
;
string str;
cin >> str;
int ans = 0;
int len = str.length();
for (int i = 0; i < len - 2; i++) {
if (str[i] == 'A' && str[i + 1] == 'B' && str[i + 2] == 'C') ans = 1;
if (str[i] == 'A' && str[i + 1] == 'C' && str[i + 2] == 'B') ans = 1;
if (str[i] == 'B' && str[i + 1] == 'A' && str[i + 2] == 'C') ans = 1;
if (str[i] == 'B' && str[i + 1] == 'C' && str[i + 2] == 'A') ans = 1;
if (str[i] == 'C' && str[i + 1] == 'A' && str[i + 2] == 'B') ans = 1;
if (str[i] == 'C' && str[i + 1] == 'B' && str[i + 2] == 'A') ans = 1;
}
if (ans == 0)
cout << "No"
<< "\n";
else
cout << "Yes"
<< "\n";
}
| 0 |
#include <bits/stdc++.h>
int min(int a, int b) {
if (a > b) return b;
return a;
}
int a[1001][1001], b[1001], u, v, sum = 0;
int main() {
int n, m, i, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &b[i]);
}
for (i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
sum += min(b[u], b[v]);
}
printf("%d\n", sum);
}
| 3 |
#include <bits/stdc++.h>
const int N = 2e4 + 10;
int n, m;
int a[N], b[N], used[2 * N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), used[a[i]] = 1;
scanf("%d", &m);
for (int i = 1; i <= m; ++i) scanf("%d", &b[i]), used[b[i]] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (not used[a[i] + b[j]]) {
printf("%d %d\n", a[i], b[j]);
return 0;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int a, b, r;
scanf("%d %d %d", &a, &b, &r);
if (a < 2 * r || b < 2 * r)
printf("Second");
else
printf("First");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
int main() {
long long int n, b, i, ans[200005];
long long int start[200005], timetaken[200005], a;
scanf("%lld %lld", &n, &b);
for (i = 0; i < n; i++) {
scanf("%lld %lld", &start[i], &timetaken[i]);
}
long long int current = 0;
i = 0;
while (i < n || !q.empty()) {
if (!q.empty()) {
a = q.front();
q.pop();
current += timetaken[a];
ans[a] = current;
}
{
if (current <= start[i] && q.size() == 0) {
current = start[i] + timetaken[i];
ans[i] = current;
i++;
} else if (current > start[i] && q.size() < b) {
while (start[i] < current && i < n) {
if (q.size() < b) {
q.push(i);
i++;
} else {
ans[i] = -1;
i++;
}
}
}
}
}
for (i = 0; i < n; i++) printf("%lld ", ans[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d1, d2, d3;
scanf("%d%d%d", &d1, &d2, &d3);
d3 = d3 > d1 + d2 ? d1 + d2 : d3;
d1 = d1 > d2 + d3 ? d2 + d3 : d1;
d2 = d2 > d1 + d3 ? d1 + d3 : d2;
printf("%d\n", d1 + d2 + d3);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> e[1000010];
long long n, m;
long long vis[1000010];
long long du[1000010];
long long c = 0;
void dfs(int rt) {
vis[rt] = 1;
int Size = e[rt].size();
for (int i = 0; i < (Size); i++) {
if (vis[e[rt][i]]) continue;
dfs(e[rt][i]);
}
}
int main() {
scanf("%I64d %I64d", &n, &m);
for (int i = 1; i < (m + 1); i++) {
int u, v;
scanf("%d %d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
if (v == u)
c++;
else {
du[v]++;
du[u]++;
}
}
for (int i = 1; i < (n + 1); i++) {
if (e[i].size() && !vis[i]) {
dfs(i);
break;
}
}
for (int i = 1; i < (n + 1); i++) {
if (e[i].size() && vis[i] == 0) {
puts("0");
return 0;
}
}
long long ans = 0;
ans = (m - c) * c + c * (c - 1) / 2;
for (int i = 1; i < (n + 1); i++) {
ans += du[i] * (du[i] - 1) / 2;
}
printf("%I64d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int mod = 1e9 + 7;
void pp(int& x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int n;
long long a[N];
long long k;
struct Mat {
int v[N][N];
Mat() { memset(v, 0, sizeof(v)); }
Mat operator*(const Mat& c) const {
Mat ans;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
pp(ans.v[i][j], 1ll * v[i][k] * c.v[k][j] % mod);
return ans;
}
};
Mat pow_mod(Mat x, long long k) {
Mat ans;
for (int i = 0; i < n; i++) ans.v[i][i] = 1;
while (k) {
if (k & 1) ans = ans * x;
x = x * x;
k >>= 1;
}
return ans;
}
long long get(long long x) {
if (x == 0) return 0;
return get(x / 2) + x % 2;
}
int main() {
scanf("%d%lld", &n, &k);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
Mat A;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (get(a[i] ^ a[j]) % 3 == 0) {
A.v[i][j] = 1;
}
}
}
A = pow_mod(A, k - 1);
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) pp(ans, A.v[i][j]);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char a[1001][1001];
int visit[1001][1001];
void dfs(int i, int j, int n, int m, int cc) {
visit[i][j] = cc;
if (i != 0 && a[i - 1][j] == '#' && visit[i - 1][j] == -1)
dfs(i - 1, j, n, m, cc);
if (j != 0 && a[i][j - 1] == '#' && visit[i][j - 1] == -1)
dfs(i, j - 1, n, m, cc);
if (i != n - 1 && a[i + 1][j] == '#' && visit[i + 1][j] == -1)
dfs(i + 1, j, n, m, cc);
if (j != m - 1 && a[i][j + 1] == '#' && visit[i][j + 1] == -1)
dfs(i, j + 1, n, m, cc);
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> a[i][j];
}
}
int rowflag = 0, f = 1, colflag = 0, c = 0, b = 0;
for (i = 0; i < n; i++) {
rowflag = 0;
c = 0;
for (j = 0; j < m; j++) {
if (rowflag == 1 && a[i][j] == '#') f = 0;
if (rowflag == 0 && a[i][j] == '#' && (j < m - 1 && a[i][j + 1] == '.'))
rowflag = 1;
if (a[i][j] == '.') c++;
}
if (c == m) b = 1;
}
int g = 0, h = 0;
for (i = 0; i < m; i++) {
colflag = 0;
g = 0;
for (j = 0; j < n; j++) {
if (colflag == 1 && a[j][i] == '#') f = 0;
if (colflag == 0 && a[j][i] == '#' && (j < n - 1 && a[j + 1][i] == '.'))
colflag = 1;
if (a[j][i] == '.') g++;
}
if (g == n) h = 1;
}
if (f == 0 || h == 1 && b == 0 || b == 1 && h == 0)
cout << "-1";
else {
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
visit[i][j] = -1;
}
}
int cc = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (a[i][j] == '#' && visit[i][j] == -1) {
cc++;
dfs(i, j, n, m, cc);
}
}
}
cout << cc << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[112345];
void init() {}
void solve() {
int n, h, k;
scanf("%d%d%d", &n, &h, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
int left = 0;
int idx = 0;
long long ans = 0;
int temp;
while (idx < n || left > 0) {
while (idx < n && left + arr[idx] <= h) left += arr[idx++];
if (idx < n)
temp = left + arr[idx] - h;
else
temp = left;
ans += (temp + (k - 1)) / k;
left -= ((temp + (k - 1)) / k) * k;
left = max(left, 0);
}
printf("%lld\n", ans);
}
int main() {
init();
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b, d, waste, ctr;
cin >> n >> b >> d;
int orange[n];
for (int i = 0; i < n; i++) cin >> orange[i];
waste = 0, ctr = 0;
for (int i = 0; i < n; i++) {
if (orange[i] > b)
continue;
else {
waste += orange[i];
if (waste > d) {
ctr++;
waste = 0;
}
}
}
cout << ctr << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 505;
double PI = acos(-1), INF = 1e20, EPS = 1e-6;
double g[Maxn][Maxn];
struct Point {
double x, y;
Point() {}
Point(double tx, double ty) {
x = tx;
y = ty;
}
bool operator<(const Point &ta) const { return x <= ta.x; }
Point operator-(const Point &b) const { return Point(x - b.x, y - b.y); }
double operator^(const Point &b) const { return x * b.y - y * b.x; }
} red[Maxn], blue[Maxn];
bool check(Point a, Point b, Point c, Point d) {
return ((b - a) ^ (d - a)) > 0 && ((c - b) ^ (d - b)) > 0 &&
((a - c) ^ (d - c)) > 0;
}
int main() {
int n, m, ans = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lf%lf", &red[i].x, &red[i].y);
for (int i = 1; i <= m; i++) scanf("%lf%lf", &blue[i].x, &blue[i].y);
sort(red + 1, red + n + 1);
Point o = red[1];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (((red[i] - o) ^ (red[j] - o)) <= 0) continue;
for (int k = 1; k <= m; k++)
if (check(o, red[i], red[j], blue[k])) g[i][j]++;
g[j][i] = -g[i][j];
}
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
for (int k = j + 1; k <= n; k++)
if (g[i][j] + g[j][k] + g[k][i] == 0) ans++;
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void file_open() {
freopen("test.txt", "rt", stdin);
freopen("test.out", "wt", stdout);
}
void xuli1(char s[]) {
int row, col;
row = 0;
col = 0;
int i = 1;
while (s[i] != 'C') {
row = row * 10 + s[i] - 48;
++i;
}
++i;
while (s[i]) {
col = col * 10 + s[i] - 48;
++i;
}
i = 1;
while (col > 26 * i) {
col -= 26 * i;
i *= 26;
}
char buff[20] = {};
int j = 0;
while (i) {
buff[j] = ((col + i - 1) / i) + 64;
col %= i;
if (col == 0) col = i;
i /= 26;
++j;
}
i = 1;
while (s[i] != 'C') {
buff[j++] = s[i++];
}
printf("%s\n", buff);
}
void xuli2(char s[]) {
int row = 0, col = 0;
int i = 0, j = 0;
while (s[i] > '9') ++i;
j = i - 1;
while (s[i]) {
row = row * 10 + s[i++] - 48;
}
i = 1;
while (j >= 0) {
col = col + (s[j] - 'A' + 1) * i;
i *= 26;
--j;
}
printf("R%dC%d\n", row, col);
}
int main() {
char s[1024] = {}, *p;
int n;
scanf("%d\n", &n);
for (int i = 0; i < n; ++i) {
scanf("%[^\n]\n", s);
p = strstr(s, "C");
if (s[0] == 'R' && s[1] <= '9' && p)
xuli1(s);
else
xuli2(s);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 4e18;
const long long maxn = 5010;
const long long mod = 1e9 + 7;
long long dp[30][maxn], tot[maxn], sm[maxn];
int main() {
long long n;
cin >> n;
string s;
cin >> s;
for (int i = int(1); i <= int(n); i++) {
long long c = s[i - 1] - 'a';
for (int j = int(1); j <= int(n); j++) {
sm[j] = (sm[j - 1] + tot[j] - dp[c][j] + mod) % mod;
}
for (int j = int(1); j <= int(n); j++) {
tot[j] = tot[j] + mod - dp[c][j];
dp[c][j] = (sm[j - 1] + 1) % mod;
tot[j] = (tot[j] + dp[c][j]) % mod;
}
}
cout << tot[n];
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char str;
int n;
struct point {
int a, b;
friend bool operator<(point A, point B) { return A.b < B.b; }
} p[204800];
long long tr[4 * 204800];
struct edge {
int to;
int nxt;
long long val;
} nd[2 * 204800];
int head[204800], cnt;
int inval[204800];
long long dist[204800], num[204800];
queue<int> q;
template <class X>
inline void read(X &x) {
x = 0;
X f = 1;
while (!isdigit(str)) {
if (str == '-') {
f = -1;
}
str = getchar();
}
while (isdigit(str)) {
x *= 10;
x += str - '0';
str = getchar();
}
x *= f;
return;
}
void init() {
memset(head, -1, sizeof(head));
memset(dist, 0x3f, sizeof(dist));
cnt = 1;
return;
}
void pushup(int x) {
tr[x] = max(tr[x << 1], tr[x << 1 | 1]);
return;
}
void addt(int x, int l, int r, int rt, long long z) {
if (l == r) {
tr[rt] = z;
return;
} else {
int mid = (l + r) >> 1;
if (x <= mid) {
addt(x, l, mid, rt << 1, z);
} else {
addt(x, mid + 1, r, rt << 1 | 1, z);
}
pushup(rt);
}
return;
}
int query(int l, int r, int rt, long long z) {
if (l == r) {
return l;
} else {
int mid = (l + r) >> 1;
if (tr[rt << 1] >= z) {
return query(l, mid, rt << 1, z);
} else {
return query(mid + 1, r, rt << 1 | 1, z);
}
}
}
void add(int x, int y, long long z) {
nd[cnt].to = y;
nd[cnt].nxt = head[x];
nd[cnt].val = z;
head[x] = cnt++;
inval[y]++;
return;
}
void bfs() {
for (int i = 0; i <= n; i++) {
if (!inval[i]) {
q.push(i);
dist[i] = 0;
num[i] = 1;
}
}
while (q.size()) {
int x = q.front();
q.pop();
for (int i = head[x]; i != -1; i = nd[i].nxt) {
int t = nd[i].to;
inval[t]--;
if (!inval[t]) {
q.push(t);
}
if (dist[t] > dist[x] + nd[i].val) {
dist[t] = dist[x] + nd[i].val;
num[t] = num[x];
} else if (dist[t] == dist[x] + nd[i].val) {
num[t] += num[x];
num[t] %= 1000000007;
}
}
}
return;
}
int main() {
init();
read(n);
for (int i = 1; i <= n; i++) {
read(p[i].a), read(p[i].b);
}
sort(p + 1, p + n + 1);
addt(n, 1, n, 1, p[n].b);
for (int i = n - 1; i; i--) {
add(i, i + 1, p[i + 1].b - p[i].b);
if (tr[1] >= p[i].a) {
int t = query(1, n, 1, p[i].a);
add(i, t, p[t].b - p[i].a);
}
addt(i, 1, n, 1, p[i].b);
}
add(0, 1, p[1].b);
bfs();
long long ans = 0, mi = 0x3f3f3f3f3f3f3f3fll;
for (int i = 1; i <= n; i++) {
if (p[i].a > p[n].b) {
mi = min(mi, dist[i]);
}
}
for (int i = 1; i <= n; i++) {
if (p[i].a > p[n].b && dist[i] == mi) {
ans += num[i];
ans %= 1000000007;
}
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, o, id;
} s[300005];
bool vis[300005];
int cmp(node x, node y) { return x.a < y.a; }
int main() {
int T, n;
long long suma, sumo, s1, s2;
scanf("%d", &T);
while (T--) {
memset(vis, false, sizeof(vis));
suma = sumo = 0;
scanf("%d", &n);
int m = 2 * n - 1;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &s[i].a, &s[i].o);
suma += s[i].a;
sumo += s[i].o;
s[i].id = i;
}
sort(s + 1, s + m + 1, cmp);
s1 = 0, s2 = 0;
for (int i = 1; i < m; i += 2) {
if (s[i].o > s[i + 1].o) {
vis[s[i].id] = true;
s1 += s[i].a;
s2 += s[i].o;
} else {
vis[s[i + 1].id] = true;
s1 += s[i + 1].a;
s2 += s[i + 1].o;
}
}
s1 += s[m].a;
s2 += s[m].o;
vis[s[m].id] = true;
if (s1 * 2 >= suma && s2 * 2 >= sumo) {
printf("YES\n");
for (int i = 1; i <= m; i++) {
if (vis[i]) printf("%d ", i);
}
printf("\n");
} else
printf("NO\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 100;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
long long n, t, dp[maxn], c[maxn], s, ans;
vector<long long> g[maxn];
long long pw(long long pa, long long push_back) {
if (push_back == 0) return 1;
long long pc = pw(pa, push_back / 2);
pc = (pc * pc) % mod;
if (push_back % 2) pc = (pc * pa) % mod;
return pc;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long i = n; i > 0; i--) {
for (long long j = 1; i * j <= n; j++) {
g[i * j].push_back(i);
}
}
for (long long i = 2; i <= n; i++) {
s = n;
for (long long j = 0; j < g[i].size(); j++) {
c[j] = n / g[i][j];
for (long long k = 0; k < j; k++) {
if (g[i][k] % g[i][j] == 0) c[j] -= c[k];
}
s = (s + c[j] * dp[g[i][j]]) % mod;
}
dp[i] = (s * pw(n - c[0], mod - 2)) % mod;
ans = (ans + dp[i]) % mod;
}
ans = (ans * pw(n, mod - 2) + 1) % mod;
cout << (ans + mod) % mod;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
template <class T>
class SegmentTree {
int maxn = 1000000;
vector<T> t;
void build(const vector<T> &a, int v, int tl, int tr) {
if (tl == tr) {
t[v] = a[tl];
} else {
int tm = (tl + tr) / 2;
build(a, v * 2 + 1, tl, tm);
build(a, v * 2 + 2, tm + 1, tr);
t[v] = t[v * 2 + 1] + t[v * 2 + 2];
}
}
T sum(int v, int tl, int tr, int l, int r) {
if (l > r) {
return 0;
}
if (l == tl && r == tr) {
return t[v];
}
int tm = (tl + tr) / 2;
return sum(v * 2 + 1, tl, tm, l, min(r, tm)) +
sum(v * 2 + 2, tm + 1, tr, max(l, tm + 1), r);
}
void update(int v, int tl, int tr, int pos, T new_val) {
if (tl == tr) {
t[v] += new_val;
} else {
int tm = (tl + tr) / 2;
if (pos <= tm) {
update(v * 2 + 1, tl, tm, pos, new_val);
} else {
update(v * 2 + 2, tm + 1, tr, pos, new_val);
}
t[v] = t[v * 2 + 1] + t[v * 2 + 2];
}
}
public:
SegmentTree(int n) {
maxn = n;
t.resize(4 * maxn);
}
SegmentTree(const vector<T> &a) {
maxn = a.size();
t.resize(4 * maxn);
build(a, 0, 0, maxn - 1);
}
void update(int pos, T add) { update(0, 0, maxn - 1, pos, add); }
T sum(int l, int r) { return sum(0, 0, maxn - 1, l, r); }
int size() { return maxn; }
SegmentTree() {}
};
long long n, k, b, c;
vector<long long> v;
struct Z {
long long x;
int operator<(const Z &a) const {
return (1100000000 - x) / 5 * b + (1100000000 - x) % 5 * c <
(1100000000 - a.x) / 5 * b + (1100000000 - a.x) % 5 * c;
}
};
inline long long ceil5(long long x) {
return (x + 2000000004LL) / 5 * 5 - 2000000000LL;
}
inline long long dist(long long x, long long y) {
x += 2000000000LL;
y += 2000000000LL;
if (x > y) {
swap(x, y);
}
return (y - x) / 5 * b + (y - x) % 5 * c;
}
long long solve() {
priority_queue<Z> pq;
long long ans = LLONG_MAX;
long long tans = 0;
long long prev_num = 0;
long long tnum = 0;
for (auto i : v) {
tnum = ceil5(i);
tans += (tnum - prev_num) / 5 * b * (long long)pq.size();
pq.push({i});
tans += dist(i, tnum);
if (pq.size() > k) {
tans -= dist(pq.top().x, tnum);
pq.pop();
}
if (pq.size() == k) {
ans = min(ans, tans);
}
prev_num = tnum;
}
return ans;
}
long long solve1() {
SegmentTree<long long> t1(v);
long long res = LLONG_MAX;
int pos2 = 0;
for (int i = (k - 1); i < (n); ++i) {
res = min(res, (k * v[i] - t1.sum(pos2, i)) * c);
++pos2;
}
cout << res;
return 0;
}
int main() {
cin >> n >> k >> b >> c;
v.resize(n);
for (int __i = 0; __i < (n); ++__i) cin >> v[__i];
;
sort(v.begin(), v.end());
if (b >= 5 * c) {
solve1();
return 0;
}
long long res = LLONG_MAX;
for (int i = (0); i < (5); ++i) {
res = min(res, solve());
for (auto &j : v) {
--j;
}
}
cout << res;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
int lmin[MAXN], lmax[MAXN], rmin[MAXN], rmax[MAXN];
int n, c;
int pos = 0;
int ans[MAXN];
int ct;
bool flag = true;
void dfs(int largest) {
int u = ++pos;
if (n + 1 != lmin[u]) {
if (lmin[u] <= pos) {
flag = false;
return;
}
dfs(lmax[u]);
if (!flag) {
return;
}
}
ans[ct++] = u;
if (n + 1 != rmin[u]) {
if (rmin[u] <= pos) {
flag = false;
return;
}
dfs(max(rmax[u], largest));
} else if (pos < largest) {
dfs(largest);
}
}
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
cin >> n >> c;
for (int i = 1; i <= n; ++i) {
lmin[i] = rmin[i] = n + 1;
lmax[i] = rmax[i] = 0;
}
for (int i = 0; i < c; ++i) {
int a, b;
char str[20];
cin >> a >> b >> str;
if ('L' == str[0]) {
lmin[a] = min(lmin[a], b);
lmax[a] = max(lmax[a], b);
} else {
rmin[a] = min(rmin[a], b);
rmax[a] = max(rmax[a], b);
}
}
dfs(n);
if (!flag) {
cout << "IMPOSSIBLE" << endl;
} else {
cout << ans[0];
for (int i = 1; i < n; ++i) {
cout << ' ' << ans[i];
}
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> dishes(n);
for (auto &x : dishes) cin >> x, x -= 1;
sort(dishes.begin(), dishes.end());
vector<vector<int>> dp(n, vector<int>(3 * n));
for (int i = 0; i < n; i++) dp[i][0] = 1e9;
dp[0][0] = dishes[0];
for (int j = 1; j < 3 * n; j++)
dp[0][j] = min(abs(j - dishes[0]), dp[0][j - 1]);
for (int i = 1; i < n; i++) {
for (int j = 1; j < 3 * n; j++) {
dp[i][j] = min(dp[i][j - 1], dp[i - 1][j - 1] + abs(j - dishes[i]));
}
}
cout << dp[n - 1][3 * n - 1] << endl;
}
int main() {
int t = 1;
cin >> t;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int l = s.size();
int len = 0;
string ans = "";
for (int i = 0; i < l; i++) {
len = ans.size();
if (s[i] == s[i - 1] && s[i] == s[i - 2]) {
continue;
} else if (len > 2 &&
(s[i] == ans[len - 1] && ans[len - 2] == ans[len - 3])) {
continue;
}
ans += s[i];
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool inside(string s, vector<long long> &l, vector<long long> &r) {
stringstream ss(s);
long long cur;
ss >> cur;
int sz = l.size();
for (int i = 0; i < sz; i++)
if (l[i] <= cur && cur <= r[i]) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
set<string> used;
map<string, string> ret;
for (int i = 1989; i <= 5000; i++) {
stringstream ss;
ss << i;
string s = ss.str();
int sz = s.size();
for (int j = 0; j < sz; j++) {
string cur = s.substr(sz - 1 - j);
if (used.find(cur) == used.end()) {
used.insert(cur);
ret[cur] = s;
break;
}
}
}
vector<long long> left, right;
left.push_back(2099);
right.push_back(3098);
long long r = 3098;
for (long long i = 10000; i < (1LL << 50); i *= 10) {
r += i;
left.push_back(i), right.push_back(r);
}
int n;
cin >> n;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
s = s.substr(4);
if (ret.find(s) != ret.end())
cout << ret[s] << endl;
else {
string t = '1' + s;
if (inside(t, left, right))
cout << t << endl;
else
cout << s << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> s[1005], t[15];
unordered_map<int, vector<int>> mp;
unordered_map<int, int> f[1005];
int g[(1 << 12) + 5], h[(1 << 12) + 5];
int rasp = 0, m;
int nr(unsigned int num) { return 32 - __builtin_clz(num); }
int dfs(int nod, int ta) {
vector<int> aux;
for (auto it : t[nod])
if (it != ta) aux.push_back(dfs(it, nod));
sort(aux.begin(), aux.end());
int cnt = 1;
for (auto it : aux) cnt = (cnt << nr(it)) | it;
cnt = cnt << 1;
if (!mp.count(cnt)) mp[cnt] = aux;
return cnt;
}
void dfs2(int nod, int ta) {
for (auto it : s[nod])
if (it != ta) dfs2(it, nod);
int i, j, c;
for (auto it : mp) {
int x = it.first;
vector<int>& y = it.second;
int l = y.size();
memset(g, 0, sizeof(int) * (1 << l));
g[0] = 1;
for (auto it2 : s[nod])
if (it2 != ta) {
memcpy(h, g, sizeof(int) * (1 << l));
for (i = 0; i < l; i++)
if (c = f[it2][y[i]])
for (j = 0; j < (1 << l); j++)
if (g[j] && !(j & (1 << i)) &&
!(i && y[i] == y[i - 1] && !(j & (1 << i - 1))))
(h[j | (1 << i)] += 1LL * c * g[j] % 1000000007) %= 1000000007;
memcpy(g, h, sizeof(int) * (1 << l));
}
f[nod][x] = g[(1 << l) - 1];
if (nr(x) == 2 * m) (rasp += g[(1 << l) - 1]) %= 1000000007;
}
}
int main() {
int n, i, x, y;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
x--;
y--;
s[x].push_back(y);
s[y].push_back(x);
}
scanf("%d", &m);
for (i = 1; i < m; i++) {
scanf("%d%d", &x, &y);
x--;
y--;
t[x].push_back(y);
t[y].push_back(x);
}
for (i = 0; i < m; i++) dfs(i, -1);
dfs2(0, -1);
printf("%d\n", rasp);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
double x[101010], b[101010], pre[101010], suc[101010];
int n, zero, m;
const double eps = 1e-6;
const int inf = 100000000;
int cmp(double x) {
if (fabs(x) <= eps) return 0;
if (x > eps)
return 1;
else
return -1;
}
int check(int n) {
if (n == 1) return 1;
double B = b[2] / b[1];
for (int i = 3; i <= n; i++)
if (cmp(b[i] / b[i - 1] - B)) return 0;
return 1;
}
int main() {
scanf("%d", &n);
zero = 0;
for (int i = 1; i <= n; i++) {
scanf("%lf", &x[i]);
if (!cmp(x[i])) zero++;
}
if (zero == n) {
cout << 0 << endl;
return 0;
}
if (zero == n - 1 && cmp(x[1])) {
cout << 0 << endl;
return 0;
}
if (!zero) {
for (int i = 1; i <= n; i++) b[i] = x[i];
if (check(n)) {
cout << 0 << endl;
return 0;
}
}
if (zero == n - 1) {
cout << 1 << endl;
return 0;
}
if (zero == n - 2 && cmp(x[1])) {
cout << 1 << endl;
return 0;
}
if (zero == 1) {
m = 0;
for (int i = 1; i <= n; i++)
if (cmp(x[i])) b[++m] = x[i];
if (check(m)) {
cout << 1 << endl;
return 0;
}
}
if (zero == 0) {
pre[1] = 0;
for (int i = 2; i <= n; i++)
if (!cmp(pre[i - 1] - inf))
pre[i] = inf;
else if (cmp(pre[i - 1]) && cmp(x[i] / x[i - 1] - pre[i - 1]))
pre[i] = inf;
else
pre[i] = x[i] / x[i - 1];
suc[n] = 0;
for (int i = n - 1; i; i--)
if (!cmp(suc[i + 1] - inf))
suc[i] = inf;
else if (cmp(suc[i + 1]) && cmp(x[i + 1] / x[i] - suc[i + 1]))
suc[i] = inf;
else
suc[i] = x[i + 1] / x[i];
int flag = 0;
for (int i = 1; i <= n; i++)
if (i == 1)
flag |= (cmp(suc[i + 1] - inf));
else if (i == n)
flag |= (cmp(pre[i - 1] - inf));
else {
double a = pre[i - 1], b = suc[i + 1], c = x[i + 1] / x[i - 1];
if (a == inf || b == inf) continue;
if (cmp(a - b) && cmp(a) && cmp(b)) continue;
if (cmp(a - c) && cmp(a) && cmp(c)) continue;
if (cmp(b - c) && cmp(b) && cmp(c)) continue;
flag = 1;
}
if (flag) {
cout << 1 << endl;
return 0;
}
}
cout << 2 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int n, f[200020], dep[200020];
unordered_set<int> G[200020];
vector<int> ans;
void dfs(int u) {
vector<int> son;
for (auto v : G[u]) {
son.push_back(v);
}
sort(son.begin(), son.end(), [&](int i, int j) { return dep[i] > dep[j]; });
for (auto x : son) dep[x] = 1145142333;
for (int i = 0; i < (int)son.size() - 1; ++i) {
int x = son[i], y = son[i + 1];
G[u].erase(x);
G[y].insert(x);
ans.push_back(x);
}
if (!son.empty()) dfs(son.back());
}
int main() {
n = read();
for (int i = 2; i <= n; ++i) {
f[i] = read() + 1;
G[f[i]].insert(i);
}
for (int i = 1; i <= n; ++i) dep[i] = dep[f[i]] + 1;
for (int i = n; i >= 2; --i) {
dep[f[i]] = max(dep[f[i]], dep[i]);
}
dfs(1);
for (int u = 1;; u = (*G[u].begin())) {
printf("%d ", u - 1);
if (G[u].empty()) break;
}
reverse(ans.begin(), ans.end());
printf("\n%d\n", (int)ans.size());
for (auto x : ans) {
printf("%d ", x - 1);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int inf = 1000 * 1000 * 1000 * 2;
char a[15] = {'a', 'e', 'i', 'o', 'u', 'y'};
int x[N];
char s[505];
int n;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> x[i];
bool flag = true;
for (int i = 0; i <= n; i++) {
cin.getline(s, 105);
int m = strlen(s);
for (int j = 0; j < m; j++) {
for (int h = 0; h < 6; h++) {
if (s[j] == a[h]) {
x[i]--;
break;
}
}
}
if (x[i] != 0) flag = false;
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 2 |
// #pragma GCC optimize("Ofast,unroll-loops")
// #pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define dd double
#define ld long double
#define sl(n) scanf("%lld", &n)
#define si(n) scanf("%d", &n)
#define sd(n) scanf("%lf", &n)
#define pll pair <ll, ll>
#define pii pair <int, int>
#define mp make_pair
#define pb push_back
#define all(v) v.begin(), v.end()
#define inf (1LL << 61)
#define loop(i, start, stop, inc) for(ll i = start; i <= stop; i += inc)
#define for1(i, stop) for(ll i = 1; i <= stop; ++i)
#define for0(i, stop) for(ll i = 0; i < stop; ++i)
#define rep1(i, start) for(ll i = start; i >= 1; --i)
#define rep0(i, start) for(ll i = (start-1); i >= 0; --i)
#define ms(n, i) memset(n, i, sizeof(n))
#define casep(n) printf("Case %lld:", ++n)
#define pn printf("\n")
#define pf printf
#define EL '\n'
#define fastio std::ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
// === Debug macro starts here ===
#ifndef ONLINE_JUDGE
#define DEBUG
#define SYS_COL system("COLOR")
#endif
int recur_depth = 0;
#ifdef DEBUG
#define dbg(x) {++recur_depth; auto x_=x; --recur_depth; SYS_COL; cerr<<string(recur_depth, '\t')<<"\e[91m"<<__func__<<":"<<__LINE__<<"\t"<<#x<<" = "<<x_<<"\e[39m"<<endl;}
template<typename Ostream, typename Cont>
typename enable_if<is_same<Ostream,ostream>::value, Ostream&>::type operator<<(Ostream& os, const Cont& v){
os<<"[";
for(auto& x:v){os<<x<<", ";}
return os<<"]";
}
template<typename Ostream, typename ...Ts>
Ostream& operator<<(Ostream& os, const pair<Ts...>& p){
return os<<"{"<<p.first<<", "<<p.second<<"}";
}
#else
#define dbg(x)
#endif
// === Debug macro ends here ===
#define ff first
#define ss second
const ll sz = 3e5 + 10, mod = 998244353;
vector <ll> dp[sz], way[sz];
vector <char> mat[sz];
ll n, m;
ll way1(ll r, ll c)
{
if(r > n)
return 1;
ll &ret = way[r][c];
if(ret != -1)
return ret;
if(c == m) {
if(mat[r][c] != 'o')
return ret = way1(r+1, 1);
return ret = (2*way1(r+1, 1)) % mod;
}
ret = way1(r, c+1);
if(mat[r][c] == 'o') ret = (2*ret) % mod;
return ret;
}
ll way2(ll r, ll c)
{
if(c > m)
return 1;
ll &ret = way[r][c];
if(ret != -1)
return ret;
if(r == n) {
if(mat[r][c] != 'o')
return ret = way2(1, c+1);
return ret = (2*way2(1, c+1)) % mod;
}
ret = way2(r+1, c);
if(mat[r][c] == 'o') ret = (2*ret) % mod;
return ret;
}
ll solve1(ll r, ll c)
{
if(r > n)
return 0;
ll &ret = dp[r][c];
if(ret != -1)
return ret;
ret = 0;
if(c == m) {
ret = solve1(r+1, 1);
if(mat[r][c] == 'o')
ret = 2*ret;
if(ret >= mod) ret -= mod;
return ret;
}
if(mat[r][c] == 'o') ret = solve1(r, c+1);
if(mat[r][c] != 'o' || mat[r][c+1] != 'o') {
ret += solve1(r, c+1);
if(ret >= mod) ret -= mod;
return ret;
}
if(c+1 == m) {
ret += way1(r+1, 1) +solve1(r+1, 1);
ret += solve1(r+1, 1);
}
else {
ret += way1(r,c+2) + solve1(r, c+2);
ret += solve1(r, c+2);
}
ret %= mod;
//cerr << r << " " << c << " || " << ret << endl;
return ret;
}
ll solve2(ll r, ll c)
{
if(c > m)
return 0;
ll &ret = dp[r][c];
if(ret != -1)
return ret;
ret = 0;
if(r == n) {
ret = solve2(1, c+1);
if(mat[r][c] == 'o')
ret = 2*ret;
if(ret >= mod) ret -= mod;
return ret;
}
if(mat[r][c] == 'o') ret = solve2(r+1, c);
if(mat[r][c] != 'o' || mat[r+1][c] != 'o') {
ret += solve2(r+1, c);
if(ret >= mod) ret -= mod;
return ret;
}
if(r+1==n) {
ret += way2(1, c+1) + solve2(1, c+1);
ret += solve2(1, c+1);
}
else {
ret += way2(r+2, c) + solve2(r+2, c);
ret += solve2(r+2, c);
}
ret %= mod;
return ret;
}
int main()
{
cin >> n >> m;
for1(i, n) {
dp[i].resize(m+2, -1);
way[i].resize(m+2, -1);
mat[i].resize(m+2);
}
for1(i, n) {
for1(j, m) {
scanf(" %c", &mat[i][j]);
}
}
ll ans1 = solve1(1, 1);
//dbg(ans1);
for1(i, n)
for1(j, m)
dp[i][j] = way[i][j] = -1;
ll ans2 = solve2(1, 1);
//dbg(ans2);
cout << (ans1+ans2) % mod << EL;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k;
int n;
cin >> n;
int a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
swap(a[0], a[n - 1]);
for (i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
cout << 2 * n - 1 << ' ' << 2 << '\n' << 1 << ' ' << 2;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int sqr(int a, int b) { return a * 2 + (b - 2) * 2; }
int main() {
long long int a, b, c, d, o, ar, oifi = 0;
cin >> a >> b >> c;
for (d = 0; d < c; d++) {
ar = (a - 4 * d);
o = (b - 4 * d);
oifi = oifi + sqr(ar, o);
}
cout << oifi << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
const int maxe = 5e6 + 7;
int n, m, d, num[maxe];
int getid(int i, int j) { return i + n * (j - 1); }
int tot, to[maxe], nxt[maxe], head1[maxe];
void addedge(int x, int y) {
to[++tot] = y;
nxt[tot] = head1[x];
head1[x] = tot;
}
int tot2, to2[maxe], nxt2[maxe], head2[maxe], in[maxe];
void addedge1(int x, int y) {
to2[++tot2] = y;
nxt2[tot2] = head2[x];
head2[x] = tot2;
in[y]++;
}
int sum, dfn[maxe], low[maxe], vis[maxe], stk[maxe], top, col[maxe];
void tarjan(int k) {
dfn[k] = low[k] = ++sum;
vis[k] = 1;
stk[++top] = k;
for (int p = head1[k]; p; p = nxt[p]) {
if (!vis[to[p]]) {
tarjan(to[p]);
low[k] = min(low[k], low[to[p]]);
} else if (vis[to[p]] == 1)
low[k] = min(low[k], dfn[to[p]]);
}
if (dfn[k] == low[k]) {
do {
vis[stk[top]] = 2;
col[stk[top]] = k;
} while (stk[top--] != k);
}
}
int dp[maxe], q[maxe];
void topo() {
int j = 0;
for (int i = 1; i <= n * d; i++)
if (col[i] == i && !in[i]) q[++j] = i;
for (int i = 1; i <= j; i++) {
dp[q[i]] += num[q[i]];
for (int p = head2[q[i]]; p; p = nxt2[p]) {
dp[to2[p]] = max(dp[to2[p]], dp[q[i]]);
if (--in[to2[p]] == 0) q[++j] = to2[p];
}
}
}
char s[55];
int main() {
scanf("%d%d%d", &n, &m, &d);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
for (int j = 1; j <= d; j++) {
addedge(getid(u, j), getid(v, j % d + 1));
}
}
tarjan(1);
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= d; j++) {
if (s[j] == '1') {
int id = col[getid(i, j)];
if (!vis[id]) vis[id] = 1, num[id]++;
}
}
for (int j = 1; j <= d; j++) vis[col[getid(i, j)]] = 0;
}
for (int i = 1; i <= n * d; i++) {
for (int j = head1[i]; j; j = nxt[j]) {
if (col[to[j]] != col[i] && col[to[j]] && col[i]) {
addedge1(col[to[j]], col[i]);
}
}
}
topo();
printf("%d\n", dp[1]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, i, l, j, m;
long long int sum, prev;
cin >> n;
vector<long long int> a, v;
for (i = 1; i < sqrt(n); i++) {
if (n % i == 0) {
a.push_back(i);
a.push_back(n / i);
}
}
if ((long long)(sqrt(n)) * (long long)(sqrt(n)) == n) a.push_back(sqrt(n));
long long int p[a.size()];
for (j = 0; j < a.size(); j++) p[j] = a[j];
sort(p, p + a.size());
for (k = a.size() - 1; k >= 0; k--)
v.push_back((n * (2 + n - p[k])) / (2 * p[k]));
for (l = 0; l < v.size(); l++) cout << v[l] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int n, dfn, rt, tot, p[N], dp[N], ll[N], rr[N], len[N], lk[N], T[N << 2],
fa[20][N], ch[N][26];
vector<int> g[N];
char s[N];
int extend(int p, int c) {
int np = ++tot;
len[np] = len[p] + 1;
while (p && !ch[p][c]) ch[p][c] = np, p = lk[p];
if (!p)
lk[np] = rt;
else {
int q = ch[p][c];
if (len[q] == len[p] + 1)
lk[np] = q;
else {
int nq = ++tot;
len[nq] = len[p] + 1;
lk[nq] = lk[q];
lk[q] = lk[np] = nq;
memcpy(ch[nq], ch[q], sizeof(ch[nq]));
while (p && ch[p][c] == q) ch[p][c] = nq, p = lk[p];
}
}
return np;
}
void dfs(int x) {
ll[x] = ++dfn;
fa[0][x] = lk[x];
for (int i = 1; i < 20; i++) fa[i][x] = fa[i - 1][fa[i - 1][x]];
for (int i = 0; i < g[x].size(); i++) dfs(g[x][i]);
rr[x] = dfn;
}
int gt(int x, int l) {
x = p[x];
for (int i = 19; i >= 0; i--)
if (len[fa[i][x]] >= l) x = fa[i][x];
return x;
}
void upd(int x, int l, int r, int p, int v) {
T[x] = max(T[x], v);
if (l == r) return;
int mid = l + r >> 1;
if (p <= mid)
upd(x << 1, l, mid, p, v);
else
upd(x << 1 | 1, mid + 1, r, p, v);
}
int qry(int x, int l, int r, int tl, int tr) {
if (tl <= l && r <= tr) return T[x];
int mid = l + r >> 1;
if (tr <= mid) return qry(x << 1, l, mid, tl, tr);
if (tl > mid) return qry(x << 1 | 1, mid + 1, r, tl, tr);
return max(qry(x << 1, l, mid, tl, tr), qry(x << 1 | 1, mid + 1, r, tl, tr));
}
bool ok(int x) {
if (dp[x] == 1) return 1;
int p = gt(x, dp[x] - 1), q = gt(x - 1, dp[x] - 1);
return qry(1, 1, tot, ll[p], rr[p]) >= dp[x] - 1 ||
qry(1, 1, tot, ll[q], rr[q]) >= dp[x] - 1;
}
int main() {
scanf("%d%s", &n, s + 1);
reverse(s + 1, s + n + 1);
rt = tot = 1;
p[0] = rt;
for (int i = 1; i <= n; i++) p[i] = extend(p[i - 1], s[i] - 'a');
for (int i = 2; i <= tot; i++) g[lk[i]].push_back(i);
dfs(rt);
int ans = 0;
for (int i = 1, j = 0; i <= n; i++) {
dp[i] = dp[i - 1] + 1;
while (!ok(i)) {
dp[i]--;
j++;
upd(1, 1, tot, ll[gt(j, dp[j])], dp[j]);
}
ans = max(ans, dp[i]);
}
printf("%d\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 10;
int n;
string s;
int main() {
cin >> n;
cin >> s;
for (int i = 0; i < n; ++i) {
for (int j = 1; i + 4 * j < n; ++j) {
bool f = 1;
int t = 0;
for (int k = i; k < n; k += j) {
t++;
if (t > 5) break;
if (s[k] == '.') f = 0;
}
if (f) {
cout << "yes\n";
return 0;
}
}
}
cout << "no\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int mod = 1000000007;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
bool isPalindrome(string s) {
long long int l = 0;
long long int h = s.size() - 1;
while (h > l) {
if (s[l++] != s[h--]) {
return false;
}
}
return true;
}
long long int powr(long long int a, long long int b) {
long long int res = (1.0);
while (b > 0) {
if (b & 1) res = (res * a);
a = (a * a);
b >>= 1;
}
return res;
}
vector<long long int> divisors(long long int n) {
vector<long long int> v;
for (long long int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if ((n / i) == i) {
v.push_back(i);
} else {
v.push_back(i);
v.push_back(n / i);
}
}
}
return v;
}
long long int spf[500004];
long long int mx = 500002;
void pre() {
for (long long int i = 1; i <= mx; i++) {
spf[i] = i;
}
for (long long int i = 2; i <= mx; i += 2) spf[i] = 2;
for (long long int i = 3; i * i <= mx; i++) {
if (spf[i] == i) {
for (long long int j = i * i; j <= mx; j += i) {
if (spf[j] == j) spf[j] = i;
}
}
}
}
vector<long long int> getprimefactors(long long int x) {
vector<long long int> v;
while (x != 1) {
v.push_back(spf[x]);
x = x / spf[x];
}
return v;
}
const long long int Nn = 1e6;
bool pp[Nn + 2];
void sieve() {
memset(pp, true, sizeof(pp));
pp[0] = false;
pp[1] = true;
for (long long int i = 2; i <= sqrt(Nn); i++) {
if (pp[i]) {
for (long long int j = i * i; j <= Nn; j += i) pp[j] = false;
}
}
}
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long int> SieveOfEratosthenes(long long int n) {
bool prime[n + 1];
vector<long long int> v;
memset(prime, true, sizeof(prime));
for (long long int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (long long int p = 2; p <= n; p++)
if (prime[p]) v.push_back(p);
return v;
}
long long int C[2001][2001];
void binomialCoeff(long long int n, long long int k) {
long long int i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
}
}
long long int nCr(long long int n, long long int r) {
if (n < r) return 0;
if (n == r) return 1;
if (r > n - r) r = n - r;
long long int ans = 1;
long long int i;
for (i = 1; i <= r; i++) {
ans *= n - r + i;
ans /= i;
}
return ans;
}
long long int inv(long long int a) { return powr(a, mod - 2); }
template <typename T>
void make_unique(vector<T> &vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
long long int fact[200006];
const long long int N1 = 200005;
long long int seg[4 * N1];
void build(long long int a[], long long int node, long long int l,
long long int r) {
if (l == r) {
seg[node] = a[l];
} else {
long long int m = (l + r) / 2;
build(a, 2 * node, l, m);
build(a, 2 * node + 1, m + 1, r);
seg[node] = seg[2 * node] + seg[2 * node + 1];
}
}
long long int query(long long int node, long long int ll, long long int rr,
long long int l, long long int r) {
if (l > r) {
return 0;
}
if (ll == l && rr == r) {
return seg[node];
}
long long int m = (ll + rr) / 2;
return query(2 * node, ll, m, l, min(m, r)) +
query(2 * node + 1, m + 1, rr, max(l, m + 1), r);
}
long long int factorial(long long int n) {
long long int res = 1;
for (long long int i = n; i >= 1; i--) (res *= i) %= mod;
return (res % mod);
}
unsigned long long power(unsigned long long x, long long int y,
long long int p) {
unsigned 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;
}
unsigned long long modInverse(unsigned long long n, long long int p) {
return power(n, p - 2, p);
}
unsigned long long nCrModPFermat(unsigned long long n, long long int r,
long long int p) {
if (n < r) return 0;
if (r == 0) return 1;
unsigned long long fac[n + 1];
fac[0] = 1;
for (long long int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
const long long int inf = 1e18;
void toggleChars(char str[]) {
for (long long int i = 0; str[i] != '\0'; i++) {
if (str[i] >= 'A' && str[i] <= 'Z')
str[i] = str[i] + 'a' - 'A';
else if (str[i] >= 'a' && str[i] <= 'z')
str[i] = str[i] + 'A' - 'a';
}
}
long long int add(long long int a, long long int b, long long int mod) {
long long int res = (a % mod + b % mod) % mod;
if (res < 0) res += mod;
return res;
}
long long int CEIL(long long int a, long long int b) {
return (a / b + (a % b != 0));
}
long long int dp[4005];
long long int solve(long long int n, long long int a, long long int b,
long long int c, long long int m) {
if (n < 0) {
return -inf;
}
if (n == 0) {
return 0;
}
if (dp[n] != -1) {
return dp[n];
}
long long int x = 0;
x += (max(solve(n - a, a, b, c, m) + 1,
max(solve(n - b, a, b, c, m) + 1, solve(n - c, a, b, c, m) + 1)));
return dp[n] = x;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(C, 0, sizeof(C));
binomialCoeff(2000, 2000);
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
long long int sum = 0;
long long int p[n];
sum += a[0];
p[0] = max(a[0], -sum);
for (long long int i = 1; i < n; i++) {
sum += a[i];
p[i] = max(p[i - 1] + a[i], -sum);
}
long long int pp[n];
long long int su = 0;
su += a[n - 1];
pp[n - 1] = max(a[n - 1], -su);
for (long long int i = n - 2; i >= 0; i--) {
su += a[i];
pp[i] = max(pp[i + 1] + a[i], -su);
}
long long int m = INT_MIN;
for (long long int i = 0; i < n - 1; i++) {
m = max(m, p[i] + pp[i + 1]);
}
m = max(m, pp[0]);
m = max(m, p[n - 1]);
cout << m << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct __s {
__s() {
srand(time(NULL));
if (1) {
ios_base::Init i;
}
}
~__s() {
if (!1)
fprintf(stderr, "Execution time: %.3lf s.\n",
(double)clock() / CLOCKS_PER_SEC);
long long n;
cin >> n;
}
} __S;
bool l, r, u, d;
int main(void) {
long long n;
string s;
cin >> n >> s;
long long ans = 1;
for (long long i = 0; i < (long long)(n); i++) {
if (s[i] == 'L')
l = true;
else if (s[i] == 'R')
r = true;
else if (s[i] == 'U')
u = true;
else
d = true;
if (l && r) {
l = r = u = d = false;
ans++;
}
if (u && d) {
l = r = u = d = false;
ans++;
}
if (s[i] == 'L')
l = true;
else if (s[i] == 'R')
r = true;
else if (s[i] == 'U')
u = true;
else
d = true;
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
const int INF = INT_MAX / 2;
const long long LLINF = 9223372036854775807 / 2;
int a[MAXN];
void solve() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
queue<pair<int, int> > q;
int res = 0;
q.push(make_pair(1, 0));
int end = 2;
while (end <= n) {
pair<int, int> now = q.front();
q.pop();
int p = now.first;
int depth = now.second;
q.push(make_pair(end, depth + 1));
res = max(res, depth + 1);
end++;
if (end > n) break;
while (true) {
if (a[end] > a[end - 1]) {
q.push(make_pair(end, depth + 1));
res = max(res, depth + 1);
end++;
if (end > n) break;
} else
break;
}
if (end > n) break;
}
printf("%d\n", res);
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long base = 998244353;
const long long oo = 1e6 + 10;
const long long gh = 1e3 + 3;
const long long inf = 1e15 + 5;
double pi = 2 * asin(1);
long long n, m, k;
long long a[oo];
long long a1[oo], a2[oo];
long long sum[oo];
string s;
char c[oo];
void print() {}
void proc() {}
void Main() {
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
long long ans = -1;
for (long long i = 1; i <= n; i++) {
a[i] = a[i] % k;
}
sort(a + 1, a + n + 1);
long long t = -1;
for (long long i = 1; i <= n; i++) {
if (a[i] == 0) continue;
if (a[i] != a[i - 1]) {
ans = max(ans, t);
t = k - a[i];
} else
t += k;
}
ans = max(ans, t);
cout << ans + 1 << "\n";
}
int32_t main() {
if (ifstream("test.txt")) {
freopen("test.txt", "r", stdin);
} else if (ifstream(""
".inp")) {
freopen(
""
".inp",
"r", stdin);
freopen(
""
".out",
"w", stdout);
}
long long t = 1;
cin >> t;
while (t--) {
Main();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const long long INF = 1ll << 60;
const double EPS = 1e-7;
const long long MOD = 998244353;
int n;
char s[N];
int x, y;
int prex[N], prey[N];
bool check(int mid) {
for (int i = (1); i <= (n - mid + 1); i++) {
int xx = x - (prex[n] - prex[i + mid - 1] + prex[i - 1]);
int yy = y - (prey[n] - prey[i + mid - 1] + prey[i - 1]);
xx = abs(xx);
yy = abs(yy);
if (xx + yy <= mid && mid % 2 == (xx + yy) % 2) return true;
}
return false;
}
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
scanf("%d%d", &x, &y);
for (int i = (1); i <= (n); i++) {
prex[i] = prex[i - 1];
prey[i] = prey[i - 1];
if (s[i] == 'U')
prey[i]++;
else if (s[i] == 'D')
prey[i]--;
else if (s[i] == 'L')
prex[i]--;
else if (s[i] == 'R')
prex[i]++;
}
int l = 0, r = n;
int ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) {
r = mid - 1;
ans = mid;
} else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.