solution
stringlengths 53
181k
| difficulty
int64 0
13
|
---|---|
#include <bits/stdc++.h>
using namespace std;
map<int, int> m1, m2;
int a[100001];
int b[100001];
int main() {
ios_base::sync_with_stdio(false);
int n, val;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
cin >> b[i];
m2[b[i]]++;
}
for (int i = 0; i < n - 2; i++) {
cin >> val;
m1[val]++;
}
int ans1, ans2;
for (int i = 0; i < n - 1; i++) {
if (m1[b[i]] == 0) {
ans1 = b[i];
} else
m1[b[i]]--;
}
for (int i = 0; i < n; i++) {
if (m2[a[i]] == 0) {
ans2 = a[i];
} else
m2[a[i]]--;
}
cout << ans2 << endl << ans1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005, inf = (int)1e9;
int l[N][N], r[N][N];
int n, m, k, ans, xx, yy;
bool flag;
inline void Swap(int &x, int &y) {
int temp = x;
x = y;
y = temp;
}
void Read(int &x) {
char c;
while (c = getchar(), c < '0' || c > '9')
;
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
}
int Get(int *fa, int x) {
if (fa[x] > inf) return x;
return fa[x] = Get(fa, fa[x]);
}
bool cmp(int ans, int x, int y, int temp, int xx, int yy) {
if (ans != temp) return ans > temp;
if (!flag) {
if (x != xx) return x > xx;
return y > yy;
} else {
if (y != yy) return y > yy;
return x > xx;
}
}
int main() {
Read(n);
Read(m);
Read(k);
int x, y;
flag = n > m;
if (n > m) Swap(n, m);
memset(l, 127, sizeof(l));
memset(r, 127, sizeof(r));
for (int i = 1; i <= k; i++) {
Read(x);
Read(y);
ans = n + m;
int temp1, temp2;
if (flag) Swap(x, y);
for (int j = 0; j <= ans; j++) {
if (x - j > 0) {
temp1 = Get(l[x - j], y);
temp2 = Get(r[x - j], y);
if (temp2)
if (cmp(ans, xx, yy, temp2 - y + j, x - j, temp2)) {
ans = temp2 - y + j;
xx = x - j;
yy = temp2;
}
if (temp1)
if (cmp(ans, xx, yy, y - temp1 + j, x - j, temp1)) {
ans = y - temp1 + j;
xx = x - j;
yy = temp1;
}
}
if (x + j <= n) {
temp1 = Get(l[x + j], y);
temp2 = Get(r[x + j], y);
if (temp1)
if (cmp(ans, xx, yy, y - temp1 + j, x + j, temp1)) {
ans = y - temp1 + j;
xx = x + j;
yy = temp1;
}
if (temp2)
if (cmp(ans, xx, yy, temp2 - y + j, x + j, temp2)) {
ans = temp2 - y + j;
xx = x + j;
yy = temp2;
}
}
}
if (!flag)
printf("%d %d\n", xx, yy);
else
printf("%d %d\n", yy, xx);
l[xx][yy] = yy - 1;
r[xx][yy] = (yy == m) ? 0 : yy + 1;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a[(long long)(1e6 + 3)];
pair<long long, long long> b[(long long)(1e6 + 3)];
long long c[(long long)(1e6 + 3)];
void solve() {
long long n;
scanf("%lld", &n);
for (long long i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
for (long long i = 0; i < n; i++) {
scanf("%lld", &(b[i].first));
b[i].second = i;
}
sort(&a[0], &a[n]);
reverse(&a[0], &a[n]);
sort(&b[0], &b[n]);
for (long long i = 0; i < n; i++) {
c[b[i].second] = a[i];
}
for (long long i = 0; i < n; i++) {
printf("%lld ", c[i]);
}
printf("\n");
}
int main() { solve(); }
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, int b) {
long long ans = 1LL;
while (b) {
if (b & 1) ans = (ans * a);
a = (a * a);
b /= 2;
}
return ans;
}
int main() {
int t, m, n, i, j, k, l;
t = 1;
while (t--) {
long long m;
cin >> n >> m;
if (n == 2 && m == 2) {
cout << "2 1\n";
return 0;
}
int a[n + 1];
memset(a, 0, sizeof(a));
int st, en;
st = 1;
en = n;
for (i = 1; i <= n; i++) {
long long x = power(2, n - i - 1);
if (m > x) {
m -= x;
a[en] = i;
en--;
} else {
a[st] = i;
st++;
}
}
for (i = 1; i <= n; i++) cout << a[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
Edge() {}
Edge(int u, int v, int w) : u(u), v(v), w(w) {}
int u, v, w;
};
vector<vector<Edge> > ve;
map<pair<int, int>, int> edges;
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
ve.resize(n);
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
--u;
--v;
ve[u].push_back(Edge(u, v, w));
ve[v].push_back(Edge(v, u, w));
edges[make_pair(u, v)] = i + 1;
edges[make_pair(v, u)] = i + 1;
}
int io;
cin >> io;
--io;
vector<long long> d(n, 999999999999999LL);
vector<int> h(n, -1);
vector<int> w(n, 999999999);
d[io] = 0;
w[io] = 0;
priority_queue<pair<long long, int> > q;
q.push(make_pair(0, io));
while (!q.empty()) {
int u = q.top().second;
q.pop();
for (int i = 0; i < ve[u].size(); ++i) {
int v = ve[u][i].v;
if ((d[u] + ve[u][i].w < d[v]) ||
(d[u] + ve[u][i].w == d[v] && ve[u][i].w < w[v])) {
d[v] = d[u] + ve[u][i].w;
h[v] = u;
w[v] = ve[u][i].w;
q.push(make_pair(-d[v], v));
}
}
}
long long sum = 0;
for (int i = 0; i < n; ++i) sum += w[i];
cout << sum << "\n";
for (int i = 0; i < n; ++i)
if (i != io) cout << edges[make_pair(i, h[i])] << " ";
cout << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &(n), &(m));
--n, --m;
int l1 = 0, l2 = 0, n1 = n, n2 = m;
while (n1) {
n1 /= 7;
++l1;
}
l1 = max(l1, 1);
while (n2) {
n2 /= 7;
++l2;
}
l2 = max(l2, 1);
if (l1 + l2 > 7) {
printf("0\n");
return 0;
}
int ans = 0;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
int vis[9] = {0};
int a = i, b = j;
for (int(k) = (0); (k) < (l1); (k)++) {
vis[a % 7]++;
a /= 7;
}
for (int(k) = (0); (k) < (l2); (k)++) {
vis[b % 7]++;
b /= 7;
}
int fl = 0;
for (int(k) = (0); (k) < (7); (k)++) {
if (vis[k] > 1) {
fl = 1;
}
}
if (!fl) ++ans;
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int _N = 5010;
int A[_N], C[_N];
int N, M;
int fk(int a, int b) {
if (a == b) return 0;
return a < b ? b - a : N - a + b;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= M; ++i) {
int x, y;
scanf("%d%d", &x, &y);
++C[x];
if (A[x])
A[x] = min(A[x], fk(x, y));
else
A[x] = fk(x, y);
}
for (int i = 1; i <= N; ++i) {
long long ans = 0;
for (int j = 1; j <= N; ++j)
if (C[j]) ans = max(ans, fk(i, j) + 1ll * (C[j] - 1) * N + A[j]);
printf("%I64d ", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
inline int getint() {
int x = 0, p = 1;
char c;
c = getchar();
while (c <= 32) c = getchar();
if (c == 45) p = -p, c = getchar();
while (c > 32) x = x * 10 + c - 48, c = getchar();
return x * p;
}
using namespace std;
const int maxn = 1e5 + 5;
const int base = 1e5 + 5;
int n, L, R, ison[maxn], res[2], m = 1;
vector<int> E;
vector<pair<int, int> > G[maxn];
vector<pair<int, pair<int, int> > > vv;
bool is_centroid[maxn];
namespace T {
pair<int, int> dat[maxn << 2];
inline void finit(int _n) {
m = 1;
while (m < _n) m <<= 1;
for (int(i) = 0; (i) < (2 * m - 1); (i)++)
dat[i] = make_pair(-1000000000, -1);
}
inline void fM(int x, pair<int, int> del) {
x += m - 1;
if (del > dat[x]) {
dat[x] = max(dat[x], del);
while (x > 0) {
x = (x - 1) / 2;
dat[x] = max(dat[2 * x + 1], dat[2 * x + 2]);
}
}
}
pair<int, int> fQ(int x, int y, int l, int r, int k) {
if (y <= l || x >= r || x >= y)
return make_pair(-1000000000, -1);
else if (x <= l && r <= y)
return dat[k];
else {
pair<int, int> lx = fQ(x, y, l, (l + r) >> 1, 2 * k + 1);
pair<int, int> ly = fQ(x, y, (l + r) >> 1, r, 2 * k + 2);
return max(lx, ly);
}
}
} // namespace T
pair<int, pair<int, int> > get_ans(int x, int p, int len, int ok, int val) {
pair<int, int> buf = T::fQ(max(L - len, 0), min(R - len + 1, m), 0, m, 0);
pair<int, pair<int, int> > ans =
make_pair(buf.first + ok, make_pair(buf.second, x));
if (ans.first >= 0)
return ans;
else {
vv.push_back(make_pair(len, make_pair(ok, x)));
if (len + 1 > R) return make_pair(-1000000000, make_pair(-1000000000, -1));
for (int(i) = 0; (i) < (G[x].size()); (i)++) {
int y = G[x][i].second, llen = G[x][i].first;
if (y == p || is_centroid[y]) continue;
ans = get_ans(y, x, len + 1, ok + ((llen >= val) ? 1 : -1), val);
if (ans.first >= 0) return ans;
}
}
return make_pair(-1000000000, make_pair(-1000000000, -1));
}
int cnt_son(int x, int p) {
int c = 1;
for (int(i) = 0; (i) < (G[x].size()); (i)++) {
int y = G[x][i].second;
if (y == p || is_centroid[y]) continue;
c += cnt_son(y, x);
}
return ison[x] = c;
}
pair<int, int> get_centroid(int x, int p, int tot) {
pair<int, int> ans = make_pair(1000000000, -1);
int c = 0, ileft = 1;
for (int(i) = 0; (i) < (G[x].size()); (i)++) {
int y = G[x][i].second;
if (y == p || is_centroid[y]) continue;
ans = min(ans, get_centroid(y, x, tot));
ileft += ison[y];
c = max(c, ison[y]);
}
c = max(c, tot - ileft);
ans = min(ans, make_pair(c, x));
return ans;
}
pair<int, pair<int, int> > work(int x, int val) {
cnt_son(x, -1);
pair<int, int> u = get_centroid(x, -1, ison[x]);
int tot = u.first, s = u.second;
is_centroid[s] = true;
for (int(i) = 0; (i) < (G[s].size()); (i)++) {
int y = G[s][i].second;
if (is_centroid[y]) continue;
pair<int, pair<int, int> > ans = work(y, val);
if (ans.first >= 0) return ans;
}
T::finit(tot + 1);
T::fM(0, make_pair(0, s));
for (int(i) = 0; (i) < (G[s].size()); (i)++) {
vv.clear();
int y = G[s][i].second, len = G[s][i].first;
if (is_centroid[y]) continue;
pair<int, pair<int, int> > ans =
get_ans(y, s, 1, ((len >= val) ? 1 : -1), val);
if (ans.first >= 0) return ans;
for (int(i) = 0; (i) < (vv.size()); (i)++)
T::fM(vv[i].first, make_pair(vv[i].second.first, vv[i].second.second));
}
is_centroid[s] = false;
return make_pair(-1000000000, make_pair(-1, -1));
}
int main() {
n = getint();
L = getint();
R = getint();
for (int(i) = 0; (i) < (n - 1); (i)++) {
int x, y, z;
x = getint();
y = getint();
z = getint();
x--;
y--;
G[x].push_back(make_pair(z, y));
G[y].push_back(make_pair(z, x));
E.push_back(z);
}
sort(E.begin(), E.end());
E.resize(unique(E.begin(), E.end()) - E.begin());
int lb = 0, rb = E.size();
if (rb - lb == 1) {
pair<int, int> ans = work(0, E[0]).second;
res[0] = ans.first;
res[1] = ans.second;
} else
while (rb - lb > 1) {
int mid = (lb + rb) >> 1;
int val = E[mid];
memset(is_centroid, 0, sizeof(is_centroid));
pair<int, pair<int, int> > ans = work(0, val);
if (ans.first >= 0) {
lb = mid;
res[0] = ans.second.first;
res[1] = ans.second.second;
} else
rb = mid;
}
for (int(i) = 0; (i) < (2); (i)++) printf("%d ", res[i] + 1);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string find(string s, int x) {
int i;
string st;
for (i = 0; i < s.length(); i++) {
if (i - x >= 0 && s[i - x] == '1')
st.push_back('1');
else if (i + x < s.length() && s[i + x] == '1')
st.push_back('1');
else
st.push_back('0');
}
return st;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t, i, x, k;
string str;
cin >> t;
while (t--) {
cin >> str;
cin >> x;
string str1;
for (i = 0; i < str.length(); i++) str1.push_back('1');
for (i = 0; i < str.length(); i++) {
if (str[i] == '0') {
if (i - x >= 0) str1[i - x] = '0';
if (i + x < str.length()) str1[i + x] = '0';
}
}
for (i = 0; i < str.length(); i++) {
if (str[i] == '0') {
if (i - x >= 0 && str1[i - x] == '1') {
break;
}
if (i + x < str1.length() && str1[i + x] == '1') break;
} else {
if (i - x >= 0 && str1[i - x] == '1') continue;
if (i + x < str1.length() && str1[i + x] == '1')
continue;
else
break;
}
}
if (i != str.length())
cout << -1 << '\n';
else
cout << str1 << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int p(string s) {
string a = s;
s += "#";
reverse(a.begin(), a.end());
s += a;
int n = s.size();
vector<int> pi(n);
pi[0] = 0;
int j = 0;
for (int i = 1; i < n; i++) {
j = pi[i - 1];
while (j > 0 && s[i] != s[j]) j = pi[j - 1];
if (s[i] == s[j]) j++;
pi[i] = j;
}
return j;
}
int main() {
int t = 1;
cin >> t;
while (t--) {
string s;
cin >> s;
int cnt = 0;
int n = s.size();
for (int i = 0; i < n / 2; i++) {
if (s[i] != s[n - 1 - i]) break;
cnt++;
}
string ans;
if (cnt > 0) cout << s.substr(0, cnt);
;
string a = s;
reverse(a.begin(), a.end());
int pos = p(s.substr(cnt, n - 2 * cnt));
string w = s.substr(cnt, pos);
pos = p(a.substr(cnt, n - 2 * cnt));
w = (pos > w.length()) ? a.substr(cnt, pos) : w;
cout << w;
if (cnt > 0) cout << s.substr(n - cnt, cnt);
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128777216")
using namespace std;
const long double eps = pow(10.0, -10.0);
void start() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(0);
cout.setf(ios::fixed);
}
int main() {
start();
cout << "INTERCAL";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k, s, t;
cin >> n >> k >> s >> t;
vector<pair<long long, long long> > vec;
for (int i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
vec.push_back({a, b});
}
sort(vec.begin(), vec.end());
long long dis[k + 2];
dis[0] = 0;
for (int i = 1; i <= k; i++) {
cin >> dis[i];
}
dis[k + 1] = s;
sort(dis, dis + k + 2);
long long mx = 0;
vector<long long> re;
for (int i = 1; i < k + 2; i++) {
mx = max(mx, dis[i] - dis[i - 1]);
re.push_back(dis[i] - dis[i - 1]);
}
sort(re.begin(), re.end());
if (t < s * 2) {
long long num = (s * 2) - t;
long long st = 0, en = 1e9, m, ans = -1;
while (st <= en) {
m = (st + en) / 2;
long long v = 0;
for (int i = 0; i < re.size(); i++) {
long long f = (m - re[i]);
if (f > re[i])
v += (re[i]);
else if (f >= 0)
v += ((re[i] - f) * 2 + f);
else
v += (1e9);
}
if (v <= t) {
ans = m;
en = m - 1;
} else
st = m + 1;
}
mx = ans;
}
if (mx == -1) return cout << -1, 0;
for (int i = 0; i < vec.size(); i++) {
if (vec[i].second >= mx) return cout << vec[i].first, 0;
}
cout << -1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
bool cmp(long long x, long long y) { return x >= y; }
signed main() {
cin >> n;
while (n--) {
long long a;
cin >> a;
long long k = 0;
while ((1 << (k + 1)) <= a) {
k++;
}
if (a == (1 << (k + 1)) - 1) {
long long one = 1;
for (long long i = 2; i <= sqrt(a); i++) {
if (a % i == 0) {
one = a / i;
break;
}
}
cout << one << "\n";
} else {
cout << ((1 << (k + 1)) - 1) << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename Iter>
ostream& outIt(ostream& out, Iter b, Iter e) {
for (Iter i = b; i != e; i++) out << (i == b ? "" : " ") << *i;
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T>& v) {
return outIt(out << '[', (v).begin(), (v).end()) << ']';
}
template <typename T>
ostream& operator<<(ostream& out, deque<T>& v) {
return outIt(out << '[', (v).begin(), (v).end()) << ']';
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
return out << '(' << p.first << ", " << p.second << ')';
}
struct point {
int64_t x, y;
};
point operator-(point a, point b) { return {a.x - b.x, a.y - b.y}; }
point operator-(point a) { return {-a.x, -a.y}; }
point operator+(point a, point b) { return {a.x + b.x, a.y + b.y}; }
bool operator==(point a, point b) { return a.x == b.x && a.y == b.y; }
ostream& operator<<(ostream& out, point a) {
return out << "P(" << a.x << ", " << a.y << ")";
}
int64_t pos[3][3] = {{5, 4, 3}, {6, -1, 2}, {7, 0, 1}};
int64_t sign(int64_t x) { return x ? x < 0 ? -1 : 1 : 0; }
bool operator<(point a, point b) {
if (a == b) return false;
if (pos[sign(a.x) + 1][sign(a.y) + 1] != pos[sign(b.x) + 1][sign(b.y) + 1])
return pos[sign(a.x) + 1][sign(a.y) + 1] <
pos[sign(b.x) + 1][sign(b.y) + 1];
return (a.x * b.x > 0) == (a.y * b.x < b.y * a.x);
}
bool between(point a, point b, point c) {
if (a < c)
return a < b && b < c;
else
return a < b || b < c;
}
inline int64_t C2(int64_t a) { return a * (a - 1) / 2; }
vector<point> v;
vector<pair<point, int64_t>> u;
vector<vector<int64_t>> ans;
const int64_t mod = 1000000007;
signed main() {
int64_t n;
cin >> n;
for (int64_t i = 0; i < n; i++) {
int64_t a, b;
cin >> a >> b;
v.push_back({a, b});
}
ans.resize(n);
for (int64_t i = 0; i < n; i++) {
ans[i].resize(n);
u.resize(0);
for (int64_t j = 0; j < n; j++)
if (i != j) u.push_back({v[j] - v[i], j});
sort((u).begin(), (u).end());
for (int64_t j = 0, l = 1; j < n - 1; j++) {
if (l % (n - 1) == j) l++;
while (between(u[j].first, u[l % (n - 1)].first, -u[j].first)) l++;
ans[i][u[j].second] = l - j - 1;
}
}
int64_t anses = 0;
for (int64_t i = 0; i < n; i++)
for (int64_t j = 0; j < n; j++)
if (i != j) (anses += C2(ans[i][j]) * C2(n - 2 - ans[i][j]));
cout << anses / 2 << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using lld = long double;
using ulli = unsigned long long int;
using pll = pair<lli, lli>;
using ttt = pair<lli, pll>;
using vttt = vector<ttt>;
using vll = vector<pll>;
using vl = vector<lli>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using cd = complex<lld>;
const double PI = acos(-1);
char p[1000010], s[210];
int tejas_919(int kkkk) {
lli n, m, k, q, u, v, temp = 0, ans = 0;
cin.getline(p, 1000010);
cin.getline(s, 210);
cin >> k;
int ls = strlen(s), lp = strlen(p);
string curans = string(k + 1, '1');
std::vector<string> prep(k);
{} {}
for (int i = 0; i < lp; i++) prep[i % k] += p[i];
{}
for (int perpart = 1; perpart < min(lp, ls) + 1; perpart++) {
std::vector<string> parts(perpart);
for (int i = 0; i < ls; i++) parts[i % perpart] += s[i];
int ind = perpart - 1;
string ans;
for (int i = k - 1; i >= 0; i--) {
if (ind >= 0 && ((lli)(prep[i]).size()) == ((lli)(parts[ind]).size()) &&
prep[i] == parts[ind]) {
ind--;
ans += '1';
} else
ans += '0';
}
if (ind >= 0) continue;
reverse(ans.begin(), ans.end());
if (((lli)(ans).size()) == k) curans = min(curans, ans);
}
if (((lli)(curans).size()) != k)
cout << 0 << '\n';
else
cout << curans << '\n';
return 0;
}
signed main() {
if (!0) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
cout << fixed << setprecision(10);
int t = 1;
for (int i = 0; i < t; i++) {
tejas_919(i + 1);
}
{};
if (0) system("pause");
}
| 8 |
#include <bits/stdc++.h>
int c[1000001];
char str[1000001];
int len;
int ct;
long long ans;
int main() {
int k;
int i;
scanf("%d", &k);
scanf("%s", str);
len = strlen(str);
if (k == 0) {
for (i = 0; i < len; i++) {
if (str[i] == '0')
ct++;
else {
ans += (long long)ct * (long long)(ct + 1) / 2;
ct = 0;
}
}
ans += (long long)ct * (long long)(ct + 1) / 2;
} else if (k > 0) {
for (i = 0; i < len; i++) {
if (str[i] == '1') ct++;
c[ct]++;
}
ans = c[k];
for (i = k; i <= len; i++) ans += (long long)c[i] * (long long)c[i - k];
}
printf("%I64d\n", ans);
scanf(" ");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int xp, yp, xv, yv;
cin >> xp >> yp >> xv >> yv;
if (xp <= xv && yp <= yv)
cout << "Polycarp" << endl;
else if (max(xv, yv) < xp + yp)
cout << "Vasiliy" << endl;
else
cout << "Polycarp" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
const int N = 1e5 + 10;
char s[N];
int K;
int Pow(int a, long long b) {
int ret = 1;
while (b) {
if (b & 1) ret = (long long)ret * a % Mod;
b >>= 1;
a = (long long)a * a % Mod;
}
return ret;
}
int pos[N], tot, len;
int get() {
int ret = Pow(2, len);
int temp = ret;
ret = Pow(ret, K);
ret = (ret - 1 + Mod) % Mod;
temp = (temp - 1 + Mod) % Mod;
ret = (long long)ret * Pow(temp, Mod - 2) % Mod;
return ret;
}
void solve() {
len = strlen(s);
tot = 0;
for (int i = 0; i < len; i++)
if (s[i] == '0' || s[i] == '5') {
pos[tot++] = i;
}
if (tot == 0) {
puts("0");
return;
}
int ret = 0;
for (int i = 0; i < tot; i++) {
ret = ret + Pow(2, pos[i]);
if (ret >= Mod) ret -= Mod;
}
ret = (long long)ret * get() % Mod;
printf("%d\n", ret);
}
void work() {
while (~scanf("%s", s)) {
scanf("%d", &K);
solve();
}
}
int main() {
work();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp[105];
int main() {
int x, temp;
cin >> x;
int i = 1, j = 1;
while (true) {
temp = (i * i + 1) / 2;
for (; j <= temp && j <= 102; j++) {
dp[j] = i;
}
if (j > 100) break;
i += 2;
}
dp[3] = 5;
cout << dp[x] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const long long linf = 4000000000000000000LL;
const long long inf = 1000000007;
const long double pi = 3.1415926535;
void pv(vector<int> a) {
for (auto& x : a) cout << x << " ";
cout << endl;
}
void pv(vector<long long> a) {
for (auto& x : a) cout << x << " ";
cout << endl;
}
void pv(vector<vector<int>> a) {
for (int i = (0); i < (int(a.size())); ++i) {
cout << i << endl;
pv(a[i]);
cout << endl;
}
}
void pv(vector<vector<long long>> a) {
for (int i = (0); i < (int(a.size())); ++i) {
cout << i << endl;
pv(a[i]);
}
cout << endl;
}
void pv(vector<string> a) {
for (auto& x : a) cout << x << endl;
cout << endl;
}
void build_primes(vector<int>& primes, int size) {
vector<int> visited;
visited.resize(size, 0);
for (int i = (2); i < (size); ++i) {
if (visited[i] == 0) {
primes.push_back(i);
int a = i;
while (a < size) {
visited[a] = 1;
a += i;
}
}
}
}
vector<vector<long long>> matrix_mult(vector<vector<long long>>& a,
vector<vector<long long>>& b) {
int n = a.size();
vector<vector<long long>> answer;
answer.resize(n);
for (int i = 0; i < n; i++) answer[i].resize(n, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++)
answer[i][j] = (answer[i][j] + a[i][k] * b[k][j]) % inf;
}
}
return answer;
}
int modInverse(int a, int m) {
int m0 = m;
int y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
int q = a / m;
int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long power(long long x, long long y) {
long long k = 1LL << 60;
long long z = 1;
while (k != 0) {
z *= z;
z %= inf;
if (y >= k) {
z *= x;
z %= inf;
y -= k;
}
k >>= 1;
}
return z;
}
struct point {
long double x, y;
bool operator<(const point& rhs) const {
if (x == rhs.x) return y < rhs.y;
return x < rhs.x;
}
};
struct pt {
long long x, y;
bool operator<(const pt& rhs) const {
if (x == rhs.x) return y < rhs.y;
return x < rhs.x;
}
};
long double area(point x, point y, point z) {
return (x.y * y.x + y.y * z.x + z.y * x.x - x.x * y.y - y.x * z.y -
z.x * x.y) /
2.0;
}
bool clockwise(point x, point y, point z) { return area(x, y, z) > 0; }
long double area(pt x, pt y, pt z) {
return (x.y * y.x + y.y * z.x + z.y * x.x - x.x * y.y - y.x * z.y -
z.x * x.y) /
2.0;
}
bool clockwise(pt x, pt y, pt z) { return area(x, y, z) > 0; }
long long gcd(long long a, long long b) {
if (a > b) swap(a, b);
if (a == 0) return b;
return gcd(a, b % a);
}
int popcount(long long a) {
int count = 0;
while (a) {
count += (a & 1);
a >>= 1;
}
return count;
}
long long choose(long long n, long long r) {
long long p = 1, k = 1;
if (n - r < r) r = n - r;
if (r != 0) {
while (r) {
p *= n;
k *= r;
long long m = gcd(p, k);
p /= m;
k /= m;
n--;
r--;
}
} else
p = 1;
return p;
}
vector<long long> prefix_hash(string& a, vector<long long>& powers,
long long mod) {
int n = int(a.size());
vector<long long> prefix(n + 1);
for (int i = (0); i < (n); ++i)
prefix[i + 1] = (prefix[i] + powers[i] * (a[i] - '1' + 1)) % mod;
return prefix;
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
uint64_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
struct custom_hash_fast {
uint64_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
x ^= FIXED_RANDOM;
return x ^ (x >> 16);
}
};
void setIO(string second) {
ios_base::sync_with_stdio(0);
cin.tie(0);
if (int(second.size())) {
freopen((second + ".in").c_str(), "r", stdin);
if (second != "test3") freopen((second + ".out").c_str(), "w", stdout);
}
}
int n, m;
vector<vector<int>> adj;
vector<vector<int>> ans;
vector<int> v;
int timenow;
bool dfs(int i, int p) {
v[i] = timenow;
vector<int> curr;
for (auto& x : adj[i]) {
if (x == p || (v[x] == timenow && x < i)) continue;
if (v[x]) {
curr.push_back(x);
if (int(curr.size()) == 2) {
ans.push_back({curr[0], i, curr[1]});
curr.pop_back();
curr.pop_back();
}
} else if (dfs(x, i)) {
curr.push_back(x);
if (int(curr.size()) == 2) {
ans.push_back({curr[0], i, curr[1]});
curr.pop_back();
curr.pop_back();
}
}
}
if (int(curr.size())) {
if (p + 1) ans.push_back({curr[0], i, p});
return 0;
}
return 1;
}
int main() {
setIO("");
cin >> n >> m;
adj.resize(n);
for (int i = (0); i < (m); ++i) {
int a, b;
cin >> a >> b;
adj[--a].push_back(--b);
adj[b].push_back(a);
}
v.resize(n);
timenow = 1;
for (int i = (0); i < (n); ++i) {
if (v[i] == 0) {
dfs(i, -1);
timenow++;
}
}
cout << int(ans.size()) << endl;
for (auto& x : ans)
cout << x[0] + 1 << " " << x[1] + 1 << " " << x[2] + 1 << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int lcm(int a, int b) { return (a * b) / gcd(a, b); }
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, 1, -1, 0, 0, -1, 1};
int dx4[] = {0, 0, 1, -1};
int dy4[] = {1, -1, 0, 0};
const long long MOD = 1000000007;
double sq(double x) { return x * x; }
template <typename T>
inline T Bigmod(T base, T power, T MOD) {
T ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
inline void normal(long long &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline long long modMul(long long a, long long b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline long long modAdd(long long a, long long b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline long long modSub(long long a, long long b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, MOD - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
const int maxn = 104;
vector<int> edj[maxn][maxn];
void solution() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
edj[a][c].push_back(b);
edj[b][c].push_back(a);
}
int q;
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
int ans = 0;
for (int i = 1; i <= m; i++) {
queue<int> q;
q.push(a);
int vis[maxn];
memset(vis, 0, sizeof(vis));
vis[a] = 1;
bool got = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int j = 0; j < (int)edj[u][i].size(); j++) {
int v = edj[u][i][j];
if (vis[v] == 0) {
if (v == b) {
got = 1;
break;
}
q.push(v);
vis[v] = 1;
}
}
if (got) {
break;
}
}
if (got) ans++;
}
cout << ans << endl;
}
}
signed main() {
ios::sync_with_stdio(false);
int t;
t = 1;
while (t--) {
solution();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, M, Size;
int Way[410][410];
int Used[410];
int Flag;
int f(int k) {
Used[k] = 1;
for (int i = 1; i <= Size; i++)
if (i != k && !Used[i] && Way[k][i]) f(i);
}
int main() {
scanf("%d %d", &N, &M);
Size = N * M;
char ch;
for (int i = 1; i <= N; i++) {
scanf(" %c", &ch);
if (ch == '>') {
for (int j = 1; j <= M; j++)
for (int k = j + 1; k <= M; k++)
Way[(i - 1) * M + j][(i - 1) * M + k] = 1;
} else {
for (int j = M; j > 0; j--)
for (int k = j - 1; k > 0; k--)
Way[(i - 1) * M + j][(i - 1) * M + k] = 1;
}
}
for (int i = 1; i <= M; i++) {
scanf(" %c", &ch);
if (ch == 'v')
for (int j = 1; j <= N; j++)
for (int k = j + 1; k <= N; k++)
Way[(j - 1) * M + i][(k - 1) * M + i] = 1;
if (ch == '^')
for (int j = N; j > 0; j--)
for (int k = j - 1; k > 0; k--)
Way[(j - 1) * M + i][(k - 1) * M + i] = 1;
}
for (int i = 1; i <= Size; i++)
for (int j = 1; j <= Size; j++)
if (i != j && Way[i][j])
for (int k = 1; k <= Size; k++)
if (k != i && k != j && Way[k][i]) Way[k][j] = 1;
int res = 1;
for (int i = 1; i <= Size; i++)
for (int j = 1; j <= Size; j++)
if (i != j) res &= Way[i][j];
if (res)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int arr[100100];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
long long sum = 0;
for (int i = 0; i + 1 < n; i++) {
sum += arr[i];
cout << sum << '\n';
int j = i, k = 1;
while (j + k < n) {
k *= 2;
}
k /= 2;
arr[j + k] += arr[i];
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool ok[200009];
int main() {
int t, n, a, i;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (i = 0; i < n; i++) ok[i] = false;
bool fl = true;
for (i = 0; i < n; i++) {
scanf("%d", &a);
a += i;
a %= n;
if (a < 0) a += n;
if (ok[a]) fl = false;
ok[a] = true;
}
if (fl)
puts("YES");
else {
puts("NO");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long n, long long m) {
if (n >= m)
return n;
else
return m;
}
long long min(long long n, long long m) {
if (n <= m)
return n;
else
return m;
}
void digest(vector<long long> &v, long long n) {
long long elem;
for (long long i = 0; i < n; i++) {
cin >> elem;
v.emplace_back(elem);
}
}
void vomit(vector<long long> &v, long long a, long long n) {
for (long long i = a; i < n; i++) cout << v.at(i) << " ";
cout << "\n";
}
bool flag = false;
void dfs(long long node, vector<long long> v[], vector<long long> &visited,
long long elem) {
visited.at(node) = 1;
if (node == elem) {
flag = true;
return;
}
for (long long i = 0; i < v[node].size(); i++) {
if (visited.at(v[node].at(i)) == -1) dfs(v[node].at(i), v, visited, elem);
}
}
void solve() {
long long n;
cin >> n;
vector<long long> v[n + 5];
vector<pair<long long, long long>> p;
p.emplace_back(-1, -1);
vector<long long> visited(n + 5, -1);
long long x, a, b;
for (long long i = 1; i < n + 1; i++) {
cin >> x;
if (x == 1) {
cin >> a >> b;
for (long long j = 1; j < p.size(); j++) {
if ((p.at(j).first < a and a < p.at(j).second) or
(p.at(j).first < b and b < p.at(j).second))
v[p.size()].emplace_back(j);
if ((a < p.at(j).first and p.at(j).first < b) or
(a < p.at(j).second and p.at(j).second < b))
v[j].emplace_back(p.size());
}
p.emplace_back(a, b);
} else {
cin >> a >> b;
fill((visited).begin(), (visited).end(), -1);
dfs(a, v, visited, b);
if (flag)
cout << "YES\n";
else
cout << "NO\n";
flag = false;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
solve();
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using std::min;
using std::sort;
const int maxn = 500000 + 10;
int stack[maxn], p = -1;
int main() {
int n, x;
scanf("%d", &n);
long long ans = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
while (p >= 1 && stack[p - 1] >= stack[p] && stack[p] < x) {
ans += min(stack[p - 1], x);
p--;
}
stack[++p] = x;
}
sort(stack, stack + p + 1);
for (int i = 0; i < p - 1; i++) ans += stack[i];
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
ostream& operator<<(ostream& o, const pair<A, B>& p) {
return o << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& v) {
o << "[";
for (__typeof((v).end()) it = (v).begin(); it != (v).end(); ++it)
o << *it << ", ";
return o << "]";
}
template <class T>
ostream& operator<<(ostream& o, const set<T>& v) {
o << "[";
for (__typeof((v).end()) it = (v).begin(); it != (v).end(); ++it)
o << *it << ", ";
return o << "]";
}
template <class T>
inline void MAX(T& a, T b) {
if (a < b) a = b;
}
template <class T>
inline void MIN(T& a, T b) {
if (a > b) a = b;
}
template <class T>
inline bool read(T& x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int mx = -1;
for (int i = 0; i < n; i++) {
int cnt = 1;
for (int j = i; j - 1 >= 0; j--) {
if (arr[j - 1] <= arr[j]) {
cnt++;
} else {
break;
}
}
for (int j = i; j + 1 < n; j++) {
if (arr[j + 1] <= arr[j]) {
cnt++;
} else {
break;
}
}
mx = max(mx, cnt);
}
cout << mx;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000, 102400000");
const int N = 5e3 + 10;
const int M = 1e3 + 10;
int n, m, x, y;
int a[N][M], t[N], ta[N], tb[N], aa[N], bb[N], f[N];
string s;
map<string, int> mp;
int check(int p, int k) {
int sum = 0;
f[0] = k;
for (int i = 1; i <= n; i++) {
if (t[i] == 0) f[i] = a[i][p];
if (t[i] == 1) f[i] = f[ta[i]] & f[tb[i]];
if (t[i] == 2) f[i] = f[ta[i]] | f[tb[i]];
if (t[i] == 3) f[i] = f[ta[i]] ^ f[tb[i]];
sum += f[i];
}
return sum;
}
int main() {
mp["?"] = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
cin >> s;
mp[s] = i;
cin >> s;
cin >> s;
if (s[0] == '0' || s[0] == '1') {
for (int j = 0; j <= m - 1; j++) {
a[i][j] = s[j] - '0';
}
continue;
}
ta[i] = mp[s];
cin >> s;
if (s[0] == 'A')
t[i] = 1;
else if (s[0] == 'O')
t[i] = 2;
else
t[i] = 3;
cin >> s;
tb[i] = mp[s];
}
for (int i = 0; i <= m - 1; i++) {
x = check(i, 0);
y = check(i, 1);
aa[i] = y < x;
bb[i] = x < y;
}
for (int i = 0; i <= m - 1; i++) printf("%d", aa[i]);
printf("\n");
for (int i = 0; i <= m - 1; i++) printf("%d", bb[i]);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
const double pi = acos(-1.0);
using namespace std;
void printtime() {
time_t my_time = time(NULL);
printf("%s", ctime(&my_time));
}
int fact(int n) { return (n == 0) || (n == 1) ? 1 : n * fact(n - 1); }
void sieve(long long n) {
bool check[n + 1];
memset(check, true, sizeof(check));
for (long long i = 2; i * i <= n; i++)
if (check[i] == true)
for (long long j = i * i; j <= n; j += i) check[j] = false;
for (long long i = 2; i <= n; i++) {
if (check[i] == true) {
cout << i << " ";
}
}
}
bool isprime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int count = 0;
int a[n + 2];
set<int> st;
int mx = -1e18;
for (int i = 0; i < n; i++) {
cin >> a[i];
st.insert(a[i]);
}
count = st.size();
if (count <= k) {
cout << 1 << "\n";
} else if (count > 1 && k == 1) {
cout << -1 << "\n";
} else {
k--;
count--;
cout << count / k + (count % k != 0) << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using db = double;
using ll = long long;
using uint = unsigned int;
using ull = unsigned long long;
using pii = pair<int, int>;
template <class T>
void cmax(T& x, const T& y) {
if (x < y) x = y;
}
template <class T>
void cmin(T& x, const T& y) {
if (x > y) x = y;
}
template <class T>
void sort(vector<T>& v) {
sort(v.begin(), v.end());
}
template <class T>
void reverse(vector<T>& v) {
reverse(v.begin(), v.end());
}
template <class T>
void unique(vector<T>& v) {
sort(v.begin(), v.end()), v.erase(unique(v.begin(), v.end()), v.end());
}
void reverse(string& s) { reverse(s.begin(), s.end()); }
const int io_size = 1 << 23 | 233;
const int io_limit = 1 << 22;
struct io_in {
char ch;
char getchar() {
static char buf[io_size], *p1 = buf, *p2 = buf;
return (p1 == p2) &&
(p2 = (p1 = buf) + fread(buf, 1, io_size, stdin), p1 == p2)
? EOF
: *p1++;
}
io_in& operator>>(char& c) {
for (c = getchar(); isspace(c); c = getchar())
;
return *this;
}
io_in& operator>>(string& s) {
for (s.clear(); isspace(ch = getchar());)
;
if (!~ch) return *this;
for (s = ch; !isspace(ch = getchar()) && ~ch; s += ch)
;
return *this;
}
io_in& operator>>(char* str) {
char* cur = str;
while (*cur) *cur++ = 0;
for (cur = str; isspace(ch = getchar());)
;
if (!~ch) return *this;
for (*cur = ch; !isspace(ch = getchar()) && ~ch; *++cur = ch)
;
return *++cur = 0, *this;
}
template <class T>
void read(T& x) {
bool f = 0;
while ((ch = getchar()) < 48 && ~ch) f ^= (ch == 45);
x = ~ch ? (ch ^ 48) : 0;
while ((ch = getchar()) > 47) x = x * 10 + (ch ^ 48);
x = f ? -x : x;
}
io_in& operator>>(int& x) { return read(x), *this; }
io_in& operator>>(ll& x) { return read(x), *this; }
io_in& operator>>(uint& x) { return read(x), *this; }
io_in& operator>>(ull& x) { return read(x), *this; }
io_in& operator>>(db& x) {
read(x);
bool f = x < 0;
x = f ? -x : x;
if (ch ^ '.') return *this;
double d = 0.1;
while ((ch = getchar()) > 47) x += d * (ch ^ 48), d *= .1;
return x = f ? -x : x, *this;
}
} in;
struct io_out {
char buf[io_size], *s = buf;
int pw[233], st[233];
io_out() {
set(7);
for (register int i = (pw[0] = 1); i <= (9); ++i) pw[i] = pw[i - 1] * 10;
}
~io_out() { flush(); }
void io_chk() {
if (s - buf > io_limit) flush();
}
void flush() { fwrite(buf, 1, s - buf, stdout), fflush(stdout), s = buf; }
io_out& operator<<(char c) { return *s++ = c, *this; }
io_out& operator<<(string str) {
for (char c : str) *s++ = c;
return io_chk(), *this;
}
io_out& operator<<(char* str) {
char* cur = str;
while (*cur) *s++ = *cur++;
return io_chk(), *this;
}
template <class T>
void write(T x) {
if (x < 0) *s++ = '-', x = -x;
do {
st[++st[0]] = x % 10, x /= 10;
} while (x);
while (st[0]) *s++ = st[st[0]--] ^ 48;
}
io_out& operator<<(int x) { return write(x), io_chk(), *this; }
io_out& operator<<(ll x) { return write(x), io_chk(), *this; }
io_out& operator<<(uint x) { return write(x), io_chk(), *this; }
io_out& operator<<(ull x) { return write(x), io_chk(), *this; }
int len, lft, rig;
void set(int _length) { len = _length; }
io_out& operator<<(db x) {
bool f = x < 0;
x = f ? -x : x, lft = x, rig = 1. * (x - lft) * pw[len];
return write(f ? -lft : lft), *s++ = '.', write(rig), io_chk(), *this;
}
} out;
template <long long sz, long long mod>
struct math_t {
math_t() {
fac.resize(sz + 1), ifac.resize(sz + 1);
for (register long long i = (fac[0] = 1); i <= (sz); ++i)
fac[i] = fac[i - 1] * i % mod;
ifac[sz] = inv(fac[sz]);
for (register long long i = (sz - 1); i >= (0); --i)
ifac[i] = ifac[i + 1] * (i + 1) % mod;
}
vector<long long> fac, ifac;
long long qpow(long long x, long long y) {
long long ans = 1;
for (; y; y >>= 1, x = x * x % mod)
if (y & 1) ans = ans * x % mod;
return ans;
}
long long inv(long long x) { return qpow(x, mod - 2); }
long long C(long long n, long long m) {
if (n < 0 || m < 0 || n < m) return 0;
return fac[n] * ifac[m] % mod * ifac[n - m] % mod;
}
};
long long gcd(long long x, long long y) { return !y ? x : gcd(y, x % y); }
long long lcm(long long x, long long y) { return x * y / gcd(x, y); }
long long dp[2][22222];
const long long mod = 1e9 + 7;
long long inc(long long x, long long y) {
return (x + y >= mod) ? (x + y - mod) : (x + y);
}
signed main() {
long long _;
in >> _;
long long p = 1, ans = 0;
for (long long i = 1; i <= _; i++) {
long long x;
in >> x;
memset(dp[p], 0, sizeof(dp[p]));
dp[p][11111 - x] = dp[p][11111 + x] = 1;
for (long long j = 0; j < 22222; j++) {
if (j - x > 0) dp[p][j] = inc(dp[p][j], dp[p ^ 1][j - x]);
if (j + x < 22222) dp[p][j] = inc(dp[p][j], dp[p ^ 1][j + x]);
}
ans = inc(ans, dp[p][11111]);
p ^= 1;
}
out << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int p[N], vis[N], ans[N], n;
vector<vector<int>> v1, v2;
bool cmp(vector<int> a, vector<int> b) { return a.size() < b.size(); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
vector<int> v;
v.clear();
v.push_back(i);
int x = p[i];
while (x != i) {
v.push_back(x);
vis[x] = 1;
x = p[x];
}
if (v.size() % 2)
v1.push_back(v);
else
v2.push_back(v);
}
if (v2.size() % 2) {
puts("-1");
return 0;
}
sort(v2.begin(), v2.end(), cmp);
for (auto v : v1) {
int n = (v.size() + 1) / 2;
for (int i = 0; i < v.size(); i++) ans[p[v[i]]] = p[v[(i + n) % v.size()]];
}
for (int j = 0; j < v2.size(); j += 2) {
if (v2[j].size() != v2[j + 1].size()) {
puts("-1");
return 0;
}
for (int i = 0; i < v2[j].size(); i++) ans[p[v2[j][i]]] = p[v2[j + 1][i]];
for (int i = 0; i < v2[j + 1].size(); i++)
ans[p[v2[j + 1][i]]] = p[v2[j][(i + 1) % v2[j].size()]];
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long md;
long long a[5000000];
void mul(long long a[2][2], long long b[2][2], long long c[2][2]) {
long long d[2][2];
int i, j, k;
memset(d, 0, sizeof(d));
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
for (k = 0; k < 2; k++) {
d[i][j] += (a[i][k] * b[k][j]) % md;
d[i][j] %= md;
}
}
}
for (i = 0; i < 2; i++)
for (j = 0; j < 2; j++) c[i][j] = d[i][j];
return;
}
int fib(long long x) {
long long top, d[200], m1[2][2], m[2][2];
int i;
top = -1;
while (x > 0) {
top++;
d[top] = x % 2;
x = x / 2;
}
m1[0][0] = 1;
m1[0][1] = 1;
m1[1][0] = 1;
m1[1][1] = 0;
m[0][0] = 1;
m[0][1] = 0;
m[1][0] = 0;
m[1][1] = 1;
for (i = top; i >= 0; i--) {
mul(m, m, m);
if (d[i] == 1) mul(m, m1, m);
}
return m[1][0];
}
int main() {
long long l, r, kk;
long long i, j, k, s;
cin >> md >> l >> r >> kk;
i = 1;
while (i * i <= r) {
a[i - 1] = i;
i++;
}
k = i;
for (j = 1; j <= i; j++) {
a[k - 1] = r / j;
k++;
}
k--;
sort(a, a + k);
for (i = k - 1; i >= 0; i--) {
s = r / a[i] - (l - 1) / a[i];
if (s >= kk) {
break;
}
}
cout << fib(a[i]) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
int a = 0, b, c;
vector<pair<int, pair<int, int>>> p;
for (int i = 1; i <= n; i += 2) {
b = i;
for (int j = 1; j <= m; ++j) {
a++;
c = j;
p.push_back(make_pair(a, make_pair(b, c)));
}
while (c--) {
a++;
b = i + 1;
p.push_back(make_pair(a, make_pair(b, c + 1)));
}
}
int q = (n * m) / k;
int r = n * m - k * q + q;
int t = 0;
int rem = n * m;
int x = k;
while (x--) {
if (rem == r) {
cout << r << " ";
for (int i = 0; i < r; ++i) {
cout << p[t + i].second.first << " " << p[t + i].second.second << " ";
}
t = t + r;
} else {
cout << q << " ";
for (int i = 0; i < q; ++i) {
cout << p[t + i].second.first << " " << p[t + i].second.second << " ";
}
t = t + q;
rem = rem - q;
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int a[100005], b[100005], n, m, c, i, j, buff;
scanf("%d%d%d", &n, &m, &c);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
for (i = 1; i < m; i++) {
b[i] += b[i - 1];
b[i] %= c;
}
buff = n - m + 1;
for (i = 0; i < n; i++) {
if (i >= m) {
a[i] += b[m - 1];
} else {
a[i] += b[i];
}
j = i - buff;
a[i] %= c;
if (j >= 0) {
a[i] -= b[j];
}
a[i] = (a[i] + c) % c;
}
for (i = 0; i < n; i++) {
printf("%d ", a[i]);
}
putchar(10);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int x[1001], used[1001], l;
int main() {
int n, ist = 0, ind = 0, yig = 0, f = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i];
}
if (x[0] == 1 && x[1] == 0) {
cout << 0 << endl;
return 0;
}
while (yig != n) {
if (ist == 0) {
f = 0;
for (int i = ind; i < n; i++) {
if (x[i] <= yig && used[i] == 0) {
f = 1;
used[i] = 1;
ind = i;
yig++;
break;
}
}
if (f == 0) {
ist = 1;
l++;
}
} else {
f = 0;
for (int i = ind; i >= 0; i--) {
if (x[i] <= yig && used[i] == 0) {
f = 1;
ind = i;
used[i] = 1;
yig++;
break;
}
}
if (f == 0) {
ist = 0;
l++;
}
}
}
cout << l << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<int, int, greater<int>> input;
map<int, int, greater<int>> output;
map<int, int, greater<int>> input_reverse;
map<int, int, greater<int>> output_reverse;
int N;
cin >> N;
int i = N;
int index = 1;
while (i--) {
int x;
scanf("%d", &x);
input[index] = x;
input_reverse[x] = index;
index++;
}
i = N;
index = 1;
while (i--) {
int x;
scanf("%d", &x);
output[index] = x;
output_reverse[x] = index;
index++;
}
map<int, int, greater<int>>::iterator it1;
map<int, int, greater<int>>::iterator it1_rev;
map<int, int, greater<int>>::iterator it2;
map<int, int, greater<int>>::iterator it2_rev;
int val = 0;
int count_val = 0;
it1 = input.begin();
while (!input.empty()) {
it2 = output.begin();
if ((*it1).second != (*(it2)).second) {
val = val + count_val;
val++;
count_val = 0;
} else {
count_val++;
}
int x = (*it1).second;
it1++;
it1_rev = input_reverse.find(x);
input.erase((*it1_rev).second);
it2_rev = output_reverse.find(x);
output.erase((*it2_rev).second);
}
printf("%d\n", val);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const N = 205;
int const NN = 11;
int ans[N], n;
bitset<1 << NN> a[N][NN];
string last[N], first[N], s[N];
void add(int index, string s) {
for (int i = 0; i < s.size(); i++) {
int val = 0;
for (int j = i; j < min((int)s.size(), i + NN); j++) {
val = val * 2 + (s[j] - '0');
a[index][j - i + 1][val] = 1;
}
}
while (1) {
for (int mask = 0; mask < (1 << (ans[index] + 1)); mask++) {
if (a[index][ans[index] + 1][mask] == 0) {
return;
}
}
ans[index]++;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
if (s[i].size() < NN) {
last[i] = first[i] = s[i];
} else {
last[i] = s[i].substr(s[i].size() - NN, NN);
first[i] = s[i].substr(0, NN);
}
add(i, s[i]);
}
int m;
cin >> m;
for (int i = n + 1; i <= n + m; i++) {
int u, v;
cin >> u >> v;
if (last[v].size() < NN) {
int rest = min(NN - last[v].size(), last[u].size());
last[i] = last[u].substr(last[u].size() - rest, rest) + last[v];
} else {
last[i] = last[v];
}
if (first[u].size() < NN) {
int rest = min(NN - first[u].size(), first[v].size());
first[i] = first[u] + first[v].substr(0, rest);
} else {
first[i] = first[u];
}
for (int j = 1; j < NN; j++) a[i][j] = a[u][j] | a[v][j];
ans[i] = max(ans[u], ans[v]);
string newStr = last[u] + first[v];
add(i, newStr);
cout << ans[i] << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n;
long sum, num;
short f[200001];
bool a[200001];
double aver;
cin >> n;
for (i = 1; i <= 200001; i++) a[i] = false;
sum = 0;
num = 0;
for (i = 1; i <= n; i++) {
cin >> j;
f[i] = j;
sum = sum + j;
}
aver = double(sum) / double(n);
for (i = 1; i <= n; i++)
if (double(f[i] == aver)) {
num++;
a[i] = true;
}
cout << num << endl;
for (i = 1; i <= n; i++)
if (a[i]) cout << i << " ";
if (num > 0) cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m, cnt[N][26], num[26];
char s[N], ans[N];
map<string, int> mp;
string ss, dat[N];
int main() {
scanf("%d", &n);
m = (n + 1) / 2;
if (m > 1) {
printf("? %d %d\n", 1, m - 1);
cout.flush();
for (int i = 1; i <= m * (m - 1) / 2; i++) {
cin >> ss;
sort(ss.begin(), ss.end());
mp[ss]++;
}
}
printf("? %d %d\n", 1, m);
cout.flush();
for (int i = 1; i <= m * (m + 1) / 2; i++) {
cin >> ss;
sort(ss.begin(), ss.end());
if (!mp[ss])
dat[ss.length()] = ss;
else
mp[ss]--;
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j < i; j++) num[dat[i][j] - 'a']++;
for (int j = m; j > m - i + 1; j--) num[ans[j] - 'a']--;
for (int j = 0; j < 26; j++)
if (num[j]) ans[m - i + 1] = j + 'a', num[j] = 0;
}
printf("? %d %d\n", 1, n);
cout.flush();
for (int i = 1; i <= n * (n + 1) / 2; i++) {
scanf("%s", s + 1);
int l = strlen(s + 1);
for (int j = 1; j <= l; j++) cnt[l][s[j] - 'a']++;
}
for (int i = n / 2 + 1; i <= n; i++) {
for (int j = 0; j < 26; j++) cnt[i][j] -= cnt[i + 1][j];
for (int j = n / 2 + 1; j < i; j++)
for (int k = 0; k < 26; k++) cnt[i][k] -= cnt[j][k];
}
for (int i = n; i > m; i--) {
for (int j = 0; j < 26; j++)
if (cnt[i][j] - (ans[n - i + 1] - 'a' == j)) ans[i] = j + 'a';
}
printf("! %s", ans + 1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, ans, arr[200001], m, mx;
map<int, int> ma;
int main() {
ios::sync_with_stdio(false);
cin >> n;
arr[1] = 1;
ma[1]++;
for (int i = 2; i <= n; i++) {
cin >> m;
arr[i] = arr[m] + 1;
ma[arr[i]]++;
mx = max(arr[i], mx);
}
for (int i = 1; i <= mx; i++) {
ans += (ma[i] % 2);
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool arr[1200006];
bool ch(long long x) {
stringstream ss;
string s;
ss << x;
ss >> s;
for (int i = 0; i <= s.size() / 2; i++)
if (s[i] != s[s.size() - 1 - i]) return 0;
return 1;
}
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
for (int i = 0; i < 1200006; i++) arr[i] = 1;
arr[0] = 0;
arr[1] = 0;
for (long long i = 2; i <= 1200006; i++) {
if (arr[i]) {
for (long long j = i * i; j <= 1200006; j += i) arr[j] = 0;
}
}
int out = -1, conprime = 0, conplant = 0;
int a, p;
cin >> a >> p;
for (int i = 1; i < 1200006; i++) {
if (ch(i)) conplant++;
if (arr[i]) conprime++;
if (conprime * p <= a * conplant) {
out = max(out, i);
}
}
if (out == -1)
cout << "Palindromic tree is better than splay tree" << endl;
else
cout << out << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define y1 temp_y1
#define all(x) x.begin(), x.end()
const int N = 3e5 + 5;
int n;
int lst[N];
int fa[N];
vector<int> g[N];
int min_leaf = -1;
int ext_cnt = 0;
bool ok = true;
void dfs1(int u, int k) {
for (auto v : g[u]) {
dfs1(v, k);
}
if (ext_cnt < k && lst[u] != ext_cnt) {
ok = false;
}
if (ext_cnt == k) {
min_leaf = u;
}
++ext_cnt;
}
long long ans = 0;
int seq[N];
int dfs_cnt = 0;
int siz[N];
void dfs2(int u, int k, int dep) {
seq[u] = dfs_cnt++;
if (lst[u] < k) {
ans += dep;
siz[u]++;
}
for (auto v : g[u]) {
dfs2(v, k, dep + 1);
siz[u] += siz[v];
}
if (lst[u] < k && lst[u] != ext_cnt) {
ok = false;
}
if (lst[u] >= k && siz[u] + seq[u] != lst[u]) {
ok = false;
}
++ext_cnt;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> lst[i];
--lst[i];
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
fa[v] = u;
g[u].push_back(v);
}
for (int i = 0; i < n; ++i) {
sort(all(g[i]), [&](int x, int y) -> bool {
return lst[x] < lst[y];
});
}
if (lst[0] == 0) {
dfs2(0, 0, 0);
if (ok) {
cout << "YES" << endl;
cout << 0 << endl;
for (int i = 0; i < n; ++i) {
cout << lst[i] + 1 << " ";
}
cout << endl;
return 0;
} else {
cout << "NO" << endl;
return 0;
}
}
int v = lst[0] - 1;
dfs1(0, v);
int u = min_leaf;
bool is_find = false;
fa[0] = -1;
//cerr << v + 1 << " " << u + 1 << " " << lst[u] + 1 <<endl;
do {
if (lst[u] == v) {
is_find = true;
}
if (lst[u] == v && fa[u] != -1) {
swap(lst[u], lst[fa[u]]);
++ans;
}
u = fa[u];
} while (u != -1);
if (!is_find) {
cout << "NO" << endl;
return 0;
}
ext_cnt = 0;
dfs2(0, v, 0);
if (ok) {
cout << "YES" << endl;
cout << ans << endl;
for (int i = 0; i < n; ++i) {
cout << seq[i] + 1 << " " ;
}
cout << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const int maxn = 4005;
struct edge {
long long to, cap;
long double cost;
long long flow;
size_t back;
};
vector<vector<edge> > g(maxn);
void add_edge(long long a, long long to, long long cap, long double cost) {
edge r1 = {to, cap, cost, 0, g[to].size()};
edge r2 = {a, 0, -cost, 0, g[a].size()};
g[a].push_back(r1);
g[to].push_back(r2);
}
long double min_cost_flow(int n, int s, int t, long long k) {
long long flow = 0;
long double cost = 0;
while (flow < k) {
vector<long long> id(n, 0);
vector<long double> d(n, INF);
vector<long long> q(n);
vector<long long> p(n);
vector<size_t> p_edge(n);
long long qh = 0, qt = 0;
q[qt++] = s;
d[s] = 0;
while (qh != qt) {
long long v = q[qh++];
id[v] = 2;
if (qh == n) qh = 0;
for (size_t i = 0; i < g[v].size(); ++i) {
edge& r = g[v][i];
if (r.flow < r.cap && d[v] + r.cost < d[r.to]) {
d[r.to] = d[v] + r.cost;
if (id[r.to] == 0) {
q[qt++] = r.to;
if (qt == n) qt = 0;
} else if (id[r.to] == 2) {
if (--qh == -1) qh = n - 1;
q[qh] = r.to;
}
id[r.to] = 1;
p[r.to] = v;
p_edge[r.to] = i;
}
}
}
if (d[t] == INF) break;
long long addflow = k - flow;
for (long long v = t; v != s; v = p[v]) {
long long pv = p[v];
size_t pr = p_edge[v];
addflow = min(addflow, g[pv][pr].cap - g[pv][pr].flow);
}
for (long long v = t; v != s; v = p[v]) {
long long pv = p[v];
size_t pr = p_edge[v], r = g[pv][pr].back;
g[pv][pr].flow += addflow;
g[v][r].flow -= addflow;
cost += g[pv][pr].cost * addflow;
}
flow += addflow;
}
if (flow < k) return -1;
return cost;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
pair<long long, long long> a[n + 1];
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
add_edge(0, i + 1, 2, 0);
}
int last = n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j || a[i].second <= a[j].second) continue;
long double d =
(a[i].second - a[j].second) * (a[i].second - a[j].second) +
(a[i].first - a[j].first) * (a[i].first - a[j].first);
d = sqrtl(d);
add_edge(i + 1, n + 1 + j, 1, d);
}
}
for (int i = 0; i < n; i++) {
add_edge(n + i + 1, last + n + 1, 1, 0);
}
long double ans = min_cost_flow(last + n + 2, 0, last + n + 1, n - 1);
if (ans < 0) {
cout << "-1\n";
return 0;
}
cout << setprecision(8) << fixed << ans << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long f = 1, sum = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum * f;
}
const int MAXN = 1000010;
long long quickpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans *= a, ans %= 998244353;
b /= 2, a *= a, a %= 998244353;
}
return ans;
}
long long fac[MAXN], inv[MAXN];
long long comb(long long n, long long m) {
long long ans = fac[n];
ans *= inv[m], ans %= 998244353;
ans *= inv[n - m], ans %= 998244353;
return ans;
}
int main() {
int n;
scanf("%d", &n);
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % 998244353;
inv[n] = quickpow(fac[n], 998244353 - 2);
for (int i = n - 1; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % 998244353;
long long ans = quickpow(3, (long long)n * n);
ans -= quickpow((quickpow(3, n) - 3), n);
if (ans < 998244353) ans += 998244353;
for (int i = 1; i <= n; i++) {
long long tmp = 1ll * 3 * quickpow((quickpow(3, n - i) - 1), n) % 998244353;
tmp += (quickpow(3, i) - 3) * quickpow(3, (long long)(n - i) * n);
tmp %= 998244353;
tmp *= comb(n, i);
tmp %= 998244353;
if (i & 1)
ans += tmp, ans %= 998244353;
else
ans = (ans - tmp + 998244353) % 998244353;
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
__attribute__((constructor)) void _() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cerr.tie(nullptr);
}
template <typename T = int>
inline T readNumber() {
T number = 0, numberSign = 1;
char currentChar = getchar();
while ((currentChar < '0' || currentChar > '9') && currentChar != EOF) {
if (currentChar == '-') numberSign = -1;
currentChar = getchar();
}
while (currentChar >= '0' && currentChar <= '9') {
number = (number << 3) + (number << 1) + (currentChar & 15);
currentChar = getchar();
}
return number * numberSign;
}
template <typename T = int>
inline void writeNumber(T number) {
bool flag = false;
if (number < 0) number *= -1, flag = true;
int indexN = 20;
char buffer[21];
buffer[20] = '\n';
do {
buffer[--indexN] = number % 10 + '0';
number /= 10;
} while (number);
if (flag) putchar('-');
do {
putchar(buffer[indexN]);
} while (buffer[indexN++] != '\n');
}
void solve() {
int n = readNumber<>();
vector<int> a(1005, 0);
for (int i = 0; i < n; i++) a[readNumber<>()]++;
int ans = -1;
for (const auto &num : a) {
ans = max(ans, num);
}
cout << n - ans << '\n';
}
int main() {
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
int n, m, t, r, stsize, lt, rt, bt, len, a[200005], b[200005];
struct op {
int t, r;
} st[200005];
int main() {
scanf(" %d %d", &n, &m);
for (int i = 0; i < n; i++) scanf(" %d", &a[i]);
for (int i = 0; i < m; i++) {
scanf(" %d %d", &t, &r);
while (stsize && st[stsize - 1].r <= r) stsize--;
st[stsize++] = {t, r};
}
st[stsize] = {0, 0};
for (int i = st[0].r; i < n; i++) b[i] = a[i];
std::sort(a, a + st[0].r);
lt = 0;
bt = rt = st[0].r - 1;
for (int i = 0; i < stsize; i++) {
len = abs(st[i].r - st[i + 1].r);
if (st[i].t == 1)
while (len--) b[bt--] = a[rt--];
else
while (len--) b[bt--] = a[lt++];
}
for (int i = 0; i < n; i++) printf("%d ", b[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
vector<int> mul[N];
bool was[N];
int divCnt[N];
map<int, int> powI;
bool cmp(int a, int b) {
int pa = 0, push_back = 0;
if (powI.count(a)) ++pa;
if (powI.count(b)) ++push_back;
return (divCnt[a] - pa) < (divCnt[b] - push_back);
}
int main() {
memset(divCnt, 0, sizeof(divCnt));
int n;
scanf("%d", &n);
for (int i = 2; i <= n; ++i) {
int m = i;
for (int j = 2; j * j <= i; ++j)
if (m % j == 0) {
mul[j].push_back(i);
divCnt[i]++;
while (m % j == 0) m /= j;
}
if (m > 1) mul[m].push_back(i), divCnt[i]++;
}
memset(was, 0, sizeof(was));
vector<pair<int, int> > ans;
for (int i = (n); i >= (2); --i)
if (((int)mul[i].size()) > 0) {
powI.clear();
for (int j = 0; j < (((int)mul[i].size())); ++j) {
powI[mul[i][j]] = 1;
}
sort(mul[i].begin(), mul[i].end(), cmp);
pair<int, int> cur = make_pair(-1, -1);
for (int j = 0; j < (((int)mul[i].size())); ++j)
if (!was[mul[i][j]]) {
if (cur.first == -1) {
cur.first = mul[i][j];
} else if (cur.second == -1) {
cur.second = mul[i][j];
ans.push_back(cur);
was[cur.first] = true;
was[cur.second] = true;
cur.first = cur.second = -1;
}
}
}
printf("%d\n", ((int)ans.size()));
for (int i = 0; i < (((int)ans.size())); ++i) {
printf("%d ", ans[i].first);
printf("%d\n", ans[i].second);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void add(int &v, int val) { v = (v + val) % 1000000007; }
int dp[5002][5002];
int a[5002];
int Next[5002][27];
int tNext[27];
int main() {
ios_base::sync_with_stdio(false);
int n;
string s;
cin >> n >> s;
for (int i = 0; i < s.size(); i++) {
a[i + 1] = s[i] - 'a';
}
if (n == 1) {
cout << 1 << endl;
return 0;
}
for (int i = 0; i < 26; i++) {
tNext[i] = 0;
}
for (int i = 1; i <= n; i++) {
if (tNext[a[i]] == 0) {
dp[1][i] = 1;
}
tNext[a[i]] = i;
}
for (int i = 0; i < 26; i++) {
tNext[i] = 0;
}
for (int i = n; i >= 1; i--) {
tNext[a[i]] = i;
for (int j = 0; j < 26; j++) {
Next[i][j] = tNext[j];
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int prev = 0; prev < 26; prev++) {
if (Next[j][prev]) {
add(dp[i + 1][Next[j][prev]], dp[i][j]);
}
}
if (i == n) {
add(ans, dp[n][j]);
}
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
long long a, r, l, m;
int ans = 0;
int v;
cin >> a >> r >> l >> m;
for (int i = 0; i < m; i++) {
scanf("%d", &v);
mp[v] = 1;
}
for (int i = 0; i < 100; i++) {
if (abs(a) > l) break;
if (!mp[a]) ans++;
a *= r;
}
if (ans < 50)
cout << ans;
else
cout << "inf";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<int, int> smash;
int iwo[100005 + 10];
int main() {
int n, m, k;
long long ans = 0;
cin >> n >> m >> k;
for (int i = (1); i < (n + 1); i++) {
int omg;
cin >> omg;
smash[omg] = i;
iwo[i] = omg;
}
for (int i = (0); i < (m); i++) {
int a, aux, aux2, rec;
cin >> a;
ans += ((smash[a] - 1) / k) + 1;
aux = smash[a];
if (aux != 1) {
smash[a] = smash[a] - 1;
smash[iwo[aux - 1]] = aux;
aux2 = iwo[aux];
iwo[aux] = iwo[aux - 1];
iwo[aux - 1] = a;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int prime(int n) {
int j = 0;
if (n <= 1) j = -1;
for (int i = 2; i < n; ++i) {
if (i == 2 && n == 2) {
j = 0;
} else if (n % i == 0) {
j = -1;
break;
}
}
if (j == -1)
return 0;
else
return n;
}
int main() {
int n, m, x;
cin >> n >> m;
for (int i = n + 1; i <= m; ++i) {
x = prime(i);
if (x >= 2) break;
}
if (x == m)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long n) {
if (a == 0) return 0;
if (a == 1 || n == 0) return 1;
if (n == 1) return a % 1000000007;
long long t = power(a, n / 2);
t = t * t % 1000000007;
if (n & 1) return t * a % 1000000007;
return t;
}
int popcount(long long a) {
int c = 0;
while (a) {
c++;
a -= a & -a;
}
return c;
}
void factorize(int a) {}
void update(int tree[], int idx, int val, int maxval) {
for (; idx <= maxval; idx += idx & -idx) {
tree[idx] += val;
}
}
int read(int tree[], int idx) {
long long sum = 0;
for (; idx > 0; idx -= idx & -idx) {
sum += tree[idx];
}
return sum;
}
struct node2 {
int id, val;
node2() {
static int ctx = 0;
id = ctx++;
};
node2(int a, int b = 0, int c = 0, int d = 0, int e = 0, int f = 0) {
val = a;
}
};
struct comp2 {
bool operator()(int a, int b) { return b < a; }
};
bool cmp2(int a, int b) { return b < a; }
struct node {
int depth, l, r;
node(){};
node(int a, int b = 0, int c = 0, int d = 0, int e = 0, int f = 0) {
depth = a;
l = b;
r = c;
}
};
struct comp {
bool operator()(node a, node b) { return a.depth < b.depth; }
};
bool cmp(int a, int b) { return b < a; }
int n, m, a, b, c, d, edge, k, w, x, y, p, q, t, res, ma, mi, T,
act = 0, pas = 1, cur, flag, now;
int dp, dp2, cnt;
int tree[4 * 3 * 100009], dep[100009], in[100009], out[100009], mom[3 * 100009],
l, r, alive;
char s[1];
double e, f, z;
vector<int> v[100009], level[100009], lsdjfkdsfkj, apsdkodjldl;
vector<bool> h;
vector<pair<int, int> > ans[100009];
set<int> sett;
map<int, int> mapp;
priority_queue<node, vector<node>, comp> pq;
void print(string s, int in[], int n, bool x = false) {
cout << s << " : ";
for (int i = 1 - x; i < n + 1; i++) cout << in[i] << " ";
cout << endl;
}
void print2() {}
void input() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 2; i < n + 1; i++) {
cin >> p;
v[i].push_back(p);
v[p].push_back(i);
}
}
void dfs(int id, int par, int d) {
level[d].push_back(id);
ma = max(ma, d);
in[id] = ++T;
mom[T] = id;
dep[id] = d;
for (auto u : v[id]) {
if (u == par) continue;
dfs(u, id, d + 1);
mom[++T] = id;
}
out[id] = T;
}
void build(int idx, int l, int r) {
if (l == r) {
tree[idx] = mom[l];
return;
}
int mid = (l + r) / 2;
build(2 * idx, l, mid);
build(2 * idx + 1, mid + 1, r);
tree[idx] = (dep[tree[2 * idx]] < dep[tree[2 * idx + 1]] ? tree[2 * idx]
: tree[2 * idx + 1]);
}
int findlca(int idx, int lup, int rup, int l, int r) {
if (lup <= l && r <= rup) return tree[idx];
if (lup > r || l > rup) return 0;
int mid = (l + r) / 2;
int p = findlca(2 * idx, lup, rup, l, mid);
int q = findlca(2 * idx + 1, lup, rup, mid + 1, r);
return dep[p] < dep[q] ? p : q;
}
inline void inity(vector<int> &sibs, int n) {
apsdkodjldl.clear();
apsdkodjldl.resize(n + 1);
lsdjfkdsfkj.clear();
lsdjfkdsfkj.resize(n + 1);
h.clear();
h.resize(n + 1);
alive = n;
for (int i = 0; i < n; i++) {
apsdkodjldl[i] = i + 1;
lsdjfkdsfkj[i] = i - 1;
}
for (int i = 0; i < n; i++) {
if (i != n - 1) {
int lca = findlca(1, in[sibs[i]], out[sibs[i + 1]], 1, T);
pq.push(node(dep[lca], i, i + 1));
}
}
}
void calc(vector<int> &sibs, int levelDepth) {
int n = sibs.size();
inity(sibs, n);
while (!pq.empty()) {
node top = pq.top();
pq.pop();
if (h[top.l] || h[top.r]) continue;
ans[abs(top.depth - levelDepth)].push_back(
make_pair(sibs[top.l], sibs[top.r]));
h[top.l] = true;
h[top.r] = true;
if (lsdjfkdsfkj[top.l] != -1 && apsdkodjldl[top.r] != n) {
int lca = findlca(1, in[sibs[lsdjfkdsfkj[top.l]]],
out[sibs[apsdkodjldl[top.r]]], 1, T);
pq.push(node(dep[lca], lsdjfkdsfkj[top.l], apsdkodjldl[top.r]));
}
int newNext = apsdkodjldl[top.r];
int newPrev = lsdjfkdsfkj[top.l];
if (lsdjfkdsfkj[top.l] != -1) apsdkodjldl[lsdjfkdsfkj[top.l]] = newNext;
if (apsdkodjldl[top.r] != n) lsdjfkdsfkj[apsdkodjldl[top.r]] = newPrev;
alive -= 2;
}
res += alive;
}
void solve() {
dfs(1, 0, 1);
dep[0] = 1e9;
build(1, 1, T);
for (int i = 1; i < ma + 1; i++) calc(level[i], i);
}
void output() { cout << res; }
int main() {
input();
solve();
output();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct P {
int t, id;
bool operator<(const P &tmp) const {
if (t != tmp.t) return t < tmp.t;
return id < tmp.id;
}
} p[N];
priority_queue<int, vector<int>, greater<int> > qu;
queue<int> q;
set<int> s;
long long ans[N];
int n, t;
long long now = 0, ed = -1, nid = 0;
void gao() {
if (qu.empty()) return;
int x = qu.top();
if (!s.empty() && (*s.begin()) < x) return;
if (q.empty()) ed += t;
qu.pop();
q.push(x);
s.insert(x);
}
int main() {
scanf("%d%d", &n, &t);
for (int i = 0; i < n; i++) scanf("%d", &p[i].t), p[i].id = i;
sort(p, p + n);
while (true) {
if (nid < n && (ed >= p[nid].t || q.empty())) {
now = p[nid].t;
if (!s.empty() && (*s.begin()) < p[nid].id)
qu.push(p[nid].id);
else if (ed == p[nid].t)
qu.push(p[nid].id);
else {
if (q.empty()) ed = now + t;
q.push(p[nid].id);
s.insert(p[nid].id);
}
nid++;
} else if (!q.empty()) {
int x = q.front();
q.pop();
now = max(now, ed);
s.erase(x);
ans[x] = ed;
if (!q.empty()) ed += t;
gao();
} else
break;
}
for (int i = 0; i < n; i++) printf("%lld ", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx,avx2,sse,sse2")
#define int long long
#define YES cout<<"YES\n";return;
#define NO cout<<"NO\n";return;
#define write(a) cout<<a<<"\n";return;
#define F first
#define S second
using namespace std;
using vi=vector<int>;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count()); //uid<int> u1(5, 10); u1(rnd);
long long powmod(long long a,long long b,long long mod) {
if (b==0 || a==1) {if (mod==1) return 0; else return 1; }
if (b%2==0) { long long k=powmod(a,b/2,mod); return (k*k)%mod; }
else {long long k=powmod(a,b/2,mod); return ( (k*k) %mod *a)% mod; }
}
long long gcd(long long a, long long b) {
if (a==0) return b;
if (b==0) return a;
if (a>b) return gcd(a%b,b); else return gcd(b%a,a);
}
int prime(int p) { // 1 - простое
if (p==1) return 0;
for (int i=2;i*i<=p;i++) {
if (p%i==0 && i<p) return i;
}
return 1;
}
int inv(int a, int mod) {
return powmod(a,mod-2,mod);
}
int random_modul() {
uniform_int_distribution <int> u1(1e9, 2e9);
int pepega=u1(rnd);
while (prime(pepega)!=1) pepega=u1(rnd);
return pepega;
}
template <typename T1> void ifmax(T1 &max, T1 kek) {
if (kek>max) max=kek;
return;
}
template <typename T1> void ifmin(T1 &min, T1 kek) {
if (kek<min) min=kek;
return;
}
template <typename T1> istream& operator>> (std::istream& in, pair<T1,T1> & a) {
in>>a.first>>a.second;
return in;
}
template <typename T1> istream& operator>> (std::istream& in, vector<T1> & a) {
for (int i=0;i<a.size();i++) in>>a[i];
return in;
}
template <typename T1> ostream& operator<< (std::ostream& out, vector <T1> &b) {
for (int i=0;i<b.size();i++) out<<b[i];
return out;
}
template <typename T1> void sort(vector <T1> &m) {
sort(m.begin(),m.end());
}
template <typename T1> void reverse(vector <T1> &m) {
reverse(m.begin(),m.end());
}
int mod=1000000007;
int fac[200005];
int inv_fac[200005];
int co(int a, int b) {
int ans=1;
ans*=fac[b];
ans*=inv_fac[b-a]; ans%=mod;
ans*=inv_fac[a];
return ans%mod;
}
void solve () {
/* ---- !! F, S !! ---- */
int a;
cin>>a;
vector <vector<int>> m1(a, vector <int> (a));
for (int i=0;i<a;i++) {
for (int j=0;j<a;j++) {
char c; cin>>c; m1[i][j]=(c-'0');
}
}
vector <vector<int>> m2(a, vector <int> (a));
for (int i=0;i<a;i++) {
for (int j=0;j<a;j++) {
char c; cin>>c; m2[i][j]=(c-'0');
}
}
vector <int> lol1(a);
vector <int> lol2(a);
for (int i=0;i<a;i++) {
for (int j=0;j<a;j++) {
if (m1[i][j]!=m2[i][j]) {
m1[i][j]=1;
} else m1[i][j]=0;
}
}
for (int i=0;i+1<a;i++) {
for (int j=0;j+1<a;j++) {
if ((m1[i][j]+m1[i+1][j]+m1[i+1][j+1]+m1[i][j+1])%2) {NO}
}
}
{YES}
/* --------- */
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout<<fixed<<setprecision(10);
int multitest = 1 ;
int tututu;
tututu=1;
int combinatorics = 1;
if (combinatorics) {
fac[1]=1;
fac[0]=1;
for (int i=2;i<200005;i++) {
fac[i]=fac[i-1]*i; fac[i]%=mod;
}
for (int i=0;i<200005;i++) {
inv_fac[i]=inv(fac[i],mod);
}
}
if (multitest) cin>>tututu; // если нет запросов, то закоментить
for (int qwerty=0;qwerty<tututu;qwerty++) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
long long x, y, z;
Point(long long x, long long y, long long z) : x(x), y(y), z(z) {}
};
bool operator==(Point const &a, Point const &b) {
return a.x == b.x && a.y == b.y && a.z == b.z;
}
bool operator!=(Point const &a, Point const &b) {
return a.x != b.x || a.y != b.y || a.z != b.z;
}
long long const INFL = 4e18 + 100;
Point const NONE(INFL, INFL, INFL);
long long set_par(long long x, int par, int delta) {
if (abs(x) % 2 != par) x += delta;
return x;
}
struct Bounds {
long long mi1, ma1, mi2, ma2, mi3, ma3, mi4, ma4;
Bounds()
: mi1(-INFL),
ma1(INFL),
mi2(-INFL),
ma2(INFL),
mi3(-INFL),
ma3(INFL),
mi4(-INFL),
ma4(INFL) {}
Bounds(Point p, long long sum)
: mi1(p.x + p.y + p.z - sum),
ma1(p.x + p.y + p.z + sum),
mi2(-p.x + p.y + p.z - sum),
ma2(-p.x + p.y + p.z + sum),
mi3(p.x - p.y + p.z - sum),
ma3(p.x - p.y + p.z + sum),
mi4(p.x + p.y - p.z - sum),
ma4(p.x + p.y - p.z + sum) {}
void inter(Bounds const &bs) {
mi1 = max(mi1, bs.mi1), ma1 = min(ma1, bs.ma1);
mi2 = max(mi2, bs.mi2), ma2 = min(ma2, bs.ma2);
mi3 = max(mi3, bs.mi3), ma3 = min(ma3, bs.ma3);
mi4 = max(mi4, bs.mi4), ma4 = min(ma4, bs.ma4);
}
explicit operator Point() {
for (int par = 0; par < 2; ++par) {
long long a1 = set_par(mi2, par, 1), b1 = set_par(mi3, par, 1),
c1 = set_par(mi4, par, 1);
long long a2 = set_par(ma2, par, -1), b2 = set_par(ma3, par, -1),
c2 = set_par(ma4, par, -1);
if (a1 <= a2 && b1 <= b2 && c1 <= c2) {
long long a = a1, b = b1, c = c1;
if (a + b + c < mi1) {
a = set_par(min(a2, mi1 - b - c), par, 1);
if (a > a2) a = a1;
}
if (a + b + c < mi1) {
b = set_par(min(b2, mi1 - a - c), par, 1);
if (b > b2) b = b1;
}
if (a + b + c < mi1) {
c = set_par(min(c2, mi1 - a - b), par, 1);
if (c > c2) c = c1;
}
if (a + b + c >= mi1 && a + b + c <= ma1) {
return Point((b + c) / 2, (a + c) / 2, (a + b) / 2);
}
}
}
return NONE;
}
};
Point solve(vector<Point> const &ps, long long sum) {
Bounds bounds;
for (Point p : ps) bounds.inter(Bounds(p, sum));
return (Point)bounds;
}
void solve() {
int n;
scanf("%d", &n);
vector<Point> ps;
for (int i = 0; i < n; ++i) {
long long x, y, z;
scanf("%I64d%I64d%I64d", &x, &y, &z);
ps.emplace_back(x, y, z);
}
long long l = -1, r = INFL;
while (r - l > 1) {
long long m = (l + r) / 2;
Point cur = solve(ps, m);
(cur == NONE ? l : r) = m;
}
Point ans = solve(ps, r);
cout << ans.x << ' ' << ans.y << ' ' << ans.z << '\n';
}
int main() {
int tests;
scanf("%d", &tests);
while (tests--) solve();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[1000009], b[1000009], f[300], ans[300];
string s;
void solve() {
cin >> n >> m >> s;
memset(f, 0, sizeof(f));
memset(ans, 0, sizeof(ans));
s = " " + s;
for (int i = 1; i <= m; i++) {
cin >> a[i];
}
sort(a + 1, a + m + 1);
int j = 1;
for (int i = 1; i <= n; i++) {
f[s[i]]++;
ans[s[i]]++;
int d = 0;
while (i == a[j] && j <= m) {
d++;
j++;
}
for (int k = 'a'; k <= 'z'; k++) {
ans[k] += d * f[k];
}
}
for (int i = 'a'; i <= 'z'; i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
int n, m, k, del[N], cnt[N], b[N];
vector<int> g[N], ans;
set<pair<double, int> > st;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
del[x] = 1;
b[x] = 1;
}
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (del[i]) continue;
for (int j : g[i]) {
if (!del[j]) cnt[i]++;
}
st.insert({double(cnt[i]) / double(g[i].size()), i});
}
double mx = 0;
while (!st.empty()) {
pair<double, int> v = *st.begin();
st.erase(st.begin());
mx = max(mx, v.first);
del[v.second] = 1;
for (int to : g[v.second]) {
if (del[to]) continue;
st.erase({double(cnt[to]) / double(g[to].size()), to});
cnt[to]--;
st.insert({double(cnt[to]) / double(g[to].size()), to});
}
}
for (int i = 1; i <= n; i++) del[i] = b[i];
for (int i = 1; i <= n; i++) {
if (del[i]) continue;
cnt[i] = 0;
for (int j : g[i]) {
if (!del[j]) cnt[i]++;
}
st.insert({double(cnt[i]) / double(g[i].size()), i});
}
while (!st.empty()) {
pair<double, int> v = *st.begin();
st.erase(st.begin());
if (mx == v.first) break;
del[v.second] = 1;
for (int to : g[v.second]) {
if (del[to]) continue;
st.erase({double(cnt[to]) / double(g[to].size()), to});
cnt[to]--;
st.insert({double(cnt[to]) / double(g[to].size()), to});
}
}
for (int i = 1; i <= n; i++) {
if (!del[i]) ans.push_back(i);
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9 + 5;
struct segment;
segment *last = 0;
struct segment {
segment *l, *r, *dad;
int key;
int best, i;
segment *next = 0, *prev = 0;
void update() {
if (!l) return;
if (r->best > l->best)
best = r->best, i = r->i;
else
best = l->best, i = l->i;
}
void update_up() {
update();
if (dad) dad->update_up();
}
segment(vector<int> &v, vector<int> &s, int a, int b, segment *dad = 0)
: dad(dad) {
if (a == b) {
l = r = 0;
key = v[a];
best = s[a];
if (last) last->next = this;
prev = last;
last = this;
} else {
int m = (a + b) / 2;
l = new segment(v, s, a, m, this);
r = new segment(v, s, m + 1, b, this);
update();
}
}
void remove() {
if (!l) {
if (prev) {
if (next) {
if (prev->key == next->key) {
prev->best += next->best;
next->best = 0;
prev->update_up();
next->update_up();
if (next->next) {
next->next->prev = prev;
prev->next = next->next;
} else
prev->next = 0;
} else {
prev->next = next;
next->prev = prev;
}
} else
prev->next = 0;
} else if (next)
next->prev = 0;
best = 0;
} else {
if (best == l->best)
l->remove();
else
r->remove();
update();
}
}
};
struct st {
segment *root;
st(vector<int> &v, vector<int> &s) {
root = new segment(v, s, 0, v.size() - 1);
}
void query() { root->remove(); }
bool empty() { return !root->best; }
};
int main() {
cin.tie(0), cin.sync_with_stdio(0);
int n;
cin >> n;
if (n == 1) return cout << 1, 0;
vector<int> v, s;
v.reserve(n), s.reserve(n);
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (v.size() && v.back() == a)
s.back()++;
else
v.push_back(a), s.push_back(1);
}
st tree(v, s);
int ans = 0;
while (!tree.empty()) {
ans++;
tree.query();
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000200;
const int maxh = 21;
int p[maxn], d[maxn];
vector<int> g[maxn];
bool vis[maxn];
int gpa[maxn][maxh];
int n, k;
inline void build() {
for (int i = 1; i <= n; ++i) gpa[i][0] = p[i];
for (int k = 1; (1 << k) <= n; ++k)
for (int i = 1; i <= n; ++i)
if (d[i] >= (1 << k)) gpa[i][k] = gpa[gpa[i][k - 1]][k - 1];
}
inline int get_gpa(int u, int h) {
for (int i = 0; h > 0; h >>= 1, ++i)
if (h & 1) u = gpa[u][i];
if (u == 0) return n;
return u;
}
inline void dfs(int u, int fa) {
p[u] = fa;
for (auto v : g[u]) {
if (v == fa) continue;
d[v] = d[u] + 1;
dfs(v, u);
}
}
int main() {
int u, v;
scanf("%d %d", &n, &k);
for (int i = 1; i < n; ++i) {
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(n, 0);
build();
int lft = n - k - 1;
vis[n] = true;
for (int i = n - 1; i; --i) {
int v = get_gpa(i, lft);
if (vis[v]) {
int t = i;
while (!vis[t]) {
vis[t] = true;
--lft;
t = p[t];
}
}
}
bool first = true;
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
if (!first) printf(" ");
first = false;
printf("%d", i);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
long long n, sum = 0;
scanf("%d", &n);
int chocolates[200000];
for (int i = 0; i < n; i++) scanf("%d", &chocolates[i]);
long long menor = chocolates[n - 1] + 1;
long long i = n - 1;
while (i != -1) {
if (chocolates[i] < menor) {
menor = chocolates[i];
sum += chocolates[i];
} else {
menor--;
if (menor < 0) menor = 0;
sum += menor;
}
i--;
}
printf("%lld\n", sum);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char a[500100], b[500100];
int main() {
int n, i;
long long ans = 0, k, A = 0, B = 0;
scanf("%d%I64d", &n, &k);
for (i = 1; i <= n; i++) scanf(" %c", &a[i]);
for (i = 1; i <= n; i++) scanf(" %c", &b[i]);
int j = 1;
while (j <= n && a[j] == b[j]) j++;
ans = j - 1;
for (i = j; i <= min(n, j + 33); i++) {
A *= 2;
if (a[i] == 'b') A++;
B *= 2;
if (b[i] == 'b') B++;
ans += min(B - A + 1, k);
}
if (n > j + 33) ans += (k * (n - j - 33));
printf("%I64d", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &t) {
os << "[";
for (__typeof((t).begin()) it = (t).begin(); it != (t).end(); it++) {
if (it != t.begin()) os << ",";
os << *it;
}
os << "]";
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &t) {
os << "{";
for (__typeof((t).begin()) it = (t).begin(); it != (t).end(); it++) {
if (it != t.begin()) os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const map<S, T> &t) {
os << "{";
for (__typeof((t).begin()) it = (t).begin(); it != (t).end(); it++) {
if (it != t.begin()) os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
const int INF = 1 << 28;
const double EPS = 1e-8;
const int MOD = 1000000007;
class BIT {
int n;
vector<int> vs;
public:
BIT(int size) {
n = size;
vs = vector<int>(n);
}
void add(int k, int a) {
for (int i = k; i < n; i |= i + 1) vs[i] += a;
}
int sum(int s, int t) {
if (t <= s) return 0;
if (s > 0) return sum(0, t) - sum(0, s);
int res = 0;
for (int i = t - 1; i >= 0; i = (i & (i + 1)) - 1) res += vs[i];
return res;
}
};
int toInt(char c) {
if (c == 'R') return 0;
if (c == 'P') return 1;
if (c == 'S') return 2;
}
int n, q;
string s;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin >> n >> q >> s;
vector<set<int>> lpos(3);
vector<set<int>> rpos(3);
for (int i = 0; i < (int)(3); i++) {
lpos[i].insert(n);
rpos[i].insert(-1);
}
vector<int> d(n);
vector<BIT> bit(3, BIT(n));
for (int i = 0; i < (int)(n); i++) {
d[i] = toInt(s[i]);
bit[d[i]].add(i, 1);
lpos[d[i]].insert(i);
rpos[d[i]].insert(i);
}
auto calc = [&]() {
int sum = 0;
for (int i = 0; i < (int)(3); i++) {
if (lpos[(i + 1) % 3].size() > 1 && lpos[(i + 2) % 3].size() == 1) {
sum += bit[i].sum(0, n);
} else {
int left_lose = *lpos[(i + 1) % 3].begin();
int left_win = *lpos[(i + 2) % 3].begin();
int right_lose = *rpos[(i + 1) % 3].rbegin();
int right_win = *rpos[(i + 2) % 3].rbegin();
if (right_win <= left_win) {
left_win = right_win;
}
sum += bit[i].sum(left_lose, left_win);
sum += bit[i].sum(right_win, right_lose);
}
}
cout << n - sum << endl;
};
calc();
for (int _ = 0; _ < (int)(q); _++) {
int p;
char c;
cin >> p >> c;
p--;
int x = toInt(c);
for (int i = 0; i < (int)(3); i++) {
if (lpos[i].count(p)) {
lpos[i].erase(p);
rpos[i].erase(p);
bit[i].add(p, -1);
}
}
rpos[x].insert(p);
lpos[x].insert(p);
bit[x].add(p, 1);
calc();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve(int tnum) {
int a, b, n;
scanf("%d%d%d", &a, &b, &n);
if (n % 3 == 0) printf("%d\n", a);
if (n % 3 == 1) printf("%d\n", b);
if (n % 3 == 2) printf("%d\n", a ^ b);
}
int main() {
int tnum;
scanf("%d", &tnum);
for (int i = 1; i <= tnum; i++) solve(i);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> Adj[205];
int a[205], dp[205][205], psdp[205][205];
int tmp[205];
void DFS(int u, int p) {
for (auto v : Adj[u]) {
if (v != p) {
DFS(v, u);
}
}
dp[u][0] = a[u];
for (auto v : Adj[u]) {
if (v != p) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i + j >= k) {
tmp[min(i, j + 1)] = max(tmp[min(i, j + 1)], dp[u][i] + dp[v][j]);
}
}
}
for (int i = 0; i < n; i++) {
dp[u][i] = tmp[i];
tmp[i] = 0;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int u, v;
for (int i = 1; i < n; i++) {
cin >> u >> v;
Adj[u].push_back(v);
Adj[v].push_back(u);
}
DFS(1, -1);
int Ans = *max_element(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < n; j++) {
Ans = max(Ans, dp[i][j]);
}
}
cout << Ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using u128 = __uint128_t;
signed main() {
long long t = 1;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n);
map<long long, long long> mp;
for (long long i = 0; i < n; i++) cin >> a[i], mp[a[i]]++;
long long mx = -1, mct = 0;
for (auto i : mp) {
if (i.second > mct) {
mct = i.second;
mx = i.first;
}
}
vector<long long> ind;
for (long long i = 0; i < n; i++) {
if (a[i] == mx) {
ind.push_back(i);
}
}
cout << n - ind.size() << "\n";
for (long long i = ind[0] - 1; i >= 0; i--) {
if (a[i] < mx) {
cout << 1 << " " << i + 1 << " " << i + 2 << "\n";
} else {
cout << 2 << " " << i + 1 << " " << i + 2 << "\n";
}
a[i] = mx;
}
for (long long i = 0; i < n - 1; i++) {
if (a[i + 1] != mx) {
if (a[i + 1] < a[i]) {
cout << 1 << " " << i + 2 << " " << i + 1 << "\n";
} else {
cout << 2 << " " << i + 2 << " " << i + 1 << "\n";
}
}
a[i + 1] = mx;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int MAXN = 100010;
long long tav10[MAXN];
long long inv10[MAXN];
long long mod;
long long calc(vector<long long> &vecin,
vector<pair<long long, long long> > vecout) {
map<long long, int> mp;
for (long long x : vecin) mp[x]++;
long long res = 0;
for (pair<long long, long long> p : vecout)
res += mp[(mod - p.second) * inv10[p.first] % mod];
return res;
}
long long n, m, k, u, v, x, y, t, a, b, ans;
bool dead[MAXN];
int sz[MAXN], h[MAXN];
long long val_down[MAXN], val_up[MAXN];
vector<int> G[MAXN];
vector<pair<int, int> > G2[MAXN];
int dfs_sz(int node, int par) {
sz[node] = 1;
for (int i : G[node])
if (!dead[i] && i != par) sz[node] += dfs_sz(i, node);
return sz[node];
}
int centroid(int node, int par, int n) {
for (int v : G[node])
if (sz[v] * 2 > n && v != par && !dead[v]) return centroid(v, node, n);
return node;
}
void dfs_path(int node, int par, vector<long long> &vecin,
vector<pair<long long, long long> > &vecout) {
vecin.push_back(val_up[node]);
vecout.push_back({h[node] = h[par] + 1, val_down[node]});
for (pair<int, int> p : G2[node])
if (p.first != par && !dead[p.first]) {
val_up[p.first] = (tav10[h[node]] * p.second + val_up[node]) % mod;
val_down[p.first] = (val_down[node] * 10ll + p.second) % mod;
dfs_path(p.first, node, vecin, vecout);
}
}
void solve(int node) {
dfs_sz(node, node);
int root = centroid(node, node, sz[node]);
dead[root] = 1;
h[root] = 0;
vector<long long> vecin;
vector<pair<long long, long long> > vecout;
for (pair<int, int> p : G2[root])
if (!dead[p.first]) {
long long v = p.first, w = p.second;
val_down[v] = val_up[v] = w;
vector<long long> vecin_tmp;
vector<pair<long long, long long> > vecout_tmp;
dfs_path(v, root, vecin_tmp, vecout_tmp);
ans -= calc(vecin_tmp, vecout_tmp);
for (long long tmp : vecin_tmp) vecin.push_back(tmp);
for (pair<long long, long long> tmp : vecout_tmp) vecout.push_back(tmp);
}
vecin.push_back(0);
vecout.push_back({0, 0});
ans += calc(vecin, vecout) - 1;
for (int v : G[root])
if (!dead[v]) solve(v);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> mod;
tav10[0] = inv10[0] = 1;
for (int i = 1; i < MAXN; i++) tav10[i] = tav10[i - 1] * 10 % mod;
for (long long i = 1; i < 11; i++)
if ((i * mod + 1) % 10 == 0) inv10[1] = (i * mod + 1) / 10;
for (int i = 2; i < MAXN; i++) inv10[i] = inv10[1] * inv10[i - 1] % mod;
for (int i = 1; i < n; i++) {
cin >> u >> v >> x;
x %= mod;
G[++u].push_back(++v);
G[v].push_back(u);
G2[u].push_back({v, x});
G2[v].push_back({u, x});
}
solve(1);
cout << ans << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n;
cin >> n;
long long ar[n];
for (long long i = 0; i < n; i++) {
cin >> ar[i];
}
long long ans = INT_MAX;
for (long long i = 1; i < n - 1; i++) {
vector<long long> v;
for (long long j = 0; j < n; j++) {
if (j != i) v.push_back(ar[j]);
}
long long cnt = 0;
for (long long j = 1; j < v.size(); j++) {
cnt = max(cnt, v[j] - v[j - 1]);
}
ans = min(ans, cnt);
}
cout << ans << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int a[110];
long long ans;
int k;
long long f[300010][110];
long long dfs(long long n, int x) {
if (x == k) return n;
if (n < 300010) {
if (f[n][x] == -1) f[n][x] = dfs(n, x + 1) - dfs(n / a[x], x + 1);
return f[n][x];
} else {
return dfs(n, x + 1) - dfs(n / a[x], x + 1);
}
}
int main() {
scanf("%I64d%d", &n, &k);
for (int i = 0; i < k; i++) scanf("%d", a + i);
sort(a, a + k);
reverse(a, a + k);
memset(f, 255, sizeof(f));
printf("%I64d\n", dfs(n, 0));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int skill[100011 * 2], vis[100011 * 2];
int rgh[100011 * 2], lf[100011 * 2];
int cup, n;
char s[100011 * 2];
struct node {
int l, r, c;
bool operator<(const node &a) const {
if (c == a.c)
return l > a.l;
else
return c > a.c;
}
} tmp;
priority_queue<node> que;
void init() {
memset(vis, 0, sizeof(vis));
while (!que.empty()) que.pop();
cup = 0;
}
int main() {
int i;
while (scanf("%d", &n) != EOF) {
init();
scanf("%s", s + 1);
for (i = 1; i <= n; i++) {
scanf("%d", &skill[i]);
lf[i] = i - 1;
rgh[i] = i + 1;
if (s[i] == 'B') cup++;
}
cup = min(n - cup, cup);
printf("%d\n", cup);
for (i = 1; i < n; i++)
if (s[i] != s[i + 1]) {
tmp.l = i;
tmp.r = i + 1;
tmp.c = abs(skill[i] - skill[i + 1]);
que.push(tmp);
}
while (cup--) {
while (!que.empty()) {
tmp = que.top();
que.pop();
if (vis[tmp.l] == 0 && vis[tmp.r] == 0) {
printf("%d %d\n", tmp.l, tmp.r);
vis[tmp.l] = vis[tmp.r] = 1;
break;
}
}
int ll = lf[tmp.l], rr = rgh[tmp.r];
rgh[ll] = rr;
lf[rr] = ll;
if (ll > 0 && rr <= n && s[ll] != s[rr]) {
tmp.l = ll;
tmp.r = rr;
tmp.c = abs(skill[ll] - skill[rr]);
que.push(tmp);
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char n;
int n2, in;
int a[100002] = {0};
int check = -1;
int x2, x4, x6, x8;
int x() {
if (x8 > 0)
return 1;
else if (x6 > 0 && x6 + x4 + x2 > 1)
return 1;
else if (x4 > 1)
return 1;
else if (x4 > 0 && x2 > 1)
return 1;
return 0;
}
void solve() {
cin >> n;
cin >> n2;
if (n == '+') {
a[n2]++;
if (a[n2] == 8) {
x8++;
x6--;
} else if (a[n2] == 6) {
x6++;
x4--;
} else if (a[n2] == 4) {
x4++;
x2--;
} else if (a[n2] == 2)
x2++;
if (check == 1) {
cout << "YES\n";
return;
}
} else {
a[n2]--;
if (a[n2] == 7) {
x8--;
x6++;
} else if (a[n2] == 5) {
x6--;
x4++;
} else if (a[n2] == 3) {
x4--;
x2++;
} else if (a[n2] == 1)
x2--;
if (check == 0) {
cout << "NO\n";
return;
}
}
check = x();
if (check == 1) {
cout << "YES\n";
return;
} else {
cout << "NO\n";
return;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
cin >> T;
for (int i = 0; i < T; i++) {
cin >> in;
a[in]++;
}
x2 = 0, x4 = 0, x6 = 0, x8 = 0;
for (int i = 1; i < 100001; i++) {
if (a[i] >= 8) {
x8++;
} else if (a[i] >= 6)
x6++;
else if (a[i] >= 4)
x4++;
else if (a[i] >= 2)
x2++;
}
check = x();
int T2;
cin >> T2;
while (T2--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16000000")
using namespace std;
const double pi = acos(-1.0);
long long gcd(long long a, long long b) {
if (a < 0) a = -a;
if (b < 0) b = -b;
if (a < b) swap(a, b);
while (b) {
long long t = b;
b = a % b;
a = t;
}
return a;
}
template <typename T>
struct Point {
T x, y;
Point(T xx = 0, T yy = 0) : x(xx), y(yy) {}
};
template <typename T>
Point<T> operator+(const Point<T>& a, const Point<T>& b) {
return Point<T>(a.first + b.first, a.second + b.second);
}
template <typename T>
Point<T> operator-(const Point<T>& a, const Point<T>& b) {
return Point<T>(a.first - b.first, a.second - b.second);
}
int main() {
long long a[3];
for (int i = 0, _i = (3); i < _i; ++i) cin >> a[i];
sort(a, a + 3);
long long res = a[0] + a[1] + a[2] - 1;
do {
if ((a[0] + a[1]) % 2 == 0) {
res = min(res, max(a[0], a[1]));
}
} while (next_permutation(a, a + 3));
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (!b) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a / gcd(a, b)) * b;
}
long long int modexp(long long int a, long long int b) {
if (b == 0) return 1;
if (b == 1) return a;
long long int temp = modexp(a, (b >> 1));
temp = (temp * temp);
return (temp * modexp(a, b & 1));
}
long long int modexp(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int temp = modexp(a, (b >> 1), m);
temp = (temp * temp) % m;
return (temp * modexp(a, b & 1, m)) % m;
}
long long int mult(long long int a, long long int b, long long int m) {
long long int res = 0;
a %= m;
while (b) {
if (b & 1ll) res = (res + a) % m;
a = (a * 2ll) % m;
b /= 2ll;
}
return (res % m);
}
long long int modinv(long long int a, long long int p) {
return modexp(a, p - 2, p);
}
map<int, int> mx, my;
map<pair<int, int>, int> xy;
int main() {
int n;
scanf("%d", &n);
int x, y;
long long int ans = 0;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x, &y);
ans += mx[x];
ans += my[y];
ans -= xy[make_pair(x, y)];
mx[x]++;
my[y]++;
xy[make_pair(x, y)]++;
}
printf("%lld\n", ans);
}
| 3 |
#include<bits/stdc++.h>
#define FOR(i,l,r) for(int i=l;i<=r;i++)
#define ROF(i,l,r) for(int i=l;i>=r;i--)
#define lson k<<1,l,mid
#define rson k<<1|1,mid+1,r
#define r(x) read(x)
#define rr(x,y) read(x);read(y)
#define rrr(x,y,z) read(x);read(y);read(z)
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define fi first
#define se second
#define sss(str) scanf("%s",str+1)
using namespace std;
typedef long long LL;
typedef pair<int,int> pt;
const int N=2e6+5;
const int M=2e3+5;
const int mod=1e9+7;
const int INF=2e9;
const double eps=1e-8;
const double pi=acos(-1);
template <class T>
inline void read(T &x) {
char c;x = 1;
while ((c = getchar()) < '0' || c > '9') if (c == '-') x = -1;
T res = c - '0';
while ((c = getchar()) >= '0' && c <= '9') res = res * 10 + c - '0';
x *= res;
}
int n,m;
char str[2][N];
bool check(int id)
{
int now=0;
FOR(i,1,n){
if(str[id][i]=='(') ++now;
else --now;
if(now<0) return 0;
}
return now==0;
}
void solve(int cas)
{
r(n);
vector<int> v;
string s; cin>>s;
for(int i=0;i<s.size();++i){
if(s[i]=='0'){
v.pb(i+1);
}
str[0][i+1]=str[1][i+1]=0;
}
if((n&1)||(v.size()&1)){
cout<<"NO\n";
return ;
}
for(int i=0;i<v.size();++i){
if(i&1){
str[0][v[i]]='(';
str[1][v[i]]=')';
}
else{
str[0][v[i]]=')';
str[1][v[i]]='(';
}
}
int left=n/2-v.size()/2;
FOR(i,1,n){
if(str[0][i]) continue;
if(left>0){
--left;
str[0][i]=str[1][i]='(';
}
else str[0][i]=str[1][i]=')';
}
if(check(0)&&check(1)){
cout<<"YES\n";
FOR(i,1,n) cout<<str[0][i];
cout<<endl;
FOR(i,1,n) cout<<str[1][i];
cout<<endl;
}
else{
cout<<"NO\n";
}
}
int main()
{
int t;
r(t);
// t=1;
// init();
FOR(i,1,t){
solve(i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T>
bool uax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool uin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &p) {
out << p.first << ' ' << p.second;
return out;
}
mt19937 rnd(1928);
long long n, m, k;
vector<long long> a;
long long get_kn(long long q) { return q + (k - 1 - (q % k)); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
a.resize(m);
for (int i = 0; i < m; i++) {
cin >> a[i];
a[i]--;
}
int ind = 0;
int ans = 0;
while (ind < m) {
long long w = get_kn(a[ind] - ind);
int l = 0, r = m - ind, mid;
while (r > l + 1) {
mid = (l + r) / 2;
if (a[ind + mid] - ind <= w) {
l = mid;
} else {
r = mid;
}
}
ans++;
ind += r;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long INF = 1000000000000000000LL;
const long double PI = 4 * atan((long double)1);
int k;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> k;
int n = 10;
while (ceil((k + n) / (double)(n - 1)) > 1e6) ++n;
cout << n << '\n' << -1;
int s = k + n;
for (int i = 1; i < n; ++i) {
if (s >= 1e6)
cout << ' ' << 1000000, s -= 1e6;
else
cout << ' ' << s, s = 0;
}
cout << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5001;
int n;
long long memo[N][N];
long long vs[N];
vector<long long> arr;
long long oo = 100000000000000000LL;
long long solve(int idx, int f) {
if (idx == n) return 0;
long long ret = memo[idx][f];
if (ret != -1) return ret;
ret = oo;
if (f + 1 < n) ret = min(ret, solve(idx, f + 1));
ret = min(ret, (solve(idx + 1, f) + abs(vs[idx] - arr[f])));
return memo[idx][f] = ret;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> vs[i];
vs[i] -= i;
arr.push_back(vs[i]);
}
sort(arr.begin(), arr.end());
for (int i = 0; i < n; i++) memo[n][i] = 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = n - 1; j >= 0; j--) {
long long ret = oo;
if (j + 1 < n) ret = min(ret, memo[i][j + 1]);
ret = min(ret, memo[i + 1][j] + abs(vs[i] - arr[j]));
memo[i][j] = ret;
}
}
cout << memo[0][0] << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 3;
const int INF = 1e9 + 7;
string a, b, cur;
int main() {
cin >> a >> b;
if (a.back() != b.back()) {
cout << (a.size() + b.size());
return 0;
}
int j = a.size() - 1, cur = 0;
for (int i = b.size() - 1; i >= 0; --i) {
if (b[i] == a[j]) {
cur++;
} else {
break;
}
if (j == 0) {
break;
}
j--;
}
cout << (a.size() + b.size()) - (cur * 2);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXLEN = (200105);
const int Alpha = 26;
int vv[MAXLEN * 2];
long long ret[MAXLEN * 2];
string s, t;
long long ans = 0;
struct state {
int len, link;
int next[Alpha];
vector<int> prev;
state() {
len = link = 0;
memset(next, -1, sizeof(next));
}
void reset() {
len = link = 0;
memset(next, -1, sizeof(next));
prev.clear();
}
};
state st[MAXLEN * 2];
int terminal[MAXLEN * 2];
class SuffixAutomata {
public:
int sz, last;
void init() {
for (int j = 0; j < 2 * MAXLEN; j++) st[j] = state(), terminal[j] = 0;
st[0].len = 0;
st[0].link = -1;
sz = 1;
last = 0;
}
void extend(char ccc) {
int c = ccc - 'a';
int cur = sz++;
st[cur].len = st[last].len + 1;
int p = last;
while (p != -1 && st[p].next[c] == -1) {
st[p].next[c] = cur;
p = st[p].link;
}
if (p == -1) {
st[cur].link = 0;
} else {
int q = st[p].next[c];
if (st[p].len + 1 == st[q].len) {
st[cur].link = q;
} else {
int clone = sz++;
st[clone].len = st[p].len + 1;
for (int j = 0; j < Alpha; j++) st[clone].next[j] = st[q].next[j];
st[clone].link = st[q].link;
while (p != -1 && st[p].next[c] == q) {
st[p].next[c] = clone;
p = st[p].link;
}
st[q].link = st[cur].link = clone;
}
}
last = cur;
}
void getTerminal() {
int p = last;
while (p > 0) terminal[p] = 1, p = st[p].link;
}
void dfs(int v) {
for (auto u : st[v].prev) dfs(u), ret[v] += ret[u];
ans = max(ans, st[v].len * ret[v]);
}
void solve() {
for (int i = 1; i < sz; i++) st[st[i].link].prev.push_back(i);
int cur = 0;
int num = 0;
for (int i = 0; i < s.size(); i++) {
int x = s[i] - 'a';
int safe = 1 - (t[i] - '0');
cur = st[cur].next[x];
if (safe) ret[cur]++;
}
dfs(0);
}
} SA;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
cin >> s >> t;
SA.init();
for (auto x : s) SA.extend(x);
SA.solve();
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int cnt[13];
string s1, s2;
string res;
int n1 = 0;
int n2 = 0;
cin >> n;
cin >> s1;
cin >> s2;
cnt[00] = cnt[01] = cnt[10] = cnt[11] = 0;
for (int i = 0; i < s1.size(); ++i) {
++cnt[(s1[i] - '0') * 10 + (s2[i] - '0')];
}
for (int i = 0; i < s1.size(); ++i) {
if (i % 2 == 0) {
if (cnt[11]) {
--cnt[11];
++n1;
} else if (cnt[10]) {
--cnt[10];
++n1;
} else if (cnt[01]) {
--cnt[01];
} else if (cnt[00]) {
--cnt[00];
}
} else {
if (cnt[11]) {
--cnt[11];
++n2;
} else if (cnt[01]) {
--cnt[01];
++n2;
} else if (cnt[10]) {
--cnt[10];
} else if (cnt[00]) {
--cnt[00];
}
}
}
if (n1 > n2) {
res = "First";
} else if (n1 < n2) {
res = "Second";
} else {
res = "Draw";
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int N;
void Init() { Get(N); }
int T[55][55];
void Mul(int A[][55], int B[][55], int N, int K, int M) {
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) {
T[i][j] = 0;
for (int k = 1; k <= K; k++) (T[i][j] ^= (A[i][k] & B[k][j]));
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) A[i][j] = T[i][j];
}
int A[55][55];
int B[55][55];
int T2[55][55];
void Pow(int X[][55], long long P) {
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) T2[i][j] = (i == j);
for (; P; P >>= 1) {
if (P & 1) Mul(T2, X, N, N, N);
Mul(X, X, N, N, N);
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) X[i][j] = T2[i][j];
}
long long Factor[100005];
int FactorTop;
bool I() {
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
if (B[i][j] != (i == j)) return 0;
return 1;
}
bool Check() {
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) B[i][j] = A[i][j];
Pow(B, (1ll << N) - 1);
int Ans = I();
if (Ans == 0) return 0;
for (int k = 1; k <= FactorTop; k++) {
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) B[i][j] = A[i][j];
Pow(B, ((1ll << N) - 1) / Factor[k]);
int Ans = I();
if (Ans == 1) return 0;
}
return 1;
}
void Debug() {
FactorTop = 0;
long long X = 1ll << N;
X--;
Factor[0] = 1;
for (long long i = 2; i * i <= X; i++) {
for (;; X /= i) {
if (X % i != 0) break;
Factor[++FactorTop] = i;
}
}
if (X > 1) Factor[++FactorTop] = X;
for (int i = 1; i < N; i++) A[i + 1][i] = 1;
for (;;) {
for (int i = 1; i <= N; i++) A[i][N] = rand() & 1;
int Ans = Check();
if (Ans) break;
}
}
void Work() { Debug(); }
void Output() {
for (int i = N; i >= 1; i--) printf("%d ", A[i][N]);
puts("");
for (int i = N; i >= 1; i--) printf("%d ", 1);
puts("");
}
int main() {
srand(time(0));
Init();
Work();
Output();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 310, MAXM = 50000 + 10;
vector<pair<pair<int, int>, int> > CC;
struct Graph {
int id, next;
} g[MAXN * 2];
int n, m, st[MAXN], a[MAXN], b[MAXN], v, f[MAXN], tot, cnt[MAXN];
pair<int, int> e[MAXM];
int getf(int first) {
if (f[first] == first) return first;
f[first] = getf(f[first]);
return f[first];
}
bool Union(int first, int second) {
int fx = getf(first), fy = getf(second);
if (fx == fy) return false;
f[fx] = fy;
return true;
}
void Add(int first, int second) {
g[tot].id = second, g[tot].next = st[first], st[first] = tot++;
g[tot].id = first, g[tot].next = st[second], st[second] = tot++;
}
void init() {
scanf("%d%d%d", &n, &v, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int j = 1; j <= n; ++j) scanf("%d", &b[j]);
for (int i = 1; i <= n; ++i) f[i] = i;
memset(st, -1, sizeof(st));
for (int i = 1; i <= m; ++i) {
int first, second;
scanf("%d%d", &first, &second);
e[i] = make_pair(first, second);
if (Union(first, second)) Add(first, second);
}
for (int i = 1; i <= n; ++i) cnt[getf(i)] += a[i] - b[i];
for (int i = 1; i <= n; ++i)
if (cnt[i] != 0) puts("NO"), exit(0);
}
int fa[MAXN];
bool used[MAXN];
int Gain(int first, int fx, int res) {
if (res == 0) return 0;
if (res > 0 && a[first] >= res) {
a[fx] += res, a[first] -= res;
CC.push_back(make_pair(make_pair(first, fx), res));
return -res;
}
if (res < 0 && v + res >= a[first]) {
a[fx] += res, a[first] -= res;
CC.push_back(make_pair(make_pair(fx, first), -res));
return -res;
}
int flow = (res > 0) ? (res - a[first]) : ((v + res) - a[first]);
for (int i = st[first]; i != -1; i = g[i].next)
if (g[i].id != fx && !used[g[i].id]) {
int F = Gain(g[i].id, first, flow);
flow += F;
if (flow == 0) break;
}
res -= flow;
a[fx] += res, a[first] -= res;
if (res + flow > 0) {
if (res != 0) CC.push_back(make_pair(make_pair(first, fx), res));
} else if (res != 0)
CC.push_back(make_pair(make_pair(fx, first), -res));
return -res;
}
void DFS(int first) {
for (int i = st[first]; i != -1; i = g[i].next)
if (g[i].id != fa[first]) fa[g[i].id] = first, DFS(g[i].id);
used[first] = true;
if (fa[first])
Gain(fa[first], first, b[first] - a[first]);
else if (a[first] != b[first])
puts("NO"), exit(0);
}
void solve() {
for (int i = 1; i <= n; ++i)
if (!used[i]) DFS(i);
cout << CC.size() << endl;
for (int i = 0; i < (int)CC.size(); ++i)
cout << CC[i].first.first << " " << CC[i].first.second << " "
<< CC[i].second << endl;
}
int main() {
init();
solve();
fclose(stdin);
fclose(stdout);
return 0;
}
| 8 |
#include <bits/stdc++.h>
const long long MOD = (long long)1e9 + 7;
using namespace std;
bool comp(string a, string b) { return a < b; }
long long dp[2500][2500];
vector<int> ones[2500];
int main() {
ios::sync_with_stdio(false);
cin.tie();
cout.tie();
long long n, k;
cin >> n >> k;
for (int i = 0; i < 2500; ++i) dp[0][i]++;
for (int i = 1; i <= 2000; ++i) {
for (int j = 1; j <= i / 2; ++j) {
if (i % j == 0) ones[i].push_back(j);
}
ones[i].push_back(i);
}
for (int i = 1; i <= k; ++i) {
for (int j = 1; j <= n; ++j) {
for (auto x : ones[j]) {
dp[i][j] += dp[i - 1][x];
dp[i][j] %= MOD;
}
}
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
ans += dp[k - 1][i];
ans %= MOD;
}
cout << ans % MOD;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
void solve() {
long long n;
cin >> n;
long long a[n + 1];
long long w;
cin >> w;
map<long long, long long> m;
long long parent[n + 1];
long long size[n + 1];
for (long long i = 0; i <= n; i++) {
parent[i] = i;
size[i] = 1;
}
vector<long long> adj[n + 1];
function<long long(long long)> find_set = [&](long long a) {
if (a == parent[a]) return a;
return parent[a] = find_set(parent[a]);
};
function<void(long long, long long)> make_set = [&](long long a,
long long b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (size[a] < size[b]) {
swap(a, b);
}
parent[b] = a;
size[a] += size[b];
}
};
for (long long i = 0; i < w; i++) {
long long x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
make_set(x, y);
}
for (long long i = 0; i <= n; i++) {
m[find_set(i)]++;
}
long long p = 1;
for (long long i = 0; i <= n; i++) {
if (adj[i].size() != m[find_set(i)] - 1) {
p = 0;
break;
}
}
if (p) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
pair<int, int> t1[4], t2[4];
set<pair<int, int> > st;
int v = 0, g = 0;
for (int i = 0; i < 4; i++) {
cin >> t1[i].first >> t1[i].second;
cin >> t2[i].first >> t2[i].second;
bool equ = false;
for (int j = 0; j < i; j++)
if (t1[j] == t1[i] && t2[j] == t2[i]) equ = true;
if ((t1[i].first != t2[i].first || t1[i].second != t2[i].second) && !equ) {
if (t1[i].first == t2[i].first) v++;
if (t1[i].second == t2[i].second) g++;
st.insert(t1[i]);
st.insert(t2[i]);
}
}
if (st.size() == 4 && v == 2 && g == 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500100;
int a[N];
int b[N];
int c[N];
bool vis[N];
int mabs(int x) { return x >= 0 ? x : -x; }
int main() {
int n;
int cnt = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] != 0) cnt++;
}
if (cnt == 0) {
printf("%d ", n * (n + 1) / 2);
for (int i = 1; i < n; i++) printf("0 ");
} else {
for (int i = 0; i < n; i++) {
if (a[i] == 0) continue;
int tmp = mabs(a[i]);
for (int j = 2; j * j <= tmp; j++) {
int t = j * j;
while (a[i] % t == 0) {
a[i] /= t;
}
}
}
for (int i = 0; i < n; i++) c[i] = a[i];
sort(c, c + n);
int js = unique(c, c + n) - c;
for (int i = 0; i < n; i++) {
if (a[i] == 0) continue;
int p = lower_bound(c, c + js, a[i]) - c + 1;
a[i] = p;
}
for (int i = 0; i < n; i++) {
memset(vis, 0, sizeof(vis));
int num = 0;
for (int j = i; j < n; j++) {
if (!vis[a[j]] && a[j] != 0) {
num++;
vis[a[j]] = 1;
}
int tt = max(num, 1);
b[tt]++;
}
}
for (int i = 1; i <= n; i++) {
printf("%d ", b[i]);
;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, k, i;
int max, pos;
char a[12];
char s[101][12];
int b[101];
memset(b, 0, sizeof(b));
scanf("%d", &n);
k = 0;
max = 0;
for (t = 0; t < n; t++) {
scanf("%s", &a);
for (i = 0; i < k; i++) {
if (strcmp(s[i], a) == 0) {
b[i]++;
break;
}
}
if (i == k) {
strcpy(s[i], a);
k++;
b[i]++;
}
}
for (i = 0; i < k; i++) {
if (max < b[i]) {
max = b[i];
pos = i;
}
}
printf("%s\n", s[pos]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a[2 * n];
for (int i = 0; i < 2 * n; i++) {
cin >> a[i];
}
sort(a, a + 2 * n);
if (a[0] == a[2 * n - 1])
cout << -1;
else
for (int i = 0; i < 2 * n; i++) cout << a[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101010;
int n;
char s[105];
int main() {
scanf("%d", &n);
scanf("%s", s);
int maxx = -999;
for (int i = 0; i <= n / 2; i++) {
int flag = 0;
for (int j = 0; j < i; j++) {
if (s[j] == s[i + j])
continue;
else {
flag = 1;
break;
}
}
if (flag == 0) maxx = max(maxx, i);
}
if (maxx == 0)
cout << n << endl;
else
cout << n - maxx + 1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int X = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') X = X * 10 + c - '0', c = getchar();
return X * w;
}
const int N = 100000 + 10, L = 100000;
const int mod = 1e9 + 7;
int qpow(int a, int b) {
int c = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) c = 1ll * c * a % mod;
return c;
}
int n, a[N], s = 0, f[N];
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read(), s += a[i];
f[1] = 1ll * (s - 1) * (s - 1) % mod * qpow(s, mod - 2) % mod;
f[2] = (2ll * f[1] - 1 + mod) % mod;
for (int i = 2; i < L; ++i)
f[i + 1] = (2ll * f[i] - f[i - 1] + mod -
1ll * (s - 1) * qpow(s - i, mod - 2) % mod + mod) %
mod;
int ans = 0;
for (int i = 1; i <= n; ++i) ans = (ans + f[a[i]]) % mod;
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
int n, m;
int l[2005], s[2005], c[2005 << 1];
int f[2005 << 1][2005];
int main() {
scanf("%d%d", &n, &m);
for (int i = n; i; i--) scanf("%d", &l[i]);
for (int i = n; i; i--) scanf("%d", &s[i]);
for (int i = 1; i <= n + m; i++) scanf("%d", &c[i]);
for (int i = 1; i <= n + m; i++)
for (int j = 1; j <= n; j++) f[i][j] = -0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
for (int j = n; j; j--)
f[l[i]][j] = std::max(f[l[i]][j], f[l[i]][j - 1] + c[l[i]] - s[i]);
for (int j = l[i]; j <= n + m; j++)
for (int k = 0; k <= (n >> (j - l[i])); k++)
f[j + 1][k / 2] = std::max(f[j + 1][k / 2], f[j][k] + k / 2 * c[j + 1]);
}
printf("%d\n", f[n + m][0]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, m, i, j, k;
vector<int> ans;
string s, t;
char a;
cin >> n;
int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
getline(cin, s);
for (i = 0; i < n; i++) {
getline(cin, s);
k = 0;
for (j = 0; j < s.length(); j++) {
if (s[j] == 'a' || s[j] == 'e' || s[j] == 'i' || s[j] == 'o' ||
s[j] == 'u' || s[j] == 'y') {
k++;
}
}
if (k == arr[i]) {
continue;
} else {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, q, last[200005];
long long a[200005];
long long t[4 * 200005];
void upd(int v, int l, int r, int pos, long long val) {
if (l == r) {
t[v] = val;
return;
}
int m = (l + r) / 2;
if (pos <= m)
upd(v * 2, l, m, pos, val);
else
upd(v * 2 + 1, m + 1, r, pos, val);
t[v] = max(t[v * 2], t[v * 2 + 1]);
}
long long get(int v, int l, int r, int i, int j) {
if (i > j) return 0;
if (l == i && r == j) return t[v];
int m = (l + r) / 2;
return max(get(v * 2, l, m, i, min(m, j)),
get(v * 2 + 1, m + 1, r, max(m + 1, i), j));
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%lld", a + i);
cin >> q;
for (int i = 1; i <= q; i++) {
int t, p;
long long x;
scanf("%d", &t);
if (t == 1) scanf("%d", &p);
scanf("%lld", &x);
if (t == 1) {
a[p] = x;
last[p] = i;
} else
upd(1, 1, q + 1, i, x);
}
for (int i = 1; i <= n; i++) {
a[i] = max(a[i], get(1, 1, q + 1, last[i] + 1, q));
printf("%lld ", a[i]);
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int L = (1 << 20) + 1;
char buf[L], *S, *T, c;
char getchar() {
if (__builtin_expect(S == T, 0)) {
T = (S = buf) + fread(buf, 1, L, stdin);
return (S == T ? EOF : *S++);
}
return *S++;
}
int inp() {
int x = 0, f = 1;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x * f;
}
unsigned inpu() {
unsigned x = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x;
}
long long inp_ll() {
long long x = 0;
int f = 1;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x * f;
}
char B[25], *outs = B + 20, *outr = B + 20;
template <class T>
inline void print(register T a, register char x = 0) {
if (x) *--outs = x, x = 0;
if (!a)
*--outs = '0';
else
while (a) *--outs = (a % 10) + 48, a /= 10;
if (x) *--outs = x;
fwrite(outs, outr - outs, 1, stdout);
outs = outr;
}
}; // namespace io
using io ::inp;
using io ::inp_ll;
using io ::inpu;
using io ::print;
using i32 = int;
using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f64 = double;
using f80 = long double;
long long power(long long a, long long b, long long p) {
if (!b) return 1;
long long t = power(a, b / 2, p);
t = t * t % p;
if (b & 1) t = t * a % p;
return t;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long px, py;
long long d = exgcd(b, a % b, px, py);
x = py;
y = px - a / b * py;
return d;
}
template <class T>
inline void freshmin(T &a, const T &b) {
if (a > b) a = b;
}
template <class T>
inline void freshmax(T &a, const T &b) {
if (a < b) a = b;
}
const int MAXN = 200010;
const int MOD = 1000000009;
const f80 MI = f80(1) / MOD;
const int INF = 1000000000;
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, -1, 1};
struct node {
node *pre, *son[2];
int rev;
} nodes[MAXN];
node *nil = nodes;
struct LinkCutTree {
void init(int n) {
nil->pre = nil->son[0] = nil->son[1] = nil;
nil->rev = 0;
for (int i = 1; i <= n; ++i) {
nodes[i].pre = nodes[i].son[0] = nodes[i].son[1] = nil;
nodes[i].rev = 0;
}
}
bool is_root(node *x) { return x->pre->son[0] != x && x->pre->son[1] != x; }
void reverse(node *x) {
if (x != nil) {
x->rev ^= 1;
swap(x->son[0], x->son[1]);
}
}
void clear(node *x) {
if (x->rev) {
reverse(x->son[0]);
reverse(x->son[1]);
x->rev = 0;
}
}
void update(node *x) {}
void rotate(node *x) {
node *y = x->pre, *z = y->pre;
int p = y->son[1] == x, q = p ^ 1;
if (!is_root(y)) z->son[z->son[1] == y] = x;
x->pre = z;
y->pre = x;
if (x->son[q]) x->son[q]->pre = y;
y->son[p] = x->son[q];
x->son[q] = y;
update(y);
update(x);
}
void clear_all(node *x) {
if (!is_root(x)) clear_all(x->pre);
clear(x);
}
void splay(node *x) {
clear_all(x);
while (!is_root(x)) {
node *y = x->pre, *z = y->pre;
if (!is_root(y)) rotate((y->son[0] == x) ^ (z->son[0] == y) ? x : y);
rotate(x);
}
}
void access(node *x0) {
for (node *x = x0, *y = nil; x != nil; x = x->pre) {
splay(x);
x->son[1] = y;
y = x;
}
splay(x0);
}
node *belong(node *x) {
access(x);
for (; x->son[0] != nil; x = x->son[0])
;
splay(x);
return x;
}
bool check(node *x, node *y) {
node *fx = belong(x);
node *fy = belong(y);
return fx == fy;
}
void link(node *x, node *y) {
access(x);
reverse(x);
x->pre = y;
}
void cut(node *x, node *y) {
access(y);
splay(x);
if (x->pre == y)
x->pre = nil;
else {
access(x);
splay(y);
if (y->pre == x) y->pre = nil;
}
}
bool check(int x, int y) { return check(nodes + x, nodes + y); }
void link(int x, int y) { link(nodes + x, nodes + y); }
bool try_link(int x, int y) {
if (check(x, y)) return 1;
link(x, y);
return 0;
}
void cut(int x, int y) { cut(nodes + x, nodes + y); }
} T;
int n, m;
int a[MAXN];
vector<int> v[MAXN];
int place(int i, int j) { return (i - 1) * m + j; }
struct segtree {
int add, min, cnt;
} tree[MAXN * 4];
void clear(int k) {
if (tree[k].add) {
tree[k << 1].add += tree[k].add;
tree[k << 1].min += tree[k].add;
tree[k << 1 | 1].add += tree[k].add;
tree[k << 1 | 1].min += tree[k].add;
tree[k].add = 0;
}
}
void update(int k) {
tree[k].min = min(tree[k << 1].min, tree[k << 1 | 1].min);
tree[k].cnt = (tree[k << 1].min == tree[k].min) * tree[k << 1].cnt +
(tree[k << 1 | 1].min == tree[k].min) * tree[k << 1 | 1].cnt;
}
void build(int k, int L, int R) {
if (L == R) {
tree[k].add = 0;
tree[k].min = 0;
tree[k].cnt = 1;
return;
}
int m = (L + R) / 2;
build(k << 1, L, m);
build(k << 1 | 1, m + 1, R);
update(k);
}
void add(int k, int L, int R, int x, int y, int p) {
if (L == x && R == y) {
tree[k].add += p;
tree[k].min += p;
return;
}
clear(k);
int m = (L + R) / 2;
if (y <= m)
add(k << 1, L, m, x, y, p);
else if (x > m)
add(k << 1 | 1, m + 1, R, x, y, p);
else {
add(k << 1, L, m, x, m, p);
add(k << 1 | 1, m + 1, R, m + 1, y, p);
}
update(k);
}
pair<int, int> query(int k, int L, int R, int x, int y) {
if (L == x && R == y) return pair<int, int>(tree[k].min, tree[k].cnt);
clear(k);
int m = (L + R) / 2;
if (y <= m) return query(k << 1, L, m, x, y);
if (x > m) return query(k << 1 | 1, m + 1, R, x, y);
auto lans = query(k << 1, L, m, x, m);
auto rans = query(k << 1 | 1, m + 1, R, m + 1, y);
return pair<int, int>(min(lans.first, rans.first),
(lans.first <= rans.first) * lans.second +
(lans.first >= rans.first) * rans.second);
}
int main() {
n = inp();
m = inp();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) a[place(i, j)] = inp();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
for (int d = 0; d < 4; ++d) {
int x = i + dx[d], y = j + dy[d];
if (1 <= x && x <= n && 1 <= y && y <= m)
v[a[place(i, j)]].push_back(a[place(x, y)]);
}
long long ans = 0;
T.init(n * m);
build(1, 1, n * m);
for (int i = 1, j = 1; i <= n * m; ++i) {
while (1) {
int flag = 0;
for (auto x : v[i])
if (j <= x && x < i) flag |= T.try_link(x, i);
if (!flag) break;
for (auto x : v[i])
if (j <= x && x < i) T.cut(x, i);
for (auto x : v[j]) T.cut(x, j);
j++;
}
add(1, 1, n * m, j, i, 1);
for (auto x : v[i])
if (j <= x && x < i) add(1, 1, n * m, j, x, -1);
auto ret = query(1, 1, n * m, j, i);
if (ret.first == 1) ans += ret.second;
}
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int N;
int lin[1010], col[1010], a[1010][1010], wl[1010], wc[1010];
int lg;
struct solution {
int Q, first, second;
solution() {}
solution(int _Q, int _first, int _second) {
this->Q = _Q;
this->first = _first;
this->second = _second;
}
inline void write() {
cout << this->Q << ' ' << this->first << ' ' << this->second << '\n';
}
} A[10010];
int main() {
cin >> N;
for (int i = 1; i < N; i++) {
int x, y;
cin >> x >> y;
lin[x]++;
col[y]++;
a[x][y]++;
wl[i] = i, wc[i] = i;
}
wl[N] = N, wc[N] = N;
for (int i = N; i > 1; i--) {
int aux;
aux = 0;
for (int j = 1; j < i; j++) {
if (col[wc[j]] == 0) {
aux = j;
break;
}
}
if (aux) {
swap(wc[i], wc[aux]);
A[++lg] = solution(2, i, aux);
}
aux = 0;
for (int j = 1; j < i; j++) {
if (lin[wl[j]]) {
aux = j;
}
}
if (aux) {
swap(wl[i], wl[aux]);
A[++lg] = solution(1, i, aux);
for (int j = 1; j <= i; j++) {
col[wc[j]] = col[wc[j]] - a[wl[i]][wc[j]];
}
}
}
cout << lg << '\n';
for (int i = 1; i <= lg; A[i].write(), i++)
;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
int a[111];
int c[111][111];
long long dp[111][111][111];
long long f(int idx, int cnt, int last) {
if (idx > n) return cnt == k ? 0 : 1e13;
if (dp[idx][cnt][last] != -1) return dp[idx][cnt][last];
long long ans = 1e13;
if (a[idx])
ans = min(ans, f(idx + 1, cnt + (a[idx] == last ? 0 : 1), a[idx]));
else {
for (int i = 1; i <= m; i++)
ans = min(ans, f(idx + 1, cnt + (last == i ? 0 : 1), i) + c[idx][i]);
}
return dp[idx][cnt][last] = ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(dp, -1, sizeof dp);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
a[0] = 111;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> c[i][j];
long long ans = f(1, 0, 111);
if (ans > 1e12)
cout << -1;
else
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v);
template <typename A, typename B>
ostream &operator<<(ostream &cout, pair<A, B> const &p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
template <typename A, typename B>
istream &operator>>(istream &cin, pair<A, B> &p) {
cin >> p.first;
return cin >> p.second;
}
const long long MAXN = 1e5 + 7;
void check() {
long long n, p;
cin >> n >> p;
long long tot = 1, li, ri, can = 0;
vector<long long> cn(n);
pair<long long, long long> a[n];
for (long long i = 0; i < n; i++) {
cin >> li >> ri;
a[i] = make_pair(li, ri);
cn[i] = (ri / p - (li - 1) / p);
}
long double ans = 0;
for (long long i = 0; i < n; i++) {
long long ai = cn[i], aj = cn[(i + 1) % n];
long long li = a[i].first, ri = a[i].second;
long long lj = a[(i + 1) % n].first, rj = a[(i + 1) % n].second;
long double not_p_i = (ri - li + 1.0 - ai) / (ri - li + 1.0);
long double not_p_j = (rj - lj + 1.0 - aj) / (rj - lj + 1.0);
long double tot_div_p = 1.0 - (not_p_i * not_p_j);
ans += tot_div_p;
}
cout << setprecision(9) << fixed << ans * 2000;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int i = 1; i <= t; i++) {
check();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ans, other;
int a[100000];
long long x[100000];
long long y[100000];
long long mod = 1e9 + 7;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
x[a[0] + 20000] = 1;
x[a[0] * (-1) + 20000] = 1;
for (int i = 1; i < n; i++) {
y[a[i] + 20000]++;
y[a[i] * (-1) + 20000]++;
for (int o = 10000; o <= 30000; o++) {
y[o + a[i]] += x[o];
y[o - a[i]] += x[o];
y[o + a[i]] %= mod;
y[o - a[i]] %= mod;
}
for (int o = 10000; o <= 30000; o++) {
x[o] = y[o];
y[o] = 0;
}
ans += x[20000];
ans %= mod;
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
struct Rec {
pair<int, int> interval[4];
};
Rec recs[111111];
bool check(set<pair<pair<int, int>, int>> st[]) {
int n = st[0].size();
if (n == 1) return true;
set<pair<pair<int, int>, int>>::iterator iter[4];
for (int i = 0; i < 4; i++) iter[i] = st[i].begin();
vector<int> mxr(4, -inf);
for (int i = 0; i < n / 2; i++) {
for (int j = 0; j < 4; j++) {
mxr[j] = max(mxr[j], iter[j]->first.second);
iter[j]++;
if (iter[j]->first.first >= mxr[j]) {
set<pair<pair<int, int>, int>> mini[4];
vector<int> indexs;
for (auto it = st[j].begin(); it != iter[j]; it++) {
int index = it->second;
indexs.push_back(index);
}
for (auto index : indexs) {
for (int z = 0; z < 4; z++) {
mini[z].insert(make_pair(recs[index].interval[z], index));
st[z].erase(make_pair(recs[index].interval[z], index));
}
}
if (check(mini) && check(st)) return true;
return false;
}
}
}
return false;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
recs[i].interval[0] = make_pair(a, c);
recs[i].interval[1] = make_pair(b, d);
recs[i].interval[2] = make_pair(-c, -a);
recs[i].interval[3] = make_pair(-d, -b);
}
set<pair<pair<int, int>, int>> st[4];
for (int i = 0; i < 4; i++)
for (int j = 0; j < n; j++) st[i].insert(make_pair(recs[j].interval[i], j));
puts(check(st) ? "YES" : "NO");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, a[1010], f[1010], d[1010];
bool mp[1010][1010];
int Dfs(int x) {
if (d[x] != -1) return d[x];
int res = 1;
for (int i = 1; i <= n; i++)
if (x != i && mp[x][i]) res = max(res, Dfs(i) + 1);
return d[x] = res;
}
int main() {
memset(d, -1, sizeof(d));
memset(f, 0, sizeof(f));
memset(mp, 1, sizeof(mp));
scanf("%d%d", &n, &m);
while (m--) {
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) mp[a[j]][a[i]] = 0;
}
ans = 0;
for (int i = 1; i <= n; i++) ans = max(ans, Dfs(i));
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l;
scanf("%d", &l);
long long add = 0, loop = 1;
long long res = 0;
stack<int> loops, bad;
bool over = false;
while (l--) {
string s;
cin >> s;
if (s == "add") {
res += loop;
if (bad.size() > 0) return cout << "OVERFLOW!!!" << endl, 0;
} else if (s == "end") {
if (bad.size() > 0) {
bad.pop();
} else if (loops.size() > 0) {
loop /= loops.top();
loops.pop();
}
} else if (s == "for") {
long long n;
cin >> n;
if (bad.size() > 0)
bad.push(n);
else if (loop * n < 4294967296) {
loops.push(n);
loop *= n;
} else {
bad.push(n);
}
}
if (res >= 4294967296) return cout << "OVERFLOW!!!" << endl, 0;
}
if (res >= 4294967296) return cout << "OVERFLOW!!!" << endl, 0;
cout << res << endl;
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.