solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
map<string, int> aa;
int main(void) {
int n;
cin >> n;
for (int e = 0; e < n; e++) {
string a;
cin >> a;
if (aa[a] == 0) {
cout << "NO\n";
aa[a]++;
} else {
cout << "YES\n";
}
}
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[40] = {1,
2,
4,
8,
16,
32,
64,
128,
256,
512,
1024,
2048,
4096,
8092,
16184,
32368,
64736,
129472,
258944,
517888,
1035776,
2071552,
4143104,
8286208,
16572416,
33144832,
66289664,
132579328,
265158656,
530317312,
1060634624,
2121269248,
4242538496ll,
8485076992ll,
16970153984ll,
33940307968ll};
int main() {
cin >> n;
cout << a[n] << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[1000];
int d = 1;
int t;
cin >> t;
for (int i = 1; i <= 1666; i++) {
if (i % 3 == 0 || i % 10 == 3) {
continue;
}
a[d] = i;
d++;
}
while (t--) {
int n;
cin >> n;
cout << a[n] << endl;
}
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long mod1 = 982886081;
const unsigned long long mod2 = 889930273;
const unsigned long long s1 = 131;
const int N = 3e6;
unsigned long long pm1[N], pm2[N];
pair<unsigned long long, unsigned long long> strhash[N];
void init(char *s, int len) {
pm1[0] = pm2[0] = 1;
for (int i = 1; i < N; ++i) {
pm1[i] = pm1[i - 1] * s1 % mod1;
pm2[i] = pm2[i - 1] * s1 % mod2;
}
strhash[0] = pair<unsigned long long, unsigned long long>(s[0] * pm1[0],
s[0] * pm2[0]);
for (int i = 1; i < len; ++i) {
strhash[i] = pair<unsigned long long, unsigned long long>(
(strhash[i - 1].first + s[i] * pm1[i]) % mod1,
(strhash[i - 1].second + s[i] * pm2[i]) % mod2);
}
}
unsigned long long qpow(unsigned long long a, unsigned long long k,
const unsigned long long &mod) {
unsigned long long res = 1;
while (k) {
if (k & 1) res = res * a % mod;
a = a * a % mod;
k >>= 1;
}
return res;
}
pair<unsigned long long, unsigned long long> shash(int l, int r) {
if (l == 0) return strhash[r];
unsigned long long one = strhash[r].first;
one = (one - strhash[l - 1].first + mod1) % mod1;
one = one * qpow(pm1[l], mod1 - 2, mod1) % mod1;
unsigned long long two = strhash[r].second;
two = (two - strhash[l - 1].second + mod2) % mod2;
two = two * qpow(pm2[l], mod2 - 2, mod2) % mod2;
return make_pair(one, two);
}
pair<unsigned long long, unsigned long long> ghash(char *s, int k) {
unsigned long long r1 = 0, r2 = 0;
for (int i = 0; i < k; ++i) {
r1 = (r1 + s[i] * pm1[i]) % mod1;
r2 = (r2 + s[i] * pm2[i]) % mod2;
}
return pair<unsigned long long, unsigned long long>(r1, r2);
}
map<pair<unsigned long long, unsigned long long>, int> mp;
bool used[N];
char s[N];
unsigned long long sh[N];
int main(int argc, const char *argv[]) {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", s);
int len = n * k;
for (int i = 0; i < len; ++i) {
s[i + len] = s[i];
}
init(s, len * 2);
int q;
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
scanf("%s", s);
pair<unsigned long long, unsigned long long> res = ghash(s, k);
mp[res] = i;
}
vector<int> ans;
for (int i = 0; i < k; ++i) {
for (int x : ans) used[x] = 0;
ans.clear();
for (int j = 0; j < n; ++j) {
pair<unsigned long long, unsigned long long> tar =
shash(i + j * k, i + (j + 1) * k - 1);
if (mp.find(tar) == mp.end() || used[mp[tar]]) break;
int id = mp[tar];
used[id] = 1;
ans.push_back(id);
if (j == n - 1) {
puts("YES");
for (int x : ans) printf("%d ", x);
return 0;
}
}
}
puts("NO");
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAX = 100010;
int n, k, a[300];
int main() {
cin >> n >> k;
for (int i = 0, _n = (n); i < _n; ++i) {
cin >> a[i];
}
int ans = INT_MIN;
for (int L = 0, _n = (n); L < _n; ++L) {
for (int R = L, _n = (n); R < _n; ++R) {
int s = 0;
vector<int> x, y;
for (int i = 0, _n = (n); i < _n; ++i) {
if (i <= R && i >= L) {
x.push_back(a[i]);
s += a[i];
} else
y.push_back(a[i]);
}
sort((x).begin(), (x).end());
sort(y.rbegin(), y.rend());
int cnt = 0;
for (int i = 0, _n = (min((int)(x).size(), (int)(y).size())); i < _n;
++i) {
if (cnt >= k || x[i] >= y[i]) break;
s -= x[i];
swap(y[i], x[i]);
s += x[i];
cnt++;
}
ans = max(ans, s);
}
}
cout << ans << endl;
return 0;
}
| 7
|
#include<bits/stdc++.h>
using namespace std;
const int maxn = 100 + 10;
int arr[maxn][maxn];
int sum[maxn * 2];
int n,m;
int main(){
int T; scanf("%d",&T);
while(T-- ){
scanf("%d%d",&n,&m);
memset(sum,0,sizeof(sum));
for(int i = 1 ; i <= n ; i++ ){
for(int j = 1 ; j <= m ; j++ ){
scanf("%d",&arr[i][j]);
sum[i + j] ^= arr[i][j];
}
}
bool ok = true;
for(int i = 1 ; i <= n + m ; i++ )
ok &= (!sum[i]);
printf("%s\n", !ok ? "Ashish" : "Jeel");
}
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int cnt[100005];
int gg[500];
int gn;
int ww[100005];
int cc[100005][455];
int n, m;
int dd[100005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &dd[i]);
if (dd[i] <= n) {
cnt[dd[i]]++;
if (cnt[dd[i]] >= dd[i] && !ww[dd[i]]) {
gg[++gn] = dd[i];
ww[dd[i]] = gn;
}
}
}
for (int i = 1; i <= n; ++i) {
memcpy(cc[i], cc[i - 1], sizeof(cc[i - 1]));
if (dd[i] <= n && ww[dd[i]]) {
cc[i][ww[dd[i]]]++;
}
}
int a, b;
for (int i = 0; i < m; ++i) {
scanf("%d%d", &a, &b);
int res = 0;
for (int j = 1; j <= gn; ++j) {
if (cc[b][j] - cc[a - 1][j] == gg[j]) res++;
}
printf("%d\n", res);
}
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << '\n';
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
const int N = 1e5 + 7;
int n, dep[N];
vector<int> g[N];
bool vis[N];
void dfs(int v, int h) {
vis[v] = true;
dep[v] = h;
for (auto nb : g[v])
if (!vis[nb]) dfs(nb, h + 1);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cout << fixed << setprecision(10);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(1, 1);
double ans = 0;
for (int i = 1; i <= n; i++) ans += 1.0 / dep[i];
cout << ans << '\n';
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
long long int m, n, a[223456], ans, i, j;
set<long long int> s1, s2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
long long int oi = 1, ei = 2, oc = 0, ec = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
s2.insert(a[i]);
if (a[i] & 1)
oc++;
else
ec++;
}
for (i = 0; i < n; i++) {
if (s1.find(a[i]) == s1.end()) {
s1.insert(a[i]);
} else {
if (oc > ec || (oc == ec && ((a[i] & 1) == 0))) {
while (s2.find(ei) != s2.end()) {
ei = ei + 2;
if (ei > m) {
cout << "-1";
return 0;
}
}
if (a[i] & 1) {
ec++;
oc--;
}
a[i] = ei;
ans++;
s2.insert(ei);
} else {
while (s2.find(oi) != s2.end()) {
oi = oi + 2;
if (oi > m) {
cout << "-1";
return 0;
}
}
if ((a[i] & 1) == 0) {
ec--;
oc++;
}
a[i] = oi;
ans++;
s2.insert(oi);
}
s1.insert(a[i]);
}
}
if (oc != ec) {
while (oc > ec) {
i = 0;
while ((a[i] & 1) == 0) i++;
while (s2.find(ei) != s2.end()) {
ei = ei + 2;
if (ei > m) {
cout << "-1";
return 0;
}
}
ec++;
oc--;
a[i] = ei;
ans++;
s2.insert(ei);
}
while (ec > oc) {
i = 0;
while (a[i] & 1) i++;
while (s2.find(oi) != s2.end()) {
oi = oi + 2;
if (oi > m) {
cout << "-1";
return 0;
}
}
ec--;
oc++;
a[i] = oi;
ans++;
s2.insert(oi);
}
}
cout << ans;
cout << "\n";
for (i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
using u64 = unsigned long long;
struct debug {
~debug() { cerr << endl; }
template <class c>
debug& operator<<(c x) {
cerr << x;
return *this;
}
template <class c, class d>
debug& operator<<(pair<c, d> x) {
*this << "(" << x.first << ", " << x.second << ")";
return *this;
}
template <class c>
debug& operator<<(vector<c> x) {
*this << "[";
int f = 0;
for (auto it : x) {
*this << (f ? ", " : "");
*this << it;
f = 1;
}
*this << "]";
return *this;
}
};
const int N = 300;
vector<int> G[N];
vector<int> GT[N];
vector<bool> vis;
vector<int> colors;
vector<int> order;
vector<int> assignment;
void dfs1(int cur) {
vis[cur] = true;
for (int to : G[cur]) {
if (!vis[to]) {
dfs1(to);
}
}
order.push_back(cur);
}
void dfs2(int cur, int col) {
colors[cur] = col;
for (int to : GT[cur]) {
if (colors[to] == 0) {
dfs2(to, col);
}
}
}
bool sat(int n) {
for (int i = 0; i < n; i++) {
if (!vis[i]) {
dfs1(i);
}
}
reverse(order.begin(), order.end());
int col = 1;
for (int i = 0; i < n; i++) {
if (colors[order[i]] == 0) {
dfs2(order[i], col++);
}
}
for (int i = 0; i < n; i += 2) {
if (colors[i] == colors[i + 1]) {
return false;
}
assignment[i / 2] = colors[i] > colors[i + 1];
}
return true;
}
void addEdge(int u, int v) {
G[u].push_back(v);
GT[v].push_back(u);
}
void addOr(int u, int v) {
addEdge(u ^ 1, v);
addEdge(v ^ 1, u);
}
void addXor(int u, int v) {
addOr(u, v);
addOr(u ^ 1, v ^ 1);
}
void init(int n) {
for (int i = 0; i < n; i++) {
G[i].clear();
GT[i].clear();
}
vis = vector<bool>(n);
colors = vector<int>(n);
assignment = vector<int>(n);
order.clear();
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
init(2 * n);
while (m--) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
--u, --v;
u *= 2;
v *= 2;
if (w == 1) {
addEdge(u, v);
addEdge(v, u);
addEdge(u ^ 1, v ^ 1);
addEdge(v ^ 1, u ^ 1);
} else {
addXor(u, v);
}
}
if (sat(2 * n)) {
vector<int> ans;
for (int i = 0; i < n; i++) {
if (assignment[i]) {
ans.push_back(i + 1);
}
}
printf("%d\n", (int)ans.size());
for (int i : ans) {
printf("%d ", i);
}
puts("");
} else {
puts("Impossible");
}
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
using Point = pair<int, int>;
template <typename T>
using Matrix = vector<vector<T>>;
const array<Point, 4> directions = {{{-1, 0}, {0, 1}, {1, 0}, {0, -1}}};
void bfs(int R, int C, const vector<Point>& source, const vector<Point>& target,
Matrix<int>& global_distance) {
vector<pair<int, Point>> sorted;
for (const auto& p : source) {
int r, c;
tie(r, c) = p;
sorted.push_back({global_distance[r][c], p});
}
sort(begin(sorted), end(sorted));
Matrix<int> distance(R, vector<int>(C, INT_MAX));
deque<pair<int, Point>> q = {sorted[0]};
int i = 1;
while (!q.empty()) {
int d;
Point p;
tie(d, p) = q.front();
q.pop_front();
int r, c;
tie(r, c) = p;
if (distance[r][c] <= d)
continue;
else
distance[r][c] = d;
for (; i < sorted.size(); i++) {
int nd;
Point np;
tie(nd, np) = sorted[i];
if (nd != d) break;
q.push_front({nd, np});
}
for (const auto& dir : directions) {
int dr, dc;
tie(dr, dc) = dir;
int nr = r + dr, nc = c + dc;
if (!(0 <= nr && nr < R && 0 <= nc && nc < C)) continue;
q.push_back({d + 1, {nr, nc}});
}
}
for (const auto& p : target) {
int r, c;
tie(r, c) = p;
global_distance[r][c] = distance[r][c];
}
}
void dag(const vector<Point>& source, const vector<Point>& target,
Matrix<int>& distance) {
for (const auto& p : source)
for (const auto& q : target) {
int r, c;
tie(r, c) = p;
int nr, nc;
tie(nr, nc) = q;
distance[nr][nc] =
min(distance[nr][nc], distance[r][c] + abs(nr - r) + abs(nc - c));
}
}
int solve(int R, int C, int P, Matrix<int> A) {
vector<vector<Point>> rank(P);
for (int r = 0; r < R; r++)
for (int c = 0; c < C; c++) rank[A[r][c]].push_back({r, c});
Matrix<int> distance(R, vector<int>(C, INT_MAX));
for (const auto& p : rank[0]) {
int r, c;
tie(r, c) = p;
distance[r][c] = r + c;
}
for (int level = 0; level + 1 < P; level++) {
int a = rank[level].size();
int b = rank[level + 1].size();
if (a * a > R * C || b * b > R * C)
bfs(R, C, rank[level], rank[level + 1], distance);
else
dag(rank[level], rank[level + 1], distance);
}
int r, c;
tie(r, c) = rank[P - 1][0];
return distance[r][c];
}
int main() {
int R, C, P;
cin >> R >> C >> P;
Matrix<int> A(R, vector<int>(C));
for (int r = 0; r < R; r++)
for (int c = 0; c < C; c++) {
cin >> A[r][c];
A[r][c]--;
}
cout << solve(R, C, P, move(A)) << endl;
vector<int> v;
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int counter = 0, counter1 = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'A') {
counter++;
} else if (s[i] == 'D') {
counter1++;
}
}
if (counter > counter1) {
cout << "Anton";
return 0;
} else if (counter1 > counter) {
cout << "Danik";
return 0;
} else if (counter == counter1) {
cout << "Friendship";
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> m;
int main() {
int b;
cin >> b;
string a[b + 1];
for (int i = 1; i <= b; i++) {
cin >> a[i];
}
for (int i = b; i >= 1; i--) {
if (m[a[i]] != 2) {
cout << a[i] << endl;
m[a[i]] = 2;
}
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int nax = 1000000 + 10;
vector<int> have;
int dp[12][12][1001];
int n;
int ans[nax];
bool solve(int bal, int prev, int step) {
if (step == n + 1) return true;
for (auto x : have) {
if (bal - x < 0 && x != prev) {
ans[step] = x;
if ((solve(x - bal, x, step + 1)) == true) {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
exit(0);
}
}
}
return false;
}
int main() {
ios::sync_with_stdio(0);
string s;
cin >> s;
for (int i = 0; i < 10; i++) {
if (s[i] == '1') have.push_back(i + 1);
}
cin >> n;
memset(dp, -1, sizeof(dp));
if (solve(0, 0, 1) == false) cout << "NO";
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> m >> n;
vector<vector<bool>> a(m, vector<bool>(n, false));
for (int i = 0; i < m; i++) {
int s;
cin >> s;
while (s--) {
int j;
cin >> j;
j--;
a[i][j] = true;
}
}
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
bool flag = false;
for (int k = 0; k < n; k++) {
flag |= (a[i][k] & a[j][k]);
}
if (!flag) {
cout << "impossible";
return 0;
}
}
}
cout << "possible";
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int M = 1e6 + 5;
const int step = 18;
int n, m, q, p[N];
int cnt, head[N], ans[N];
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
struct edge {
int to, next, dis;
} e[N << 1];
inline void add_edge(int u, int v, int d) {
cnt++;
e[cnt].dis = d;
e[cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt;
}
inline void dfs(int u, int f) {
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == f) continue;
ans[v] = max(ans[u], e[i].dis);
dfs(v, u);
}
}
struct node {
int u, v, d, id;
bool fg;
} a[M];
bool cmp(node a, node b) { return a.d < b.d; }
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= m; i++) {
a[i].u = read();
a[i].v = read();
a[i].d = read();
a[i].id = i;
}
sort(a + 2, a + m + 1, cmp);
for (int i = 2; i <= m; i++) {
int u = a[i].u, v = a[i].v, d = a[i].d;
if (find(u) != find(v)) {
add_edge(u, v, d);
add_edge(v, u, d);
p[find(u)] = p[v];
a[i].fg = 1;
}
}
int u = a[1].u, v = a[1].v;
if (find(u) != find(v)) {
puts("1000000000");
return 0;
}
dfs(u, 0);
printf("%d\n", ans[v]);
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
struct Pt {
long long x, y;
Pt(long long x_, long long y_) {
x = x_;
y = y_;
}
bool operator<(const Pt& p) const {
if (x < p.x) return true;
if (x > p.x) return false;
return y > p.y;
}
bool contains(const Pt& p) const { return p.y > y + (x - p.x) * (x - p.x); }
};
bool below(Pt p, Pt q, Pt r) {
long long y21 = q.y - p.y;
long long y32 = r.y - q.y;
long long x21 = q.x - p.x;
long long x32 = r.x - q.x;
long long x31 = r.x - p.x;
return y21 * x32 - y32 * x21 + x31 * x21 * x32 > 0;
}
int main() {
int N;
scanf("%d", &N);
vector<Pt> pts;
for (int i = 0; i < N; ++i) {
int x, y;
scanf("%d%d", &x, &y);
pts.emplace_back(x, y);
}
sort(pts.begin(), pts.end());
vector<Pt> hull;
hull.push_back(pts[0]);
for (int i = 1; i < N; ++i) {
if (pts[i].x == hull.back().x) continue;
while (hull.size() > 1 &&
!below(hull[hull.size() - 2], hull.back(), pts[i])) {
hull.pop_back();
}
hull.push_back(pts[i]);
}
printf("%d\n", (int)hull.size() - 1);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int x, y, val, id;
bool operator<(const Edge e) const { return val < e.val; }
};
int n, m;
Edge e[200010];
int tid[200010];
int ans[200010];
bool vis[200010];
void init() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++)
scanf("%d%d%d", &e[i].x, &e[i].y, &e[i].val), e[i].id = i;
}
int fa[200010];
int find(int x) {
if (x != fa[x]) fa[x] = find(fa[x]);
return fa[x];
}
void kruskal() {
memset(vis, 0, sizeof(vis));
sort(e, e + m);
for (int i = 1; i <= n; i++) fa[i] = i;
int sum = 0;
for (int i = 0; i < m; i++) {
int lx = find(e[i].x), ly = find(e[i].y);
if (lx != ly) {
fa[lx] = ly;
vis[e[i].id] = true;
sum++;
if (sum == n - 1) break;
}
}
}
vector<Edge> adj[200010];
int gra[200010][22 + 2], disMax[200010][22 + 2];
int dep[200010];
void initLCA() {
for (int i = 0; i < m; i++)
if (vis[e[i].id] == true) {
adj[e[i].x].push_back((Edge){e[i].x, e[i].y, e[i].val, e[i].id});
adj[e[i].y].push_back((Edge){e[i].y, e[i].x, e[i].val, e[i].id});
}
dep[0] = -1;
dep[1] = 1;
}
void dfs(int u, int pre) {
int len = adj[u].size();
for (int i = 1; i <= 22; i++) {
gra[u][i] = gra[gra[u][i - 1]][i - 1];
disMax[u][i] = max(disMax[u][i - 1], disMax[gra[u][i - 1]][i - 1]);
if (!gra[u][i]) break;
}
for (int i = 0; i < len; i++)
if (adj[u][i].y != pre) {
int to = adj[u][i].y;
dep[to] = dep[u] + 1;
gra[to][0] = u;
tid[to] = adj[u][i].id;
disMax[to][0] = adj[u][i].val;
dfs(to, u);
}
}
int LCA(int x, int y) {
int Maxx = 0;
if (dep[x] > dep[y]) swap(x, y);
for (int i = 22; i >= 0; i--)
if (dep[gra[y][i]] >= dep[x]) {
Maxx = max(Maxx, disMax[y][i]);
y = gra[y][i];
}
for (int i = 22; i >= 0; i--)
if (gra[x][i] != gra[y][i]) {
Maxx = max(Maxx, max(disMax[x][i], disMax[y][i]));
x = gra[x][i];
y = gra[y][i];
}
if (x != y) Maxx = max(Maxx, max(disMax[x][0], disMax[y][0]));
return Maxx;
}
void GetAns() {
int u, v, val, id;
for (int i = 0; i <= n; i++) fa[i] = i;
for (int i = 0; i < m; i++)
if (!vis[e[i].id]) {
u = e[i].x;
v = e[i].y;
val = e[i].val;
id = e[i].id;
ans[id] = LCA(u, v);
for (;;) {
u = find(u);
v = find(v);
if (u == v) break;
if (dep[u] < dep[v]) swap(u, v);
ans[tid[u]] = max(ans[tid[u]], val);
fa[u] = find(gra[u][0]);
}
}
}
void Print() {
for (int i = 0; i < m; i++) printf("%d ", ans[i] - 1);
return;
}
int main() {
init();
kruskal();
initLCA();
dfs(1, 0);
GetAns();
Print();
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int N, Q, tot;
int root[200010];
long long ans;
class rec {
public:
int lson, rson;
int s;
} seg[5000010];
long long C2(long long x) { return x * (x - 1) / 2; }
void Init(int &x, int l, int r, int t) {
int xx = x;
x = ++tot;
seg[x] = seg[xx];
seg[x].s++;
if (l == r) return;
int mid = (l + r) >> 1;
if (t <= mid)
Init(seg[x].lson, l, mid, t);
else
Init(seg[x].rson, mid + 1, r, t);
}
int calc(int xr, int xl, int l, int r, int ll, int rr) {
if (ll > rr) return 0;
if (l == ll && r == rr) return seg[xr].s - seg[xl].s;
int mid = (l + r) >> 1;
if (rr <= mid)
return calc(seg[xr].lson, seg[xl].lson, l, mid, ll, rr);
else if (ll > mid)
return calc(seg[xr].rson, seg[xl].rson, mid + 1, r, ll, rr);
else
return calc(seg[xr].lson, seg[xl].lson, l, mid, ll, mid) +
calc(seg[xr].rson, seg[xl].rson, mid + 1, r, mid + 1, rr);
}
int main() {
scanf("%d%d", &N, &Q);
tot = 0;
root[0] = 0;
for (int i = 1; i <= N; i++) {
int x;
scanf("%d", &x);
root[i] = root[i - 1];
Init(root[i], 1, N, x);
}
for (int i = 1; i <= Q; i++) {
int l, r, u, d;
scanf("%d%d%d%d", &l, &d, &r, &u);
ans = C2(N);
ans -= C2(calc(root[l - 1], root[0], 1, N, 1, N));
ans -= C2(calc(root[N], root[r], 1, N, 1, N));
ans -= C2(calc(root[N], root[0], 1, N, 1, d - 1));
ans -= C2(calc(root[N], root[0], 1, N, u + 1, N));
ans += C2(calc(root[l - 1], root[0], 1, N, 1, d - 1));
ans += C2(calc(root[l - 1], root[0], 1, N, u + 1, N));
ans += C2(calc(root[N], root[r], 1, N, 1, d - 1));
ans += C2(calc(root[N], root[r], 1, N, u + 1, N));
printf("%I64d\n", ans);
}
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
vector<int> pos, reg;
map<int, int> back;
int solve(int position, int length) {
if (length == 0) return position;
vector<int>::iterator t =
upper_bound(pos.begin(), pos.end(), position + length);
t--;
int nextone = t - pos.begin();
if (pos[nextone] - position >= length / 2 && length != 1)
return solve(pos[nextone], length - (pos[nextone] - position));
int rem = length - (pos[nextone] - position);
if (rem == 0) return pos[nextone];
t = lower_bound(pos.begin(), pos.end(), pos[nextone] - rem);
int prevone = t - pos.begin();
if (nextone == prevone) return pos[nextone];
int dist = pos[nextone] - pos[prevone];
if (dist >= rem / 2) return solve(pos[prevone], rem - dist);
if ((rem / dist) & 1) {
return solve(pos[prevone], rem % dist);
} else
return solve(pos[nextone], rem % dist);
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int g = 0; g < n; g++) {
int k;
scanf("%d", &k);
reg.push_back(k);
pos.push_back(k);
back[k] = g + 1;
}
sort(pos.begin(), pos.end());
for (int g = 0; g < m; g++) {
int start, leng;
scanf("%d %d", &start, &leng);
start--;
printf("%d\n", back[solve(reg[start], leng)]);
}
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 3];
a[0] = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) a[i] += a[i - 1];
int mx = 0;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
mx = max(mx, a[i - 1] + a[n] - a[j] + ((j - i + 1) - (a[j] - a[i - 1])));
}
cout << mx << endl;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
void CI(int &_x) { scanf("%d", &_x); }
void CI(int &_x, int &_y) {
CI(_x);
CI(_y);
}
void CI(int &_x, int &_y, int &_z) {
CI(_x);
CI(_y, _z);
}
void CI(int &_a, int &_b, int &_c, int &_d) {
CI(_a, _b);
CI(_c, _d);
}
template <typename T>
void getarray(T a[], int b, int e) {
for (int i = b; i < e + b; i++) cin >> a[i];
}
template <typename T>
void printarray(T a[], int b, int e) {
for (int i = b; i < e - 1 + b; i++) cout << a[i] << " ";
cout << a[e - 1 + b] << endl;
}
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <class T>
inline void read(T &x) {
bool Minus = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') Minus = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (Minus) x = -x;
};
char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
const double EPS = 1e-9;
const int INF = 0x7f7f7f7f;
int dr8[8] = {1, -1, 0, 0, 1, -1, -1, 1};
int dc8[8] = {0, 0, -1, 1, 1, 1, -1, -1};
int dr4[4] = {0, 0, 1, -1};
int dc4[4] = {-1, 1, 0, 0};
int kn8r[8] = {1, 2, 2, 1, -1, -2, -2, -1};
int kn8c[8] = {2, 1, -1, -2, -2, -1, 1, 2};
int main() {
int i;
int n, k;
CI(n, k);
cout << k * (6 * n - 1) << endl;
for (i = 0; i < n; i++) {
int t = 6 * i;
cout << k * (t + 1) << " ";
cout << k * (t + 2) << " ";
cout << k * (t + 3) << " ";
cout << k * (t + 5) << "\n";
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, k = 0, p, j, ans = 0;
scanf("%d", &n);
pair<int, int> arr[100001];
arr[0].first = 0;
arr[0].second = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
if (x >= arr[k].second) {
k++;
ans++;
arr[k].first = x;
arr[k].second = x;
continue;
}
arr[k].first = min(arr[k].first, x);
arr[k].second = max(arr[k].second, x);
for (j = k; j >= 0; j--) {
if (x >= arr[j].second) {
p = j + 1;
arr[p].first = min(arr[p].first, x);
arr[p].second = arr[k].second;
k = p;
break;
}
}
}
cout << k;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
struct people {
int num;
int date;
} P[1000010];
bool cmp(people a, people b) { return a.date < b.date; }
int main() {
int n, i;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &P[i].date);
P[i].num = i + 1;
}
sort(P, P + n, cmp);
printf("%d\n%d", n / 2, P[1].num);
for (i = 3; i < n; i += 2) printf(" %d", P[i].num);
printf("\n%d\n%d", n - n / 2, P[0].num);
for (i = 2; i < n; i += 2) printf(" %d", P[i].num);
putchar(10);
return (0);
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int dx[9] = {0, 1, 0, -1, 0, -1, -1, 1, 1};
const int dy[9] = {0, 0, -1, 0, 1, -1, 1, -1, 1};
const double pi = acos(-1.0);
const int N = 30 + 5;
struct point {
long long x, y;
};
int n, du[N];
vector<int> G[N];
point ans[N];
void dfs(int v, int fa, long long x0, long long y0, long long len, int fx) {
ans[v].x = x0, ans[v].y = y0;
int l = G[v].size();
int now = 0;
for (int i = 0; i <= l - 1; i++) {
if (G[v][i] == fa) continue;
now++;
int tnow = now + 2;
if (tnow > 4) tnow -= 4;
if (tnow == fx) now++;
long long x1 = x0 + 1LL * dx[now] * len;
long long y1 = y0 + 1LL * dy[now] * len;
dfs(G[v][i], v, x1, y1, len >> 1, now);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
int x, y;
scanf("%d", &x), scanf("%d", &y);
du[x]++, du[y]++;
G[x].push_back(y), G[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (du[i] > 4) return puts("NO"), 0;
puts("YES");
dfs(1, 0, 0, 0, 1 << 30, 0);
for (int i = 1; i <= n; i++) cout << ans[i].x << ' ' << ans[i].y << endl;
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, o;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
o = (round(n + 1.5 - sqrt(2 * (n + k) + 2.75)));
cout << o << "\n";
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int max(int x, int y) {
if (x > y)
return x;
else
return y;
}
int main() {
string a, b;
int x = 0, y = 0;
cin >> a >> b;
int l = a.length();
for (int i = 0; i < l; i++) {
if (a[i] == '4' && b[i] == '7') x++;
if (a[i] == '7' && b[i] == '4') y++;
}
cout << max(x, y);
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
const long double PI = 3.141592653589793;
const long long INF = 9223372036854775807ll;
const long long mod = 1e9 + 7;
const int N = 1e5 + 5;
long long tree[4 * N];
long long lazy[4 * N];
long long b[N];
void build(int node, int start, int end) {
if (start == end) {
tree[node] = b[start];
return;
}
int mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
tree[node] = tree[2 * node] + tree[2 * node + 1];
}
long long query(int node, int start, int end, int l, int r) {
if (lazy[node] != -INF / 2) {
tree[node] = lazy[node] * (end - start + 1);
if (start != end) {
lazy[2 * node] = lazy[node];
lazy[2 * node + 1] = lazy[node];
}
lazy[node] = -INF / 2;
}
if (l > end || r < start) return 0;
if (l <= start && r >= end) {
return tree[node];
}
int mid = (start + end) / 2;
return query(2 * node, start, mid, l, r) +
query(2 * node + 1, mid + 1, end, l, r);
}
void update(int node, int start, int end, int l, int r, long long val) {
if (lazy[node] != (-INF / 2)) {
tree[node] = lazy[node] * (end - start + 1ll);
if (start != end) {
lazy[2 * node] = lazy[node];
lazy[2 * node + 1] = lazy[node];
}
lazy[node] = (-INF / 2);
}
if (l > end || r < start) return;
if (l <= start && r >= end) {
tree[node] = (end - start + 1) * val;
if (start != end) {
lazy[2 * node] = val;
lazy[2 * node + 1] = val;
}
return;
}
int mid = (start + end) / 2;
update(2 * node, start, mid, l, r, val);
update(2 * node + 1, mid + 1, end, l, r, val);
tree[node] = tree[2 * node] + tree[2 * node + 1];
}
void solve() {
fill(tree, tree + 4 * N, 0ll);
fill(lazy, lazy + 4 * N, -INF / 2);
long long n;
cin >> n;
long long a[n];
long long t[n + 1];
t[0] = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 1; i < n; ++i) {
long long k;
cin >> k;
t[i] = t[i - 1] + k;
}
for (int i = 0; i < n; ++i) {
b[i] = a[i] - t[i];
}
for (int i = 1; i < n; ++i) {
t[i] += t[i - 1];
}
b[n] = INF / 2;
build(1, 0, n);
int q;
cin >> q;
while (q--) {
char now;
cin >> now;
if (now == 's') {
int l;
int r;
cin >> l >> r;
l--;
r--;
long long pr = query(1, 0, n, l, r);
if (l - 1 < 0) l++;
cout << (pr + t[r] - t[l - 1]) << '\n';
} else {
int i;
long long x;
cin >> i >> x;
i--;
long long val = query(1, 0, n, i, i) + x;
int lo = i;
int hi = n;
while (hi - lo > 1) {
int mid = (hi + lo) / 2;
if (query(1, 0, n, mid, mid) <= val) {
lo = mid;
} else {
hi = mid;
}
}
update(1, 0, n, i, lo, val);
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
solve();
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
template <typename T = long long>
inline T read() {
T s = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
s = (s << 3) + (s << 1) + ch - 48;
ch = getchar();
}
return s * f;
}
const int N = 2e5 + 5, M = 1e6 + 5, MOD = 1e9 + 7, CM = 998244353,
INF = 0x3f3f3f3f;
const long long linf = 0x7f7f7f7f7f7f7f7f;
long long pow(long long a, long long b, long long p) {
long long ans = 1;
a %= p;
while (b) {
if (b & 1) ans = ans * a % p;
a = a * a % p;
b >>= 1;
}
return ans;
}
namespace Combination {
const int MAXN = 2e5 + 5;
long long fac[MAXN], invfac[MAXN], mod;
void init(int n, long long MOD) {
fac[0] = 1;
mod = MOD;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mod;
invfac[n] = pow(fac[n], mod - 2, mod);
for (int i = n; i >= 1; i--) invfac[i - 1] = invfac[i] * i % mod;
}
long long C(long long n, long long m) {
if (n < 0 || m < 0) return 0;
return n >= m ? fac[n] * invfac[n - m] % mod * invfac[m] % mod : 0;
}
} // namespace Combination
long long F(long long n, long long m, long long MOD) {
long long ans = 0;
int base = 1;
for (int i = 0; i <= m; i++) {
long long now =
base * Combination::C(m, m - i) % MOD * pow(m - i, n, MOD) % MOD;
now = (now + MOD) % MOD;
base *= -1;
ans = (ans + now) % MOD;
}
return ans;
}
void solve(int kase) {
Combination::init(N - 5, CM);
long long n = read(), k = read();
if (k == 0) {
long long ans = 1;
for (int i = 1; i <= n; i++) ans = ans * i % CM;
printf("%lld\n", ans);
return;
}
long long ans1 = Combination::C(n, n - k);
long long ans2 = 0;
for (int i = 0; i <= n - k; i++) {
long long now = ((i & 1) ? -1 : 1) * Combination::C(n - k, n - k - i) % CM;
now = (now + CM) % CM;
now = now * pow(n - k - i, n, CM) % CM;
ans2 = (ans2 + now) % CM;
}
printf("%lld\n", 2 * ans1 * ans2 % CM);
}
const bool ISFILE = 0, DUO = 0;
int main() {
clock_t start, finish;
start = clock();
if (ISFILE) freopen("/Users/i/Desktop/practice/in.txt", "r", stdin);
if (DUO) {
int Kase = 0;
cin >> Kase;
for (int kase = 1; kase <= Kase; kase++) solve(kase);
} else
solve(1);
finish = clock();
;
;
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100100;
const long long mod = 1000000007;
long long mpow(long long n, long long p) {
if (p == 0)
return 1;
else {
long long aux = mpow(n, p / 2);
aux *= aux;
aux %= mod;
if (p % 2 == 0)
return aux;
else
return (n * aux) % mod;
}
}
long long inv(long long n) { return mpow(n, mod - 2); }
int a[MAX], b[MAX], accA[MAX], accB[MAX];
int main() {
int n;
long long m;
scanf("%d %lld", &n, &m);
for (int i = 0; i < int(n); i++) scanf("%d", a + i + 1);
for (int i = 0; i < int(n); i++) scanf("%d", b + i + 1);
for (int i = 1; i <= n; i++) {
accA[i] = accA[i - 1];
accB[i] = accB[i - 1];
if (a[i] == 0) accA[i]++;
if (b[i] == 0) accB[i]++;
}
int cnt = 0;
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (a[i] != 0 && b[i] != 0 && a[i] != b[i]) {
if (a[i] > b[i]) ans += inv(mpow(m, cnt));
break;
}
if (a[i] == 0 || b[i] == 0) {
long long prod = inv(mpow(m, cnt));
if (a[i] == 0 && b[i] == 0)
prod *= ((m - 1ll) * inv(2ll * m)) % mod;
else if (a[i] == 0)
prod *= ((m - b[i]) * inv(m)) % mod;
else if (b[i] == 0)
prod *= ((a[i] - 1) * inv(m)) % mod;
prod %= mod;
ans += prod;
ans %= mod;
cnt++;
}
}
printf("%lld\n", ans % mod);
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, grot = 0, grotagn = 0;
cin >> n;
int a[n / 2];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n / 2);
for (int i = 1; i <= n; i += 2) grot += abs(a[(i - 1) / 2] - i);
for (int i = 2; i <= n; i += 2) grotagn += abs(a[(i - 1) / 2] - i);
cout << min(grot, grotagn);
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3f;
const long long mod = 1000000007;
const double eps = 1e-5;
const int maxn = 2005;
const int maxm = 20005;
const int base = 27;
int n, m;
char str[2505][5005];
int hanming[5005];
int cnt[30];
int cnt0[30];
char ans[5005];
bool isdup = 0;
bool check(int now) {
for (int i = 0; i < n; i++) {
if (i == now) continue;
int nowcnt = 0;
for (int j = 0; j < m; j++) {
if (str[now][j] != str[i][j]) {
nowcnt++;
}
}
if (nowcnt != 2 && nowcnt != 0) return 0;
if (nowcnt == 0 && isdup == 0) return 0;
}
for (int i = 0; i < m; i++) ans[i] = str[now][i];
ans[m] = '\0';
return 1;
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", str[i]);
}
int mark1 = -1, mark2 = -1;
memset(hanming, 0, sizeof(hanming));
for (int i = 1; i < n; i++) {
for (int j = 0; j < m; j++) {
if (str[0][j] != str[i][j]) {
hanming[i]++;
}
}
}
bool ok = 1;
memset(cnt0, 0, sizeof(cnt0));
for (int i = 0; i < m; i++) {
cnt0[str[0][i] - 'a']++;
if (cnt0[str[0][i] - 'a'] > 1) isdup = 1;
}
for (int i = 1; i < n; i++) {
memset(cnt, 0, sizeof(cnt));
for (int j = 0; j < m; j++) {
cnt[str[i][j] - 'a']++;
}
for (int j = 0; j < 26; j++) {
if (cnt[j] != cnt0[j]) {
ok = 0;
}
}
}
int mark = -1;
int marklen = 0;
if (ok) {
for (int i = 1; i < n; i++) {
if (hanming[i] > 4 || hanming[i] == 1) {
ok = 0;
}
if (hanming[i] > marklen) mark = i;
}
}
if (mark == -1) ok = 0;
if (ok) {
vector<int> v;
v.clear();
for (int i = 0; i < m; i++) {
if (str[0][i] != str[mark][i]) {
v.push_back(i);
}
}
bool flag = 0;
for (int i = 0; i < v.size(); i++) {
int now = v[i];
for (int j = 0; j < m; j++) {
if (j == now) continue;
swap(str[0][now], str[0][j]);
if (check(0)) {
flag = 1;
break;
}
swap(str[0][now], str[0][j]);
swap(str[mark][now], str[mark][j]);
if (check(mark)) {
flag = 1;
break;
}
swap(str[mark][now], str[mark][j]);
}
if (flag) break;
}
ok = flag;
}
bool flag = 0;
for (int i = 0; i < n; i++) {
if (hanming[i] != 0) {
flag = 1;
}
}
if (flag == 0 || n == 1) {
for (int i = 0; i < m; i++) ans[i] = str[0][i];
ans[m] = '\0';
swap(ans[0], ans[1]);
ok = 1;
}
if (ok)
printf("%s\n", ans);
else
printf("-1\n");
return;
}
int main() {
solve();
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int a[1001][1001];
int m = 0, o1[100001], o2[100001], t[100001];
void f(int n) {
int c = -1;
if (n == 1) return;
for (int i = 1; i <= n; i++) {
bool f = 0;
for (int j = 1; j <= n; j++)
if (a[j][i]) {
f = 1;
break;
}
if (!f) {
c = i;
break;
}
}
if (n != c) {
for (int i = 1; i <= n; i++) swap(a[i][n], a[i][c]);
m++;
o1[m] = c;
o2[m] = n;
t[m] = 2;
}
int r = -1;
for (int j = n; j >= 1; j--) {
bool f = 0;
for (int i = n - 1; i >= 1; i--)
if (a[j][i]) {
f = 1;
break;
}
if (f) {
r = j;
break;
}
}
if (r == -1) return;
if (n != r) {
for (int i = 1; i <= n; i++) swap(a[n][i], a[r][i]);
m++;
o1[m] = r;
o2[m] = n;
t[m] = 1;
}
f(n - 1);
}
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
a[x][y] = 1;
}
f(n);
cout << m << endl;
for (int i = 1; i <= m; i++)
cout << t[i] << " " << o1[i] << " " << o2[i] << endl;
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
int N, M, dp[MAXN], res[MAXN];
vector<pair<int, int>> adj[MAXN];
int check(int v) {
if (dp[v]) return dp[v];
dp[v] = 1;
for (auto p : adj[v]) {
int n = p.first;
if (check(n) + 1 > dp[v]) {
dp[v] = dp[n] + 1;
res[v] = max(res[n], p.second);
}
}
return dp[v];
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < M; i++) {
int a, b;
scanf("%d%d", &a, &b);
a -= 1, b -= 1;
adj[a].push_back({b, i + 1});
}
for (int i = 0; i < N; i++) {
if (check(i) == N) {
printf("%d", res[i]);
return 0;
}
}
printf("-1");
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
typedef struct MCMF {
int n, m;
vector<int> ghead, gnxt, gto, gcap;
vector<long long> gcost;
vector<long long> d;
vector<int> bck;
vector<long long> pot;
vector<int> flow;
void init(int _n) {
n = _n, m = 0;
ghead = vector<int>(n, -1);
gnxt.clear(), gto.clear(), gcap.clear(), gcost.clear();
d = vector<long long>(n);
bck = vector<int>(n);
pot = vector<long long>(n, 0);
flow = vector<int>(n);
}
void addedge(int a, int b, int c, long long d) {
gnxt.push_back(ghead[a]);
ghead[a] = m;
gto.push_back(b);
gcap.push_back(c);
gcost.push_back(+d);
++m;
gnxt.push_back(ghead[b]);
ghead[b] = m;
gto.push_back(a);
gcap.push_back(0);
gcost.push_back(-d);
++m;
}
pair<int, long long> solve(int s, int t) {
for (int i = (0); i < (n); ++i) d[i] = LLONG_MAX, bck[i] = -1;
d[s] = 0, bck[s] = -2;
while (true) {
bool change = false;
for (int at = (0); at < (n); ++at)
if (d[at] != LLONG_MAX)
for (int x = ghead[at]; x != -1; x = gnxt[x])
if (gcap[x] > 0) {
int to = gto[x];
if (d[at] + gcost[x] >= d[to]) continue;
d[to] = d[at] + gcost[x];
bck[to] = x ^ 1;
change = true;
}
if (!change) break;
}
if (d[t] == LLONG_MAX) return make_pair(0, 0);
for (int i = (0); i < (n); ++i) pot[i] = d[i];
pair<int, long long> ret = make_pair(0, 0LL);
while (true) {
for (int i = (0); i < (n); ++i)
d[i] = LLONG_MAX, bck[i] = -1, flow[i] = 0;
d[s] = 0, bck[s] = -2, flow[s] = INT_MAX;
priority_queue<pair<long long, int> > q;
q.push(make_pair(-d[s], s));
while (!q.empty()) {
long long cost = -q.top().first;
int at = q.top().second;
q.pop();
if (cost > d[at]) continue;
for (int x = ghead[at]; x != -1; x = gnxt[x])
if (gcap[x] > 0) {
int to = gto[x];
long long rcost = gcost[x] - pot[at] + pot[to];
if (d[at] + rcost >= d[to]) continue;
d[to] = d[at] + rcost;
bck[to] = x ^ 1;
flow[to] = min(flow[at], gcap[x]);
q.push(make_pair(-d[to], to));
}
}
if (d[t] == LLONG_MAX) break;
assert(flow[t] > 0);
ret.first += flow[t], ret.second += (d[t] - pot[t]) * flow[t];
for (int i = (0); i < (n); ++i)
if (d[i] != LLONG_MAX) pot[i] -= d[i];
for (int at = t; at != s; at = gto[bck[at]]) {
gcap[bck[at]] += flow[t];
gcap[bck[at] ^ 1] -= flow[t];
}
}
return ret;
}
} MCMF;
const int MAXN = 50;
const int MAXK = 50;
const int MAXT = MAXN + MAXK;
int n, m, k, c, d;
int start[MAXN];
vector<int> adj[MAXN];
int nid, sid, tid;
int vid[MAXN][MAXT + 1];
MCMF g;
long long solve() {
nid = 0;
sid = nid++;
tid = nid++;
for (int i = (0); i < (n); ++i)
for (int j = (0); j <= (n + k); ++j) vid[i][j] = nid++;
g.init(nid);
for (int i = (0); i < (k); ++i) g.addedge(sid, vid[start[i]][0], 1, 0);
for (int z = k - 1; z >= 0; --z)
for (int at = (0); at < (n); ++at)
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
for (int j = (0); j < (n + k); ++j)
g.addedge(vid[at][j], vid[to][j + 1], 1, (2 * z + 1) * d);
}
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n + k); ++j)
g.addedge(vid[i][j], vid[i][j + 1], k, 0);
for (int j = (0); j <= (n + k); ++j) g.addedge(vid[0][j], tid, k, c * j);
pair<int, long long> res = g.solve(sid, tid);
assert(res.first == k);
return res.second;
}
void run() {
scanf("%d%d%d%d%d", &n, &m, &k, &c, &d);
for (int i = (0); i < (k); ++i) scanf("%d", &start[i]), --start[i];
for (int i = (0); i < (m); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
adj[a].push_back(b);
adj[b].push_back(a);
}
printf("%lld\n", solve());
}
int main() {
run();
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int tt = 1;
scanf("%d", &tt);
;
while (tt--) {
long long int i, n, m, ans = 0, mx = 0, up = 0;
scanf("%lli %lli", &n, &m);
;
long long int a[n + 5], c[n + 5], b;
for (int i = 0; i < n; i++) {
scanf("%lli", &a[i]);
;
c[a[i]] = i + 1;
}
for (int i = 0; i < m; i++) {
scanf("%lli", &b);
;
if (i == 0) {
mx = c[b];
ans += ((c[b] - 1) * 2 + 1);
up++;
} else {
if (c[b] < mx) {
ans++;
up++;
} else {
mx = c[b];
ans += ((c[b] - 1 - up) * 2 + 1);
up++;
}
}
}
printf("%lli\n", ans);
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
const long long MOD = 1000000007;
const int INF = 1000000000;
const int MAXN = 200005;
const double EPS = 1e-6;
const int HASH_POW = 7;
const double PI = acos(-1.0);
using namespace std;
void my_return(int code) { exit(code); }
int main() {
mt19937 mt_rand(time(NULL));
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
if (x1 + y1 <= max(x2, y2))
printf("Polycarp\n");
else if (x1 <= x2 && y1 <= y2)
printf("Polycarp\n");
else
printf("Vasiliy\n");
my_return(0);
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m, k, a[105][105], ones[105][105];
int main() {
scanf("%lld%lld%lld", &n, &m, &k);
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
scanf("%lld", &a[i][j]);
}
}
for (long long int j = 0; j < m; j++) {
for (long long int i = 0; i < n; i++) {
ones[i][j] = a[i][j];
if (i == 0) continue;
ones[i][j] += ones[i - 1][j];
}
}
long long int score = 0, replc = 0;
for (long long int j = 0; j < m; j++) {
long long int mx = 0, pos = 0;
for (long long int i = 0; i < n; i++) {
if (a[i][j] == 1) {
long long int got = ones[min(i + k - 1, n - 1)][j];
if (i > 0) got -= ones[i - 1][j];
if (got > mx) {
mx = got;
pos = i;
}
}
}
score += mx;
if (pos > 0) replc += ones[pos - 1][j];
}
printf("%lld %lld\n", score, replc);
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500000 + 10;
char s[maxn];
long long sum[maxn], sum2[maxn];
int isvowel(char c) {
switch (c) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'Y':
return 1;
default:
return 0;
}
}
int main() {
double ans = 0;
scanf("%s", s + 1);
int len = strlen(s + 1);
for (int i = 1; i <= len; ++i) sum[i] = sum[i - 1] + isvowel(s[i]);
int maxl = (len + 1) / 2;
for (int l = 1; l <= maxl; ++l) {
int L = l, R = len - l + 1;
sum2[l] = sum2[l - 1] + (sum[R] - sum[L - 1]);
}
for (int i = 1; i <= len; ++i) ans += (double)sum2[min(i, len - i + 1)] / i;
printf("%.8f\n", ans);
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
int a[n + 1];
for (int k = 1; k <= n; k++) cin >> a[k];
sort(a + 1, a + 1 + n);
int mx = 1;
for (int k = n; k > 1; k--)
if (a[k] == a[k - 1])
mx++;
else {
ans = max(mx, ans);
mx = 1;
}
ans = max(mx, ans);
if (a[1] == a[n])
cout << 0;
else
cout << n - ans;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
void rd(int &a) { scanf("%d", &a); }
void rd(int &a, int &b) { scanf("%d %d", &a, &b); }
void rd(int &a, int &b, int &c) { scanf("%d %d %d", &a, &b, &c); }
void rd(long long &a) { scanf("%lld", &a); }
void rd(long long &a, long long &b) { scanf("%lld %lld", &a, &b); }
void rd(long long &a, long long &b, long long &c) {
scanf("%lld %lld %lld", &a, &b, &c);
}
void rd(double &a) { scanf("%lf", &a); }
void rd(double &a, double &b) { scanf("%lf %lf", &a, &b); }
void rd(double &a, double &b, double &c) { scanf("%lf %lf %lf", &a, &b, &c); }
int main() {
long long a, b, c;
rd(a, b, c);
long long i, t, n, x = 0;
rd(n);
for (i = 0; i < n; i++) {
rd(t);
if (t > b && t < c) {
x++;
}
}
cout << x << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long double x, y, z;
cin >> x >> y >> z;
cout << setprecision(15)
<< ((x * x * x / 2.0L / sqrt(2.0L)) + (y * y * y / sqrt(2.0L)) +
(z * z * z * (5.0L + sqrt(5.0L)) / 8.0L)) /
3.0L;
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
long long f[N][N][N], a[N];
char s[N];
int main() {
int n;
scanf(" %d %s", &n, s + 1);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j < i; j++) {
a[i] = max(a[i], a[i - j] + a[j]);
}
}
memset(f, -0x3f, sizeof f);
for (int i = 1; i <= n; i++) f[i][i][0] = a[1], f[i][i][1] = 0;
for (int len = 2; len <= n; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int ed = i + len - 1;
f[i][ed][1] = f[i][ed - 1][0];
for (int k = 1; k <= n; k++) {
for (int j = i; j < ed; j++) {
if (s[j] == s[ed] && j + 1 <= ed - 1)
f[i][ed][k] =
max(f[i][ed][k], f[i][j][k - 1] + f[j + 1][ed - 1][0]);
else if (s[j] == s[ed])
f[i][ed][k] = max(f[i][ed][k], f[i][j][k - 1]);
}
}
for (int k = 1; k <= n; k++)
f[i][ed][0] = max(f[i][ed][0], f[i][ed][k] + a[k]);
}
}
cout << f[1][n][0];
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
void solve() {
int t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
string s;
cin >> s;
long long l = 0, r = 0, u = 0, d = 0;
long long x = 0, y = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'L') {
x--;
} else if (s[i] == 'R') {
x++;
} else if (s[i] == 'U') {
y++;
} else {
y--;
}
if ((max(r, x) - min(l, x)) + 1 > m || (max(u, y) - min(d, y)) + 1 > n) {
break;
}
l = min(l, x);
r = max(r, x);
u = max(u, y);
d = min(d, y);
}
cout << 1 + u << " " << 1 - l << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, t;
scanf("%d%d%d", &n, &k, &t);
int a = t / k, b = t % k, ans;
if (t <= n)
ans = b + (a ? k - b : 0);
else {
int r = t - n;
a = n / k, b = n % k;
ans = b + (a ? k - b : 0);
ans -= r;
if (ans < 0) ans = 0;
}
printf("%d\n", ans);
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1001;
int countof[MAXN];
int main() {
int n, l, x, minimum = 10000;
cin >> n >> l;
for (int i = 0; i < l; i++) {
cin >> x;
countof[x]++;
}
for (int i = 1; i <= n; i++) minimum = min(minimum, countof[i]);
cout << minimum;
return 0;
}
| 1
|
#include<bits/stdc++.h>
using namespace std;
const int N = 2e5+10;
int main()
{
int T;
cin>>T;
while(T--)
{
int a,b;
cin>>a>>b;
cout<<a-1<<' '<<b<<endl;
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, P = 998244353;
using ll = long long;
int n;
ll dp[N][3], pre[N], suf[N];
vector<pair<int, int>> v[N];
void dfs(int pos, int fa) {
int fp = -1;
for (int i = 0; i < int(v[pos].size()); i++) {
if (v[pos][i].first == fa) {
fp = i;
continue;
}
dfs(v[pos][i].first, pos);
}
pre[0] = suf[v[pos].size() + 1] = 1;
for (int i = 0; i < int(v[pos].size()); i++) {
int vv = v[pos][i].first;
if (i == fp)
pre[i + 1] = pre[i];
else
pre[i + 1] = pre[i] * (dp[vv][0] + dp[vv][1]) % P;
}
for (int i = int(v[pos].size()) - 1; i >= 0; --i) {
int vv = v[pos][i].first;
if (i == fp)
suf[i + 1] = suf[i + 2];
else
suf[i + 1] = suf[i + 2] * (dp[vv][0] + dp[vv][2]) % P;
}
for (int i = 0; i < fp; i++)
dp[pos][0] =
(dp[pos][0] + pre[i] * dp[v[pos][i].first][2] % P * suf[i + 2]) % P;
if (pos != 1) dp[pos][1] = pre[fp] * suf[fp + 2] % P;
for (int i = fp + 1; i < int(v[pos].size()); i++)
dp[pos][2] =
(dp[pos][2] + pre[i] * dp[v[pos][i].first][2] % P * suf[i + 2]) % P;
dp[pos][2] = (dp[pos][2] + pre[v[pos].size()]) % P;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
int t1, t2;
for (int i = 1; i < n; i++)
cin >> t1 >> t2, v[t1].push_back({t2, i}), v[t2].push_back({t1, i});
dfs(1, 0);
cout << dp[1][2] << endl;
return 0;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
int sub_ans(int i, int idx, string s) {
if (!(i - 1)) return s[idx] == '4' ? 1 : 2;
return (1 << (i - 1)) * (s[idx] != '4') + sub_ans(i - 1, idx + 1, s);
}
int main() {
ios::sync_with_stdio(false);
string x;
cin >> x;
int ans = (1 << x.size()) - 2 + sub_ans(x.size(), 0, x);
cout << ans << endl;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int main(){
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(ios::badbit | ios::failbit);
auto __solve_tc = [&](int __tc_num){
int n;
long long k;
cin >> n >> k;
if(n <= 61 && 1LL << n - 1 < k){
cout << "-1\n";
return 0;
}
-- k;
vector<int> res(n);
iota(res.rbegin(), res.rend(), 1);
for(auto bit = 0, s = 0; bit <= 60; ++ bit){
if(~k & 1LL << bit){
reverse(res.begin() + s, res.begin() + bit + 1);
s = bit + 1;
}
}
reverse(res.begin(), res.end());
for(auto x: res){
cout << x << " ";
}
cout << "\n";
return 0;
};
int __tc_cnt;
cin >> __tc_cnt;
for(auto __tc_num = 0; __tc_num < __tc_cnt; ++ __tc_num){
__solve_tc(__tc_num);
}
return 0;
}
/*
*/
////////////////////////////////////////////////////////////////////////////////////////
// //
// Coded by Aeren //
// //
////////////////////////////////////////////////////////////////////////////////////////
| 10
|
#include <bits/stdc++.h>
using namespace std;
int p[100005];
int d[100005];
int ans[100005];
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> p[i];
p[i]--;
}
d[0] = 0;
for (int i = 1; i < n; i++) d[i] = d[p[i]] + 1;
int maxd = 0;
for (int i = 0; i < n; i++) maxd = max(maxd, d[i]);
for (int i = 0; i <= maxd; i++) ans[i] = 0;
for (int i = 0; i < n; i++) ans[d[i]] ^= 1;
int out = 0;
for (int i = 0; i <= maxd; i++) {
out += ans[i];
}
cout << out << endl;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, q;
int pre[N], nxt[N];
int sq;
int num;
int cnt;
int now;
int c[N], f[N], t[N];
vector<int> need_resolve;
int calc_nxt(int x) {
int k = sq;
for (; k >= 4; k -= 4) {
x = nxt[nxt[nxt[nxt[x]]]];
}
for (; k--;) {
x = nxt[x];
}
return x;
}
int calc_pre(int x) {
int k = sq;
for (; k >= 4; k -= 4) {
x = pre[pre[pre[pre[x]]]];
}
for (; k--;) {
x = pre[x];
}
return x;
}
int main() {
scanf("%d%d", &n, &q);
sq = sqrt(n);
sq = min(sq, 100);
for (int i = 1; i <= n; ++i) {
scanf("%d", nxt + i);
pre[nxt[i]] = i;
}
for (int i = 1; i <= n; ++i) {
f[i] = calc_nxt(i);
}
while (q--) {
int op, x, y;
scanf("%d%d%d", &op, &x, &y);
int nx = nxt[x], ny = nxt[y];
if (op == 1) {
need_resolve.clear();
need_resolve.emplace_back(calc_pre(x));
need_resolve.emplace_back(calc_pre(y));
need_resolve.emplace_back(calc_pre(nx));
need_resolve.emplace_back(calc_pre(ny));
nxt[x] = ny;
pre[ny] = x;
nxt[y] = nx;
pre[nx] = y;
need_resolve.emplace_back(calc_pre(nx));
need_resolve.emplace_back(calc_pre(ny));
for (auto u : need_resolve) {
t[1] = u;
for (int i = 2; i <= 2 * sq + 2; ++i) {
t[i] = nxt[t[i - 1]];
}
for (int i = 1; i <= sq + 2; ++i) {
f[t[i]] = t[i + sq];
}
}
} else {
int ret = x;
for (; y > sq; y -= sq) {
ret = f[ret];
}
for (; y; --y) {
ret = nxt[ret];
}
printf("%d\n", ret);
}
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<long long> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int l = 0, r = 1001001001;
while (l + 1 < r) {
int mid = (l + r) / 2;
vector<long long> w = h;
bool flag = true;
for (int i = n - 1; i >= 2; i--) {
if (w[i] < mid) {
flag = false;
break;
}
long long cal = min((w[i] - mid) / 3, h[i] / 3);
w[i - 2] += cal * 2;
w[i - 1] += cal;
}
if (min(w[0], w[1]) < mid) {
flag = false;
}
if (flag) {
l = mid;
} else {
r = mid;
}
}
cout << l << endl;
}
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
vector<int> a(n, 0);
long long int even = 0, odd = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i % 2 == 0 && a[i] % 2 == 1)
odd++;
else if (i % 2 == 1 && a[i] % 2 == 0)
even++;
}
if (even != odd) {
cout << -1 << '\n';
} else
cout << even << '\n';
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, s, i, j, k, cnt = 1;
cin >> n;
s = pow(2, n);
if (n >= 13) {
i = n - 13;
j = pow(2, i);
s = pow(2, n) - 100 * j;
}
cout << s << endl;
}
| 11
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
const long double pi = acos(-1);
const long long maxn = 2e5 + 5;
const int mod = 1e9 + 7;
const long long INF = 1e18;
const int MX = 2000000001;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
long long t, q, n, a, b, c, d, k, l, m, r, x = 0, y = 0, z = 0, sum = 0,
ans = 0, temp = 0, res = 0;
string second;
cin >> n >> second;
a = b = c = 0;
for (auto x : second) {
a += (x == 'A');
b += (x == 'I');
c += (x == 'F');
}
cout << (b > 1 ? 0 : (b == 1 ? 1 : a));
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int check[10000];
int main() {
int n, k, x;
cin >> n >> k;
for (int i = 0; i < k; i++) {
cin >> x;
check[x] = i + 1;
}
int counter = 0, j;
for (int i = 0; i < k; i++) {
counter = 0;
for (j = 1; j <= n * k; j++) {
if (check[j] == i + 1) {
cout << j << " ";
counter++;
}
if (counter == n) {
cout << endl;
break;
}
}
j = 1;
while (counter <= n) {
if (!check[j]) {
check[j] = i + 1;
cout << j << " ";
counter++;
}
if (counter == n) {
cout << endl;
break;
}
j++;
}
}
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << "Mahmoud";
} else
cout << "Ehab";
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
const double PI = acos(-1.);
const double eps = 1e-15;
const int MOD = 1e9 + 7;
long long power(long long x, long long y) {
if (y == 0) return 1;
long long s = power(x, y / 2);
s *= s;
if (y & 1) s *= x;
return s;
}
long long Ceil(long long x, long long y) { return (x + y - 1) / y; }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int n;
long long h;
bool check(long long k, vector<long long>& a) {
long long hp = h;
for (int i = 0; i < n; i++) {
long long damage = min(a[i + 1] - a[i], k);
hp -= damage;
}
return hp <= 0;
}
void solve() {
cin >> n >> h;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
a.emplace_back(INT64_MAX);
long long l = 1, r = h;
while (l < r) {
long long mid = (l + r) / 2;
if (check(mid, a))
r = mid;
else
l = mid + 1;
}
cout << l << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int TESTS = 1;
cin >> TESTS;
while (TESTS--) {
solve();
}
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int On(int N, int pos) { return N = N | (1 << pos); }
int Off(int N, int pos) { return N = N & ~(1 << pos); }
bool isOn(int N, int pos) { return (bool)(N & (1 << pos)); }
int main() {
int tc, cs;
int i, j, k;
int n;
cin >> n;
int arr[100005] = {0};
for (i = 0; i < n; i++) cin >> arr[i];
int sum[100005] = {0};
int mx = 0;
for (i = 2; i < n; i++)
if (arr[i] == arr[i - 1] + arr[i - 2]) {
sum[i] = sum[i - 1] + 1;
if (sum[i] > mx) mx = sum[i];
}
if (n == 1)
cout << 1 << endl;
else if (n == 2)
cout << 2 << endl;
else {
cout << mx + 2 << endl;
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3005;
const int INF = 0x3f3f3f3f;
const int mod = 10000007;
const double eps = 1e-9;
int __ = 1, kase = 0;
int n, m, d[maxn][maxn];
vector<int> G[maxn];
void init() {}
void read() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
G[a].push_back(b);
}
}
void solve() {
for (int i = 1; i <= n; i++) {
for (int j = 0; j < G[i].size(); j++) {
int u = G[i][j];
for (int k = 0; k < G[u].size(); k++) {
int r = G[u][k];
d[i][r]++;
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i != j) {
if (d[i][j] > 1) {
ans += d[i][j] * (d[i][j] - 1) / 2;
}
}
}
}
printf("%d\n", ans);
}
int main() {
while (__--) {
init();
read();
solve();
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
long long int bin(long long int a, long long int b) {
if (b == 0) return 1;
if (b & 1) return (a * bin((a * a) % 1000000007, b / 2)) % 1000000007;
return (1 * bin((a * a) % 1000000007, b / 2)) % 1000000007;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string str;
cin >> str;
vector<set<int> > s(26);
int n = str.size();
for (int i = 0; i < n; i++) {
int k = str[i] - 'a';
s[k].insert(i + 1);
}
str = " " + str;
int q;
cin >> q;
while (q--) {
int temp;
cin >> temp;
if (temp == 1) {
int pos;
char ch;
cin >> pos >> ch;
char k = str[pos];
int k1 = k - 'a';
s[k1].erase(pos);
str[pos] = ch;
k1 = ch - 'a';
s[k1].insert(pos);
} else {
int l, r;
cin >> l >> r;
int cnt = 0;
for (int i = 0; i < 26; i++) {
set<int>::iterator it;
it = s[i].lower_bound(l);
int k1 = *it;
if (k1 >= l && k1 <= r) {
cnt++;
}
}
cout << cnt << endl;
}
}
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
struct Edge {
long long to;
long long cost;
long long from;
Edge(long long t, long long c, long long f = -1) : to(t), cost(c), from(f) {
;
}
};
long long n;
vector<vector<Edge> > G;
vector<int> subt;
long long count_visit(long long index, long long prev) {
subt[index] = 1;
for (auto e : G[index]) {
if (e.to != prev) subt[index] += count_visit(e.to, index);
}
return subt[index];
}
long long sum_visit(long long index, long long prev) {
long long ret = 0;
for (auto e : G[index]) {
if (e.to != prev) {
ret += subt[e.to] * (n - subt[e.to]) * e.cost;
ret += sum_visit(e.to, index);
}
}
return ret;
}
int main() {
cin >> n;
G.resize(n);
vector<Edge> edges(n - 1, Edge(0, 0, 0));
for (long long i = 0; i < n - 1; i++) {
long long a, b, c;
cin >> a >> b >> c;
a--;
b--;
edges[i] = Edge(b, c, a);
G[a].push_back(Edge(b, c));
G[b].push_back(Edge(a, c));
}
long long allcost;
double allcase = n * (n - 1) / (1 * 2 * 3);
subt.resize(n);
count_visit(0, -1);
allcost = sum_visit(0, -1);
long long q;
cin >> q;
for (long long i = 0; i < q; i++) {
long long r, w;
cin >> r >> w;
r--;
long long temp = min(subt[edges[r].from], subt[edges[r].to]);
allcost += (w - edges[r].cost) * temp * (n - temp);
edges[r].cost = w;
printf("%.10lf\n", (double)allcost * 2 * 3 / n / (n - 1));
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, ans;
cin >> n;
ans = (n * (n - 1)) >> 1;
string s;
cin >> s;
vector<int> A, B;
for (int i = 0; i < int(n); i++) {
if (s[i] == 'A')
A.push_back(i);
else
B.push_back(i);
}
for (int i = 0; i < int(n - 1); i++) {
if (s[i] == 'A') {
if (s[i + 1] == 'A') {
auto it = lower_bound(B.begin(), B.end(), i + 1);
if (it != B.end()) ans--;
} else {
for (int j = i + 1; j < n && s[j] == 'B'; j++) ans--;
}
} else {
if (s[i + 1] == 'A') {
for (int j = i + 1; j < n && s[j] == 'A'; j++) ans--;
} else {
auto it = lower_bound(A.begin(), A.end(), i + 1);
if (it != A.end()) ans--;
}
}
}
cout << ans << endl;
}
| 11
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse3,sse4,popcnt,abm,mmx")
const int N = (int)3e7 + 7;
const int inf = (int)1e9 + 7;
const int mod = (int)1e9 + 7;
const long long linf = (long long)1e18 + 7;
const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
using namespace std;
void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int n, m, x;
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m >> x;
if (n > m) cout << 0, exit(0);
int dp[m + 2][n + 2][n + 2][2];
memset(dp, 0, sizeof(dp));
dp[1][1][1][(x == 1)] = 1;
dp[1][1][0][(x == 1)] = 1;
dp[1][0][0][0] = 1;
--x;
for (int v = 1; v < m; v++) {
for (int cnt = 0; cnt <= min(n, v); cnt++) {
for (int o = 0; o <= cnt; o++) {
for (int first = 0; first <= 1; first++) {
int now = dp[v][cnt][o][first];
if (!now) continue;
add(dp[v + 1][cnt + 1][o + 1][first | (v == x)], now);
if (o) {
add(dp[v + 1][cnt][o - 1][first], now);
add(dp[v + 1][cnt + 1][o][first | (v == x)], now);
} else
add(dp[v + 1][cnt + 1][o][first | (v == x)], now);
add(dp[v + 1][cnt][o][first], now);
}
}
}
}
int first = 1;
for (int i = 2; i <= n; i++) {
first = first * 1ll * i % mod;
}
cout << dp[m][n][0][1] * 1ll * first % mod;
exit(0);
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int maxn = 100100;
long long exponentiation(long long A, long long B, long long MOD) {
long long ans = 1;
for (; B; A = (A * A) % MOD, B >>= 1)
if (B & 1) ans = (ans * A) % MOD;
return ans;
}
pair<int, int> tree[maxn << 2];
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
return {1ll * a.first * b.first % mod, a.second + b.second};
}
void upd(int pos, int v) {
for (pos++; pos < maxn << 2; pos += pos & -pos)
tree[pos] = tree[pos] + make_pair(v, 1);
}
void update(int pos, int v) { upd(pos + 2 * maxn - 100, v); }
void ree(int pos) {
for (pos++; pos < maxn << 2; pos += pos & -pos) tree[pos] = make_pair(1, 0);
}
void remove(int pos) { ree(pos + 2 * maxn - 100); }
void clear() {
for (int e = 0; e < maxn << 2; e++) tree[e] = {1, 0};
}
pair<int, int> sum(int pos) {
pair<int, int> ruu = {1ll, 0};
for (pos++; pos; pos -= pos & -pos) ruu = ruu + tree[pos];
return ruu;
}
pair<int, int> query(int x, int y) {
pair<int, int> down = sum(x + 2 * maxn - 101);
pair<int, int> up = sum(y + 2 * maxn - 100);
return make_pair(
1ll * exponentiation(down.first, mod - 2, mod) * up.first % mod,
up.second - down.second);
}
int online[maxn], sz[maxn];
int color[maxn], clam[maxn];
int u[maxn], v[maxn], x[maxn], c[maxn];
vector<int> g[maxn];
vector<long long> res;
void init(int cur, int p) {
sz[cur] = 1;
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt]) {
init(nxt, cur);
sz[cur] += sz[nxt];
}
}
}
int get_centroid(int cur, int p, int w) {
int biggest = -1;
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt] && (biggest == -1 || sz[biggest] < sz[nxt]))
biggest = nxt;
}
if (biggest == -1 || sz[biggest] * 2 <= w / 2) return cur;
return get_centroid(biggest, cur, w);
}
const int zx = 100000;
void count0(int cur, int p, int r, int b, int co) {
pair<int, int> mul = query(-2 * zx, 2 * r - b);
if (mul.second) {
res.back() *= 1ll * mul.first * exponentiation(co, mul.second, mod) % mod;
res.back() %= mod;
}
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt]) {
count0(nxt, cur, r + 1 - c[d], b + c[d], 1ll * co * x[d] % mod);
}
}
}
void add0(int cur, int p, int r, int b, int co) {
update(b - 2 * r, co);
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt])
add0(nxt, cur, r + 1 - c[d], b + c[d], 1ll * co * x[d] % mod);
}
}
void rem0(int cur, int p, int r, int b) {
remove(b - 2 * r);
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt]) rem0(nxt, cur, r + 1 - c[d], b + c[d]);
}
}
void find0(int cur) {
init(cur, -1);
cur = get_centroid(cur, -1, sz[cur]);
update(0, 1);
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (online[nxt]) continue;
count0(nxt, cur, 1 - c[d], c[d], x[d]);
add0(nxt, cur, 1 - c[d], c[d], x[d]);
}
remove(0);
rem0(cur, -1, 0, 0);
online[cur] = 1;
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (online[nxt]) continue;
find0(nxt);
}
}
void count1(int cur, int p, int r, int b, int co) {
pair<int, int> mul = query(2 * b - r + 1, 2 * zx + 1);
if (mul.second) {
res.back() *= 1ll * mul.first * exponentiation(co, mul.second, mod) % mod;
res.back() %= mod;
}
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt]) {
count1(nxt, cur, r + 1 - c[d], b + c[d], 1ll * co * x[d] % mod);
}
}
}
void add1(int cur, int p, int r, int b, int co) {
update(r - 2 * b, co);
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt])
add1(nxt, cur, r + 1 - c[d], b + c[d], 1ll * co * x[d] % mod);
}
}
void rem1(int cur, int p, int r, int b) {
remove(r - 2 * b);
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt]) rem1(nxt, cur, r + 1 - c[d], b + c[d]);
}
}
void find1(int cur) {
init(cur, -1);
cur = get_centroid(cur, -1, sz[cur]);
update(0, 1);
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (online[nxt]) continue;
count1(nxt, cur, 1 - c[d], c[d], x[d]);
add1(nxt, cur, 1 - c[d], c[d], x[d]);
}
remove(0);
rem1(cur, -1, 0, 0);
online[cur] = 1;
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (online[nxt]) continue;
find1(nxt);
}
}
int main() {
int n;
scanf("%d", &n);
for (int e = 0; e < n - 1; e++) {
scanf("%d %d %d %d", u + e, v + e, x + e, c + e);
u[e]--;
v[e]--;
g[u[e]].push_back(e);
g[v[e]].push_back(e);
}
clear();
memset(online, 0, sizeof(online));
res.push_back(1ll);
find0(0);
memset(online, 0, sizeof(online));
res.push_back(1ll);
find1(0);
cout << res[0] * exponentiation(res[1], mod - 2, mod) % mod << endl;
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
void solve(long long tc) {
long long n, m;
cin >> n >> m;
vector<long long> v(m);
vector<long long> ans(m);
long long s = 0;
for (long long i = 0; i < m; i++) cin >> v[i], s += v[i];
if (s < n) {
cout << "-1\n";
return;
}
ans[m - 1] = n - v[m - 1] + 1;
long long req = s - n, i, cur = n - v[m - 1];
bool f = 1;
for (i = m - 2; i >= 0; i--) {
if (cur <= 0) {
f = 0;
break;
}
if (req == 0) {
ans[i] = cur + 1 - v[i];
cur = ans[i] - 1;
continue;
}
if (n - v[i] + 1 < cur) {
if (v[i + 1] > req) {
ans[i] = cur - (v[i] - req - 1);
req = 0;
cur = ans[i] - 1;
} else {
req -= (n - cur);
ans[i] = n - v[i] + 1;
cur = ans[i] - 1;
}
} else {
if (req < v[i] - 1) {
ans[i] = cur - (v[i] - req - 1);
req = 0;
cur = ans[i] - 1;
} else {
req -= (v[i] - 1);
ans[i] = cur;
cur = ans[i] - 1;
}
}
}
if (!f)
cout << -1;
else {
for (long long i = 0; i < m; i++) cout << ans[i] << " ";
}
}
int32_t main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed;
cerr.tie(NULL);
cout.precision(20);
long long t = 1;
long long ctr = 0;
while (t--) {
solve(ctr + 1);
ctr++;
}
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int maxn = 301;
int cl[maxn][maxn], cr[maxn][maxn], cd[maxn][maxn], cu[maxn][maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, t, tp, tu, td;
cin >> n >> m >> t >> tp >> tu >> td;
vector<vector<int>> gr(n + 1, vector<int>(m + 1));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> gr[i][j];
}
}
auto calc = [&](int i1, int j1, int i2, int j2) {
if (gr[i1][j1] == gr[i2][j2]) return tp;
if (gr[i1][j1] < gr[i2][j2]) return tu;
return td;
};
for (int i = 1; i <= n; i++) {
cl[i][1] = 0;
cr[i][1] = 0;
for (int j = 2; j <= m; j++) {
cl[i][j] = cl[i][j - 1] + calc(i, j, i, j - 1);
cr[i][j] = cr[i][j - 1] + calc(i, j - 1, i, j);
}
}
for (int j = 1; j <= m; j++) {
cu[1][j] = 0;
cd[1][j] = 0;
for (int i = 2; i <= n; i++) {
cu[i][j] = cu[i - 1][j] + calc(i, j, i - 1, j);
cd[i][j] = cd[i - 1][j] + calc(i - 1, j, i, j);
}
}
int ans = -1, ai1 = 1, aj1 = 1, ai2 = n, aj2 = n;
for (int i = 1; i <= n; i++) {
for (int i2 = i + 2; i2 <= n; i2++) {
auto getTot = [&](int j) {
return cr[i][j] + cl[i2][j] + cd[i2][j] - cd[i][j];
};
auto getVal = [&](int j) { return cu[i2][j] - cu[i][j]; };
set<pair<int, int>> sp;
int offset = 0;
for (int j = 3; j <= m; j++) {
sp.insert({getTot(j), j});
}
for (int j = 1; j < m - 1; j++) {
int val = getVal(j) + offset;
pair<int, int> p = {t - val, 0};
auto it = sp.lower_bound(p);
if (it != sp.end()) {
int anst = val + it->first;
if (ans == -1 || abs(anst - t) < abs(ans - t)) {
ans = anst;
ai1 = i, aj1 = j, ai2 = i2, aj2 = it->second;
}
}
if (it != sp.begin()) {
it--;
int anst = val + it->first;
if (ans == -1 || abs(anst - t) < abs(ans - t)) {
ans = anst;
ai1 = i, aj1 = j, ai2 = i2, aj2 = it->second;
}
}
sp.erase({getTot(j + 2), j + 2});
offset -= calc(i, j, i, j + 1) + calc(i2, j + 1, i2, j);
}
}
}
cout << ai1 << ' ' << aj1 << ' ' << ai2 << ' ' << aj2;
return 0;
}
| 15
|
#include <bits/stdc++.h>
#define N 100005
using namespace std;
#define putchar(c) cout << c
template <typename T>
void read(T &a)
{
cin >> a;
// T x = 0,f = 1;
// char ch = getchar();
// while (ch < '0' || ch > '9')
// {
// if (ch == '-') f = -1;
// ch = getchar();
// }
// while (ch >= '0' && ch <= '9')
// {
// x = (x << 1) + (x << 3) + (ch ^ 48);
// ch = getchar();
// }
// a = x * f;
}
template <typename T>
void write(T x)
{
cout << x;
// if (x < 0) putchar('-'),x = -x;
// if (x < 10) return (void) putchar(x + '0');
// write(x / 10);
// putchar(x % 10 + '0');
}
template <typename T>
void writeln(T x)
{
write(x);
putchar('\n');
}
template <typename T>
void writes(T x)
{
write(x);
putchar(' ');
}
template <typename T,typename... Args>
void read(T &maxx,Args &... args)
{
read(maxx);
read(args...);
}
template <typename T,typename... Args>
void writeln(T maxx,Args ... args)
{
writes(maxx);
writes(args...);
putchar('\n');
}
const int B = 300;
int n,q,a[N],num,bl[N],vis[N];
std::vector<int> v;
struct Block
{
int f[B],lazy,flag,cnt,L,R;
void update()
{
flag = 1;
for (int i = L; i <= R; i++)
{
if (bl[i] != bl[a[i]]) f[i - L] = i;
else f[i - L] = f[a[i] - L],flag = 0;
}
}
void update(int l,int r,int x)
{
for (int i = l; i <= r; i++)
a[i] = i == 1 ? 0 : max(a[i] - x,1);
update();
}
void update(int x)
{
if (flag) lazy += x;
else update(L,R,x);
}
}T[(N - 1) / B + 5];
void update(int l,int r,int x)
{
if (bl[l] == bl[r])
{
T[bl[l]].update(l,r,x);
return ;
}
T[bl[l]].update(l,T[bl[l]].R,x);
for (int i = bl[l] + 1; i < bl[r]; i++)
T[i].update(x);
T[bl[r]].update(T[bl[r]].L,r,x);
// cout << l << ' ' << r << ' ' << x << endl;
// cout << '0' << ' ';
// for (int i = 2; i <= n; i++)
// cout << max(a[i] - T[bl[i]].lazy,1) << ' ';
// cout << endl;
}
void clear()
{
for (int i = 0; i < v.size(); i++)
vis[v[i]] = 0;
v.clear();
}
int query(int x,int y)
{
// cout << '0' << ' ';
// for (int i = 2; i <= n; i++)
// cout << max(a[i] - T[bl[i]].lazy,1) << ' ';
// cout << endl;
while (T[bl[x]].f[x - T[bl[x]].L] != T[bl[y]].f[y - T[bl[y]].L])
{
if (bl[x] < bl[y]) swap(x,y);
// cout << x << ' ' << T[bl[x]].f[x - T[bl[x]].L] << endl;
x = (T[bl[x]].f[x - T[bl[x]].L] == 1) ? 0 : max(a[T[bl[x]].f[x - T[bl[x]].L]] - T[bl[x]].lazy,1);
}
int qaq = (T[bl[x]].f[x - T[bl[x]].L] == 1) ? 0 : max(a[T[bl[x]].f[x - T[bl[x]].L]] - T[bl[x]].lazy,1);
while (x != qaq)
{
assert(x != qaq);
vis[x] = 1;
v.push_back(x);
x = (x == 1) ? 0 : max(a[x] - T[bl[x]].lazy,1);
}
while (y != qaq)
{
if (vis[y]) return clear(),y;
y = (y == 1) ? 0 : max(a[y] - T[bl[y]].lazy,1);
}
}
signed main()
{
ios_base::sync_with_stdio(0), cin.tie(0);
read(n,q);
for (int i = 2; i <= n; i++) read(a[i]);
num = (n - 1) / B + 1;
for (int i = 1; i <= num; i++)
{
T[i].L = (i - 1) * B + 1;
T[i].R = min(i * B,n);
T[i].cnt = i * B - (i - 1) * B;
T[i].flag = T[i].lazy = 0;
for (int j = T[i].L; j <= T[i].R; j++)
bl[j] = i;
}
for (int i = 1; i <= num; i++)
T[i].update();
while (q--)
{
int opt;
read(opt);
if (opt == 1)
{
int l,r,x;
read(l,r,x);
update(l,r,x);
}
if (opt == 2)
{
int u,v;
read(u,v);
writeln(query(u,v));
}
}
// cerr << (double) clock() / CLOCKS_PER_SEC << endl;
return 0;
}
| 26
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
char ch[3] =
{
0,
},
cm[3] = {
0,
};
scanf("%d", &n);
scanf("%2s:%2s", ch, cm);
int h = atoi(ch);
int m = atoi(cm);
if (n == 12) {
if (h == 0) {
ch[1] = '1';
} else if (h > 12) {
if (ch[1] != '0')
ch[0] = '0';
else
ch[0] = '1';
}
} else {
if (h >= 24) {
ch[0] = '0';
}
}
if (m >= 60) {
cm[0] = '0';
}
printf("%2s:%2s\n", ch, cm);
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a, b, c;
for (int i = 1; i <= n; i++) {
cin >> a >> b >> c;
printf("%lld\n", a + b + c - 1);
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, a, b;
cin >> n >> a >> b;
string pre = "abcdefghijklmnopqrstuvwxyz";
string p = pre.substr(0, b), ans;
while (ans.size() <= n) {
ans += p;
}
ans = ans.substr(0, n);
cout << ans << "\n";
}
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, arr[100000];
cin >> N;
for (int i = 0; i < N; cin >> arr[i++])
;
sort(arr, arr + N);
int res = 0;
for (int i = 0; i < N; i++) {
if (arr[i] != arr[0] && arr[i] != arr[N - 1]) {
res++;
}
}
cout << res;
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const long long inf = 1e18;
const int mo = 998244353;
int n;
long long a0;
long long a[N], p[N];
int s[N], ls[N];
void f(int x, long long y) {
for (; x <= n; x += x & -x) a[x] += y;
}
long long q(int x) {
long long r = a0;
for (; x; x -= x & -x) r += a[x];
return r;
}
int main() {
int m;
scanf("%d", &n);
for (auto i = (1); i <= (n); ++i) scanf("%d", &s[i]);
for (auto i = (1); i <= (n); ++i) scanf("%lld", &p[i]);
scanf("%d", &m);
int LS = 0;
for (auto i = (0); i <= (n); ++i) ls[i] = -1;
for (auto i = (1); i <= (m); ++i) {
int x;
scanf("%d", &x);
ls[x] = LS;
LS = x;
}
f(1, inf);
for (auto i = (1); i <= (n); ++i) {
long long res;
if (~ls[s[i]]) res = q(ls[s[i]]);
a0 += p[i];
if (p[i] > 0) f(s[i], -p[i]);
if (~ls[s[i]]) {
long long nw = q(s[i]);
if (res < nw) {
f(s[i], res - nw);
if (s[i] < n) f(s[i] + 1, nw - res);
}
}
}
long long ans = q(LS);
if (ans >= inf / 2)
printf("NO\n");
else
printf("YES\n%lld\n", ans);
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
double a, d, x, y;
double calc() {
double tt = 0.0000000;
double s1 = y * y / (2.000000 * a);
if (s1 <= d) {
double rem = d - s1;
tt = y / a;
tt += rem / y;
return tt;
}
return (sqrt((2 * d) / a));
}
int main() {
int n;
scanf("%d", &n);
scanf("%lf%lf", &a, &d);
double val, maxm = -1.000000;
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &x, &y);
val = x + calc();
if (maxm > val)
val = maxm;
else
maxm = val;
printf("%.9lf\n", val);
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1001000;
long long a[N], b[N], c[N], sum[N];
struct Node {
long long l, r, num;
};
Node tree[4 * N];
map<int, int> m1, m2;
void build(long long l, long long r, long long o) {
tree[o].l = l, tree[o].r = r;
tree[o].num = 0;
if (l == r) return;
long long mid = (l + r) >> 1;
build(l, mid, o << 1);
build(mid + 1, r, o + o + 1);
}
void update(long long t, long long o) {
if (tree[o].l == tree[o].r && tree[o].l == t) {
tree[o].num++;
return;
}
long long mid = (tree[o].l + tree[o].r) >> 1;
if (t > mid)
update(t, o + o + 1);
else
update(t, o + o);
tree[o].num = tree[o + o].num + tree[o + o + 1].num;
}
long long query(long long l, long long r, long long o) {
if (tree[o].l == l && tree[o].r == r) {
return tree[o].num;
}
long long mid = (tree[o].l + tree[o].r) >> 1;
if (r <= mid)
return query(l, r, o + o);
else if (l > mid)
return query(l, r, o + o + 1);
else
return query(l, mid, o * 2) + query(mid + 1, r, o * 2 + 1);
}
int main() {
long long n;
while (~scanf("%lld", &n)) {
for (long long i = 0; i < n; i++) scanf("%lld", &a[i]);
long long cnt = 1;
for (long long i = 0; i < n; i++) {
if (!m1[a[i]]) m1[a[i]] = cnt++;
a[i] = m1[a[i]];
}
cnt = 0;
memset(sum, 0, sizeof(sum));
for (long long i = 0; i < n; i++) {
sum[a[i]]++;
b[i] = sum[a[i]];
cnt = max(cnt, b[i]);
}
memset(sum, 0, sizeof(sum));
for (long long i = n - 1; i >= 0; i--) {
sum[a[i]]++;
c[i] = sum[a[i]];
}
build(1, cnt, 1);
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (c[i] < cnt) ans += query(c[i] + 1, cnt, 1);
update(b[i], 1);
}
printf("%lld\n", ans);
m1.clear();
m2.clear();
}
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 45;
const long long maxk = 205;
double dp[maxk][maxn][maxn];
long long a[maxn];
long long n, x;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> x;
double N = n * (n + 1) / 2;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++)
if (i - j && i > j) dp[0][i][j] = 1;
for (long long i = 1; i <= x; i++) {
for (long long j = 0; j < n; j++)
for (long long k = 0; k < n; k++)
if (j - k)
for (long long l = 0; l < n; l++)
for (long long r = l; r < n; r++) {
long long j1 = j, k1 = k;
if (l <= j && j <= r) j1 = r - (j - l);
if (l <= k && k <= r) k1 = r - (k - l);
dp[i][j][k] += dp[i - 1][j1][k1] / N;
}
}
double res = 0;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++)
if (a[j] > a[i])
res += dp[x][i][j];
else
res += dp[x][j][i];
}
cout << fixed << setprecision(12) << res << '\n';
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h, t;
vector<vector<int> > g;
int sizes[100 * 1000];
int minht, maxht;
void init() {
scanf("%d %d %d %d", &n, &m, &h, &t);
g.resize(n);
for (int i = 0; i < m; ++i) {
int from, to;
scanf("%d %d", &from, &to);
--from, --to;
g[from].push_back(to);
g[to].push_back(from);
}
for (int i = 0; i < n; ++i) sizes[i] = g[i].size();
minht = min(h, t);
maxht = max(h, t);
}
int main() {
init();
int isAns = false;
int v1, v2;
for (int i = 0; i < n && !isAns; ++i) {
vector<bool> intersect(100 * 1000, false);
for (int c = 0; c < sizes[i]; ++c) intersect[g[i][c]] = true;
for (int j = 0; j < sizes[i] && !isAns; ++j) {
if (g[i][j] > i) {
v1 = i;
v2 = g[i][j];
int u1 = sizes[v1] - 1;
int u2 = sizes[v2] - 1;
if (min(u1, u2) < minht || max(u1, u2) < maxht) continue;
int k = 0;
for (int r = 0; r < sizes[v2]; ++r) k += intersect[g[v2][r]];
if (u1 + u2 - k < h + t) continue;
if (h < t != u1 < u2) swap(v1, v2);
isAns = true;
}
}
}
if (!isAns)
printf("NO\n");
else {
printf("YES\n%d %d\n", v1 + 1, v2 + 1);
vector<int> inter(100 * 1000, 0);
vector<bool> isUse(100 * 1000, false);
for (int c = 0; c < sizes[v1]; ++c) ++inter[g[v1][c]];
for (int r = 0; r < sizes[v2]; ++r) ++inter[g[v2][r]];
int k = 0;
for (int j = 0; j < sizes[v1] && k < h; ++j)
if (inter[g[v1][j]] < 2 && g[v1][j] != v2)
printf("%d ", g[v1][j] + 1), ++k;
for (int j = 0; j < sizes[v1] && k < h; ++j)
if (inter[g[v1][j]] == 2 && g[v1][j] != v2)
printf("%d ", g[v1][j] + 1), ++k, isUse[g[v1][j]] = true;
printf("\n");
k = 0;
for (int i = 0; i < g[v2].size() && k < t; ++i)
if (!isUse[g[v2][i]] && g[v2][i] != v1) printf("%d ", g[v2][i] + 1), ++k;
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
ios_base::sync_with_stdio(false);
string a, b;
cin >> a >> b;
int i, m = 0, n = 0, k, j;
for (i = 0; i < a.length(); i++) {
if (a[i] != b[i]) {
if (a[i] == '1')
m++;
else
n++;
}
}
if ((m - n) % 2)
cout << "impossible" << endl;
else {
if (m == max(m, n)) {
k = (m - n) / 2;
j = 0;
for (i = 0; i < a.length(); i++) {
if (a[i] == b[i])
cout << a[i];
else {
if (a[i] == '1' && j < k) {
cout << a[i];
j++;
} else {
cout << '0';
}
}
}
} else {
k = (n - m) / 2;
j = 0;
for (i = 0; i < a.length(); i++) {
if (a[i] == b[i])
cout << a[i];
else {
if (b[i] == '1' && j < k) {
cout << b[i];
j++;
} else {
cout << '0';
}
}
}
}
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if ((n & (n - 1)) == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int inp;
int num = 0, sum = 0;
scanf("%d", &inp);
n = inp * 2;
for (int i = 0; i < n; ++i) {
int x;
scanf("%*d%*c%d", &x);
sum += x;
if (x == 0) num++;
}
int ans = INT_MAX;
for (int i = 0; i <= inp; ++i) {
if (inp - i > num) continue;
if (i > (n - num)) continue;
int lans = abs(1000 * i - sum);
ans = min(ans, lans);
}
printf("%d.%03d\n", ans / 1000, ans % 1000);
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
struct matrix {
int a[130][130];
};
struct matrix g, f, e;
struct unit {
int x;
vector<int> w;
};
struct unit a[30];
long long n;
int m, mod = 12345, ans;
int b[30], c[30];
bool cmp(struct unit aa, struct unit bb) { return aa.x > bb.x; }
int gcd(int i, int j) {
if (j == 0)
return i;
else
return gcd(j, i % j);
}
matrix operator*(matrix aa, matrix bb) {
matrix ret;
int i, j, k;
memset(ret.a, 0, sizeof(ret.a));
for (i = 0; i <= 123; i++)
for (k = 0; k <= 123; k++)
if (aa.a[i][k]) {
for (j = 0; j <= 123; j++)
ret.a[i][j] = (ret.a[i][j] + aa.a[i][k] * bb.a[k][j] % mod) % mod;
}
return ret;
}
matrix fpow(long long j) {
matrix ret = e, t;
t = g;
while (j > 0) {
if (j & 1) ret = ret * t;
t = t * t;
j /= 2;
}
return ret;
}
int main() {
int i, j, x, s, s1, flag;
char ch[2];
for (i = 0; i <= 123; i++) e.a[i][i] = 1;
scanf("%I64d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%s%d", ch, &x);
if (a[ch[0] - 64].x == 0)
a[ch[0] - 64].x = x;
else
a[ch[0] - 64].x = a[ch[0] - 64].x * x / gcd(a[ch[0] - 64].x, x);
a[ch[0] - 64].w.push_back(x);
}
sort(a + 1, a + 26 + 1, cmp);
for (i = 1; i <= 26; i++)
if (a[i].x == 0) {
m = i - 1;
break;
}
for (i = m; i >= 1; i--) {
b[i] = 1;
for (j = i + 1; j <= m; j++) b[i] += (a[j].x - 1) * b[j];
}
while (c[0] == 0) {
s = 0;
for (i = 1; i <= m; i++) s += c[i] * b[i];
for (i = 1; i <= m; i++) {
if (c[i] == a[i].x - 1)
s1 = s - b[i] * (a[i].x - 1);
else
s1 = s + b[i];
g.a[s][s1]++;
}
i = m;
while (c[i] == a[i].x - 1) {
c[i] = 0;
i--;
}
c[i]++;
}
f = fpow(n);
memset(c, 0, sizeof(c));
while (c[0] == 0) {
s = 0;
flag = 1;
for (i = 1; i <= m; i++) s += c[i] * b[i];
for (i = 1; i <= m; i++) {
flag = 0;
for (j = 0; j < a[i].w.size(); j++)
if (c[i] % a[i].w[j] == 0) {
flag = 1;
break;
}
if (!flag) break;
}
if (flag) ans = (ans + f.a[0][s]) % mod;
i = m;
while (c[i] == a[i].x - 1) {
c[i] = 0;
i--;
}
c[i]++;
}
cout << ans << endl;
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
struct node {
int to;
long long dis;
node() {}
node(int a, long long b) : to(a), dis(b) {}
};
vector<node> g[maxn];
int dep[maxn], dfs[maxn], sum, tot[maxn], f[maxn], d[maxn][30], st;
long long dis[maxn], ans;
int lca(int x, int y) {
st = 18;
if (dep[x] < dep[y]) swap(x, y);
while (dep[x] != dep[y]) {
if (dep[d[x][st]] >= dep[y]) x = d[x][st];
st--;
}
st = 18;
if (x == y) return x;
while (1) {
if (f[x] == f[y]) return f[x];
if (d[x][st] != d[y][st]) x = d[x][st], y = d[y][st];
st--;
}
}
int fa[maxn], son[maxn][2], num[maxn], root, head, tail;
void rotate(int p) {
int x = fa[p], cnt = p == son[x][1], y = son[p][cnt ^ 1], z = fa[x];
if (y != 0) fa[y] = x;
if (x == son[z][0]) son[z][0] = p;
if (x == son[z][1]) son[z][1] = p;
fa[x] = p, son[x][cnt] = y, fa[p] = z, son[p][cnt ^ 1] = x;
}
void splay(int p) {
while (fa[p] != 0) {
int x = fa[p], y = fa[x];
if (y == 0)
rotate(p);
else if ((p == son[x][0]) ^ (x == son[y][0]))
rotate(p), rotate(p);
else
rotate(x), rotate(p);
}
root = p;
}
int pre(int x) {
if (son[x][0] == 0) return 0;
for (int i = son[x][0];; i = son[i][1])
if (son[i][1] == 0) return i;
}
int suf(int x) {
if (son[x][1] == 0) return 0;
for (int i = son[x][1];; i = son[i][0])
if (son[i][0] == 0) return i;
}
long long dist(int x, int y) { return dis[x] + dis[y] - dis[lca(x, y)] * 2; }
void Insert(int x, int p) {
if (root == 0) {
root = x, num[x] = p, head = tail = x;
return;
}
for (int i = root;; i = son[i][p > num[i]])
if (son[i][p > num[i]] == 0) {
son[i][p > num[i]] = x;
fa[x] = i, num[x] = p;
splay(x);
break;
}
int a = pre(x), b = suf(x);
if (a == 0 && b != 0)
ans += dist(x, b) + dist(x, tail) - dist(b, tail), head = x;
else if (a != 0 && b == 0)
ans += dist(x, a) + dist(x, head) - dist(a, head), tail = x;
else if (a != 0 && b != 0)
ans += dist(x, a) + dist(x, b) - dist(a, b);
}
void Delete(int x) {
splay(x);
int a = pre(x), b = suf(x);
if (a == 0 && b != 0)
ans -= dist(x, b) + dist(x, tail) - dist(b, tail), head = b;
else if (a != 0 && b == 0)
ans -= dist(x, a) + dist(x, head) - dist(a, head), tail = a;
else if (a != 0 && b != 0)
ans -= dist(x, a) + dist(x, b) - dist(a, b);
if (son[x][0] == 0 && son[x][1] == 0)
root = head = tail = 0;
else if (son[x][0] == 0 && son[x][1] != 0)
root = son[x][1], fa[root] = 0;
else if (son[x][0] != 0 && son[x][1] == 0)
root = son[x][0], fa[root] = 0;
else {
fa[son[x][0]] = 0, son[a][1] = son[x][1], fa[son[x][1]] = a;
splay(a);
}
son[x][0] = son[x][1] = 0;
}
void fd(int x, int cur, long long cnt, int father) {
dep[x] = cur, dis[x] = cnt, dfs[x] = ++sum, f[x] = father, d[x][0] = f[x];
for (int i = 1; i <= 18; i++) d[x][i] = d[d[x][i - 1]][i - 1];
for (int i = 0; i < g[x].size(); i++)
if (g[x][i].to != f[x]) fd(g[x][i].to, cur + 1, cnt + g[x][i].dis, x);
}
int main() {
int n, t, x, y, a, b;
long long c;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d %I64d", &a, &b, &c);
g[a].push_back(node(b, c));
g[b].push_back(node(a, c));
}
fd(1, 1, 0, 0);
scanf("%d\n", &t);
while (t--) {
char f;
scanf("%c", &f);
if (f == '+') {
scanf("%d\n", &x);
Insert(x, sum - dfs[x] + 1);
} else if (f == '-') {
scanf("%d\n", &x);
Delete(x);
} else {
printf("%I64d\n", ans / 2);
getchar();
}
}
return 0;
}
| 23
|
#include <bits/stdc++.h>
using namespace std;
pair<long long, int> dp[66][2][2];
pair<long long, int> getmin(long long L, long long R, int b, bool ig, bool il) {
if (b == -1) {
return make_pair(0, 0);
}
if (dp[b][ig][il].second != -1) return dp[b][ig][il];
pair<long long, int> answer = make_pair(0, -1);
for (int bb = 0; bb <= 1; bb++) {
if (bb == 0 && !ig && ((L >> b) & 1)) {
continue;
}
if (bb == 1 && !il && !((R >> b) & 1)) {
continue;
}
bool nig = (ig || (bb == 1 && !((L >> b) & 1)));
bool nil = (il || (bb == 0 && ((R >> b) & 1)));
pair<long long, int> curr = getmin(L, R, b - 1, nig, nil);
if (curr.second + bb > answer.second) {
answer = make_pair((1ll << b) * bb + curr.first, bb + curr.second);
}
}
return dp[b][ig][il] = answer;
}
int main() {
int T;
cin >> T;
for (int t = 1; t <= T; t++) {
long long L, R;
cin >> L >> R;
for (int i = 0; i <= 61; i++)
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 1; k++) dp[i][j][k] = make_pair(-1, -1);
pair<long long, int> answer = getmin(L, R, 60, false, false);
cout << answer.first << endl;
}
}
| 9
|
#include <bits/stdc++.h>
int N, res;
int v[1000010];
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
int x;
scanf("%d", &x);
++v[x];
}
for (int i = 0; i < 1000010 - 1; ++i) {
res += (v[i] & 1);
v[i + 1] += (v[i] >> 1);
}
res += __builtin_popcount(v[1000010 - 1]);
printf("%d\n", res);
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int G = 3;
#pragma GCC target("avx")
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("unroll-loops")
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x * f;
}
int n, m;
long long t;
int fac[600040], inv[600040];
int qpow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = (long long)ans * a % mod;
a = (long long)a * a % mod;
b >>= 1;
}
return ans;
}
const int invG = qpow(G, mod - 2);
int f[600040], g[600040], a[600040];
int tr[600040];
void NTT(int *f, int flag, int n) {
for (int i = 0; i < n; ++i) {
if (i < tr[i]) swap(f[i], f[tr[i]]);
}
for (int p = 2; p <= n; p <<= 1) {
int len = (p >> 1);
int wn = qpow(flag ? G : invG, (mod - 1) / p);
for (int k = 0; k < n; k += p) {
int buf = 1;
for (int i = k; i < k + len; ++i) {
int tmp = (long long)f[i + len] * buf % mod;
f[i + len] = (f[i] - tmp + mod) % mod;
f[i] = (f[i] + tmp) % mod;
buf = (long long)buf * wn % mod;
}
}
}
if (!flag) {
int invn = qpow(n, mod - 2);
for (int i = 0; i < n; ++i) {
f[i] = (long long)f[i] * invn % mod;
}
}
}
void init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; ++i) {
fac[i] = (long long)fac[i - 1] * i % mod;
}
inv[n] = qpow(fac[n], mod - 2);
for (int i = n - 1; i >= 0; --i) {
inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
}
}
int C(int n, int m) {
return (long long)fac[n] * inv[m] % mod * inv[n - m] % mod;
}
void Solve(int l, int r) {
if (l + 1 == r) {
if (!l) return;
f[l] = (qpow(l, m) - (long long)f[l] * fac[l] % mod + mod) % mod;
return;
}
int mid = (l + r) >> 1;
Solve(l, mid);
int lim = r - l;
for (int i = 0; i < lim; ++i) {
tr[i] = ((tr[i >> 1] >> 1) | ((i & 1) ? lim >> 1 : 0));
}
static int w[600040];
for (int i = 0; i < lim; ++i) {
g[i] = inv[i];
}
for (int i = l; i < mid; ++i) {
w[i - l] = (long long)f[i] * inv[i] % mod;
}
for (int i = mid; i < r; ++i) {
w[i - l] = 0;
}
NTT(g, 1, lim), NTT(w, 1, lim);
for (int i = 0; i < lim; ++i) {
g[i] = (long long)g[i] * w[i] % mod;
}
NTT(g, 0, lim);
for (int i = mid; i < r; ++i) f[i] = (f[i] + g[i - l]) % mod;
Solve(mid, r);
}
int main() {
m = read(), t = read();
if (t >= m) {
printf("0\n");
return 0;
}
init(m);
n = m - t;
if (n == m) {
printf("%d\n", fac[m]);
return 0;
}
int lim = 1;
while (lim < n + 1) lim <<= 1;
Solve(0, lim);
printf("%d\n", 2LL * f[n] % mod * C(m, n) % mod);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int A, B, K, Cnt[1 << 20];
bool Prime[1 << 20];
vector<int> Primes;
int main(void) {
for (int i = 2; i <= 1000000; i++) {
Cnt[i] = Cnt[i - 1];
if (Prime[i]) continue;
for (int j = i; j <= 1000000; j += i) Prime[j] = true;
Primes.push_back(i);
Cnt[i]++;
}
scanf("%d %d %d", &A, &B, &K);
if (Cnt[B] - Cnt[A - 1] < K) {
puts("-1");
return 0;
}
int L = 1, R = B - A + 1, Sol = R;
while (L <= R) {
int M = (L + R) >> 1;
bool Ok = true;
for (int i = A; i + M - 1 <= B; i++)
Ok &= (Cnt[i + M - 1] - Cnt[i - 1] >= K);
if (Ok) {
if (M < Sol) Sol = M;
R = M - 1;
} else
L = M + 1;
}
printf("%d\n", Sol);
return 0;
}
| 8
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
struct Dinic {
static const int MXN = 100010;
struct Edge {
int v, f, re;
};
int n, s, t, level[MXN];
vector<Edge> E[MXN];
void init(int _n, int _s, int _t) {
n = _n;
s = _s;
t = _t;
for (int i = 0; i < n; i++) E[i].clear();
}
void add_edge(int u, int v, int f) {
E[u].push_back({v, f, (int)E[v].size()});
E[v].push_back({u, 0, (int)E[u].size() - 1});
}
bool BFS() {
for (int i = 0; i < n; i++) level[i] = -1;
queue<int> que;
que.push(s);
level[s] = 0;
while (!que.empty()) {
int u = que.front();
que.pop();
for (auto &it : E[u]) {
if (it.f > 0 && level[it.v] == -1) {
level[it.v] = level[u] + 1;
que.push(it.v);
}
}
}
return level[t] != -1;
}
int DFS(int u, int nf) {
if (u == t) return nf;
int res = 0;
for (auto &it : E[u]) {
if (it.f > 0 && level[it.v] == level[u] + 1) {
int tf = DFS(it.v, min(nf, it.f));
res += tf;
nf -= tf;
it.f -= tf;
E[it.v][it.re].f += tf;
if (nf == 0) return res;
}
}
if (!res) level[u] = -1;
return res;
}
int flow(int res = 0) {
while (BFS()) res += DFS(s, 2147483647);
return res;
}
} flow;
string a[202];
int hid[202][202], vid[202][202];
int main() {
cin.tie(0), ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
int cid = 0;
for (int i = 0; i + 1 < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '#' && a[i + 1][j] == '#') {
hid[i][j] = ++cid;
}
}
}
int mid = cid;
for (int i = 0; i < n; i++) {
for (int j = 0; j + 1 < m; j++) {
if (a[i][j] == '#' && a[i][j + 1] == '#') {
vid[i][j] = ++cid;
}
}
}
flow.init(cid + 2, 0, cid + 1);
for (int i = 1; i <= mid; i++) flow.add_edge(flow.s, i, 1);
for (int i = mid + 1; i <= cid; i++) flow.add_edge(i, flow.t, 1);
for (int i = 0; i + 1 < n; i++) {
for (int j = 0; j < m; j++) {
if (hid[i][j]) {
if (j && vid[i][j - 1]) flow.add_edge(hid[i][j], vid[i][j - 1], 1);
if (j + 1 < m && vid[i][j]) flow.add_edge(hid[i][j], vid[i][j], 1);
if (j && vid[i + 1][j - 1])
flow.add_edge(hid[i][j], vid[i + 1][j - 1], 1);
if (j + 1 < m && vid[i + 1][j])
flow.add_edge(hid[i][j], vid[i + 1][j], 1);
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) ans += (a[i][j] == '#');
}
ans -= (cid - flow.flow());
cout << ans << "\n";
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
const int UNDEF = -1;
const int INF = 2000000000;
const long long INF64 = 4000000000000000000;
const double PI = 3.1415926535897932384626433832795;
const double EPS = 1e-12;
template <typename T>
T sqr(const T &x) {
return x * x;
}
template <typename T>
const string GetString(const T &val) {
ostringstream sout;
sout << val;
return sout.str();
}
namespace Ololo {
double x1, y1, r1;
double x2, y2, r2;
double xx1, yy1;
double FindMin(double a, double b, double (*F)(double)) {
while (fabs(a - b) >= EPS) {
double l = a + (b - a) / 3.0;
double r = b - (b - a) / 3.0;
if (F(l) > F(r))
a = l;
else
b = r;
}
return (a + b) / 2.0;
}
double F2(double alpha) {
double xx2 = x2 + r2 * cos(alpha);
double yy2 = y2 + r2 * sin(alpha);
return sqrt(sqr(xx1 - xx2) + sqr(yy1 - yy2));
}
double F1(double phi) {
xx1 = x1 + r1 * cos(phi);
yy1 = y1 + r1 * sin(phi);
double alpha = FindMin(0, 2 * PI, F2);
double xx2 = x2 + r2 * cos(alpha);
double yy2 = y2 + r2 * sin(alpha);
return sqrt(sqr(xx1 - xx2) + sqr(yy1 - yy2));
}
void Solve() {
cin >> x1 >> y1 >> r1;
cin >> x2 >> y2 >> r2;
double phi = FindMin(0, 2 * PI, F1);
xx1 = x1 + r1 * cos(phi);
yy1 = y1 + r1 * sin(phi);
double alpha = FindMin(0, 2 * PI, F2);
double xx2 = x2 + r2 * cos(alpha);
double yy2 = y2 + r2 * sin(alpha);
double r = sqrt(sqr(xx1 - xx2) + sqr(yy1 - yy2)) / 2.0;
printf("%.15f\n", r);
}
} // namespace Ololo
int main() {
Ololo::Solve();
return 0;
}
| 10
|
#include <bits/stdc++.h>
int n, m;
char map[200][200];
int st[200], en[200];
int abs(int x) { return x > 0 ? x : -x; }
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a > b ? b : a; }
int main() {
while (scanf("%d%d", &n, &m) == 2) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf(" %c", &map[i][j]);
map[1][1] = 'W';
int cnt = 0;
for (int i = 1; i <= n; i++) {
for (st[i] = 1; st[i] <= m; st[i]++)
if (map[i][st[i]] == 'W') break;
for (en[i] = m; en[i] >= 1; en[i]--)
if (map[i][en[i]] == 'W') break;
if (st[i] == m + 1 && en[i] == 0) {
cnt++;
if (i % 2) {
st[i] = en[i] = st[i - 1];
} else
st[i] = en[i] = en[i - 1];
} else
cnt = 0;
}
for (int i = 1; i < n; i++)
if (i % 2) {
en[i] = max(en[i], en[i + 1]);
en[i + 1] = max(en[i], en[i + 1]);
} else {
st[i] = min(st[i], st[i + 1]);
st[i + 1] = min(st[i], st[i + 1]);
}
int ans = 0;
for (int i = 1; i <= n; i++) ans += en[i] - st[i];
printf("%d\n", ans + n - 1 - cnt);
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[2 * 100 * 1000 + 5];
vector<int> dpMax, dpMin, leaves;
void dfs(int node, int l) {
if (G[node].empty()) {
dpMax[node] = dpMin[node] = leaves[node] = 1;
return;
}
for (auto v : G[node]) dfs(v, 1 - l);
int sum = 0, sum2 = 0, minn = 3e5, gminn = 3e5;
for (auto v : G[node]) {
leaves[node] += leaves[v];
sum += leaves[v] - dpMax[v] + 1;
sum2 += leaves[v] - dpMin[v];
minn = min(minn, leaves[v] - dpMax[v]);
gminn = min(gminn, dpMin[v]);
}
if (l == 0) {
dpMax[node] = leaves[node] - minn;
dpMin[node] = leaves[node] - sum2;
} else {
dpMax[node] = leaves[node] - (sum - 1);
dpMin[node] = gminn;
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
}
dpMax = vector<int>(n + 1, 0);
dpMin = vector<int>(n + 1, 0);
leaves = vector<int>(n + 1, 0);
dfs(1, 0);
cout << dpMax[1] << " " << dpMin[1] << "\n";
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long int l = s.size(), lasta = 0, lastabefb = 0, i, ans = 0;
long long int arr[l + 1];
arr[0] = 0;
for (i = 0; i < l; i++) {
if (s[i] == 'a') {
arr[i + 1] = (1 + arr[lasta] + arr[lastabefb]) % 1000000007;
lasta = i + 1;
ans = arr[i + 1];
} else if (s[i] == 'b') {
lastabefb = lasta;
}
}
cout << (ans + 1000000007) % 1000000007;
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
struct wall {
int no, x, t;
friend bool operator<(wall a, wall b) {
if (a.x != b.x) return a.x < b.x;
return a.t < b.t;
}
} w[110000 << 1];
struct Point {
int x, y, type, no;
friend bool operator<(Point a, Point b) { return a.y - a.x < b.y - b.x; }
} p[110000 * 5];
int tot;
int L[110000], R[110000], T[110000];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
bool vis[110000];
int ans[110000];
int main() {
int n, m, i, k, now, cnt;
scanf("%d%d", &m, &n);
for (i = 1; i <= n; i++) {
scanf("%d%d%d", L + i, R + i, T + i);
w[i << 1].no = w[i << 1 | 1].no = i;
w[i << 1].x = L[i], w[i << 1 | 1].x = R[i];
w[i << 1].t = w[i << 1 | 1].t = T[i];
}
sort(w + 2, w + n + n + 2);
q.push(pair<int, int>(0x7f7f7f7f, 0));
vis[0] = 1;
for (i = 2; i <= n + n + 1; i++) {
if (!vis[w[i].no]) {
while (!q.empty() && !vis[q.top().second]) q.pop();
if (!q.empty() && w[i].t < q.top().first) {
tot++;
p[tot].x = w[i].x;
p[tot].y = q.top().first;
p[tot].type = 1;
tot++;
p[tot].x = w[i].x;
p[tot].y = w[i].t;
p[tot].type = -1;
}
q.push(pair<int, int>(w[i].t, w[i].no));
vis[w[i].no] = 1;
} else {
while (!q.empty() && !vis[q.top().second]) q.pop();
if (q.top().second == w[i].no) {
q.pop();
while (!q.empty() && !vis[q.top().second]) q.pop();
tot++;
p[tot].x = w[i].x;
p[tot].y = w[i].t;
p[tot].type = 1;
tot++;
p[tot].x = w[i].x;
p[tot].y = q.top().first;
p[tot].type = -1;
}
vis[w[i].no] = 0;
}
}
for (i = 1; i <= m; i++) {
scanf("%d", &k);
tot++;
p[tot].type = 0;
p[tot].x = 0;
p[tot].y = k;
p[tot].no = i;
}
sort(p + 1, p + tot + 1);
for (i = 1, now = 0, cnt = 0; i <= tot; i++) {
now += cnt * (p[i].y - p[i].x - p[i - 1].y + p[i - 1].x);
cnt += p[i].type;
if (!p[i].type) ans[p[i].no] = now;
}
for (i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
int main() {
int N, K;
string S;
cin >> N >> K;
cin >> S;
set<char> second;
vector<char> V;
for (int i = 0; i < (int)S.size(); i++) {
second.insert(S[i]);
}
for (set<char>::iterator it = second.begin(); it != second.end(); it++) {
V.push_back(*it);
}
if (N < K) {
for (int i = 0; i < N; i++) {
cout << S[i];
}
for (int i = 0; i < K - N; i++) {
cout << V[0];
}
cout << endl;
} else {
vector<char> ans;
for (int i = 0; i < K; i++) {
ans.push_back(S[i]);
}
for (int i = K - 1; i >= 0; i--) {
vector<char>::iterator it;
it = upper_bound(V.begin(), V.end(), ans[i]);
if (it == V.end()) {
continue;
} else {
ans[i] = *it;
for (int j = i + 1; j < K; j++) {
ans[j] = V[0];
}
break;
}
}
for (int i = 0; i < K; i++) {
cout << ans[i];
}
cout << endl;
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
long long max(long long x, long long y) { return x > y ? x : y; }
long long min(long long x, long long y) { return x < y ? x : y; }
using namespace std;
const long long INF = 1e18 + 14;
const long long N = 4e6 + 9;
string s;
long long n, m;
long long op[N], cl[N];
struct node {
long long g = 0, c = 0, o = 0;
} t[N];
void build(long long at, long long l, long long r) {
if (l == r) {
if (s[l] == '(')
t[at].o = 1;
else
t[at].c = 1;
return;
}
long long mid = (l + r) / 2;
build(at * 2 + 1, l, mid);
build(at * 2 + 2, mid + 1, r);
t[at].g =
t[at * 2 + 1].g + t[at * 2 + 2].g + min(t[at * 2 + 1].o, t[at * 2 + 2].c);
t[at].o = max(0, t[at * 2 + 1].o - t[at * 2 + 2].c) + t[at * 2 + 2].o;
t[at].c = max(0, t[at * 2 + 2].c - t[at * 2 + 1].o) + t[at * 2 + 1].c;
}
long long query(long long at, long long l, long long r, long long L,
long long R) {
if (l == L && r == R) return t[at].g;
long long mid = (L + R) / 2, lres = 0, rres = 0;
if (l > mid) return query(at * 2 + 2, l, r, mid + 1, R);
if (r <= mid) return query(at * 2 + 1, l, r, L, mid);
lres = query(at * 2 + 1, l, mid, L, mid);
rres = query(at * 2 + 2, mid + 1, r, mid + 1, R);
long long ores = (op[mid] - op[l - 1]) - lres;
long long cres = (cl[r] - cl[mid]) - rres;
return lres + rres + min(ores, cres);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s;
n = s.size();
build(0, 0, n - 1);
for (long long i = 0; i < n; i++) {
op[i] = op[i - 1] + (s[i] == '(');
cl[i] = cl[i - 1] + (s[i] == ')');
}
cin >> m;
for (long long i = 0; i < m; i++) {
long long l, r;
cin >> l >> r;
l--;
r--;
cout << query(0, l, r, 0, n - 1) * 2 << endl;
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("date.in");
ofstream fout("date.out");
struct data {
long long nr;
long long val;
long long parcurs;
} curent, adaugare;
bool operator<(data a, data b) {
if (a.parcurs == b.parcurs) return a.val > b.val;
return a.parcurs < b.parcurs;
}
priority_queue<data> heap;
unsigned long long vx[100];
unsigned long long vy[100];
const unsigned long long val_max = 200000000000000000;
unsigned long long distanta(long long a, long long b, long long c,
long long d) {
return abs(a - c) + abs(b - d);
}
unsigned long long m[100][100];
bool verificat[100];
unsigned long long dijkstra(long long n, long long t) {
int i, max1 = 0, sem;
curent.val = 0;
curent.nr = 0;
curent.parcurs = 0;
heap.push(curent);
while (!heap.empty()) {
curent = heap.top();
heap.pop();
verificat[curent.nr] = 1;
sem = 0;
for (i = 1; i <= n; i++)
if (curent.val + m[curent.nr][i] <= t) {
sem = 1;
adaugare.nr = i;
if (verificat[i] == 0)
adaugare.parcurs = curent.parcurs + 1;
else
adaugare.parcurs = curent.parcurs;
adaugare.val = curent.val + m[curent.nr][i];
heap.push(adaugare);
}
if (sem == 0) return curent.parcurs;
}
return 0;
}
unsigned long long dist_i_j(unsigned long long i, unsigned long long j) {
unsigned long long suma = 0;
for (unsigned long long i2 = i + 1; i2 <= j; i2++) suma += m[i2 - 1][i2];
return suma;
}
unsigned long long distanta_adevarata2(unsigned long long n,
unsigned long long t) {
unsigned long long min1 = val_max, minn = 0, aux;
for (int i = 1; i <= n; i++) {
if (min1 > m[0][i]) {
min1 = m[0][i];
minn = i;
}
}
unsigned long long nr1, nr2, x, y, i, j, minct = 1;
bool sem = 1;
nr2 = minn;
if (m[0][nr2] > t) return 0;
for (j = nr2; j <= n; j++)
for (i = nr2; i >= 1; i--) {
aux = dist_i_j(i, j) +
min(min(dist_i_j(i, nr2), dist_i_j(nr2, j)) + m[0][nr2],
min(m[0][i], m[0][j]));
if (aux <= t)
if (minct < nr2 - i + j - nr2 + 1) minct = nr2 - i + j - nr2 + 1;
}
return minct;
}
int main() {
unsigned long long x0, y0, xs, ys, t, ax, ay, bx, by, n = 1, i, j;
cin >> x0 >> y0 >> ax >> ay >> bx >> by >> xs >> ys >> t;
vx[0] = xs;
vy[0] = ys;
while (x0 < val_max && y0 < val_max) {
vx[n] = x0;
vy[n] = y0;
n++;
x0 = ax * x0 + bx;
y0 = ay * y0 + by;
}
n--;
for (i = 0; i <= n; i++)
for (j = 0; j <= n; j++) {
if (i == j) continue;
m[i][j] = distanta(vx[i], vy[i], vx[j], vy[j]);
}
cout << distanta_adevarata2(n, t);
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const int N = 2e5 + 10;
const long long mod = 998244353;
const bool debug = false;
long double F[N];
void init() {
for (int i = 1; i < N; ++i) F[i] = F[i - 1] + logl(i);
}
long double comb(int n, int m) { return F[n] - F[m] - F[n - m]; }
int main() {
init();
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
long double ans;
if (m >= k + 1)
ans = expl(comb(n + m, m - k - 1) - comb(m + n, m));
else
ans = 0;
printf("%.12Lf\n", max(1.0 - ans, (long double)0.0));
return 0;
}
| 16
|
#include <bits/stdc++.h>
using LL = long long;
const int maxn = 1011000;
const LL mod = 1000000123;
int seed = 29, n;
char str[maxn];
LL base[maxn], Hash[maxn];
int ans[maxn];
void init() {
memset(base, 0, sizeof(base));
base[0] = 1;
for (int i = 1; i < maxn; i++) {
base[i] = base[i - 1] * seed;
base[i] %= mod;
}
}
void init_hash() {
memset(Hash, 0, sizeof(Hash));
for (int i = n - 1; i >= 0; i--) {
Hash[i] = Hash[i + 1] * seed + str[i] - 'a' + 1;
Hash[i] %= mod;
}
}
LL get_hash(int i, int len) {
auto ans = Hash[i] - Hash[i + len] * base[len];
ans %= mod;
if (ans < 0) ans += mod;
return ans;
}
int main() {
init();
while (std::cin >> n) {
std::cin >> str;
init_hash();
memset(ans, -1, sizeof(ans));
int cur = -1;
for (int i = (n - 1) / 2; i >= 0; i--) {
cur += 2;
if (2 * i == n - 1) {
cur = -1;
}
while (cur != -1 && get_hash(i, cur) != get_hash(n - i - cur, cur))
cur -= 2;
ans[i] = cur;
}
for (int i = 0; i <= (n - 1) / 2; i++) {
std::cout << ans[i] << " ";
}
std::cout << std::endl;
}
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int next_state[110][4], max_len[110];
int dp[1010][15][110];
const int MOD = 1000000009;
int main() {
memset(max_len, -1, sizeof(max_len));
int N, M;
cin >> N >> M;
vector<string> pat(M);
for (int i = 0; i < M; i++) {
cin >> pat[i];
}
vector<string> pfx;
for (int i = 0; i < M; i++) {
for (int k = 0; k <= (int)pat[i].length(); k++) {
pfx.push_back(pat[i].substr(0, k));
}
}
sort(pfx.begin(), pfx.end());
pfx.erase(unique(pfx.begin(), pfx.end()), pfx.end());
int P = pfx.size();
const string DNA = "AGCT";
for (int i = 0; i < P; i++) {
for (int k = 0; k < M; k++) {
int lenA = pfx[i].length(), lenB = pat[k].length();
if (lenA < lenB) continue;
if (pfx[i].substr(lenA - lenB, lenB) == pat[k]) {
max_len[i] = max(max_len[i], lenB);
}
}
for (int c = 0; c < 4; c++) {
string s = pfx[i] + DNA[c];
int idx = -1;
while (1) {
idx = lower_bound(pfx.begin(), pfx.end(), s) - pfx.begin();
if (idx < P && pfx[idx] == s) break;
s = s.substr(1);
}
next_state[i][c] = idx;
}
}
dp[0][0][0] = 1;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 10; j++) {
for (int k = 0; k < P; k++) {
if (dp[i][j][k] == 0) continue;
for (int c = 0; c < 4; c++) {
int nk = next_state[k][c], ma = max_len[nk];
if (j < ma) {
(dp[i + 1][0][nk] += dp[i][j][k]) %= MOD;
} else if (j + 1 < 10) {
(dp[i + 1][j + 1][nk] += dp[i][j][k]) %= MOD;
}
}
}
}
}
int ans = 0;
for (int i = 0; i < P; i++) {
(ans += dp[N][0][i]) %= MOD;
}
cout << ans << endl;
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int inf = 1e7;
template <typename T>
T maxi(T x, T y) {
return (x > y) ? x : y;
}
template <typename T>
T mini(T x, T y) {
return (x < y) ? x : y;
}
long long modExpo(long long a, long long b, long long c) {
if (b == 0)
return 1;
else if (b % 2 == 0)
return modExpo(((a % c) * (a % c)) % c, b / 2, c) % c;
else
return ((a % c) * (modExpo(((a % c) * (a % c)) % c, b / 2, c) % c)) % c;
}
int n;
long long k;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
long long arr[n];
for (int i = (0); i < (n); i++) cin >> arr[i];
if (k == 0) {
for (int i = (0); i < (n); i++) cout << arr[i] << " ";
exit(0);
}
long long ans[n];
vector<int> adj[n + 10];
long long denom = 1, prev = k, last = 1;
for (int i = (1); i < (n); i++) {
long long n1 = ((prev % mod) * (last % mod)) % mod;
denom = ((denom % mod) * (i % mod)) % mod;
long long inv = modExpo(denom, mod - 2, mod) % mod;
long long num = ((n1 % mod) * (inv % mod)) % mod;
++prev;
last = n1;
adj[i].push_back(num);
}
memset(ans, 0, sizeof(ans));
ans[0] = arr[0];
adj[1].push_back(1);
for (int i = (1); i < (n); i++) {
int cnt = 0;
for (auto u : adj[i]) {
adj[i + 1].push_back(u);
long long temp = ((u % mod) * (arr[cnt] % mod)) % mod;
ans[i] = ((ans[i] % mod) + (temp % mod)) % mod;
++cnt;
}
}
for (int i = (0); i < (n); i++) cout << ans[i] << " ";
return 0;
}
| 11
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.