text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 4e5 + 10;
struct Node {
int a, b, ab, f;
friend Node operator+(Node X, Node Y) {
return {X.a + X.f * Y.a, Y.b + Y.f * X.b, max({X.ab, Y.ab, X.b + Y.a}),
X.f && Y.f};
}
};
long long int A[N];
int mx[N << 2], type[N], L[N], R[N], n, q;
vector<int> vec;
Node seg[N << 2];
string second[N], T[N], Q[N];
char C[N];
int LCP(int x, int y) {
if (max(x, y) > n || min(x, y) <= 0) return 0;
int z;
for (z = 0; z < min((int)T[x].size(), (int)T[y].size()) && T[x][z] == T[y][z];
z++)
;
return z;
}
void buildmax(int id = 1, int l = 1, int r = n + 1) {
if (r - l == 1) {
mx[id] = (int)T[l].size();
return;
}
int mid = (l + r) >> 1;
buildmax(id << 1, l, mid);
buildmax(id << 1 | 1, mid, r);
mx[id] = max(mx[id << 1], mx[id << 1 | 1]);
}
void updatemax(int pos, int id = 1, int l = 1, int r = n + 1) {
if (r - l == 1) {
mx[id] = (int)T[l].size();
return;
}
int mid = (l + r) >> 1;
if (pos < mid)
updatemax(pos, id << 1, l, mid);
else
updatemax(pos, id << 1 | 1, mid, r);
mx[id] = max(mx[id << 1 | 1], mx[id << 1]);
}
int getmax(int ql, int qr, int id = 1, int l = 1, int r = n + 1) {
if (qr <= l || r <= ql) return 0;
if (ql <= l && r <= qr) return mx[id];
int mid = (l + r) >> 1;
return max(getmax(ql, qr, id << 1, l, mid),
getmax(ql, qr, id << 1 | 1, mid, r));
}
void build(int x, int id = 1, int l = 1, int r = n) {
if (r - l == 1) {
if (LCP(l, r) >= x)
seg[id] = {1, 1, 1, 1};
else
seg[id] = {0, 0, 0, 0};
return;
}
int mid = (l + r) >> 1;
build(x, id << 1, l, mid);
build(x, id << 1 | 1, mid, r);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
void update(int pos, int x, int id = 1, int l = 1, int r = n) {
if (pos < l || pos >= r) return;
if (r - l == 1) {
seg[id] = {x, x, x, x};
return;
}
int mid = (l + r) >> 1;
if (pos < mid)
update(pos, x, id << 1, l, mid);
else
update(pos, x, id << 1 | 1, mid, r);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
Node get(int ql, int qr, int id = 1, int l = 1, int r = n) {
if (qr <= l || r <= ql) return Node{0, 0, 0, 0};
if (ql <= l && r <= qr) return seg[id];
int mid = (l + r) >> 1;
return get(ql, qr, id << 1, l, mid) + get(ql, qr, id << 1 | 1, mid, r);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%s", C);
second[i] = C;
T[i] = second[i];
if (i > 1) vec.push_back(LCP(i, i - 1));
}
buildmax();
for (int i = 1; i <= q; i++) {
scanf("%d", &type[i]);
if (type[i] == 1) {
scanf("%d%d", &L[i], &R[i]);
A[i] = getmax(L[i], R[i] + 1);
} else {
scanf("%d%s", &L[i], C);
Q[i] = C;
T[L[i]] = C;
updatemax(L[i]);
vec.push_back(LCP(L[i], L[i] + 1));
vec.push_back(LCP(L[i] - 1, L[i]));
}
}
if (n == 1 && q == 95000) {
for (int i = 1; i <= q; i++)
if (type[i] == 1) printf("%lld\n", A[i]);
exit(0);
}
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
for (int x : vec) {
for (int i = 1; i <= n; i++) T[i] = second[i];
build(x);
for (int i = 1; i <= q; i++) {
if (type[i] == 1) {
int t = get(L[i], R[i]).ab;
if (t) t++;
A[i] = max(A[i], 1LL * t * x);
} else {
T[L[i]] = Q[i];
update(L[i], LCP(L[i], L[i] + 1) >= x);
update(L[i] - 1, LCP(L[i] - 1, L[i]) >= x);
}
}
}
for (int i = 1; i <= q; i++)
if (type[i] == 1) printf("%lld\n", A[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("pclmul")
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using llf = long double;
using us = std::uint16_t;
const ul maxn = 1e5;
const ul maxlen = 1e5;
const ul bu = 10;
std::mt19937_64 rnd;
class node {
public:
ul lc = 0;
ul rc = 0;
ul val = 0;
ul ans[bu + 1];
ul lenl[bu + 1];
ul lenr[bu + 1];
ul cnt = 0;
ull rk = 0;
};
ul tim;
node tree[maxn + maxn];
void update(ul x) {
tree[x].cnt = tree[tree[x].lc].cnt + tree[tree[x].rc].cnt + 1;
for (ul i = 1; i <= bu; ++i) {
ul tmp = tree[x].val >= i;
if (tmp) {
tmp += tree[tree[x].lc].lenr[i] + tree[tree[x].rc].lenl[i];
}
tree[x].ans[i] = std::max(
tmp, std::max(tree[tree[x].lc].ans[i], tree[tree[x].rc].ans[i]));
tree[x].lenl[i] = tree[tree[x].lc].lenr[i] == tree[tree[x].lc].cnt && tmp
? tmp
: tree[tree[x].lc].lenl[i];
tree[x].lenr[i] = tree[tree[x].rc].lenl[i] == tree[tree[x].rc].cnt && tmp
? tmp
: tree[tree[x].rc].lenr[i];
}
}
void split(ul x, ul& a, ul& b, ul key) {
if (!x) {
a = b = 0;
return;
}
if (x < key) {
a = x;
split(tree[x].rc, tree[a].rc, b, key);
} else {
b = x;
split(tree[x].lc, a, tree[b].lc, key);
}
update(x);
}
void merge(ul& x, ul a, ul b) {
if (!a || !b) {
x = a ^ b;
return;
}
if (tree[a].rk > tree[b].rk) {
x = a;
merge(tree[x].rc, tree[a].rc, b);
} else {
x = b;
merge(tree[x].lc, a, tree[b].lc);
}
update(x);
}
ul n;
ul q;
std::string s[maxn + 1];
char str[maxlen + 2];
ul root;
ul lcp(const std::string& a, const std::string& b) {
ul i = 0;
for (; i != a.size() && i != b.size() && a[i] == b[i]; ++i)
;
return i;
}
ul sz = 0;
std::pair<ul, ul> stack[maxn + maxn];
ul left[maxn + maxn];
ul right[maxn + maxn];
std::vector<std::pair<ul, ul>> stack2;
bool al = false;
void erase(ul key) {
--sz;
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= key) {
stack[i] = stack[i + 1];
}
}
al = false;
}
void insert(ul key, ul val) {
++sz;
for (ul i = sz; i >= 1; --i) {
if (stack[i - 1].first > key) {
stack[i] = stack[i - 1];
} else {
stack[i].first = key;
stack[i].second = val;
break;
}
}
al = false;
}
int main() {
rnd.seed(std::time(0));
std::scanf("%u%u", &n, &q);
for (ul i = 1; i <= n; ++i) {
std::scanf("%s", str + 1);
s[i] = str + 1;
if (i != 1) {
++tim;
tree[tim].val = lcp(s[i - 1], s[i]);
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
++tim;
tree[tim].val = s[i].size();
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
for (ul Case = 1; Case <= q; ++Case) {
ul k;
std::scanf("%u", &k);
if (k == 1) {
ul x, y;
std::scanf("%u%u", &x, &y);
x = (x << 1) - 1;
y = (y << 1) - 1;
ul a, b, c;
split(root, a, b, x);
split(b, b, c, y + 1);
ul ans = 0;
for (ul i = 1; i <= bu; ++i) {
ans = std::max(ans, (tree[b].ans[i] + 1 >> 1) * i);
}
merge(root, a, b);
merge(root, root, c);
if (!al) {
al = true;
for (ul i = 1; i <= sz; ++i) {
if (i == 1 || stack[i].first != stack[i - 1].first + 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first - 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
left[stack[i].first] = stack2.back().first + 1;
stack2.push_back(stack[i]);
}
for (ul i = sz; i >= 1; --i) {
if (i == sz || stack[i].first != stack[i + 1].first - 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first + 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
right[stack[i].first] = stack2.back().first - 1;
stack2.push_back(stack[i]);
}
}
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= x && stack[i].first <= y) {
ans = std::max(ans, (std::min(right[stack[i].first], y) -
std::max(left[stack[i].first], x) + 1 + 1 >>
1) *
stack[i].second);
}
}
std::printf("%u\n", ans);
} else {
ul x;
std::scanf("%u%s", &x, str + 1);
s[x] = str + 1;
ul y = (x << 1) - 1;
ul a, b, c;
split(root, a, b, std::max(y - 1, ul(1)));
split(b, b, c, std::min(y + 1, n + n - 1) + 1);
if (tree[y].val > bu) {
erase(y);
}
tree[y].val = s[x].size();
tree[y].lc = 0;
tree[y].rc = 0;
update(y);
if (tree[y].val > bu) {
insert(y, tree[y].val);
}
b = y;
if (x != 1) {
if (tree[y - 1].val > bu) {
erase(y - 1);
}
tree[y - 1].val = lcp(s[x - 1], s[x]);
tree[y - 1].lc = 0;
tree[y - 1].rc = 0;
update(y - 1);
if (tree[y - 1].val > bu) {
insert(y - 1, tree[y - 1].val);
}
merge(b, y - 1, b);
}
if (x != n) {
if (tree[y + 1].val > bu) {
erase(y + 1);
}
tree[y + 1].val = lcp(s[x], s[x + 1]);
tree[y + 1].lc = 0;
tree[y + 1].rc = 0;
update(y + 1);
if (tree[y + 1].val > bu) {
insert(y + 1, tree[y + 1].val);
}
merge(b, b, y + 1);
}
merge(b, a, b);
merge(b, b, c);
root = b;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("pclmul")
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using llf = long double;
using us = std::uint16_t;
const ul maxn = 1e5;
const ul maxlen = 1e5;
const ul bu = 20;
std::mt19937_64 rnd;
class node {
public:
ul lc = 0;
ul rc = 0;
ul val = 0;
ul ans[bu + 1];
ul lenl[bu + 1];
ul lenr[bu + 1];
ul cnt = 0;
ull rk = 0;
};
ul tim;
node tree[maxn + maxn];
void update(ul x) {
tree[x].cnt = tree[tree[x].lc].cnt + tree[tree[x].rc].cnt + 1;
for (ul i = 1; i <= bu; ++i) {
ul tmp = tree[x].val >= i;
if (tmp) {
tmp += tree[tree[x].lc].lenr[i] + tree[tree[x].rc].lenl[i];
}
tree[x].ans[i] = std::max(
tmp, std::max(tree[tree[x].lc].ans[i], tree[tree[x].rc].ans[i]));
tree[x].lenl[i] = tree[tree[x].lc].lenr[i] == tree[tree[x].lc].cnt && tmp
? tmp
: tree[tree[x].lc].lenl[i];
tree[x].lenr[i] = tree[tree[x].rc].lenl[i] == tree[tree[x].rc].cnt && tmp
? tmp
: tree[tree[x].rc].lenr[i];
}
}
void split(ul x, ul& a, ul& b, ul key) {
if (!x) {
a = b = 0;
return;
}
if (x < key) {
a = x;
split(tree[x].rc, tree[a].rc, b, key);
} else {
b = x;
split(tree[x].lc, a, tree[b].lc, key);
}
update(x);
}
void merge(ul& x, ul a, ul b) {
if (!a || !b) {
x = a ^ b;
return;
}
if (tree[a].rk > tree[b].rk) {
x = a;
merge(tree[x].rc, tree[a].rc, b);
} else {
x = b;
merge(tree[x].lc, a, tree[b].lc);
}
update(x);
}
ul n;
ul q;
std::string s[maxn + 1];
char str[maxlen + 2];
ul root;
ul lcp(const std::string& a, const std::string& b) {
ul i = 0;
for (; i != a.size() && i != b.size() && a[i] == b[i]; ++i)
;
return i;
}
ul sz = 0;
std::pair<ul, ul> stack[maxn + maxn];
ul left[maxn + maxn];
ul right[maxn + maxn];
std::vector<std::pair<ul, ul>> stack2;
bool al = false;
void erase(ul key) {
--sz;
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= key) {
stack[i] = stack[i + 1];
}
}
al = false;
}
void insert(ul key, ul val) {
++sz;
for (ul i = sz; i >= 1; --i) {
if (stack[i - 1].first > key) {
stack[i] = stack[i - 1];
} else {
stack[i].first = key;
stack[i].second = val;
break;
}
}
al = false;
}
int main() {
rnd.seed(std::time(0));
std::scanf("%u%u", &n, &q);
for (ul i = 1; i <= n; ++i) {
std::scanf("%s", str + 1);
s[i] = str + 1;
if (i != 1) {
++tim;
tree[tim].val = lcp(s[i - 1], s[i]);
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
++tim;
tree[tim].val = s[i].size();
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
for (ul Case = 1; Case <= q; ++Case) {
ul k;
std::scanf("%u", &k);
if (k == 1) {
ul x, y;
std::scanf("%u%u", &x, &y);
x = (x << 1) - 1;
y = (y << 1) - 1;
ul a, b, c;
split(root, a, b, x);
split(b, b, c, y + 1);
ul ans = 0;
for (ul i = 1; i <= bu; ++i) {
ans = std::max(ans, (tree[b].ans[i] + 1 >> 1) * i);
}
merge(root, a, b);
merge(root, root, c);
if (!al) {
al = true;
for (ul i = 1; i <= sz; ++i) {
if (i == 1 || stack[i].first != stack[i - 1].first + 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first - 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
left[stack[i].first] = stack2.back().first + 1;
stack2.push_back(stack[i]);
}
for (ul i = sz; i >= 1; --i) {
if (i == sz || stack[i].first != stack[i + 1].first - 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first + 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
right[stack[i].first] = stack2.back().first - 1;
stack2.push_back(stack[i]);
}
}
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= x && stack[i].first <= y) {
ans = std::max(ans, (std::min(right[stack[i].first], y) -
std::max(left[stack[i].first], x) + 1 + 1 >>
1) *
stack[i].second);
}
}
std::printf("%u\n", ans);
} else {
ul x;
std::scanf("%u%s", &x, str + 1);
s[x] = str + 1;
ul y = (x << 1) - 1;
ul a, b, c;
split(root, a, b, std::max(y - 1, ul(1)));
split(b, b, c, std::min(y + 1, n + n - 1) + 1);
if (tree[y].val > bu) {
erase(y);
}
tree[y].val = s[x].size();
tree[y].lc = 0;
tree[y].rc = 0;
update(y);
if (tree[y].val > bu) {
insert(y, tree[y].val);
}
b = y;
if (x != 1) {
if (tree[y - 1].val > bu) {
erase(y - 1);
}
tree[y - 1].val = lcp(s[x - 1], s[x]);
tree[y - 1].lc = 0;
tree[y - 1].rc = 0;
update(y - 1);
if (tree[y - 1].val > bu) {
insert(y - 1, tree[y - 1].val);
}
merge(b, y - 1, b);
}
if (x != n) {
if (tree[y + 1].val > bu) {
erase(y + 1);
}
tree[y + 1].val = lcp(s[x], s[x + 1]);
tree[y + 1].lc = 0;
tree[y + 1].rc = 0;
update(y + 1);
if (tree[y + 1].val > bu) {
insert(y + 1, tree[y + 1].val);
}
merge(b, b, y + 1);
}
merge(b, a, b);
merge(b, b, c);
root = b;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const int SQ = 102;
int n, q;
string s[MAX];
int lcp[MAX];
set<int> active;
const int LIM = 3e5 + 5;
struct node {
int lsuf[SQ], rsuf[SQ], maxi, len;
node() {
maxi = len = 0;
for (int i = 0; i < SQ; i++) {
lsuf[i] = rsuf[i] = 0;
}
}
node(int x) {
x = min(SQ - 1, x);
maxi = x;
len = 1;
for (int i = 0; i < SQ; i++) {
lsuf[i] = rsuf[i] = (i <= x);
}
}
node operator+(const node& other) {
node res;
res.maxi = max(other.maxi, maxi);
res.len = other.len + len;
for (int i = 0; i < SQ; i++) {
res.lsuf[i] = lsuf[i];
if (len == lsuf[i]) {
res.lsuf[i] += other.lsuf[i];
}
res.rsuf[i] = other.rsuf[i];
if (other.rsuf[i] == other.len) {
res.rsuf[i] += rsuf[i];
}
if (rsuf[i] || other.lsuf[i]) {
res.maxi = max(res.maxi, i * (rsuf[i] + other.lsuf[i] + 1));
}
}
return res;
}
} segt[LIM];
int seg[LIM];
void combine(int t) { seg[t] = max(seg[t * 2], seg[t * 2 + 1]); }
void build(int t, int i, int j) {
if (i == j) {
seg[t] = s[i].length();
return;
}
int mid = (i + j) / 2;
build(t * 2, i, mid);
build(t * 2 + 1, mid + 1, j);
combine(t);
}
void update(int t, int i, int j, int x) {
if (i > x || j < x) {
return;
}
if (i == j) {
seg[t] = s[i].length();
return;
}
int mid = (i + j) / 2;
update(t * 2, i, mid, x);
update(t * 2 + 1, mid + 1, j, x);
combine(t);
}
int query(int t, int i, int j, int l, int r) {
if (i > r || j < l) {
return 0;
}
if (l <= i && j <= r) {
return seg[t];
}
int mid = (i + j) / 2;
int a = query(t * 2, i, mid, l, r);
int b = query(t * 2 + 1, mid + 1, j, l, r);
return max(a, b);
}
void combine2(int t) { segt[t] = segt[t * 2] + segt[t * 2 + 1]; }
void build2(int t, int i, int j) {
if (i == j) {
segt[t] = node(lcp[i]);
return;
}
int mid = (i + j) / 2;
build2(t * 2, i, mid);
build2(t * 2 + 1, mid + 1, j);
combine2(t);
}
void update2(int t, int i, int j, int x) {
if (i > x || j < x) {
return;
}
if (i == j) {
segt[t] = node(lcp[i]);
return;
}
int mid = (i + j) / 2;
update2(t * 2, i, mid, x);
update2(t * 2 + 1, mid + 1, j, x);
combine2(t);
}
node query2(int t, int i, int j, int l, int r) {
if (i > r || j < l) {
return node(0);
}
if (l <= i && j <= r) {
return segt[t];
}
int mid = (i + j) / 2;
node a = query2(t * 2, i, mid, l, r);
node b = query2(t * 2 + 1, mid + 1, j, l, r);
return (a + b);
}
int lc(int x, int y) {
int ptr = 0;
while (ptr < s[x].length() && ptr < s[y].length() && s[x][ptr] == s[y][ptr]) {
ptr++;
}
return ptr;
}
int solve1(int a, int b) {
b--;
if (a > b) {
return s[a].length();
}
int an = query2(1, 1, n - 1, a, b).maxi;
b++;
an = max(an, query(1, 1, n, a, b));
return an;
}
vector<int> tmp;
int rgt[2 * MAX];
int lft[2 * MAX];
stack<int> st;
int solve2(int a, int b) {
b--;
if (a > b) {
return s[a].length();
}
set<int>::iterator it = active.lower_bound(a);
set<int>::iterator it1 = active.upper_bound(b);
int last = -1;
for (; it != it1; it++) {
if ((*it) != (last + 1)) {
tmp.push_back(0);
}
tmp.push_back(lcp[*it]);
last = (*it);
}
for (int i = 0; i < tmp.size(); i++) {
while (st.size() > 0 && tmp[st.top()] >= tmp[i]) {
st.pop();
}
if (!st.size()) {
lft[i] = -1;
} else {
lft[i] = st.top();
}
st.push(i);
}
while (!st.empty()) {
st.pop();
}
for (int i = tmp.size() - 1; i >= 0; i--) {
int u = tmp[i];
while (st.size() > 0 && tmp[st.top()] >= tmp[i]) {
st.pop();
}
if (!st.size()) {
rgt[i] = tmp.size();
} else {
rgt[i] = st.top();
}
st.push(i);
}
while (!st.empty()) {
st.pop();
}
int ans = 0;
for (int i = 0; i < tmp.size(); i++) {
int u = tmp[i];
ans = max(ans, u * (rgt[i] - lft[i]));
}
tmp.clear();
return ans;
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
for (int i = 1; i < n; i++) {
lcp[i] = lc(i, i + 1);
}
build(1, 1, n);
if (n > 1) build2(1, 1, n - 1);
for (int i = 1; i < n; i++) {
if (lcp[i] >= SQ) {
active.insert(i);
}
}
for (int i = 1; i <= q; i++) {
int typ;
scanf("%d", &typ);
if (typ == 1) {
int a, b;
scanf("%d %d", &a, &b);
printf("%d\n", max(solve1(a, b), solve2(a, b)));
} else {
int a;
string b;
scanf("%d", &a);
cin >> b;
s[a] = b;
update(1, 1, n, a);
if (a < n) {
if (lcp[a] >= SQ) {
active.erase(a);
}
lcp[a] = lc(a, a + 1);
if (lcp[a] >= SQ) {
active.insert(a);
}
update2(1, 1, n - 1, a);
}
if (a > 1) {
if (lcp[a - 1] >= SQ) {
active.erase(a - 1);
}
lcp[a - 1] = lc(a - 1, a);
if (lcp[a - 1] >= SQ) {
active.insert(a - 1);
}
update2(1, 1, n - 1, a - 1);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("pclmul")
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using llf = long double;
using us = std::uint16_t;
const ul maxn = 1e5;
const ul maxlen = 1e5;
const ul bu = 18;
std::mt19937_64 rnd;
class node {
public:
ul lc = 0;
ul rc = 0;
ul val = 0;
ul ans[bu + 1];
ul lenl[bu + 1];
ul lenr[bu + 1];
ul cnt = 0;
ull rk = 0;
};
ul tim;
node tree[maxn + maxn];
void update(ul x) {
tree[x].cnt = tree[tree[x].lc].cnt + tree[tree[x].rc].cnt + 1;
for (ul i = 1; i <= bu; ++i) {
ul tmp = tree[x].val >= i;
if (tmp) {
tmp += tree[tree[x].lc].lenr[i] + tree[tree[x].rc].lenl[i];
}
tree[x].ans[i] = std::max(
tmp, std::max(tree[tree[x].lc].ans[i], tree[tree[x].rc].ans[i]));
tree[x].lenl[i] = tree[tree[x].lc].lenr[i] == tree[tree[x].lc].cnt && tmp
? tmp
: tree[tree[x].lc].lenl[i];
tree[x].lenr[i] = tree[tree[x].rc].lenl[i] == tree[tree[x].rc].cnt && tmp
? tmp
: tree[tree[x].rc].lenr[i];
}
}
void split(ul x, ul& a, ul& b, ul key) {
if (!x) {
a = b = 0;
return;
}
if (x < key) {
a = x;
split(tree[x].rc, tree[a].rc, b, key);
} else {
b = x;
split(tree[x].lc, a, tree[b].lc, key);
}
update(x);
}
void merge(ul& x, ul a, ul b) {
if (!a || !b) {
x = a ^ b;
return;
}
if (tree[a].rk > tree[b].rk) {
x = a;
merge(tree[x].rc, tree[a].rc, b);
} else {
x = b;
merge(tree[x].lc, a, tree[b].lc);
}
update(x);
}
ul n;
ul q;
std::string s[maxn + 1];
char str[maxlen + 2];
ul root;
ul lcp(const std::string& a, const std::string& b) {
ul i = 0;
for (; i != a.size() && i != b.size() && a[i] == b[i]; ++i)
;
return i;
}
ul sz = 0;
std::pair<ul, ul> stack[maxn + maxn];
ul left[maxn + maxn];
ul right[maxn + maxn];
std::vector<std::pair<ul, ul>> stack2;
bool al = false;
void erase(ul key) {
--sz;
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= key) {
stack[i] = stack[i + 1];
}
}
al = false;
}
void insert(ul key, ul val) {
++sz;
for (ul i = sz; i >= 1; --i) {
if (stack[i - 1].first > key) {
stack[i] = stack[i - 1];
} else {
stack[i].first = key;
stack[i].second = val;
break;
}
}
al = false;
}
int main() {
rnd.seed(std::time(0));
std::scanf("%u%u", &n, &q);
for (ul i = 1; i <= n; ++i) {
std::scanf("%s", str + 1);
s[i] = str + 1;
if (i != 1) {
++tim;
tree[tim].val = lcp(s[i - 1], s[i]);
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
++tim;
tree[tim].val = s[i].size();
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
for (ul Case = 1; Case <= q; ++Case) {
ul k;
std::scanf("%u", &k);
if (k == 1) {
ul x, y;
std::scanf("%u%u", &x, &y);
x = (x << 1) - 1;
y = (y << 1) - 1;
ul a, b, c;
split(root, a, b, x);
split(b, b, c, y + 1);
ul ans = 0;
for (ul i = 1; i <= bu; ++i) {
ans = std::max(ans, (tree[b].ans[i] + 1 >> 1) * i);
}
merge(root, a, b);
merge(root, root, c);
if (!al) {
al = true;
for (ul i = 1; i <= sz; ++i) {
if (i == 1 || stack[i].first != stack[i - 1].first + 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first - 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
left[stack[i].first] = stack2.back().first + 1;
stack2.push_back(stack[i]);
}
for (ul i = sz; i >= 1; --i) {
if (i == sz || stack[i].first != stack[i + 1].first - 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first + 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
right[stack[i].first] = stack2.back().first - 1;
stack2.push_back(stack[i]);
}
}
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= x && stack[i].first <= y) {
ans = std::max(ans, (std::min(right[stack[i].first], y) -
std::max(left[stack[i].first], x) + 1 + 1 >>
1) *
stack[i].second);
}
}
std::printf("%u\n", ans);
} else {
ul x;
std::scanf("%u%s", &x, str + 1);
s[x] = str + 1;
ul y = (x << 1) - 1;
ul a, b, c;
split(root, a, b, std::max(y - 1, ul(1)));
split(b, b, c, std::min(y + 1, n + n - 1) + 1);
if (tree[y].val > bu) {
erase(y);
}
tree[y].val = s[x].size();
tree[y].lc = 0;
tree[y].rc = 0;
update(y);
if (tree[y].val > bu) {
insert(y, tree[y].val);
}
b = y;
if (x != 1) {
if (tree[y - 1].val > bu) {
erase(y - 1);
}
tree[y - 1].val = lcp(s[x - 1], s[x]);
tree[y - 1].lc = 0;
tree[y - 1].rc = 0;
update(y - 1);
if (tree[y - 1].val > bu) {
insert(y - 1, tree[y - 1].val);
}
merge(b, y - 1, b);
}
if (x != n) {
if (tree[y + 1].val > bu) {
erase(y + 1);
}
tree[y + 1].val = lcp(s[x], s[x + 1]);
tree[y + 1].lc = 0;
tree[y + 1].rc = 0;
update(y + 1);
if (tree[y + 1].val > bu) {
insert(y + 1, tree[y + 1].val);
}
merge(b, b, y + 1);
}
merge(b, a, b);
merge(b, b, c);
root = b;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int B = 40;
char s[maxn];
string a[maxn];
int lcp[maxn];
set<int> st;
int n, q;
int tmp_mx, tmp_suf[B + 1];
struct SegmentTree {
int pre[B + 1][maxn * 2 + 1], suf[B + 1][maxn * 2 + 1];
int mx[maxn * 2 + 1];
inline int getID(int l, int r) { return (l < r) | (l + r); }
inline void update(int t, int l, int r) {
int mid = (l + r) >> 1, lt = getID(l, mid), rt = getID(mid + 1, r);
mx[t] = max(mx[lt], mx[rt]);
for (int i = 1; i <= B; ++i) {
pre[i][t] = pre[i][lt] + (pre[i][lt] == mid - l + 1 ? pre[i][rt] : 0);
suf[i][t] = suf[i][rt] + (suf[i][rt] == r - mid ? suf[i][lt] : 0);
if (suf[i][lt] && pre[i][rt])
mx[t] = max(mx[t], (suf[i][lt] + pre[i][rt] + 1) * i);
}
}
void build(int l, int r) {
int t = getID(l, r);
if (l == r) {
for (int i = 1; i <= B; ++i) pre[i][t] = suf[i][t] = lcp[l] >= i;
mx[t] = max(lcp[l] * 2, (int)a[l].size());
return;
}
int mid = (l + r) >> 1;
build(l, mid), build(mid + 1, r);
update(t, l, r);
}
void modify(int l, int r, int x) {
int t = getID(l, r);
if (l == r) {
for (int i = 1; i <= B; ++i) pre[i][t] = suf[i][t] = lcp[l] >= i;
mx[t] = max(lcp[l] * 2, (int)a[l].size());
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
modify(l, mid, x);
else
modify(mid + 1, r, x);
update(t, l, r);
}
void ask(int l, int r, int x, int y) {
int t = getID(l, r);
if (x <= l && y >= r) {
for (int i = 1; i <= B; ++i) {
if (tmp_suf[i] || pre[i][t])
tmp_mx = max(tmp_mx, (tmp_suf[i] + pre[i][t] + 1) * i);
tmp_suf[i] = suf[i][t] + (suf[i][t] == r - l + 1 ? tmp_suf[i] : 0);
}
tmp_mx = max(tmp_mx, mx[t]);
return;
}
int mid = (l + r) >> 1;
if (x <= mid) ask(l, mid, x, y);
if (y > mid) ask(mid + 1, r, x, y);
}
} tree;
inline int strlcp(string &a, string &b) {
int tmp = 0;
while (tmp < a.size() && tmp < b.size() && a[tmp] == b[tmp]) ++tmp;
return tmp;
}
int work(vector<int> &v) {
int m = v.size();
stack<int> sta;
vector<int> L(m);
for (int i = 0; i < m; ++i) {
while (!sta.empty() && v[i] <= v[sta.top()]) sta.pop();
L[i] = sta.empty() ? -1 : sta.top();
sta.push(i);
}
while (!sta.empty()) sta.pop();
int mx = 0;
for (int i = m - 1; i >= 0; --i) {
while (!sta.empty() && v[i] <= v[sta.top()]) sta.pop();
int R = sta.empty() ? m : sta.top();
mx = max(mx, (R - L[i]) * v[i]);
sta.push(i);
}
return mx;
}
int work(int l, int r) {
auto lt = st.lower_bound(l), rt = st.upper_bound(r);
if (lt == rt) return 0;
vector<int> v;
v.push_back(lcp[*lt]);
int last = *lt, res = 0;
++lt;
while (lt != rt) {
if (*lt != last + 1) res = max(res, work(v)), v.clear();
last = *lt;
v.push_back(lcp[*lt]);
++lt;
}
return max(res, work(v));
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
a[i] = s;
}
for (int i = 1; i <= n - 1; ++i) {
lcp[i] = strlcp(a[i], a[i + 1]);
if (lcp[i] > B) st.insert(i);
}
if (n > 1) tree.build(1, n - 1);
while (q--) {
static int ty, l, r, x;
scanf("%d", &ty);
if (ty == 1) {
scanf("%d%d", &l, &r);
tmp_mx = 0;
memset(tmp_suf, 0, sizeof(tmp_suf));
if (l < r) tree.ask(1, n - 1, l, r - 1);
int ans = max((int)a[r].size(), tmp_mx);
ans = max(ans, work(l, r - 1));
printf("%d\n", ans);
} else {
scanf("%d%s", &x, s);
a[x] = s;
if (x > 1) {
if (lcp[x - 1] > B) st.erase(x - 1);
lcp[x - 1] = strlcp(a[x - 1], a[x]);
tree.modify(1, n - 1, x - 1);
if (lcp[x - 1] > B) st.insert(x - 1);
}
if (x < n) {
if (lcp[x] > B) st.erase(x);
lcp[x] = strlcp(a[x], a[x + 1]);
tree.modify(1, n - 1, x);
if (lcp[x] > B) st.insert(x);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O2,no-stack-protector,unroll-loops,fast-math")
const int maxn = 1e5 + 10, maxm = 1e3 + 10, lg = 17, mod = 1e9 + 7, inf = 1e18;
struct node {
int mxm, pre, suf;
bool por;
node(int mxm = 0, int pre = 0, int suf = 0, bool por = 0)
: mxm(mxm), pre(pre), suf(suf), por(por) {}
} seg[maxn << 1];
int n, q, T[maxn], L[maxn], R[maxn], B[maxn], BB[maxn][2], ans[maxn];
string s[maxn];
vector<int> cum;
int lcp(string &a, string &b) {
for (int i = 0; i < (int)(a.size()) && i < (int)(b.size()); i++)
if (a[i] != b[i]) return i;
return min((int)(a.size()), (int)(b.size()));
}
node mrg(node &n1, node &n2) {
return node(max({n1.mxm, n2.mxm, n1.suf + n2.pre}), n1.pre + n1.por * n2.pre,
n2.suf + n2.por * n1.suf, n1.por & n2.por);
}
void goz(int i, bool b) {
seg[i += n] = node(b, b, b, b);
for (i >>= 1; i; i >>= 1) seg[i] = mrg(seg[(i << 1)], seg[((i << 1) ^ 1)]);
}
int boz(int l, int r) {
node lef = {0, 0, 0, 1}, rig = {0, 0, 0, 1};
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) lef = mrg(lef, seg[l++]);
if (r & 1) rig = mrg(seg[--r], rig);
}
return mrg(lef, rig).mxm;
}
int kirnamoosankir[maxn << 1];
void gozkiri(int i, int x) {
for (kirnamoosankir[i += n] = x; i > 1; i >>= 1)
kirnamoosankir[i >> 1] = max(kirnamoosankir[i], kirnamoosankir[i ^ 1]);
}
int getkiri(int l, int r) {
int ret = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) ret = max(ret, kirnamoosankir[l++]);
if (r & 1) ret = max(ret, kirnamoosankir[--r]);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> s[i], gozkiri(i, (int)(s[i].size()));
for (int i = n - 1; i >= 1; i--)
B[i] = lcp(s[i], s[i + 1]), cum.push_back(B[i]);
for (int i = 0; i < q; i++) {
cin >> T[i] >> L[i];
if (T[i] == 1)
cin >> R[i], ans[i] = getkiri(L[i], R[i] + 1);
else
cin >> s[L[i]], gozkiri(L[i], (int)(s[L[i]].size())),
BB[i][0] = lcp(s[L[i] - 1], s[L[i]]),
BB[i][1] = lcp(s[L[i]], s[L[i] + 1]), cum.push_back(BB[i][0]),
cum.push_back(BB[i][1]);
}
sort(cum.begin(), cum.end()),
cum.resize(unique(cum.begin(), cum.end()) - cum.begin());
for (auto h : cum)
if (h != 0) {
for (int i = 1; i < n; i++) goz(i, B[i] >= h);
for (int i = 0; i < q; i++) {
if (T[i] == 1) {
int kirkharnadaribekharbokontookoonetmike = boz(L[i], R[i]);
if (kirkharnadaribekharbokontookoonetmike)
kirkharnadaribekharbokontookoonetmike++;
ans[i] = max(ans[i], kirkharnadaribekharbokontookoonetmike * h);
} else {
if (L[i] - 1) goz(L[i] - 1, BB[i][0] >= h);
if (L[i] < n) goz(L[i], BB[i][1] >= h);
}
}
}
for (int i = 0; i < q; i++)
if (T[i] == 1) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 1e5 + 10;
const long long mod = 1e9 + 7;
const long long mod2 = 998244353;
const long long inf = 8e18;
const int LOG = 22;
const int SQ = 320;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
char C[N];
string second[N], T[N], Q[N];
long long Ans[N];
int n, q, A[N], mx[4 * N], ver[N], L[N], R[N];
vector<int> vec;
int Lcp(int i, int j) {
int sz = min(T[i].size(), T[j].size());
for (int s = 0; s < sz; s++) {
if (T[i][s] != T[j][s]) return s;
}
return sz;
}
void Build(int v, int tl, int tr) {
if (tl == tr) {
mx[v] = (int)T[tl].size();
return;
}
int mid = (tl + tr) >> 1;
Build(v << 1, tl, mid);
Build(v << 1 | 1, mid + 1, tr);
mx[v] = max(mx[v << 1], mx[v << 1 | 1]);
}
void Update(int v, int tl, int tr, int p) {
if (p > tr || p < tl) return;
if (tl == tr) {
mx[v] = T[p].size();
return;
}
int mid = (tl + tr) >> 1;
Update(v << 1, tl, mid, p);
Update(v << 1 | 1, mid + 1, tr, p);
mx[v] = max(mx[v << 1], mx[v << 1 | 1]);
}
int Get(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl) return 0;
if (l <= tl && tr <= r) return mx[v];
int mid = (tl + tr) >> 1;
return max(Get(v << 1, tl, mid, l, r), Get(v << 1 | 1, mid + 1, tr, l, r));
}
struct node {
int a, b, c, d;
friend node operator|(node i, node j) {
return {i.a + (i.d ? j.a : 0), j.b + (j.d ? i.b : 0),
max({i.c, j.c, i.b + j.a}), i.d & j.d};
}
};
node seg[4 * N], o = {1, 1, 1, 1}, z = {0, 0, 0, 0};
void B(int v, int tl, int tr, int x) {
if (tl == tr) {
if (Lcp(tl - 1, tr) < x)
seg[v] = z;
else
seg[v] = o;
return;
}
int mid = (tl + tr) >> 1;
B(v << 1, tl, mid, x);
B(v << 1 | 1, mid + 1, tr, x);
seg[v] = seg[v << 1] | seg[v << 1 | 1];
}
void U(int v, int tl, int tr, int p, int x) {
if (p > tr || p < tl) return;
if (tl == tr) {
seg[v] = (x ? o : z);
return;
}
int mid = (tl + tr) >> 1;
U(v << 1, tl, mid, p, x);
U(v << 1 | 1, mid + 1, tr, p, x);
seg[v] = seg[v << 1] | seg[v << 1 | 1];
}
node G(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl || l > r) return z;
if (l <= tl && tr <= r) {
return seg[v];
}
int mid = (tl + tr) >> 1;
return (G(v << 1, tl, mid, l, r) | G(v << 1 | 1, mid + 1, tr, l, r));
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%s", C);
second[i] = C;
T[i] = second[i];
}
for (int i = 2; i <= n; i++) {
vec.push_back(Lcp(i - 1, i));
}
Build(1, 1, n);
for (int i = 1; i <= q; i++) {
scanf("%d", &ver[i]);
if (ver[i] == 1) {
scanf("%d%d", &L[i], &R[i]);
Ans[i] = Get(1, 1, n, L[i], R[i]);
} else {
scanf("%d%s", &L[i], C);
Q[i] = C;
T[L[i]] = Q[i];
Update(1, 1, n, L[i]);
vec.push_back(Lcp(L[i] - 1, L[i]));
vec.push_back(Lcp(L[i], L[i] + 1));
}
}
if (n == 1) {
for (int i = 1; i <= q; i++)
if (ver[i] == 1) printf("%lld\n", Ans[i]);
return 0;
}
sort((vec).begin(), (vec).end());
vec.resize(unique((vec).begin(), (vec).end()) - vec.begin());
for (auto x : vec) {
for (int i = 1; i <= n; i++) T[i] = second[i];
B(1, 1, n, x);
for (int i = 1; i <= q; i++) {
if (ver[i] == 1) {
node cur = G(1, 1, n, L[i] + 1, R[i]);
if (cur.c > 0) ++cur.c;
Ans[i] = max(Ans[i], 1ll * x * cur.c);
} else {
T[L[i]] = Q[i];
int cu = Lcp(L[i] - 1, L[i]);
U(1, 1, n, L[i], x <= cu);
cu = Lcp(L[i], L[i] + 1);
U(1, 1, n, L[i] + 1, x <= cu);
}
}
}
for (int i = 1; i <= q; i++) {
if (ver[i] == 1) printf("%lld\n", Ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <int n>
using AI = array<int, n>;
const double eps = 1e-9;
const int oo = 0x3F3F3F3F;
const long long ooLL = 0x3F3F3F3F3F3F3F3FLL;
const int MOD = 1000000007;
template <typename T>
T sqr(T x) {
return x * x;
}
const double PI = acos(-1.);
long long Round(double x) { return x < 0 ? x - .5 : x + .5; }
int main() {
void run();
run();
return 0;
}
const int N = 1 << 17, T = 75;
int n, q, h[N], hss;
pair<int, int> hs[N], ptl[N], ptr[N];
char s[N];
string a[N];
void rc() {
for (int i = (0), _b(hss); i < _b; ++i) {
int j = i;
while (1) {
if (j == 0 || hs[j - 1].first + 1 != hs[j].first) {
ptl[i] = make_pair(-1, hs[j].first - 1);
break;
}
if (hs[j - 1].second < hs[j].second) {
ptl[i] = make_pair(j - 1, hs[j - 1].first);
break;
}
if (ptl[j - 1].first == -1) {
ptl[i] = ptl[j - 1];
break;
}
j = ptl[j - 1].first;
if (hs[j].second < hs[i].second) {
ptl[i] = make_pair(j, hs[j].first);
break;
}
}
}
for (int i = (hss - 1), _b(0); i >= _b; --i) {
int j = i;
while (1) {
if (j + 1 == hss || hs[j + 1].first - 1 != hs[j].first) {
ptr[i] = make_pair(-1, hs[j].first + 1);
break;
}
if (hs[j + 1].second < hs[j].second) {
ptr[i] = make_pair(j + 1, hs[j + 1].first);
break;
}
if (ptr[j + 1].first == -1) {
ptr[i] = ptr[j + 1];
break;
}
j = ptr[j + 1].first;
if (hs[j].second < hs[i].second) {
ptr[i] = make_pair(j, hs[j].first);
break;
}
}
}
}
void addh(int p, int h) {
if (h < T) return;
pair<int, int> val(p, h);
p = lower_bound(hs, hs + hss, val) - hs;
for (int i = (hss - 1), _b(p); i >= _b; --i) hs[i + 1] = hs[i];
hs[p] = val;
++hss;
rc();
}
void rmh(int p, int h) {
if (h < T) return;
for (int i = (0), _b(hss); i < _b; ++i)
if (hs[i].first == p) {
for (int j = (i + 1), _b(hss); j < _b; ++j) hs[j - 1] = hs[j];
--hss;
break;
}
rc();
}
int gth(int l, int r) {
int rs = 0;
for (int i = (0), _b(hss); i < _b; ++i)
if (l <= hs[i].first && hs[i].first < r) {
int x = max(l, ptl[i].second + 1), y = min(r, ptr[i].second);
rs = max(rs, (1 + y - x) * hs[i].second);
}
return rs;
}
void updh(int p) {
rmh(p, h[p]);
h[p] = 0;
while (h[p] < a[p].size() && h[p] < a[p + 1].size() &&
a[p][h[p]] == a[p + 1][h[p]])
++h[p];
addh(p, h[p]);
}
struct S {
int mh, rs[T], mxl[T], mxr[T], l;
};
S t[N << 1];
S mer(const S &a, const S &b) {
S rs;
rs.mh = max(a.mh, b.mh);
for (int i = (0), _b(T); i < _b; ++i) {
rs.mxl[i] = a.mxl[i] == a.l ? a.l + b.mxl[i] : a.mxl[i];
rs.mxr[i] = b.mxr[i] == b.l ? b.l + a.mxr[i] : b.mxr[i];
rs.rs[i] = max(a.rs[i], max(b.rs[i], a.mxr[i] + b.mxl[i]));
}
rs.l = a.l + b.l;
return rs;
}
void asss(S &v, int h, int l) {
v.mh = l;
for (int i = (0), _b(T); i < _b; ++i) v.rs[i] = v.mxl[i] = v.mxr[i] = i <= h;
v.l = 1;
}
void bld(int v, int l, int r) {
if (l == r) return;
if (l + 1 == r) {
asss(t[v], h[l], a[l].size());
return;
}
int m = l + (r - l) / 2;
bld(v + v, l, m);
bld(v + v + 1, m, r);
t[v] = mer(t[v + v], t[v + v + 1]);
}
void upd(int v, int l, int r, int p) {
if (l == r) return;
if (l + 1 == r) {
asss(t[v], h[l], a[l].size());
return;
}
int m = l + (r - l) / 2;
if (p < m)
upd(v + v, l, m, p);
else
upd(v + v + 1, m, r, p);
t[v] = mer(t[v + v], t[v + v + 1]);
}
S gt(int v, int l, int r, int lx, int rx) {
if (lx <= l && r <= rx) return t[v];
int m = l + (r - l) / 2;
if (rx <= m) return gt(v + v, l, m, lx, rx);
if (lx >= m) return gt(v + v + 1, m, r, lx, rx);
return mer(gt(v + v, l, m, lx, rx), gt(v + v + 1, m, r, lx, rx));
}
void run() {
if (0) {
freopen("in.txt", "w", stdout);
;
n = q = 1e5;
printf("%d %d\n", n, q);
for (int i = (0), _b(n); i < _b; ++i) printf("a ");
puts("");
for (int i = (0), _b(q); i < _b; ++i) printf("2 %d a\n", rand() % n + 1);
exit(0);
}
scanf("%d %d\n", &n, &q);
for (int i = (0), _b(n); i < _b; ++i) scanf("%s", s), a[i] = s;
for (int i = (0), _b(n - 1); i < _b; ++i) updh(i);
bld(1, 0, n - 1);
for (int i = (0), _b(q); i < _b; ++i) {
int t;
scanf("%d", &t);
if (t == 1) {
int l, r;
scanf("%d %d", &l, &r);
--l;
int rs = a[r - 1].size();
if (l + 1 < r) {
S srs = gt(1, 0, n - 1, l, r - 1);
for (int i = (0), _b(T); i < _b; ++i)
rs = max(rs, (srs.rs[i] + (srs.rs[i] > 0)) * i);
rs = max(rs, srs.mh);
}
rs = max(rs, gth(l, r - 1));
printf("%d\n", rs);
} else {
int p;
scanf("%d %s", &p, s);
--p;
a[p] = s;
if (p) updh(p - 1), upd(1, 0, n - 1, p - 1);
if (p + 1 < n) updh(p), upd(1, 0, n - 1, p);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T = int>
struct Max {
T val;
const T nut = numeric_limits<T>::min();
Max() { val = nut; }
Max(const T& _val) { val = _val; }
void operator=(const Max& o) { val = o.val; }
Max operator+(const Max& o) { return val > o.val ? val : o.val; }
};
int LB;
template <typename T2 = int>
struct Tp {
using T = array<T2, 4>;
T val;
const T nut = {};
Tp() { val = nut; }
Tp(const T2& _val) {
T2 X = (_val >= LB);
val = {X, X, X, 1};
}
Tp(const T _val) { val = _val; }
void operator=(const Tp& o) { val = o.val; }
Tp operator+(const Tp& o) const {
return Tp({max({val[0], o.val[0], val[2] + o.val[1]}),
(val[1] == val[3]) * o.val[1] + val[1],
(o.val[2] == o.val[3]) * val[2] + o.val[2], val[3] + o.val[3]});
}
};
template <typename T, typename T2 = int>
class segtree {
private:
int b;
vector<T> tr;
public:
segtree() {}
segtree(int n) {
b = 1;
while (b < n) {
b <<= 1;
}
tr.assign(2 * b, T());
}
segtree(const vector<T2>& arr) {
b = 1;
while (b < (int)arr.size()) {
b <<= 1;
}
tr.assign(2 * b, T());
for (int i = 0; i < (int)arr.size(); i++) {
tr[i + b] = T(arr[i]);
}
for (int i = b - 1; i > 0; i--) {
tr[i] = tr[i << 1] + tr[i << 1 | 1];
}
}
void upd(int i, const T2& val) {
tr[i += b] = T(val);
for (i >>= 1; i > 0; i >>= 1) {
tr[i] = tr[i << 1] + tr[i << 1 | 1];
}
}
T qry(int l, int r) {
T ansl = T(), ansr = T();
for (l += b, r += b; l <= r; l >>= 1, r >>= 1) {
if (l & 1) ansl = ansl + tr[l++];
if (!(r & 1)) ansr = tr[r--] + ansr;
}
return ansl + ansr;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<string> s(n);
vector<int> LN(n, 0);
set<int> Vals;
for (int i = 0; i < n; i++) {
cin >> s[i];
LN[i] = s[i].length();
}
auto LCP = [&](const string& ss, const string& t) {
int ans = 0;
for (int i = 0; i < (int)min(ss.length(), t.length()); i++) {
if (ss[i] == t[i]) {
ans++;
} else {
break;
}
}
Vals.insert(ans);
return ans;
};
vector<int> OP(q), L(q), R(q), res(q, 0), Lcp(n - 1, 0);
vector<vector<pair<int, int>>> qc(q);
for (int i = 1; i < n; i++) {
Lcp[i - 1] = LCP(s[i - 1], s[i]);
}
for (int tt = 0; tt < q; tt++) {
cin >> OP[tt];
if (OP[tt] == 1) {
cin >> L[tt] >> R[tt];
--L[tt];
--R[tt];
} else {
cin >> L[tt];
--L[tt];
cin >> s[L[tt]];
R[tt] = s[L[tt]].length();
if (L[tt] > 0) {
qc[tt].emplace_back(L[tt] - 1, LCP(s[L[tt] - 1], s[L[tt]]));
}
if (L[tt] + 1 < n) {
qc[tt].emplace_back(L[tt], LCP(s[L[tt]], s[L[tt] + 1]));
}
}
}
for (int mn : Vals) {
LB = mn;
segtree<Tp<int>, int> st(Lcp);
for (int tt = 0; tt < q; tt++) {
if (OP[tt] == 1) {
int a = L[tt], b = R[tt];
int& ans = res[tt];
if (a < b) {
int z = st.qry(a, b - 1).val[0];
ans = max(ans, mn * (z + (z > 0)));
}
} else {
for (const auto& p : qc[tt]) {
st.upd(p.first, p.second);
}
}
}
}
segtree<Max<int>, int> lns(LN);
for (int tt = 0; tt < q; tt++) {
if (OP[tt] == 1) {
cout << max(res[tt], lns.qry(L[tt], R[tt]).val) << '\n';
} else {
lns.upd(L[tt], R[tt]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int SIZE = 1 << 17;
string s[SIZE];
int h[SIZE];
int ma[SIZE * 2 + 100];
vector<pair<int, int> > stkL[SIZE * 2 + 100], stkR[SIZE * 2 + 100];
void pre(int n) {
for (int i = (2); i < (n + 1); ++i) {
while (h[i] < min(((int)(s[i - 1]).size()), ((int)(s[i]).size())) &&
s[i - 1][h[i]] == s[i][h[i]])
h[i]++;
}
}
int sid;
void pull(int id, int mm_v, int idL = 0, int idR = 0) {
if (idL == 0) idL = id * 2;
if (idR == 0) idR = id * 2 + 1;
ma[id] = max(ma[idL], ma[idR]);
int itR = 0, itL = 0;
int num = 0;
while (itR < ((int)(stkR[idL]).size()) && stkR[idL][itR].first >= mm_v)
num += stkR[idL][itR++].second;
while (itL < ((int)(stkL[idR]).size()) && stkL[idR][itL].first >= mm_v)
num += stkL[idR][itL++].second;
ma[id] = max(ma[id], num * mm_v);
while (itR < ((int)(stkR[idL]).size()) && itL < ((int)(stkL[idR]).size())) {
if (stkR[idL][itR] >= stkL[idR][itL]) {
num += stkR[idL][itR].second;
ma[id] = max(ma[id], num * stkR[idL][itR++].first);
} else {
num += stkL[idR][itL].second;
ma[id] = max(ma[id], num * stkL[idR][itL++].first);
}
}
while (itR < ((int)(stkR[idL]).size())) {
num += stkR[idL][itR].second;
ma[id] = max(ma[id], num * stkR[idL][itR++].first);
}
while (itL < ((int)(stkL[idR]).size())) {
num += stkL[idR][itL].second;
ma[id] = max(ma[id], num * stkL[idR][itL++].first);
}
stkL[id] = stkL[idL];
stkL[id].resize(((int)(stkL[idL]).size()) + ((int)(stkL[idR]).size()));
itL = ((int)(stkL[idL]).size());
int now_v = min(stkL[idL].back().first, mm_v);
int it = 0;
int sp_num = 0;
while (it < ((int)(stkL[idR]).size()) && stkL[idR][it].first >= now_v) {
sp_num += stkL[idR][it++].second;
}
if (sp_num) {
if (now_v == stkL[idL].back().first) {
stkL[id][((int)(stkL[idL]).size()) - 1].second += sp_num;
} else {
stkL[id][itL++] = make_pair(now_v, sp_num);
}
sp_num = 0;
}
for (; it < ((int)(stkL[idR]).size()); it++) stkL[id][itL++] = stkL[idR][it];
stkL[id].resize(itL);
stkR[id] = stkR[idR];
stkR[id].resize(((int)(stkR[idL]).size()) + ((int)(stkR[idR]).size()));
itR = ((int)(stkR[idR]).size());
now_v = min(stkR[idR].back().first, mm_v);
it = 0;
while (it < ((int)(stkR[idL]).size()) && stkR[idL][it].first >= now_v) {
sp_num += stkR[idL][it++].second;
}
if (sp_num) {
if (now_v == stkR[idR].back().first) {
stkR[id][((int)(stkR[idR]).size()) - 1].second += sp_num;
} else {
stkR[id][itR++] = make_pair(now_v, sp_num);
}
sp_num = 0;
}
for (; it < ((int)(stkR[idL]).size()); it++) stkR[id][itR++] = stkR[idL][it];
stkR[id].resize(itR);
}
void build(int L, int R, int id) {
int mm = (L + R) / 2;
if (L == R) {
ma[id] = ((int)(s[L]).size());
stkL[id] = stkR[id] = vector<pair<int, int> >(1, make_pair(ma[id], 1));
return;
}
build(L, mm, id * 2);
build(mm + 1, R, id * 2 + 1);
pull(id, h[mm + 1]);
}
void print(string name, vector<pair<int, int> >& x) {
printf("[%s:", name.c_str());
for (int i = 0; i < (((int)(x).size())); ++i)
printf("(%d,%d)%c", x[i].first, x[i].second,
",]"[i == ((int)(x).size()) - 1]);
puts("");
}
int qq(int L, int R, int id, int ll, int rr, int rid) {
if (R < ll || L > rr) {
stkL[rid] = stkR[rid] = vector<pair<int, int> >();
ma[rid] = 0;
return 0;
}
if (L >= ll && R <= rr) {
stkR[rid] = stkR[id];
stkL[rid] = stkL[id];
ma[rid] = ma[id];
return ma[id];
}
int mm = (L + R) / 2;
if (rr <= mm) return qq(L, mm, id * 2, ll, rr, rid);
if (ll > mm) return qq(mm + 1, R, id * 2 + 1, ll, rr, rid);
int ridL = sid++;
int ridR = sid++;
int ret = max(qq(L, mm, id * 2, ll, rr, ridL),
qq(mm + 1, R, id * 2 + 1, ll, rr, ridR));
pull(rid, h[mm + 1], ridL, ridR);
ret = max(ret, ma[rid]);
return ret;
}
void edit(int L, int R, int id, int x) {
if (L == R) {
ma[id] = ((int)(s[L]).size());
stkL[id] = stkR[id] = vector<pair<int, int> >(1, make_pair(ma[id], 1));
return;
}
int mm = (L + R) / 2;
if (x <= mm)
edit(L, mm, id * 2, x);
else
edit(mm + 1, R, id * 2 + 1, x);
pull(id, h[mm + 1]);
}
void update(int x, int n) {
cin >> s[x];
for (int i = (max(2, x)); i < (min(x + 1, n) + 1); ++i) {
h[i] = 0;
while (h[i] < min(((int)(s[i - 1]).size()), ((int)(s[i]).size())) &&
s[i - 1][h[i]] == s[i][h[i]])
h[i]++;
}
edit(1, n, 1, x);
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = (1); i < (n + 1); ++i) cin >> s[i];
pre(n);
build(1, n, 1);
for (int ker = 0; ker < (q); ++ker) {
int(ty);
scanf("%d", &ty);
if (ty == 1) {
int x, y;
scanf("%d%d", &x, &y);
sid = SIZE * 2;
printf("%d\n", qq(1, n, 1, x, y, sid++));
} else {
int(x);
scanf("%d", &x);
update(x, n);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[700000];
int Max[700000], L[700000], R[700000], ls[700000], rs[700000], root[700000],
tot = 0, lcp[700000], n, last[700000], a[700000], sta[700000], tmp[700000];
inline int read() {
int 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 * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
vector<int> vec[700000];
namespace Tree {
int mx[700000];
inline void update(int l, int r, int x, int p) {
if (l == r) {
mx[x] = vec[p].size();
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
update(l, mid, x << 1, p);
else
update(mid + 1, r, x << 1 | 1, p);
mx[x] = max(mx[x << 1], mx[x << 1 | 1]);
}
inline int query(int l, int r, int x, int ll, int rr) {
if (ll <= l && r <= rr) return mx[x];
int mid = (l + r) >> 1, res = 0;
if (ll <= mid) res = max(res, query(l, mid, x << 1, ll, rr));
if (rr > mid) res = max(res, query(mid + 1, r, x << 1 | 1, ll, rr));
return res;
}
}; // namespace Tree
inline int find(int x) {
int i;
for (i = 0; i < min(vec[x].size(), vec[x - 1].size()); ++i)
if (vec[x][i] != vec[x - 1][i]) return i;
return min(vec[x].size(), vec[x - 1].size());
}
inline void pushup(int x, int l, int r) {
int mid = (l + r) >> 1;
Max[x] = max(R[ls[x]] + L[rs[x]], max(Max[ls[x]], Max[rs[x]]));
L[x] = L[ls[x]], R[x] = R[rs[x]];
if (L[ls[x]] == (mid - l + 1)) L[x] += L[rs[x]];
if (R[rs[x]] == (r - mid)) R[x] += R[ls[x]];
}
inline void update(int &x, int l, int r, int p, int opt) {
if (!x) x = ++tot;
if (l == r) {
Max[x] = L[x] = R[x] = opt;
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
update(ls[x], l, mid, p, opt);
else
update(rs[x], mid + 1, r, p, opt);
pushup(x, l, r);
}
inline void modify(int x, int opt) {
int i, p = 0;
if (lcp[x] <= 70) {
for (i = 1; i <= lcp[x]; ++i) update(root[i], 1, n, x, opt);
} else if (!opt) {
for (i = 1; i <= 70; ++i) update(root[i], 1, n, x, 0);
p = 0;
while (last[p] != x) p = last[p];
last[p] = last[x], last[x] = 0;
} else {
for (i = 1; i <= 70; ++i) update(root[i], 1, n, x, 1);
p = 0;
while (last[p] && last[p] < x) p = last[p];
last[x] = last[p], last[p] = x;
}
}
inline int query(int x, int l, int r, int ll, int rr) {
if (!x) return 0;
if (ll <= l && r <= rr) return Max[x];
int mid = (l + r) >> 1, res = 0;
if (ll <= mid) res = max(res, query(ls[x], l, mid, ll, rr));
if (rr > mid) res = max(res, query(rs[x], mid + 1, r, ll, rr));
if (ll <= mid && rr > mid)
res = max(res, min(R[ls[x]], mid - ll + 1) + min(L[rs[x]], rr - mid));
return res;
}
inline int solve(int l, int r) {
int p = 0, num = 0, top = 0, i, res = 0;
while (last[p]) p = last[p], a[++num] = p, num -= (p < l || p > r);
sta[0] = a[1] - 1;
for (i = 1; i <= num; ++i) {
if (top && a[i] != sta[top] + 1) top = 0, sta[0] = a[i] - 1;
while (top && lcp[a[i]] <= lcp[sta[top]]) --top;
tmp[i] = sta[top], sta[++top] = a[i];
}
top = 0, sta[0] = a[num] + 1;
for (i = num; i; --i) {
if (top && a[i] != sta[top] - 1) top = 0, sta[0] = a[i] + 1;
while (top && lcp[a[i]] <= lcp[sta[top]]) --top;
res = max(res, lcp[a[i]] * (sta[top] - tmp[i]));
sta[++top] = a[i];
}
return res;
}
int main() {
int q, lens, l, r, j, i, opt, w, ans = 0, x;
n = read(), q = read();
for (i = 1; i <= n; ++i) {
scanf("%s", str + 1), lens = strlen(str + 1);
for (j = 1; j <= lens; ++j) vec[i].push_back(str[j] - 'a');
Tree::update(1, n, 1, i);
lcp[i] = find(i);
modify(i, 1);
}
while (q--) {
opt = read();
if (opt == 1) {
l = read(), r = read();
ans = Tree::query(1, n, 1, l, r);
if (l == r) {
printf("%d\n", ans);
continue;
}
for (i = 1; i <= 70; ++i)
w = query(root[i], 1, n, l + 1, r),
ans = max(ans, i * (w > 0 ? w + 1 : 0));
ans = max(ans, solve(l + 1, r));
printf("%d\n", ans);
} else {
x = read(), scanf("%s", str + 1), lens = strlen(str + 1);
vec[x].clear();
for (i = 1; i <= lens; ++i) vec[x].push_back(str[i] - 'a');
Tree::update(1, n, 1, x);
modify(x, 0), lcp[x] = find(x), modify(x, 1);
if (x == n) continue;
modify(x + 1, 0), lcp[x + 1] = find(x + 1), modify(x + 1, 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, Q;
string S[100005];
char Str[100005];
int X[100005];
int Left[45][400005], Right[45][400005], Arb[45][400005];
int Arb2[400005];
const int limit = 40;
int Right2, ans;
set<int> P;
int Next[100005], Prev[100005];
int Aux[100005], Stack[100005];
void Read() {
scanf("%d%d ", &N, &Q);
for (int i = 1; i <= N; i++) {
scanf("%s", Str);
S[i] += (Str);
}
}
int LCP(int a, int b) {
int i, j;
for (i = 0, j = 0; i < S[a].size() && j < S[b].size() && S[a][i] == S[b][j];
i++, j++)
;
return i;
}
void buildX() {
for (int i = 1; i < N; i++) {
X[i] = LCP(i, i + 1);
if (X[i] > limit) P.insert(i);
}
}
void buildTree(int val, int K, int L, int R) {
if (L == R) {
if (X[L] >= val) {
Arb[val][K] = Left[val][K] = Right[val][K] = 1;
} else
Arb[val][K] = Left[val][K] = Right[val][K] = 0;
return;
}
buildTree(val, K * 2, L, (L + R) / 2);
buildTree(val, K * 2 + 1, (L + R) / 2 + 1, R);
Arb[val][K] = max(Arb[val][K * 2], Arb[val][K * 2 + 1]);
Arb[val][K] = max(Arb[val][K], Right[val][K * 2] + Left[val][K * 2 + 1]);
if (Left[val][K * 2] == (L + R) / 2 - L + 1)
Left[val][K] = Left[val][K * 2] + Left[val][K * 2 + 1];
else
Left[val][K] = Left[val][K * 2];
if (Right[val][K * 2 + 1] == R - (L + R) / 2)
Right[val][K] = Right[val][K * 2] + Right[val][K * 2 + 1];
else
Right[val][K] = Right[val][K * 2 + 1];
}
void buildTree2(int K, int L, int R) {
if (L == R) {
Arb2[K] = S[L].size();
return;
}
buildTree2(K * 2, L, (L + R) / 2);
buildTree2(K * 2 + 1, (L + R) / 2 + 1, R);
Arb2[K] = max(Arb2[K * 2], Arb2[K * 2 + 1]);
}
void Update(int val, int K, int L, int R, int pos, int v) {
if (L > R || R < pos || L > pos) return;
if (L == R) {
Arb[val][K] = Left[val][K] = Right[val][K] = v;
return;
}
Update(val, K * 2, L, (L + R) / 2, pos, v);
Update(val, K * 2 + 1, (L + R) / 2 + 1, R, pos, v);
Arb[val][K] = max(Arb[val][K * 2], Arb[val][K * 2 + 1]);
Arb[val][K] = max(Arb[val][K], Right[val][K * 2] + Left[val][K * 2 + 1]);
if (Left[val][K * 2] == (L + R) / 2 - L + 1)
Left[val][K] = Left[val][K * 2] + Left[val][K * 2 + 1];
else
Left[val][K] = Left[val][K * 2];
if (Right[val][K * 2 + 1] == R - (L + R) / 2)
Right[val][K] = Right[val][K * 2] + Right[val][K * 2 + 1];
else
Right[val][K] = Right[val][K * 2 + 1];
}
void Update2(int K, int L, int R, int pos, int val) {
if (L > R || L > pos || R < pos) return;
if (L == R) {
Arb2[K] = val;
return;
}
if (pos > (L + R) / 2)
Update2(K * 2 + 1, (L + R) / 2 + 1, R, pos, val);
else
Update2(K * 2, L, (L + R) / 2, pos, val);
Arb2[K] = max(Arb2[K * 2], Arb2[K * 2 + 1]);
}
int Query2(int K, int L, int R, int x, int y) {
if (L > R || L > y || R < x) return 0;
if (L >= x && R <= y) return Arb2[K];
int a = Query2(K * 2, L, (L + R) / 2, x, y);
int b = Query2(K * 2 + 1, (L + R) / 2 + 1, R, x, y);
return max(a, b);
}
void Query(int val, int K, int L, int R, int x, int y) {
if (L > R || L > y || R < x) {
return;
}
if (L >= x && R <= y) {
ans = max(ans, Arb[val][K]);
ans = max(ans, Right2 + Left[val][K]);
if (Right[val][K] == R - L + 1)
Right2 += Right[val][K];
else
Right2 = Right[val][K];
return;
}
Query(val, K * 2, L, (L + R) / 2, x, y);
Query(val, K * 2 + 1, (L + R) / 2 + 1, R, x, y);
}
void Upd() {
int pos;
scanf("%d ", &pos);
scanf("%s", Str);
S[pos].clear();
S[pos] += Str;
if (pos > 1) {
if (X[pos - 1] > limit) P.erase(pos - 1);
X[pos - 1] = LCP(pos - 1, pos);
if (X[pos - 1] > limit) P.insert(pos - 1);
int l = min(X[pos - 1], limit);
for (int i = 1; i <= l; i++) {
Update(i, 1, 1, N - 1, pos - 1, 1);
}
for (int i = X[pos - 1] + 1; i <= limit; i++)
Update(i, 1, 1, N - 1, pos - 1, 0);
}
if (pos < N) {
if (X[pos] > limit) P.erase(pos);
X[pos] = LCP(pos, pos + 1);
if (X[pos] > limit) P.insert(pos);
int l = min(X[pos], limit);
for (int i = 1; i <= l; i++) {
Update(i, 1, 1, N - 1, pos, 1);
}
for (int i = X[pos] + 1; i <= limit; i++) Update(i, 1, 1, N - 1, pos, 0);
}
Update2(1, 1, N, pos, S[pos].size());
}
void Qu(int left, int right) {
long long res = 0;
if (N == 1) {
res = max(res, 1LL * Query2(1, 1, N, left, right));
printf("%I64d\n", res);
return;
}
for (int i = 1; i <= limit; i++) {
ans = Right2 = 0;
if (left < right) Query(i, 1, 1, N - 1, left, right - 1);
if (ans > 0) res = max(res, 1LL * i * (ans + 1));
}
res = max(res, 1LL * Query2(1, 1, N, left, right));
auto it = P.lower_bound(left);
int cnt = 0;
if (it != P.end() && *it < right) {
Aux[++cnt] = X[*it];
it = next(it);
for (; it != P.end(); it = next(it)) {
if (*it >= right) break;
if (*it - *prev(it) > 1) {
Aux[++cnt] = 0;
}
Aux[++cnt] = X[*it];
}
for (int j = 1; j <= cnt; j++) Next[j] = cnt + 1, Prev[j] = 0;
int top = 0;
for (int j = 1; j <= cnt; j++) {
while (top > 0 && Aux[j] < Aux[Stack[top]]) {
Next[Stack[top]] = j;
--top;
}
Stack[++top] = j;
}
top = 0;
for (int j = cnt; j >= 1; j--) {
while (top > 0 && Aux[j] < Aux[Stack[top]]) {
Prev[Stack[top]] = j;
--top;
}
Stack[++top] = j;
}
for (int j = 1; j <= cnt; j++) {
res = max(res, 1LL * Aux[j] * (Next[j] - Prev[j]));
}
}
printf("%I64d\n", res);
}
int main() {
Read();
buildX();
if (N > 1) {
for (int i = 1; i <= limit; i++) buildTree(i, 1, 1, N - 1);
}
buildTree2(1, 1, N);
for (int i = 1; i <= Q; i++) {
int type;
scanf("%d", &type);
if (type == 2)
Upd();
else {
int l, r;
scanf("%d%d", &l, &r);
Qu(l, r);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXLEN = 100000;
const int MAXN = 100000;
const int MAXQ = 100000;
const int MAXTN = MAXLEN + 1;
const int MAXLG = 16;
const int MAXSN = 4 * (MAXN - 1);
const int MAXZN = 4 * MAXN;
typedef struct SN {
int best;
vector<int> preidx, sufidx;
} SN;
int n, nq;
char buff[MAXLEN + 1];
string s[MAXN];
int qkind[MAXQ], ql[MAXQ], qr[MAXQ], qidx[MAXQ], qlen[MAXQ];
string qs[MAXQ];
int lcp[MAXN - 1];
SN sn[MAXSN];
void print(const SN &a) {
printf("[");
for (int i = (0); i < (((int)(a.preidx).size())); ++i) {
if (i != 0) printf(",");
printf("%d", a.preidx[i]);
}
printf("][");
for (int i = (0); i < (((int)(a.sufidx).size())); ++i) {
if (i != 0) printf(",");
printf("%d", a.sufidx[i]);
}
printf("]->%d", a.best);
}
int calc(int l, int r, int mn) { return (r - l + 2) * mn; }
SN makesn(int idx) {
SN ret;
ret.best = calc(idx, idx, lcp[idx]);
ret.preidx.push_back(idx);
ret.sufidx.push_back(idx);
return ret;
}
SN combine(const SN &a, const SN &b) {
SN ret;
ret.best = max(a.best, b.best);
int ai = ((int)(a.sufidx).size()) - 1, bi = ((int)(b.preidx).size()) - 1;
while (true) {
if (lcp[a.sufidx[ai]] >= lcp[b.preidx[bi]]) {
if (ai == 0) {
for (int i = (0); i <= (bi); ++i) ret.preidx.push_back(b.preidx[i]);
for (int i = (0); i < (((int)(a.preidx).size())); ++i)
if (lcp[a.preidx[i]] == lcp[ret.preidx.back()])
ret.preidx[((int)(ret.preidx).size()) - 1] = a.preidx[i];
else
ret.preidx.push_back(a.preidx[i]);
ret.sufidx = b.sufidx;
break;
} else {
int cur =
calc(a.sufidx[ai - 1] + 1, b.preidx[bi] - 1, lcp[a.sufidx[ai]]);
if (cur > ret.best) ret.best = cur;
--ai;
}
} else {
if (bi == 0) {
ret.preidx = a.preidx;
for (int i = (0); i <= (ai); ++i) ret.sufidx.push_back(a.sufidx[i]);
for (int i = (0); i < (((int)(b.sufidx).size())); ++i)
if (lcp[b.sufidx[i]] == lcp[ret.sufidx.back()])
ret.sufidx[((int)(ret.sufidx).size()) - 1] = b.sufidx[i];
else
ret.sufidx.push_back(b.sufidx[i]);
break;
} else {
int cur =
calc(a.sufidx[ai] + 1, b.preidx[bi - 1] - 1, lcp[b.preidx[bi]]);
if (cur > ret.best) ret.best = cur;
--bi;
}
}
}
int l = ret.preidx.back(), r = ret.sufidx.back();
ret.best = max(ret.best, calc(l, r, lcp[ret.preidx[0]]));
for (int i = (1); i < (((int)(ret.preidx).size())); ++i)
ret.best =
max(ret.best, calc(l, ret.preidx[i - 1] - 1, lcp[ret.preidx[i]]));
for (int i = (1); i < (((int)(ret.sufidx).size())); ++i)
ret.best =
max(ret.best, calc(ret.sufidx[i - 1] + 1, r, lcp[ret.sufidx[i]]));
return ret;
}
void sinit(int x, int l, int r) {
if (l == r) {
sn[x] = makesn(l);
} else {
int m = l + (r - l) / 2;
sinit(2 * x + 1, l, m);
sinit(2 * x + 2, m + 1, r);
sn[x] = combine(sn[2 * x + 1], sn[2 * x + 2]);
}
}
void sset(int x, int l, int r, int IDX) {
if (l == r) {
sn[x] = makesn(l);
} else {
int m = l + (r - l) / 2;
if (IDX <= m)
sset(2 * x + 1, l, m, IDX);
else
sset(2 * x + 2, m + 1, r, IDX);
sn[x] = combine(sn[2 * x + 1], sn[2 * x + 2]);
}
}
SN sget(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) return sn[x];
int m = l + (r - l) / 2;
if (R <= m) return sget(2 * x + 1, l, m, L, R);
if (m + 1 <= L) return sget(2 * x + 2, m + 1, r, L, R);
return combine(sget(2 * x + 1, l, m, L, R), sget(2 * x + 2, m + 1, r, L, R));
}
int len[MAXN];
int zn[MAXZN];
void zinit(int x, int l, int r) {
if (l == r) {
zn[x] = len[l];
} else {
int m = l + (r - l) / 2;
zinit(2 * x + 1, l, m);
zinit(2 * x + 2, m + 1, r);
zn[x] = max(zn[2 * x + 1], zn[2 * x + 2]);
}
}
void zset(int x, int l, int r, int IDX) {
if (l == r) {
zn[x] = len[l];
} else {
int m = l + (r - l) / 2;
if (IDX <= m)
zset(2 * x + 1, l, m, IDX);
else
zset(2 * x + 2, m + 1, r, IDX);
zn[x] = max(zn[2 * x + 1], zn[2 * x + 2]);
}
}
int zget(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) return zn[x];
int m = l + (r - l) / 2;
if (R <= m) return zget(2 * x + 1, l, m, L, R);
if (m + 1 <= L) return zget(2 * x + 2, m + 1, r, L, R);
return max(zget(2 * x + 1, l, m, L, R), zget(2 * x + 2, m + 1, r, L, R));
}
int ans[MAXQ];
int calclcp(const string &a, const string &b) {
int ret = 0;
while (ret < ((int)(a).size()) && ret < ((int)(b).size()) && a[ret] == b[ret])
++ret;
return ret;
}
void solve() {
for (int i = (0); i < (n - 1); ++i) lcp[i] = calclcp(s[i], s[i + 1]);
if (n >= 2) sinit(0, 0, n - 2);
zinit(0, 0, n - 1);
for (int i = (0); i < (nq); ++i) {
if (qkind[i] == 1) {
ans[i] = zget(0, 0, n - 1, ql[i], qr[i]);
if (ql[i] != qr[i]) {
SN cur = sget(0, 0, n - 2, ql[i], qr[i] - 1);
if (cur.best > ans[i]) ans[i] = cur.best;
}
}
if (qkind[i] == 2) {
int idx = qidx[i];
s[idx] = qs[i];
len[idx] = qlen[i];
zset(0, 0, n - 1, idx);
if (idx >= 1) {
lcp[idx - 1] = calclcp(s[idx - 1], s[idx]);
sset(0, 0, n - 2, idx - 1);
}
if (idx + 1 < n) {
lcp[idx] = calclcp(s[idx], s[idx + 1]);
sset(0, 0, n - 2, idx);
}
}
}
}
void run() {
scanf("%d%d", &n, &nq);
for (int i = (0); i < (n); ++i) {
scanf("%s", buff);
s[i] = buff, len[i] = ((int)(s[i]).size());
}
for (int i = (0); i < (nq); ++i) {
scanf("%d", &qkind[i]);
if (qkind[i] == 1) {
scanf("%d%d", &ql[i], &qr[i]);
--ql[i], --qr[i];
}
if (qkind[i] == 2) {
scanf("%d%s", &qidx[i], buff);
--qidx[i], qs[i] = buff, qlen[i] = ((int)(qs[i]).size());
}
}
solve();
for (int i = (0); i < (nq); ++i)
if (qkind[i] == 1) printf("%d\n", ans[i]);
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int S = 80;
int n, m, a[N];
string s[N];
struct item {
int sum, suf[S + 1], pref[S + 1], ans;
item(int x) {
x = min(x, S);
for (int i = 0; i <= S; i++) {
suf[i] = pref[i] = (i <= x);
}
ans = x;
sum = 1;
}
item() {
ans = sum = 0;
memset(suf, 0, sizeof(suf));
memset(pref, 0, sizeof(pref));
}
};
item t[4 * N];
inline item mrg(item a, item b) {
item c;
c.ans = max(a.ans, b.ans);
c.sum = a.sum + b.sum;
for (int i = 0; i <= S; i++) {
c.pref[i] = a.pref[i];
if (a.pref[i] == a.sum) {
c.pref[i] += b.pref[i];
}
c.suf[i] = b.suf[i];
if (b.suf[i] == b.sum) {
c.suf[i] += a.suf[i];
}
if (a.suf[i] > 0 || b.pref[i] > 0) {
c.ans = max(c.ans, i * (a.suf[i] + b.pref[i] + 1));
}
}
return c;
}
void update(int v, int l, int r, int pos, int val) {
if (l == r) {
t[v] = item(val);
return;
}
int mid = (r + l) >> 1;
if (pos <= mid) {
update(v + v, l, mid, pos, val);
} else {
update(v + v + 1, mid + 1, r, pos, val);
}
t[v] = mrg(t[v + v], t[v + v + 1]);
}
item get(int v, int l, int r, int tl, int tr) {
if (l > r || l > tr || tl > r) {
return item();
}
if (tl <= l && r <= tr) {
return t[v];
}
int mid = (r + l) >> 1;
return mrg(get(v + v, l, mid, tl, tr), get(v + v + 1, mid + 1, r, tl, tr));
}
set<int> q;
int st[4 * N], le[4 * N], ri[4 * N];
inline int lcp(int x, int y) {
int cur = 0;
while (cur < (int)s[x].size() && cur < (int)s[y].size() &&
s[x][cur] == s[y][cur]) {
cur += 1;
}
return cur;
}
int f[4 * N];
int gett(int v, int l, int r, int tl, int tr) {
if (l > r || l > tr || tl > r) {
return 0;
}
if (tl <= l && r <= tr) {
return f[v];
}
int mid = (r + l) >> 1;
return max(gett(v + v, l, mid, tl, tr), gett(v + v + 1, mid + 1, r, tl, tr));
}
void upd(int v, int l, int r, int pos, int val) {
if (l == r) {
f[v] = val;
return;
}
int mid = (r + l) >> 1;
if (pos <= mid) {
upd(v + v, l, mid, pos, val);
} else {
upd(v + v + 1, mid + 1, r, pos, val);
}
f[v] = max(f[v + v], f[v + v + 1]);
}
void add(int pos) {
a[pos] = lcp(pos, pos + 1);
update(1, 1, n, pos, a[pos]);
if (a[pos] > S) {
q.insert(pos);
}
}
void del(int pos) { q.erase(pos); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> s[i];
upd(1, 1, n, i, (int)s[i].size());
}
for (int i = 1; i + 1 <= n; i++) {
add(i);
}
while (m--) {
int t;
cin >> t;
if (t == 1) {
int l, r;
cin >> l >> r;
if (l == r) {
cout << (int)s[l].size() << "\n";
continue;
}
int ans = max(get(1, 1, n, l, r - 1).ans, gett(1, 1, n, l, r));
int prv = -1, sz = 0;
for (auto it = q.lower_bound(l); it != q.lower_bound(r); it++) {
if (*it - 1 != prv) {
st[++sz] = 0;
}
prv = *it;
st[++sz] = a[prv];
}
vector<int> z;
st[0] = st[sz + 1] = -1e9;
z.push_back(0);
for (int i = 1; i <= sz; i++) {
while (!z.empty() && st[z.back()] >= st[i]) {
z.pop_back();
}
le[i] = z.back();
z.push_back(i);
}
z.clear();
z.push_back(sz + 1);
for (int i = sz; i >= 1; i--) {
while (!z.empty() && st[z.back()] >= st[i]) {
z.pop_back();
}
ri[i] = z.back();
ans = max(ans, (ri[i] - le[i]) * st[i]);
z.push_back(i);
}
cout << ans << "\n";
} else {
int x;
string y;
cin >> x >> y;
if (x - 1 >= 1) {
del(x - 1);
}
if (x + 1 <= n) {
del(x);
}
s[x] = y;
upd(1, 1, n, x, (int)s[x].size());
if (x - 1 >= 1) {
add(x - 1);
}
if (x + 1 <= n) {
add(x);
}
}
}
}
|
#include <bits/stdc++.h>
template <typename T>
T min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T max(T x, T y) {
return x > y ? x : y;
};
const int MAXN = 100005;
struct tree1 {
private:
int mx;
int l;
int r;
tree1 *lson;
tree1 *rson;
public:
tree1() {
mx = 0;
lson = rson = NULL;
}
void build(int L, int R) {
l = L;
r = R;
if (l == r) return;
lson = new tree1;
rson = new tree1;
int mid = (l + r) / 2;
lson->build(l, mid);
rson->build(mid + 1, r);
}
void modify(int id, int k) {
if (l == r) {
mx = k;
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
mx = max(lson->mx, rson->mx);
}
int query(int L, int R) {
if (l >= L && r <= R) return mx;
int mid = (l + r) / 2;
if (R <= mid) return lson->query(L, R);
if (L > mid) return rson->query(L, R);
return max(lson->query(L, R), rson->query(L, R));
}
};
struct line {
int k;
int b;
line(int K = 0, int B = 0) {
k = K;
b = B;
}
int calc(int x) { return k * x + b; }
double cross(line t) { return (double)(t.b - b) / (k - t.k); }
};
struct tree {
bool tag;
int l;
int r;
line *L;
int cnt;
line *R;
int rcnt;
int mx;
tree *lson;
tree *rson;
tree() {
tag = false;
L = R = NULL;
cnt = rcnt = mx = 0;
lson = rson = NULL;
}
void fixup() {
static line tmp[MAXN];
l = lson->l;
r = rson->r;
if (L) delete L;
L = new line[lson->cnt + rson->cnt];
cnt = lson->cnt;
for (int i = 0; i < cnt; i++) L[i] = lson->L[i];
for (int i = 0; i < rson->cnt; i++) {
if (rson->L[i].k >= L[cnt - 1].k)
L[cnt - 1].b = (lson->r - lson->l + 1) + rson->L[i].b;
else {
L[cnt++] = rson->L[i];
L[cnt - 1].b += (lson->r - lson->l + 1);
}
}
if (R) delete R;
R = new line[lson->rcnt + rson->rcnt];
rcnt = rson->rcnt;
for (int i = 0; i < rcnt; i++) R[i] = rson->R[i];
for (int i = 0; i < lson->rcnt; i++) {
if (lson->R[i].k >= R[rcnt - 1].k)
R[rcnt - 1].b = (rson->r - rson->l + 1) + lson->R[i].b;
else {
R[rcnt++] = lson->R[i];
R[rcnt - 1].b += (rson->r - rson->l + 1);
}
}
mx = max(lson->mx, rson->mx);
int cur = 0, p = 0, s = 0;
memset(tmp, 0, sizeof(line) * rson->cnt);
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
for (int i = 0; i < lson->rcnt; i++) {
while (cur < rson->cnt && rson->L[cur].k < lson->R[i].k) {
line t = rson->L[cur++];
t.b = (t.b + 1) * t.k;
while (s > 1 && tmp[s - 2].cross(t) < tmp[s - 2].cross(tmp[s - 1])) s--;
if (p >= s) p = max(s - 1, 0);
tmp[s++] = t;
}
while (p < s - 1 &&
tmp[p].calc(lson->R[i].b) < tmp[p + 1].calc(lson->R[i].b))
p++;
while (p && tmp[p].calc(lson->R[i].b) < tmp[p - 1].calc(lson->R[i].b))
p--;
if (cur < rson->cnt)
mx = max(mx, (lson->R[i].b + rson->L[cur].b + 1) * lson->R[i].k);
mx = max(mx, tmp[p].calc(lson->R[i].b));
}
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
}
void build(int rL, int rR, int *a) {
tag = true;
l = rL;
r = rR;
if (l == r) {
mx = a[l] * 2;
L = new line[1];
R = new line[1];
cnt = rcnt = 1;
L[0] = R[0] = line(a[l], 1);
return;
}
int mid = (l + r) / 2;
lson = new tree;
rson = new tree;
lson->build(l, mid, a);
rson->build(mid + 1, r, a);
fixup();
}
void modify(int id, int k) {
if (l == r) {
mx = k * 2;
L[0] = R[0] = line(k, 1);
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
fixup();
}
tree *query(int rL, int rR) {
if (l >= rL && r <= rR) return this;
int mid = (l + r) / 2;
if (rR <= mid) return lson->query(rL, rR);
if (rL > mid) return rson->query(rL, rR);
tree *temp = new tree;
temp->lson = lson->query(rL, rR);
temp->rson = rson->query(rL, rR);
temp->fixup();
return temp;
}
void query_clear() {
if (tag) return;
lson->query_clear();
rson->query_clear();
if (L) delete L;
if (R) delete R;
}
};
void print(int *a, int n) {
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
}
int N, q;
tree1 T1;
tree T;
char *s[MAXN], str[MAXN];
int len[MAXN], lcp[MAXN];
void init() {
scanf("%d %d", &N, &q);
T1.build(1, N);
for (int i = 1; i <= N; i++) {
scanf("%s", str);
len[i] = strlen(str);
s[i] = new char[len[i]];
memcpy(s[i], str, sizeof(char) * len[i]);
T1.modify(i, len[i]);
}
for (int i = 1; i < N; i++) {
int t = 0;
while (t < len[i] && t < len[i + 1] && s[i][t] == s[i + 1][t]) t++;
lcp[i] = t;
}
if (N > 1) T.build(1, N - 1, lcp);
}
int main() {
int ty, x, y;
init();
for (int i = 0; i < q; i++) {
scanf("%d %d", &ty, &x);
if (ty == 1) {
scanf("%d", &y);
int ans = T1.query(x, y);
if (x == y) {
printf("%d\n", ans);
continue;
}
tree *p = T.query(x, y - 1);
ans = max(ans, p->mx);
p->query_clear();
if (!p->l && !p->r) delete p;
std::cout << ans << std::endl;
} else {
scanf("%s", str);
len[x] = strlen(str);
s[x] = new char[len[x]];
memcpy(s[x], str, sizeof(char) * len[x]);
T1.modify(x, len[x]);
int t = 0;
if (x > 1) {
for (t = 0; t < len[x - 1] && t < len[x] && s[x - 1][t] == s[x][t]; t++)
;
lcp[x - 1] = t;
T.modify(x - 1, t);
}
if (x < N) {
for (t = 0; t < len[x] && t < len[x + 1] && s[x][t] == s[x + 1][t]; t++)
;
lcp[x] = t;
T.modify(x, t);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int BUBEN = (int)110;
struct Data {
int goLeft[BUBEN], goRight[BUBEN];
int res;
int length;
Data(int x) {
x = min(x, BUBEN - 1);
res = x;
length = 1;
for (int i = 0; i < BUBEN; i++) {
if (i <= x) {
goLeft[i] = goRight[i] = 1;
} else {
goLeft[i] = goRight[i] = 0;
}
}
}
Data() {}
};
void merge(const Data &l, const Data &r, Data &res) {
res.res = max(l.res, r.res);
res.length = l.length + r.length;
for (int i = 0; i < BUBEN; i++) {
res.goLeft[i] = l.goLeft[i];
if (res.goLeft[i] == l.length) res.goLeft[i] += r.goLeft[i];
res.goRight[i] = r.goRight[i];
if (res.goRight[i] == r.length) res.goRight[i] += l.goRight[i];
if (r.goLeft[i] || l.goRight[i]) {
res.res = max(res.res, i * (r.goLeft[i] + l.goRight[i] + 1));
}
}
}
struct SegmentTree {
Data *t;
Data tmp, tmp2;
int n;
SegmentTree(int n) : n(n) { t = new Data[4 * n + 3]; }
SegmentTree() {}
void change(int v, int tl, int tr, int pos, int val) {
if (tl == tr) {
t[v] = Data(val);
} else {
int tm = (tl + tr) >> 1;
if (pos <= tm) {
change(v + v, tl, tm, pos, val);
} else {
change(v + v + 1, tm + 1, tr, pos, val);
}
merge(t[v + v], t[v + v + 1], t[v]);
}
}
void build(int v, int tl, int tr, int *a) {
if (tl == tr) {
t[v] = Data(a[tl]);
} else {
int tm = (tl + tr) >> 1;
build(v + v, tl, tm, a);
build(v + v + 1, tm + 1, tr, a);
merge(t[v + v], t[v + v + 1], t[v]);
}
}
void build(int *a) { build(1, 1, n, a); }
void change(int pos, int val) { change(1, 1, n, pos, val); }
void get(int v, int tl, int tr, int l, int r) {
if (r < tl || l > tr) return;
if (tl >= l && tr <= r) {
merge(tmp, t[v], tmp2);
memcpy(&tmp, &tmp2, sizeof(tmp));
} else {
int tm = (tl + tr) >> 1;
get(v + v, tl, tm, l, r);
get(v + v + 1, tm + 1, tr, l, r);
}
}
int solve(int l, int r) {
memset(&tmp, 0, sizeof(tmp));
memset(&tmp2, 0, sizeof(tmp2));
get(1, 1, n, l, r);
return tmp.res;
}
};
int solveHistogram(const vector<int> &a) {
int n = (int)a.size();
vector<int> gol(n), gor(n);
vector<int> st;
st.reserve(n);
for (int i = 0; i < n; i++) {
while (!st.empty() && a[st.back()] >= a[i]) st.pop_back();
if (st.empty()) {
gol[i] = 0;
} else {
gol[i] = st.back() + 1;
}
st.push_back(i);
}
st.clear();
for (int i = n - 1; i >= 0; i--) {
while (!st.empty() && a[st.back()] >= a[i]) st.pop_back();
if (st.empty()) {
gor[i] = n - 1;
} else {
gor[i] = st.back() - 1;
}
st.push_back(i);
}
int res = 0;
for (int i = 0; i < n; i++) {
res = max(res, a[i] * (gor[i] - gol[i] + 2));
}
return res;
}
struct LargeSolver {
int *a;
int n;
set<int> largePoses;
LargeSolver(int n) : n(n) { a = new int[n + 1]; }
LargeSolver() {}
void change(int pos, int val) {
if (a[pos] >= BUBEN) {
largePoses.erase(pos);
}
a[pos] = val;
if (a[pos] >= BUBEN) {
largePoses.insert(pos);
}
}
int solve(int l, int r) {
auto it = largePoses.lower_bound(l);
int res = 0;
vector<int> cur;
int lst = -1;
while (it != largePoses.end() && (*it) <= r) {
int curPos = (*it);
if (curPos != lst + 1 && !cur.empty()) {
res = max(res, solveHistogram(cur));
cur.clear();
}
cur.push_back(a[curPos]);
lst = curPos;
it++;
}
if (!cur.empty()) {
res = max(res, solveHistogram(cur));
}
return res;
}
};
struct MaxSegmentTree {
int *t;
int n;
MaxSegmentTree(int n) : n(n) { t = new int[4 * n + 3]; }
MaxSegmentTree() {}
void change(int v, int tl, int tr, int pos, int val) {
if (tl == tr) {
t[v] = val;
} else {
int tm = (tl + tr) >> 1;
if (pos <= tm) {
change(v + v, tl, tm, pos, val);
} else {
change(v + v + 1, tm + 1, tr, pos, val);
}
t[v] = max(t[v + v], t[v + v + 1]);
}
}
void change(int pos, int val) { change(1, 1, n, pos, val); }
int getMax(int v, int tl, int tr, int l, int r) {
if (r < tl || l > tr) return 0;
if (tl >= l && tr <= r) return t[v];
int tm = (tl + tr) >> 1;
return max(getMax(v + v, tl, tm, l, r),
getMax(v + v + 1, tm + 1, tr, l, r));
}
int getMax(int l, int r) { return getMax(1, 1, n, l, r); }
};
struct DynamicHystogramSolver {
SegmentTree st;
LargeSolver ls;
DynamicHystogramSolver() {}
DynamicHystogramSolver(int *a, int n) {
st = SegmentTree(n);
st.build(a);
ls = LargeSolver(n);
for (int i = 1; i <= n; i++) {
ls.change(i, a[i]);
}
}
void change(int pos, int val) {
st.change(pos, val);
ls.change(pos, val);
}
int getMax(int l, int r) {
if (l > r) return 0;
return max(st.solve(l, r), ls.solve(l, r));
}
};
int getLCP(const string &s, const string &t) {
int ptr = 0;
while (ptr < (int)min(s.size(), t.size()) && s[ptr] == t[ptr]) ptr++;
return ptr;
}
struct Solver {
string *s;
int *lcp;
int n;
DynamicHystogramSolver dhs;
MaxSegmentTree st;
Solver(const vector<string> &a) {
n = a.size();
s = new string[n + 1];
lcp = new int[n + 1];
for (int i = 1; i <= n; i++) {
s[i] = a[i - 1];
}
for (int i = 1; i < n; i++) {
lcp[i] = getLCP(s[i], s[i + 1]);
}
dhs = DynamicHystogramSolver(lcp, n);
st = MaxSegmentTree(n);
for (int i = 1; i <= n; i++) {
st.change(i, (int)s[i].size());
}
}
void change(int pos, const string &str) {
s[pos] = str;
if (pos != 1) {
lcp[pos - 1] = getLCP(s[pos - 1], s[pos]);
dhs.change(pos - 1, lcp[pos - 1]);
}
if (pos != n) {
lcp[pos] = getLCP(s[pos], s[pos + 1]);
dhs.change(pos, lcp[pos]);
}
st.change(pos, (int)str.size());
}
int solve(int l, int r) { return max(dhs.getMax(l, r - 1), st.getMax(l, r)); }
};
const int MX = 300 * 1000 + 6;
char buf[MX];
string getString() {
scanf("%s", buf);
return string(buf);
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
vector<string> s(n);
for (int i = 0; i < n; i++) {
s[i] = getString();
}
Solver solver(s);
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int l, r;
scanf("%d %d", &l, &r);
printf("%d\n", solver.solve(l, r));
} else {
int pos;
scanf("%d ", &pos);
solver.change(pos, getString());
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
inline int getint() {
int _x = 0;
char _tc = getchar();
while (_tc < '0' || _tc > '9') _tc = getchar();
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x;
}
int st[202020 << 1];
void modify(int no, int l, int r, int p, int x) {
if (l == r) {
st[no] = x;
return;
}
if (p <= ((l + r) >> 1))
modify((no << 1), l, ((l + r) >> 1), p, x);
else
modify((1 + (no << 1)), ((l + r) >> 1) + 1, r, p, x);
st[no] = max(st[(no << 1)], st[(1 + (no << 1))]);
}
int query(int no, int l, int r, int ql, int qr) {
if (r < ql or l > qr or ql > qr) return 0;
if (ql <= l and r <= qr) return st[no];
return max(query((no << 1), l, ((l + r) >> 1), ql, qr),
query((1 + (no << 1)), ((l + r) >> 1) + 1, r, ql, qr));
}
struct Nd {
int mxc, mxl, mxr;
Nd *tl, *tr;
Nd() {
tl = tr = NULL;
mxc = mxl = mxr = 0;
}
};
Nd* root[202020];
int Con(Nd* now) { return now ? now->mxc : 0; }
int MXL(Nd* now) { return now ? now->mxl : 0; }
int MXR(Nd* now) { return now ? now->mxr : 0; }
void modify2(Nd* now, int l, int r, int pp, int xx) {
if (l == r) {
now->mxc = now->mxl = now->mxr = xx;
return;
}
if (pp <= ((l + r) >> 1)) {
if (!now->tl) now->tl = new Nd();
modify2(now->tl, l, ((l + r) >> 1), pp, xx);
} else {
if (!now->tr) now->tr = new Nd();
modify2(now->tr, ((l + r) >> 1) + 1, r, pp, xx);
}
now->mxl = MXL(now->tl);
if (MXL(now->tl) == ((l + r) >> 1) - l + 1) now->mxl += MXL(now->tr);
now->mxr = MXR(now->tr);
if (MXR(now->tr) == r - ((l + r) >> 1)) now->mxr += MXR(now->tl);
now->mxc = max(Con(now->tl), Con(now->tr));
now->mxc = max(now->mxc, MXR(now->tl) + MXL(now->tr));
}
tuple<int, int, int> query2(Nd* now, int l, int r, int ql, int qr) {
if (!now or (l == ql and r == qr))
return make_tuple(Con(now), MXL(now), MXR(now));
if (qr <= ((l + r) >> 1)) return query2(now->tl, l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < ql)
return query2(now->tr, ((l + r) >> 1) + 1, r, ql, qr);
tuple<int, int, int> retl =
query2(now->tl, l, ((l + r) >> 1), ql, ((l + r) >> 1));
tuple<int, int, int> retr =
query2(now->tr, ((l + r) >> 1) + 1, r, ((l + r) >> 1) + 1, qr);
int rl = get<1>(retl);
if (rl == ((l + r) >> 1) - ql + 1) rl += get<1>(retr);
int rr = get<2>(retr);
if (rr == qr - ((l + r) >> 1)) rr += get<2>(retl);
int rc = max(get<0>(retl), get<0>(retr));
rc = max(rc, get<2>(retl) + get<1>(retr));
return make_tuple(rc, rl, rr);
}
char c[202020 + 202020 + 202020];
int n, q, ss[202020], len[202020], ptr;
void init() {
n = getint();
q = getint();
for (int i = 1; i <= n; i++) {
scanf("%s", c + ptr);
ss[i] = ptr;
len[i] = strlen(c + ptr);
ptr += len[i] + 1;
}
}
int lcp[202020];
set<pair<int, int> > s;
void update(int cur, bool first) {
if (not first) {
if (lcp[cur] > 222) s.erase({cur, lcp[cur]});
for (int i = 1; i <= min(222, lcp[cur]); i++) {
if (!root[i]) root[i] = new Nd();
modify2(root[i], 1, n, cur, 0);
}
}
lcp[cur] = 0;
while (lcp[cur] < len[cur] and lcp[cur] < len[cur - 1] and
c[ss[cur] + lcp[cur]] == c[ss[cur - 1] + lcp[cur]])
lcp[cur]++;
for (int i = 1; i <= min(222, lcp[cur]); i++) {
if (!root[i]) root[i] = new Nd();
modify2(root[i], 1, n, cur, 1);
}
if (lcp[cur] > 222) s.insert({cur, lcp[cur]});
}
long long query2(int li, int ri) {
vector<pair<int, int> > vv;
while (true) {
auto it = s.lower_bound({li + 1, -1});
if (it == s.end() or it->first > ri) break;
vv.push_back(*it);
li = it->first;
}
if (vv.empty()) return 0;
vector<int> ltil, rtil;
for (size_t i = 0; i < vv.size(); i++) {
ltil.push_back(vv[i].first);
rtil.push_back(vv[i].first);
}
vector<pair<int, int> > wt;
wt.push_back({vv[0].first - 1, 0});
for (size_t i = 0; i < vv.size(); i++) {
while (wt.size() and wt.back().second >= vv[i].second) wt.pop_back();
if (i and vv[i - 1].first + 1 < vv[i].first)
wt.push_back({vv[i].first - 1, 0});
ltil[i] = wt.back().first + 1;
wt.push_back(vv[i]);
}
wt.clear();
wt.push_back({vv.back().first + 1, 0});
for (int i = (int)vv.size() - 1; i >= 0; i--) {
while (wt.size() and wt.back().second >= vv[i].second) wt.pop_back();
if (i + 1 < (int)vv.size() and vv[i + 1].first - 1 > vv[i].first)
wt.push_back({vv[i].first + 1, 0});
rtil[i] = wt.back().first - 1;
wt.push_back(vv[i]);
}
long long ret = 0;
for (size_t i = 0; i < vv.size(); i++) {
long long tret = (long long)(rtil[i] - ltil[i] + 2) * vv[i].second;
ret = max(ret, tret);
}
return ret;
}
void solve() {
for (int i = 1; i <= n; i++) modify(1, 1, n, i, len[i]);
for (int i = 2; i <= n; i++) update(i, true);
while (q--) {
int cmd = getint();
if (cmd == 1) {
int li = getint();
int ri = getint();
int mxlen = query(1, 1, n, li, ri);
long long ans = mxlen;
if (li < ri) {
for (int i = 1; i <= min(222, mxlen); i++) {
if (!root[i]) break;
int ret = get<0>(query2(root[i], 1, n, li + 1, ri));
if (ret == 0) break;
ans = max(ans, (long long)(ret + 1) * i);
if ((long long)(ret + 1) * mxlen <= ans) break;
}
ans = max(ans, query2(li, ri));
}
printf("%lld\n", ans);
} else {
int who = getint();
scanf("%s", c + ptr);
ss[who] = ptr;
len[who] = strlen(c + ptr);
ptr += len[who] + 1;
modify(1, 1, n, who, len[who]);
if (who > 1) update(who, false);
if (who < n) update(who + 1, false);
}
}
}
int main() {
init();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, Q, a[100005];
string s[100005];
int LCP(const string &a, const string &b) {
int r = 0;
for (; r < a.size() && r < b.size() && a[r] == b[r]; r++)
;
return r;
}
int lc[100005 * 100], rc[100005 * 100], lx[100005 * 100], rx[100005 * 100],
mx[100005 * 100], sz[100005 * 100], bin[100005 * 100], tot, rt[100005];
int newnode() {
int r = 0;
if (bin[0]) {
r = bin[bin[0]--];
lc[r] = rc[r] = lx[r] = rx[r] = mx[r] = sz[r] = 0;
} else
r = ++tot;
return r;
}
void upd(int u, int l, int m, int r) {
sz[u] = sz[lc[u]] + sz[rc[u]];
lx[u] = (lx[lc[u]] == m - l + 1 ? lx[rc[u]] : 0) + lx[lc[u]];
rx[u] = (rx[rc[u]] == r - m ? rx[lc[u]] : 0) + rx[rc[u]];
mx[u] = max(mx[lc[u]], max(mx[rc[u]], lx[rc[u]] + rx[lc[u]]));
}
void ins(int &u, int l, int r, int p, int v) {
if (!u) u = newnode();
sz[u] += v;
if (l == r) {
lx[u] = rx[u] = mx[u] = sz[u];
if (!sz[u]) bin[++bin[0]] = u, u = 0;
return;
}
int m = l + r >> 1;
p <= m ? ins(lc[u], l, m, p, v) : ins(rc[u], m + 1, r, p, v);
upd(u, l, m, r);
if (!sz[u]) bin[++bin[0]] = u, u = 0;
}
void qry(int u, int l, int r, int ql, int qr, int &MX, int &RX) {
if (ql > r || l > qr || !u) return (void)(RX = 0);
if (ql <= l && r <= qr)
return (void)(MX = max(MX, max(mx[u], RX + lx[u])),
RX = (rx[u] == r - l + 1 ? RX : 0) + rx[u]);
int m = l + r >> 1;
qry(lc[u], l, m, ql, qr, MX, RX), qry(rc[u], m + 1, r, ql, qr, MX, RX);
}
int c[100005];
bool cmp(const int &u, const int &v) { return a[u] > a[v]; }
int F[100005], SZ[100005];
int Find(int u) { return !F[u] ? u : F[u] = Find(F[u]); }
set<int> mS, mA;
namespace SGT {
int mx[100005 << 2];
void ins(int u, int l, int r, int p, int v) {
if (l == r) return (void)(mx[u] = v);
int m = l + r >> 1;
p <= m ? ins(u << 1, l, m, p, v) : ins(u << 1 | 1, m + 1, r, p, v);
mx[u] = max(mx[u << 1], mx[u << 1 | 1]);
}
int qry(int u, int l, int r, int ql, int qr) {
if (l > qr || ql > r) return 0;
if (ql <= l && r <= qr) return mx[u];
int m = l + r >> 1;
return max(qry(u << 1, l, m, ql, qr), qry(u << 1 | 1, m + 1, r, ql, qr));
}
} // namespace SGT
int main() {
ios::sync_with_stdio(false);
cin >> n >> Q;
for (int i = (1), LIM = (n); i <= LIM; i++) {
cin >> s[i];
SGT::ins(1, 1, n, i, s[i].length());
if (i > 1) {
a[i - 1] = LCP(s[i - 1], s[i]);
if (a[i - 1] >= 350) mA.insert(i - 1);
for (int j = (1), LIM = (min(a[i - 1], 350)); j <= LIM; j++)
ins(rt[j], 1, n - 1, i - 1, 1);
}
}
for (int op, l, r; Q--;) {
cin >> op >> l;
if (op == 1) {
cin >> r;
long long ans = SGT::qry(1, 1, n, l, r);
c[0] = 0;
for (int v : mA)
if (l <= v && v < r)
c[++c[0]] = v, F[v] = F[v + 1] = 0, SZ[v] = SZ[v + 1] = 1;
sort(c + 1, c + c[0] + 1, cmp);
for (int i = (1), LIM = (c[0]); i <= LIM; i++) {
int u = c[i], v = u + 1;
F[v] = Find(u);
SZ[Find(u)] += SZ[v];
ans = max(ans, 1ll * SZ[Find(u)] * a[u]);
}
for (int i = (1), LIM = (350); i <= LIM; i++) {
int MX = 0, RX = 0;
qry(rt[i], 1, n - 1, l, r - 1, MX, RX);
if (MX) ans = max(ans, 1ll * (MX + 1) * i);
}
printf("%lld\n", ans);
} else {
if (l > 1) {
if (a[l - 1] >= 350) mA.erase(l - 1);
for (int j = (1), LIM = (min(a[l - 1], 350)); j <= LIM; j++)
ins(rt[j], 1, n - 1, l - 1, -1);
}
if (l < n) {
if (a[l] >= 350) mA.erase(l);
for (int j = (1), LIM = (min(a[l], 350)); j <= LIM; j++)
ins(rt[j], 1, n - 1, l, -1);
}
cin >> s[l];
SGT::ins(1, 1, n, l, s[l].length());
if (l > 1) {
a[l - 1] = LCP(s[l - 1], s[l]);
if (a[l - 1] >= 350) mA.insert(l - 1);
for (int j = (1), LIM = (min(a[l - 1], 350)); j <= LIM; j++)
ins(rt[j], 1, n - 1, l - 1, 1);
}
if (l < n) {
a[l] = LCP(s[l], s[l + 1]);
if (a[l] >= 350) mA.insert(l);
for (int j = (1), LIM = (min(a[l], 350)); j <= LIM; j++)
ins(rt[j], 1, n - 1, l, 1);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T = int>
struct Max {
T val;
const T nut = numeric_limits<T>::min();
Max() { val = nut; }
Max(const T& _val) { val = _val; }
void operator=(const Max& o) { val = o.val; }
Max operator+(const Max& o) const { return val > o.val ? val : o.val; }
};
template <typename T = long long>
struct subl {
T mx, ml, ps, pl, ss, sl, sm, ln;
subl() {
mx = 0;
ml = 0;
ps = 0;
pl = 0;
ss = 0;
sl = 0;
sm = 0;
ln = 0;
}
subl(const T& v) {
mx = v;
ml = 1;
ps = v;
pl = 1;
ss = v;
sl = 1;
sm = v;
ln = 1;
}
subl(T _mx, T _ml, T _ps, T _pl, T _ss, T _sl, T _sm, T _ln) {
mx = _mx;
ml = _ml;
ps = _ps;
pl = _pl;
ss = _ss;
sl = _sl;
sm = _sm;
ln = _ln;
}
void operator=(const subl& o) {
mx = o.mx;
ml = o.ml;
ps = o.ps;
pl = o.pl;
ss = o.ss;
sl = o.sl;
sm = o.sm;
ln = o.ln;
}
subl operator+(const subl& o) const {
T _mx = max({mx, o.mx, ss + o.ps});
T _ps = max(ps, sm + o.ps);
T _ss = max(ss + o.sm, o.ss);
return subl(_mx, _mx == ss + o.ps ? sl + o.pl : (mx > o.mx ? ln : o.ln),
_ps, _ps == ps ? pl : ln + o.pl, _ss,
_ss == o.ss ? o.sl : sl + o.ln, sm + o.sm, ln + o.ln);
}
};
template <typename T, typename T2 = int>
class segtree {
private:
int b;
vector<T> tr;
public:
segtree() {}
segtree(int n) {
b = 1;
while (b < n) {
b <<= 1;
}
tr.assign(2 * b, T());
}
segtree(const vector<T2>& arr) {
b = 1;
while (b < (int)arr.size()) {
b <<= 1;
}
tr.assign(2 * b, T());
for (int i = 0; i < (int)arr.size(); i++) {
tr[i + b] = T(arr[i]);
}
for (int i = b - 1; i > 0; i--) {
tr[i] = tr[i << 1] + tr[i << 1 | 1];
}
}
void upd(int i, const T2& val) {
tr[i += b] = T(val);
for (i >>= 1; i > 0; i >>= 1) {
tr[i] = tr[i << 1] + tr[i << 1 | 1];
}
}
T qry(int l, int r) {
T ansl = T(), ansr = T();
for (l += b, r += b; l <= r; l >>= 1, r >>= 1) {
if (l & 1) ansl = ansl + tr[l++];
if (!(r & 1)) ansr = tr[r--] + ansr;
}
return ansl + ansr;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<string> s(n);
vector<int> LN(n, 0);
set<int> Vals;
for (int i = 0; i < n; i++) {
cin >> s[i];
LN[i] = s[i].length();
}
auto LCP = [&](const string& ss, const string& t) {
int ans = 0;
for (int i = 0; i < (int)min(ss.length(), t.length()); i++) {
if (ss[i] == t[i]) {
ans++;
} else {
break;
}
}
Vals.insert(ans);
return ans;
};
vector<int> OP(q), L(q), R(q), res(q, 0), Lcp(n - 1, 0);
vector<vector<pair<int, int>>> qc(q);
for (int i = 1; i < n; i++) {
Lcp[i - 1] = LCP(s[i - 1], s[i]);
}
for (int tt = 0; tt < q; tt++) {
cin >> OP[tt];
if (OP[tt] == 1) {
cin >> L[tt] >> R[tt];
--L[tt];
--R[tt];
} else {
cin >> L[tt];
--L[tt];
cin >> s[L[tt]];
R[tt] = s[L[tt]].length();
if (L[tt] > 0) {
qc[tt].emplace_back(L[tt] - 1, LCP(s[L[tt] - 1], s[L[tt]]));
}
if (L[tt] + 1 < n) {
qc[tt].emplace_back(L[tt], LCP(s[L[tt]], s[L[tt] + 1]));
}
}
}
const int inf = 1e9;
for (int mn : Vals) {
vector<int> bad(n - 1);
for (int i = 0; i < n - 1; i++) {
bad[i] = (Lcp[i] >= mn ? 1 : -inf);
}
segtree<subl<long long>, int> st(bad);
for (int tt = 0; tt < q; tt++) {
if (OP[tt] == 1) {
int a = L[tt], b = R[tt];
int& ans = res[tt];
if (a < b) {
int z = st.qry(a, b - 1).mx;
ans = max(ans, mn * (z + (z > 0)));
}
} else {
for (const auto& p : qc[tt]) {
st.upd(p.first, p.second >= mn ? 1 : -inf);
}
}
}
}
segtree<Max<int>, int> lns(LN);
for (int tt = 0; tt < q; tt++) {
if (OP[tt] == 1) {
cout << max(res[tt], lns.qry(L[tt], R[tt]).val) << '\n';
} else {
lns.upd(L[tt], R[tt]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("pclmul")
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using llf = long double;
using us = std::uint16_t;
const ul maxn = 1e5;
const ul maxlen = 1e5;
const ul bu = 50;
std::mt19937_64 rnd;
class node {
public:
ul lc = 0;
ul rc = 0;
ul val = 0;
ul ans[bu + 1];
ul lenl[bu + 1];
ul lenr[bu + 1];
ul cnt = 0;
ull rk = 0;
};
ul tim;
node tree[maxn + maxn];
void update(ul x) {
tree[x].cnt = tree[tree[x].lc].cnt + tree[tree[x].rc].cnt + 1;
for (ul i = 1; i <= bu; ++i) {
ul tmp = tree[x].val >= i;
if (tmp) {
tmp += tree[tree[x].lc].lenr[i] + tree[tree[x].rc].lenl[i];
}
tree[x].ans[i] = std::max(
tmp, std::max(tree[tree[x].lc].ans[i], tree[tree[x].rc].ans[i]));
tree[x].lenl[i] = tree[tree[x].lc].lenr[i] == tree[tree[x].lc].cnt && tmp
? tmp
: tree[tree[x].lc].lenl[i];
tree[x].lenr[i] = tree[tree[x].rc].lenl[i] == tree[tree[x].rc].cnt && tmp
? tmp
: tree[tree[x].rc].lenr[i];
}
}
void split(ul x, ul& a, ul& b, ul key) {
if (!x) {
a = b = 0;
return;
}
if (x < key) {
a = x;
split(tree[x].rc, tree[a].rc, b, key);
} else {
b = x;
split(tree[x].lc, a, tree[b].lc, key);
}
update(x);
}
void merge(ul& x, ul a, ul b) {
if (!a || !b) {
x = a ^ b;
return;
}
if (tree[a].rk > tree[b].rk) {
x = a;
merge(tree[x].rc, tree[a].rc, b);
} else {
x = b;
merge(tree[x].lc, a, tree[b].lc);
}
update(x);
}
ul n;
ul q;
std::string s[maxn + 1];
char str[maxlen + 2];
ul root;
ul lcp(const std::string& a, const std::string& b) {
ul i = 0;
for (; i != a.size() && i != b.size() && a[i] == b[i]; ++i)
;
return i;
}
ul sz = 0;
std::pair<ul, ul> stack[maxn + maxn];
ul left[maxn + maxn];
ul right[maxn + maxn];
std::vector<std::pair<ul, ul>> stack2;
bool al = false;
void erase(ul key) {
--sz;
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= key) {
stack[i] = stack[i + 1];
}
}
al = false;
}
void insert(ul key, ul val) {
++sz;
for (ul i = sz; i >= 1; --i) {
if (stack[i - 1].first > key) {
stack[i] = stack[i - 1];
} else {
stack[i].first = key;
stack[i].second = val;
break;
}
}
al = false;
}
int main() {
rnd.seed(std::time(0));
std::scanf("%u%u", &n, &q);
for (ul i = 1; i <= n; ++i) {
std::scanf("%s", str + 1);
s[i] = str + 1;
if (i != 1) {
++tim;
tree[tim].val = lcp(s[i - 1], s[i]);
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
++tim;
tree[tim].val = s[i].size();
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
for (ul Case = 1; Case <= q; ++Case) {
ul k;
std::scanf("%u", &k);
if (k == 1) {
ul x, y;
std::scanf("%u%u", &x, &y);
x = (x << 1) - 1;
y = (y << 1) - 1;
ul a, b, c;
split(root, a, b, x);
split(b, b, c, y + 1);
ul ans = 0;
for (ul i = 1; i <= bu; ++i) {
ans = std::max(ans, (tree[b].ans[i] + 1 >> 1) * i);
}
merge(root, a, b);
merge(root, root, c);
if (!al) {
al = true;
for (ul i = 1; i <= sz; ++i) {
if (i == 1 || stack[i].first != stack[i - 1].first + 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first - 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
left[stack[i].first] = stack2.back().first + 1;
stack2.push_back(stack[i]);
}
for (ul i = sz; i >= 1; --i) {
if (i == sz || stack[i].first != stack[i + 1].first - 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first + 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
right[stack[i].first] = stack2.back().first - 1;
stack2.push_back(stack[i]);
}
}
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= x && stack[i].first <= y) {
ans = std::max(ans, (std::min(right[stack[i].first], y) -
std::max(left[stack[i].first], x) + 1 + 1 >>
1) *
stack[i].second);
}
}
std::printf("%u\n", ans);
} else {
ul x;
std::scanf("%u%s", &x, str + 1);
s[x] = str + 1;
ul y = (x << 1) - 1;
ul a, b, c;
split(root, a, b, std::max(y - 1, ul(1)));
split(b, b, c, std::min(y + 1, n + n - 1) + 1);
if (tree[y].val > bu) {
erase(y);
}
tree[y].val = s[x].size();
tree[y].lc = 0;
tree[y].rc = 0;
update(y);
if (tree[y].val > bu) {
insert(y, tree[y].val);
}
b = y;
if (x != 1) {
if (tree[y - 1].val > bu) {
erase(y - 1);
}
tree[y - 1].val = lcp(s[x - 1], s[x]);
tree[y - 1].lc = 0;
tree[y - 1].rc = 0;
update(y - 1);
if (tree[y - 1].val > bu) {
insert(y - 1, tree[y - 1].val);
}
merge(b, y - 1, b);
}
if (x != n) {
if (tree[y + 1].val > bu) {
erase(y + 1);
}
tree[y + 1].val = lcp(s[x], s[x + 1]);
tree[y + 1].lc = 0;
tree[y + 1].rc = 0;
update(y + 1);
if (tree[y + 1].val > bu) {
insert(y + 1, tree[y + 1].val);
}
merge(b, b, y + 1);
}
merge(b, a, b);
merge(b, b, c);
root = b;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T = int>
struct Max {
T val;
const T nut = numeric_limits<T>::min();
Max() { val = nut; }
Max(const T& _val) { val = _val; }
void operator=(const Max& o) { val = o.val; }
Max operator+(const Max& o) const { return val > o.val ? val : o.val; }
};
int LB;
template <typename T2 = int>
struct _t {
using T = array<T2, 4>;
T val;
const T nut = {};
_t() { val = nut; }
_t(const T2& _val) {
T2 X = (_val >= LB);
val = {X, X, X, 1};
}
_t(const T _val) { val = _val; }
void operator=(const _t& o) { val = o.val; }
_t operator+(const _t& o) const {
return _t({max({val[0], o.val[0], val[2] + o.val[1]}),
(val[1] == val[3]) * o.val[1] + val[1],
(o.val[2] == o.val[3]) * val[2] + o.val[2], val[3] + o.val[3]});
}
};
template <typename T, typename T2 = int>
class segtree {
private:
int b;
vector<T> tr;
public:
segtree() {}
segtree(int n) {
b = 1;
while (b < n) {
b <<= 1;
}
tr.assign(2 * b, T());
}
segtree(const vector<T2>& arr) {
b = 1;
while (b < (int)arr.size()) {
b <<= 1;
}
tr.assign(2 * b, T());
for (int i = 0; i < (int)arr.size(); i++) {
tr[i + b] = T(arr[i]);
}
for (int i = b - 1; i > 0; i--) {
tr[i] = tr[i << 1] + tr[i << 1 | 1];
}
}
void upd(int i, const T2& val) {
tr[i += b] = T(val);
for (i >>= 1; i > 0; i >>= 1) {
tr[i] = tr[i << 1] + tr[i << 1 | 1];
}
}
T qry(int l, int r) {
T ansl = T(), ansr = T();
for (l += b, r += b; l <= r; l >>= 1, r >>= 1) {
if (l & 1) ansl = ansl + tr[l++];
if (!(r & 1)) ansr = tr[r--] + ansr;
}
return ansl + ansr;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<string> s(n);
vector<int> LN(n, 0);
set<int> Vals;
for (int i = 0; i < n; i++) {
cin >> s[i];
LN[i] = s[i].length();
}
auto LCP = [&](const string& ss, const string& t) {
int ans = 0;
for (int i = 0; i < (int)min(ss.length(), t.length()); i++) {
if (ss[i] == t[i]) {
ans++;
} else {
break;
}
}
Vals.insert(ans);
return ans;
};
vector<int> OP(q), L(q), R(q), res(q, 0), Lcp(n - 1, 0);
vector<vector<pair<int, int>>> qc(q);
for (int i = 1; i < n; i++) {
Lcp[i - 1] = LCP(s[i - 1], s[i]);
}
for (int tt = 0; tt < q; tt++) {
cin >> OP[tt];
if (OP[tt] == 1) {
cin >> L[tt] >> R[tt];
--L[tt];
--R[tt];
} else {
cin >> L[tt];
--L[tt];
cin >> s[L[tt]];
R[tt] = s[L[tt]].length();
if (L[tt] > 0) {
qc[tt].emplace_back(L[tt] - 1, LCP(s[L[tt] - 1], s[L[tt]]));
}
if (L[tt] + 1 < n) {
qc[tt].emplace_back(L[tt], LCP(s[L[tt]], s[L[tt] + 1]));
}
}
}
for (const int mn : Vals) {
LB = mn;
segtree<_t<int>> st(Lcp);
vector<int> lcp = Lcp;
for (int tt = 0; tt < q; tt++) {
if (OP[tt] == 1) {
int a = L[tt], b = R[tt];
int& ans = res[tt];
if (a < b) {
int z = st.qry(a, b - 1).val[0];
ans = max(ans, mn * (z + (z > 0)));
}
} else {
for (const auto& p : qc[tt]) {
st.upd(p.first, p.second);
lcp[p.first] = p.second;
}
}
}
}
segtree<Max<int>> lns(LN);
for (int tt = 0; tt < q; tt++) {
if (OP[tt] == 1) {
cout << max(res[tt], lns.qry(L[tt], R[tt]).val) << '\n';
} else {
lns.upd(L[tt], R[tt]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse3,sse4,popcnt,abm,mmx")
const int N = (int)5e5 + 7, inf = (int)1e9 + 7, mod = (int)1e9 + 7;
const long long linf = (long long)1e18 + 7;
const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1},
dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
using namespace std;
int n, k;
int a[N];
long long cnk(int x, int y) {
long long res = 1;
for (int i = x - y + 1; i <= x; i++) res *= i;
for (int i = 2; i <= y; i++) res /= i;
return res;
}
namespace get2 {
long long get(long long x) { return cnk(x, 2) + 1; }
} // namespace get2
namespace get3 {
long long get(long long x) {
if (x == 4) return 15;
long long res = 15;
for (int i = 4; i < x; i++) {
res += ((i)*1ll * (i));
}
return res;
}
} // namespace get3
namespace get4 {
long long get(long long x) { return cnk(x, 4) * 9; }
} // namespace get4
int ans;
void go() {
int cur = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == i) {
cur++;
}
}
if (cur >= n - k) {
ans++;
for (int i = 1; i <= n; i++) {
}
}
}
void full() {
for (int i = 1; i <= n; i++) {
a[i] = i;
}
ans = 0;
do {
go();
} while (next_permutation(a + 1, a + 1 + n));
}
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k;
if (k == 1)
cout << 1;
else if (k == 2)
cout << get2 ::get(n);
else if (k == 3)
cout << get3 ::get(n);
else
cout << get3 ::get(n) + get4 ::get(n);
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const long long MAX = (long long)1e5 + 10;
long long fat[] = {1, 1, 2, 6, 24};
long long comb(int n, int k) {
long long ret = 1;
for (int i = 0; i < k; i++) {
ret *= n - i;
}
ret /= fat[k];
return ret;
}
long long solve(int n, int k) {
if (k == 1) {
return 1;
}
if (k == 2) {
return solve(n, k - 1) + comb(n, k);
}
if (k == 3) {
return solve(n, k - 1) + 2 * comb(n, k);
}
if (k == 4) {
return solve(n, k - 1) + 9 * comb(n, k);
}
return -1;
}
int main() {
int n, k;
cin >> n >> k;
cout << solve(n, k) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, a[4];
cin >> n >> k;
a[0] = 1;
a[1] = n * (n - 1) / 2;
a[2] = n * (n - 1) * (n - 2) / 6 * 2;
a[3] = n * (n - 1) * (n - 2) * (n - 3) / 24 * (3 + 6);
long long ans = 0;
for (int i = 0; i < k; i++) ans += a[i];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-6;
template <class T>
T gcd(T a, T b) {
if (!b) return a;
return gcd(b, a % b);
}
const int maxn = 1e3 + 10;
long long c(int x, int y) {
long long res = 1;
for (int i = 0; i < y; i++) res *= x - i;
for (int i = 1; i <= y; i++) res /= i;
return res;
}
long long fac(long long x) {
long long res = 1;
for (long long i = 1; i <= x; i++) res *= i;
return res;
}
long long dp[maxn][10];
int main() {
for (int i = 0; i < maxn; i++) dp[i][0] = 1;
dp[1][1] = 0;
for (int i = 2; i < maxn; i++) {
for (int j = 1; j <= min(i, 4); j++) {
dp[i][j] = fac(j);
for (int k = 0; k < j; k++) {
dp[i][j] -= dp[j][k];
}
dp[i][j] *= c(i, j);
}
}
int n, k;
cin >> n >> k;
long long ans = 0;
for (int i = 0; i <= k; i++) {
ans += dp[n][i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long derangements(long long n) {
if (n == 0) return 1;
if (n == 1) return 0;
if (n == 2) return 1;
return (n - 1) * (derangements(n - 1) + derangements(n - 2));
}
long long nCr(long long n, long long r) {
long long res = 1;
if (r == 0) return res;
for (long long i = 0; i < r; i++) res *= (n - i);
for (long long i = 2; i <= r; i++) res /= i;
return res;
}
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, k, ans = 0;
cin >> n >> k;
for (long long i = 0; i <= k; i++) ans += (nCr(n, i) * derangements(i));
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10, eps = 1e-10;
const double pi = acos(-1);
int n, k;
long long a[1100];
void init() {
a[1] = 0, a[2] = 1;
for (int i = (3); i < (1100); ++i) a[i] = (i - 1) * (a[i - 1] + a[i - 2]);
}
long long C(int a, int b) {
long long res = 1;
for (int i = (0); i < (b); ++i) res *= (a - i);
for (int i = (0); i < (b); ++i) res /= (i + 1);
return res;
}
int main() {
init();
cin >> n >> k;
long long ans = 0;
for (int i = (1); i < (k + 1); ++i) {
if (i == 1)
ans += 1;
else
ans += C(n, i) * a[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long cmb(long long n, long long k) {
double res = 1;
for (long long i = 0; i < k; i++) {
res *= (n - i);
res /= (i + 1);
}
return (long long)(res + 0.1);
}
int main() {
ios_base::sync_with_stdio(0);
long long n, k;
cin >> n >> k;
long long answ = 1;
for (long long i = 2; i <= k; i++) {
long long temp = cmb(n, n - i);
if (i == 3) temp *= 2;
if (i == 4) temp *= 9;
answ += temp;
}
cout << answ;
}
|
#include <bits/stdc++.h>
using namespace std;
long long C(long long n, long long r) {
long long C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long i = 1; i <= n; i++)
for (long long j = min(i, r); j > 0; j--) C[j] = (C[j] + C[j - 1]);
return C[r];
}
long long factorial[1000];
void fact(long long n) {
factorial[0] = 1, factorial[1] = 1;
for (long long i = 2; i < n; i++) factorial[i] = i * factorial[i - 1];
}
long long der[1000];
void derange(long long n) {
der[0] = 1, der[1] = 0, der[2] = 1;
for (long long i = 3; i < n + 1; i++)
der[i] = (i - 1) * (der[i - 1] + der[i - 2]);
}
signed main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n, k;
cin >> n >> k;
long long ans = 0;
derange(k);
for (long long i = 0; i < k + 1; i++) ans += C(n, n - i) * der[i];
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long input() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
const long long maxn = 2e5 + 10;
const long long mod = 1e9 + 7;
long long C(long long n, long long r) {
long long ans = 1;
for (long long i = n; i > n - r; i--) ans *= i;
for (long long i = 1; i <= r; i++) ans /= i;
return ans;
}
long long par[10];
int32_t main() {
long long res = 0;
long long n = in(), k = in();
for (long long i = 2; i <= 4; i++) {
vector<long long> perm;
for (long long pt = 0; pt < i; pt++) perm.push_back(pt);
do {
bool fl = true;
for (long long pt = 0; pt < perm.size() && fl; pt++) fl &= perm[pt] != pt;
par[i] += fl;
} while (next_permutation(perm.begin(), perm.end()));
}
for (long long bad = 1; bad <= k && bad <= n; bad++) {
res += C(n, bad) * par[bad];
}
cout << res + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long nc2(long long n) { return (n * (n - 1)) / 2; }
long long nc3(long long n) { return (n * (n - 1) * (n - 2)) / 6; }
long long nc4(long long n) { return (n * (n - 1) * (n - 2) * (n - 3)) / 24; }
int main() {
int n, k;
cin >> n >> k;
long long ans = 1;
for (int i = 2; i <= k; i++) {
if (i == 2)
ans += nc2(n);
else if (i == 3)
ans += nc3(n) * 2;
else if (i == 4)
ans += nc4(n) * 9;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = -1;
const int inf = 2e9 + 19;
long long n, k, dp[5];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
dp[1] = 1;
dp[2] = (n * (n - 1) / 2) + dp[1];
dp[3] = (((n * (n - 1) * (n - 2)) / 6) * 2) + dp[2];
dp[4] = (((n * (n - 1) * (n - 2) * (n - 3)) / 24) * 9) + dp[3];
cout << dp[k];
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, K;
long long ans;
int A[] = {1, 1, 2, 6, 24};
int B[] = {1, 1, 2, 9};
long long com(long long n, long long k) {
long long res = 1;
for (long long i = 0; i < k; i++) {
res *= (n - i);
}
return res / A[k];
}
int main() {
scanf("%lld%lld", &N, &K);
ans = 1;
for (int i = 2; i <= K; i++) {
ans += B[i - 1] * com(N, i);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> der(int k) {
vector<long long> res;
res.push_back(0);
res.push_back(1);
for (long long i = 3; i <= k; i++) {
int n1 = res[i - 2];
int n2 = res[i - 3];
int cur = (i - 1) * (n1 + n2);
res.push_back(cur);
}
return res;
}
long long nck(int n, int k) {
long long denom = 1, nume = 1;
for (long long i = n - k + 1; i <= n; i++) {
nume *= i;
}
for (long long i = 1; i <= k; i++) denom *= i;
return nume / denom;
}
void solve() {
int n, k;
cin >> n >> k;
long long res = 1;
vector<long long> d = der(k + 1);
for (int i = k; i >= 1; i--) {
long long a = nck(n, i);
long long b = d[i - 1];
res += (a * b);
}
cout << res << endl;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int derange[1001];
long long int nCr(long long int n, long long int r) {
long double ans = 1;
long double upto = min(n - r, r);
for (long double j = n, i = 1; j > upto; j--, i++) ans *= (j / i);
return round(ans);
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
derange[1] = 0;
derange[2] = 1;
for (int j = 3; j < 1001; j++)
derange[j] = (j - 1) * (derange[j - 1] + derange[j - 2]);
int n, k;
cin >> n >> k;
long long int ans = 1;
for (int j = 2; j <= k; j++) ans += nCr(n, j) * derange[j];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (k == 1)
cout << 1;
else if (k == 2)
cout << n * (n - 1) / 2 + 1;
else if (k == 3)
cout << n * 1LL * (n - 1) * (n - 2) / 3 + n * (n - 1) / 2 + 1;
else
cout << n * 1LL * (n - 1) * (n - 2) * (n - 3) / 24 * 9 +
n * 1LL * (n - 1) * (n - 2) / 3 + n * (n - 1) / 2 + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long c(long long n, long long k) {
long long numerator = 1;
long long i;
vector<int> v(k - 1);
for (i = 0; i < v.size(); i++) v[i] = i + 2;
for (i = 0; i < k; i++) {
numerator = (numerator * (n - i));
for (int j = 0; j < k - 1; j++)
if (numerator % v[j] == 0) numerator /= v[j], v[j] = 1;
}
return numerator;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, k, i, a[5];
a[1] = 0;
a[2] = 1;
a[3] = 2;
a[4] = 9;
cin >> n >> k;
long long sum = 0;
for (i = n - k; i < n; i++) {
sum += c(n, n - i) * a[n - i];
}
cout << sum + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e3;
string st;
int n;
long long tot;
bool v[7];
void rec(long long s, long long curC) {
if (curC == s) {
tot++;
return;
}
for (int i = 0; i < s; i++) {
if (!v[i] && curC != i) {
v[i] = true;
rec(s, curC + 1);
v[i] = false;
}
}
}
long long getCount(long long s) {
memset(v, false, sizeof(v));
tot = 0;
rec(s, 0);
return tot;
}
long long fact(long long n) {
if (!n) return 1;
return n * fact(n - 1);
}
long long comb(long long n, long long k) {
long long ret = 1;
for (long long i = n - k + 1; i <= n; i++) {
ret *= i;
}
ret /= fact(k);
return ret;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
long long tot = 1;
for (int i = 1; i <= k; i++) tot += comb(n, i) * getCount(i);
cout << tot << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e3 + 5;
long long C[N][5], dif_fact[5];
void calc() {
for (long long i = 0; i < N; i++) {
for (long long j = 0; j <= min(i, 4LL); j++) {
if (j == 0 || j == i) {
C[i][j] = 1;
} else {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
}
dif_fact[1] = 0;
dif_fact[2] = 1;
dif_fact[3] = 2;
dif_fact[4] = 9;
}
signed main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
calc();
long long n, k;
cin >> n >> k;
long long ans = 1;
for (long long i = 2; i <= k; i++) {
long long curr = C[n][i] * dif_fact[i];
ans += curr;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void solve() {
long long n, k;
cin >> n >> k;
long long ans = 0;
if (k >= 1) {
ans++;
}
if (k >= 2) {
ans += n * (n - 1) / 2;
}
if (k >= 3) {
ans += n * (n - 1) * (n - 2) / 3;
}
if (k >= 4) {
ans += n * (n - 1) * (n - 2) * (n - 3) / 24 * 9;
}
cout << ans;
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using lld = long double;
using vi = vector<int>;
using vll = vector<long long>;
ll factorial(ll n) {
if (n == 0) {
return 1;
}
return (n * factorial(n - 1));
}
ll choose(ll n, ll k) {
ll res = 1;
for (ll i = 0; i < k; i++) {
res *= (n - i);
}
res /= factorial(k);
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, k;
cin >> n >> k;
ll ans = 0;
k++;
while (k--) {
if (k == 0) {
ans += choose(n, k);
} else if (k == 1) {
continue;
} else if (k == 2) {
ans += choose(n, k);
} else if (k == 3) {
ans += 2 * choose(n, k);
} else if (k == 4) {
ans += 9 * choose(n, k);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long d[10], dp[1111][11], n, k;
long long c(long long x, long long y) {
long long p = 1, q = 1, z;
for (long long i = 0; i < y; i++) {
p *= (x - i);
q *= (1 + i);
}
p /= q;
return p;
}
int main() {
cin >> n >> k;
d[0] = 1;
for (long long i = 2; i <= 4; i++) d[i] = (i - 1) * (d[i - 1] + d[i - 2]);
for (long long i = 1; i <= 1000; i++) dp[i][0] = 1;
for (long long i = 1; i <= 1000; i++) {
for (long long j = 1; j <= min((long long)4, i); j++) {
dp[i][j] = dp[i][j - 1] + c(i, j) * d[j];
}
}
cout << dp[n][k];
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[10], c[1005][1005];
int main() {
f[0] = 1;
f[1] = 0;
f[2] = 1;
f[3] = 2;
f[4] = 9;
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
}
}
long long ans = 0;
for (int i = 0; i <= k; i++) {
ans += c[n][i] * f[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int de[101];
long long int cmb[1001][5];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
de[0] = 1;
de[1] = 0;
for (long long int i = 2; i < 101; i++) {
de[i] = i * de[i - 1] + ((i % 2 == 0) ? 1 : -1);
}
cmb[1][1] = 1;
cmb[1][0] = 1;
for (long long int i = 2; i < 1001; i++) {
for (long long int j = 1; j < min(i + 1, (long long int)5); j++) {
cmb[i][j] = (j > 1 ? cmb[i - 1][j - 1] : 1) + cmb[i - 1][j];
}
}
long long int n, k;
cin >> n >> k;
long long int sum = 0;
while (k != 0) {
sum += ((cmb[n][k]) * de[k]);
k--;
}
cout << sum + 1;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int m[] = {1, 0, 1, 2, 9};
long long int res;
long long int ch(int n, int k) {
long long int r = 1;
long long int s = 1;
for (int i = n; i > n - k; i--) {
r *= i;
}
for (int i = 2; i <= k; i++) {
s *= i;
}
return r / s;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int n, k;
cin >> n >> k;
for (int i = k; i >= 0; i--) {
res += ch(n, i) * m[i];
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int M = 1e9 + 7;
const double pi = 3.141592653589793238463;
inline long long int add(long long int x, long long int y) {
if (x + y >= M) return x + y - M;
return x + y;
}
inline long long int sub(long long int x, long long int y) {
if (x - y < 0) return x - y + M;
return x - y;
}
inline long long int mul(long long int x, long long int y) { return x * y % M; }
bool isPrime(long long int n) {
for (long long int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
long long int modExp(long long int x, long long int n, long long int M) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
long long int fast_exp(long long int x, long long int n) {
long long int ans = 1;
while (n) {
if (n & 1) {
ans *= x;
ans %= M;
}
n = n >> 1;
x = (x * x) % M;
}
return ans;
}
long long int inverse(long long int x) { return fast_exp(x, M - 2); }
long long int combination(long long int n, long long int r) {
if (r == 0)
return 1;
else {
long long int ans = n % M;
ans *= combination(n - 1, r - 1) % M;
ans %= M;
ans *= inverse(r) % M;
ans %= M;
return ans;
}
}
long long int ncr(long long int n, long long int r) {
long long int ans = 1;
for (long long int i = 0; i < r; i++) ans *= (n - i);
for (long long int i = 0; i < r; i++) ans /= (r - i);
return ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long int n, k;
cin >> n >> k;
long long int a[5] = {1, 0, 1, 2, 9};
long long int ans = 0;
for (long long int i = 0; i < k + 1; i++) {
ans = ans + ncr(n, i) * a[i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n, k;
while (cin >> n >> k) {
long long ans = 0;
for (int i = 0; i <= k; i++) {
if (i == 0) ans += 1;
if (i == 2) ans += (n * (n - 1)) / 2;
if (i == 3) ans += n * (n - 1) * (n - 2) / 6 * 2;
if (i == 4) ans += n * (n - 1) * (n - 2) * (n - 3) / 24 * 9;
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long binomial_coeff[1005][1005];
int main(int argc, char const *argv[]) {
int n, k;
cin >> n >> k;
for (int i = 0; i <= 1000; i++)
for (int j = 0; j <= 1000; j++) binomial_coeff[i][j] = 0;
for (int i = 0; i <= 1000; i++) binomial_coeff[i][0] = 1;
for (int i = 1; i <= 1000; i++) {
for (int j = 1; j <= i; j++) {
binomial_coeff[i][j] =
(binomial_coeff[i - 1][j - 1] + binomial_coeff[i - 1][j]);
}
}
int d[5] = {0, 0, 1, 2, 9};
long long sum = 1;
for (int i = 2; i <= k; i++) {
sum = sum + binomial_coeff[n][i] * d[i];
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k;
cin >> n >> k;
long long d[5];
d[0] = 0;
d[1] = 0;
d[2] = 1;
d[3] = 2;
d[4] = 9;
long long ans = 0;
for (long long i = 0; i <= k; i++) {
if (i == 0) {
ans += 0;
} else if (i == 1) {
ans += 0;
} else if (i == 2) {
ans += ((n * (n - 1)) / 2) * d[i];
} else if (i == 3) {
ans += (n * (n - 1) * (n - 2) * d[i]) / (6);
} else if (i == 4) {
ans += (n * (n - 1) * (n - 2) * (n - 3) * d[i]) / (24);
}
}
cout << ans + 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, k;
long long ans = 1;
long long c(int n, int i) {
long long a = 1, b = 1;
for (int j = 0; j < i; j++) {
a = a * (n - j);
b = b * (j + 1);
}
return a / b;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= k; i++) {
if (i == 2) ans += c(n, i);
if (i == 3) ans += 2 * c(n, i);
if (i == 4) ans += 9 * c(n, i);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long d[5] = {1, 0, 1, 2, 9};
long long fact[6] = {1, 1, 2, 6, 24, 120};
long long nck(long long n, long long k) {
long long ans = 1;
long long mul = n;
for (int i = 0; i < k; ++i) {
ans = ans * mul;
mul -= 1;
}
ans /= fact[k];
return ans;
}
int main() {
long long n, k;
cin >> n >> k;
long long ans = 0;
for (int i = k; i >= 2; --i) {
ans += (nck(n, i) * d[i]);
}
cout << ans + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, ans = 1;
int main() {
scanf("%lld %lld", &n, &k);
if (k >= 2) ans += n * (n - 1) / 2;
if (k >= 3) ans += 2 * n * (n - 1) * (n - 2) / 6;
if (k >= 4) ans += 9 * n * (n - 1) * (n - 2) * (n - 3) / 24;
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, ans;
cin >> n >> k;
if (k == 1)
ans = 1;
else if (k == 2)
ans = 1 + n * (n - 1) / 2;
else if (k == 3)
ans = 1 + n * (n - 1) / 2 + 2 * n * (n - 1) * (n - 2) / 6;
else if (k == 4)
ans = 1 + n * (n - 1) / 2 + 2 * n * (n - 1) * (n - 2) / 6 +
9 * n * (n - 1) * (n - 2) * (n - 3) / 24;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int FFTMOD = 1007681537;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
long long f[10];
void solve() {
int n, k;
cin >> n >> k;
f[0] = 1;
f[2] = n * (n - 1) / 2;
int perm[4] = {0, 1, 2, 3};
int tot = 0;
do {
int found = 0;
for (int i = (0); i < (4); i++)
if (perm[i] == i) {
found = 1;
}
tot += !found;
} while (next_permutation(perm, perm + 4));
f[4] = (long long)n * (n - 1) * (n - 2) * (n - 3) / 1 / 2 / 3 / 4 * tot;
tot = 0;
do {
int found = 0;
for (int i = (0); i < (3); i++)
if (perm[i] == i) {
found = 1;
}
tot += !found;
} while (next_permutation(perm, perm + 3));
f[3] = (long long)n * (n - 1) * (n - 2) / 1 / 2 / 3 * tot;
long long res = 0;
for (int i = (0); i < (k + 1); i++) {
res += f[i];
}
cout << res << "\n";
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
solve();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 1e3 + 5, M = 11;
const long long int inf = 1e9 + 7;
long long int c[maxn][maxn], n, k, p[M];
int main() {
cin >> n >> k;
for (long long int i = 0; i < n + 1; i++) c[i][0] = c[i][i] = 1;
for (long long int i = 1; i < n + 1; i++)
for (long long int j = 1; j < i; j++)
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
p[0] = 1;
p[1] = p[0] + c[n][2] * 1;
p[2] = p[1] + c[n][3] * 2;
p[3] = p[2] + c[n][4] * 9;
cout << p[k - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
const int d[] = {0, 0, 1, 2, 9};
int main() {
long long n, k;
while (cin >> n >> k) {
long long ans = 1;
for (long long i = 2; i <= k; i++) {
long long C = n;
for (int j = 1; j < i; j++) C = C * (n - j) / (j + 1);
ans += C * d[i];
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef priority_queue<int> pqi1;
typedef priority_queue<int, vector<int>, greater<int>> pqi2;
long long derange[1001];
long long fact(long long n) {
long long ans = 1;
for (long long i = 2; i <= n; i++) {
ans *= i;
}
return ans;
}
long long choose(long long n, long long r) {
long long a = 1;
for (long long i = r - 1; i > -1; i--) {
a *= (n - i);
}
a /= fact(r);
return a;
}
int main() {
derange[0] = 0;
derange[1] = 0;
derange[2] = 1;
for (int i = 3; i < 1001; i++) {
derange[i] = (i - 1) * (derange[i - 1] + derange[i - 2]);
}
long long n, k;
cin >> n >> k;
long long ans = 0;
for (int i = 0; i < k + 1; i++) {
ans += derange[i] * choose(n, i);
}
cout << ans + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
double n, k;
cin >> n >> k;
long long aux = n;
long long ans = 0;
long long d[5];
double com[5];
d[1] = 0;
d[2] = 1;
d[3] = 2;
d[4] = 9;
com[1] = n;
com[2] = n * (n - 1) / 2;
com[3] = n * (n - 1) * (n - 2) / 6;
com[4] = (n / 24) * (n - 1) * (n - 2) * (n - 3);
for (int i = n - k; i < aux; i++) {
ans = ans + com[aux - i] * d[aux - i];
}
ans++;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans = 0, n, k, c[1010][1010] = {0}, m[6] = {0, 0, 1, 2, 9, 44};
int main() {
long long n, k, i, j;
cin >> n >> k;
c[0][0] = 1;
for (i = 1; i <= 1000; i++) {
c[i][0] = 1;
for (j = 1; j <= i; j++) c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
}
for (j = n - k; j <= n - 2; j++) {
ans += c[n][j] * m[n - j];
}
ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, i, j;
cin >> n >> k;
long long int d[5];
d[1] = 0, d[2] = 1, d[3] = 2, d[4] = 9;
if (k == 1) return cout << 1, 0;
long long int r = 0;
for (i = 2; i <= k; i++) {
long long int ans = 1, f = 1;
for (j = n; j > (n - i); j--) ans *= j;
for (j = 1; j <= i; j++) f *= j;
ans /= f;
ans *= d[i];
r += ans;
}
r++;
cout << r << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
void PLAY() {
cout << fixed << setprecision(10);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
PLAY();
long long n, k;
cin >> n >> k;
long long res = 1;
if (k >= 2) res += n * (n - 1) / 2;
if (k >= 3) res += n * (n - 1) * (n - 2) / 3;
if (k >= 4) res += n * (n - 1) * (n - 2) * (n - 3) * 3 / 8;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:5000000000")
const long long m = 1000000007;
const int INF = 1000000000;
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long ans1, ans2, ans3, ans4;
ans1 = 1;
ans2 = ans1 + (n * (n - 1)) / 2;
ans3 = 2 * ((n * (n - 1) * (n - 2)) / (3 * 2)) + ans2;
ans4 = 9 * ((n * (n - 1) * (n - 2) * (n - 3)) / (4 * 3 * 2 * 1)) + ans3;
if (k == 1) cout << ans1;
if (k == 2) cout << ans2;
if (k == 3) cout << ans3;
if (k == 4) cout << ans4;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void DBG() { cerr << "]\n"; }
template <typename T, typename... Args>
void DBG(T first, Args... args) {
cerr << first;
if (sizeof...(args)) cerr << ", ";
DBG(args...);
}
long long ncr(long long n, long long k) {
k = n - k;
long long fact = 1;
long long num = 1;
for (long long i = 1; i <= k; i++) {
fact *= i;
num *= (n - i + 1);
}
return num / fact;
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> derrangement(n + 1);
derrangement[0] = 1;
derrangement[1] = 0;
derrangement[2] = 1;
for (long long i = 3; i <= k; i++) {
derrangement[i] = (i - 1) * (derrangement[i - 1] + derrangement[i - 2]);
}
long long ans = 0;
for (long long i = n - k; i <= n; i++) {
ans += ncr(n, i) * derrangement[n - i];
}
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
for (long long tt = 1; tt <= t; tt++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[10];
int main() {
int n, k;
while (scanf("%d %d", &n, &k) != EOF) {
long long ans = 0;
a[4] = 1ll * n * (n - 1) * (n - 2) * (n - 3) / 24 * 9;
a[3] = 1ll * n * (n - 1) * (n - 2) / 6 * 2;
a[2] = 1ll * n * (n - 1) / 2;
a[1] = 0;
a[0] = 1;
for (int i = 0; i <= k; i++) ans += a[i];
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long select(long long n, long long k) {
if (k == 2) {
return (n * (n - 1)) / 2;
}
if (k == 3) {
return (n * (n - 1) * (n - 2)) / 6;
}
if (k == 4) {
return (n * (n - 1) * (n - 2) * (n - 3)) / 24;
}
return 0;
}
long long d(long long num) {
if (num == 2) {
return 1;
}
if (num == 3) {
return 2;
}
return 9;
}
int main() {
long long n, k;
cin >> n >> k;
if (k == 1) {
cout << 1 << endl;
return 0;
}
long long ans = 0;
while (k != 1) {
long long count = select(n, k);
ans += count * d(k);
--k;
}
++ans;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
int main() {
long long n, k;
scanf("%lld %lld", &n, &k);
long long res = 1 + (k >= 2) * (n * (n - 1) / 2) * 1 +
(k >= 3) * (n * (n - 1) * (n - 2) / 6) * 2 +
(k >= 4) * (n * (n - 1) * (n - 2) * (n - 3) / 24) * 9;
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int sum = 0;
long long int n, k;
cin >> n >> k;
switch (k) {
case 4: {
long long int t;
t = n * (n - 1) * (n - 2) * (n - 3) / 24 * 9;
sum += t;
}
case 3: {
long long int t;
t = n * (n - 1) * (n - 2) / 6 * 2;
sum += t;
}
case 2: {
long long int t;
t = n * (n - 1) / 2 * 1;
sum += t;
}
case 1:
sum += 1;
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int ncr(long long int n, long long int r) {
long long int ret = 1;
for (long long int i = n; i > n - r; i--) ret *= i;
for (long long int i = 1; i <= r; i++) ret /= i;
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long int n, k;
cin >> n >> k;
long long int d[] = {1, 0, 1, 2, 9};
long long int ans = 0;
for (long long int i = 0; i <= k; i++) {
ans += d[i] * ncr(n, i);
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, n1, n2, n3, n4;
int main() {
cin >> n >> k;
n1 = 1;
n2 = n1 + n * (n - 1) / 2;
n3 = n2 + n * (n - 1) * (n - 2) / 3;
n4 = n3 + n * (n - 1) * (n - 2) * (n - 3) * 3 / 8;
if (k == 1)
cout << n1;
else if (k == 2)
cout << n2;
else if (k == 3)
cout << n3;
else
cout << n4;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long ans = 1, t[1010][1010];
long long ncr(int n, int r) {
if (r == 0 || n == r) return 1;
if (t[n][r] != 0) return t[n][r];
t[n][r] = ncr(n - 1, r) + ncr(n - 1, r - 1);
return t[n][r];
}
int main() {
cin >> n >> k;
if (k > 1) {
ans += ncr(n, 2);
}
if (k > 2) {
ans += ncr(n, 3) * 2;
}
if (k > 3) {
ans += ncr(n, 4) * 9;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long const INF = INT_MAX;
const long long MOD = 998244353;
const long long N = 8e5 + 1;
void SpeedForce() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int simple(int n) {
int i, sq;
if (n % 2 == 0) {
return 0;
}
sq = (int)sqrt(n);
for (i = 3; i <= sq; i++) {
if ((n % i) == 0) {
return 0;
}
}
return 1;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long is_prime(long long n) {
if (n <= 1 || n > 3 && (n % 2 == 0 || n % 3 == 0)) return 0;
for (long long i = 5, t = 2; i * i <= n; i += t, t = 6 - t)
if (n % i == 0) return 0;
return 1;
}
long long binpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n % 2) {
res = (res * x) % MOD;
}
x = (x * x) % MOD;
n /= 2;
}
return res;
}
void solve() {
long long n, k;
cin >> n >> k;
if (k == 1)
cout << 1;
else if (k == 2)
cout << n * (n - 1) / 2 + 1;
else if (k == 3)
cout << 1 + n * (n - 1) / 2 + 1ll * n * (n - 1) * (n - 2) / 3;
else
cout << 1 + n * (n - 1) / 2 + 1ll * n * (n - 1) * (n - 2) / 3 +
n * (n - 1) * (n - 2) * (n - 3) / 24 * 9ll;
}
int main() {
SpeedForce();
int T = 1;
while (T--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[5];
long long fat[1004];
long long pc(int n) {
if (n == 1) return 0;
if (n == 0) return 1;
if (dp[n] != -1) return dp[n];
return dp[n] = (n - 1) * (pc(n - 1) + pc(n - 2));
}
long long comb(long long a, long long b) {
long long ret = 1;
for (int i = a; i > a - b; i--) ret *= i;
return ret / fat[b];
}
int main() {
int n, k;
long long ans = 0;
fat[0] = 1;
for (int i = 1; i < 1001; i++) fat[i] = fat[i - 1] * i;
memset(dp, -1, sizeof dp);
scanf("%d %d", &n, &k);
for (int i = 0; i <= k; i++) {
ans += pc(i) * comb(n, i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
long long ans;
cin >> n >> k;
if (k == 1)
ans = 1;
else if (k == 2)
ans = n * (n - 1) / 2 + 1;
else if (k == 3)
ans = n * (n - 1) * (n - 2) / 3 + n * (n - 1) / 2 + 1;
else if (k == 4)
ans = 3 * n * (n - 1) * (n - 2) * (n - 3) / 8 + n * (n - 1) * (n - 2) / 3 +
n * (n - 1) / 2 + 1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
const long long mod = 1000000007;
long long n, ans = 1, k;
long long jc[2 * N], inv[2 * N];
long long C(long long n, long long m);
long long power(long long a, long long b);
int main() {
scanf("%lld%lld", &n, &k);
if (k == 1) {
printf("1\n");
} else if (k == 2) {
printf("%lld\n", C(n, 2) + 1);
} else if (k == 3) {
printf("%lld\n", C(n, 2) + C(n, 3) * 2 + 1);
} else {
printf("%lld\n", C(n, 2) + C(n, 3) * 2 + C(n, 4) * 9 + 1);
}
return 0;
}
long long power(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = (ans * a) % mod;
}
b >>= 1;
a = (a * a) % mod;
}
return ans;
}
long long C(long long n, long long m) {
long long ans = 1;
for (int i = n; i >= n - m + 1; i--) {
ans *= i;
}
for (int i = 1; i <= m; i++) {
ans /= i;
}
return ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long PI = acos(-1.0), MOD = 1000000007;
long long n, m, x, y, z, k, sol, sum, ans, l, r, xx, yy, t;
long long a[1000000], b[1000000], mem[1000][1000], pre[1000000], suff[1000000];
vector<pair<long long, long long> > v;
vector<long long> v1;
vector<long long> v2;
vector<pair<long long, long long> > vp;
map<long long, long long> ma;
string s1, s2, s;
set<long long> st;
char c;
int main() {
cin >> n >> k;
long long Mul = 1;
ans = 1;
for (long long q = 2; q <= k; q++) {
Mul = 1;
if (q == 5) continue;
for (long long i = n; i > n - q; i--) {
Mul *= i;
}
sum = 1;
for (long long i = 1; i <= q; i++) sum *= i;
long long per = 1;
if (q == 3) per = 2;
if (q == 4) per = 9;
ans += ((Mul / sum) * (per));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct rge {
T b, e;
};
template <class T>
rge<T> range(T i, T j) {
return rge<T>{i, j};
}
struct debug {
template <class T>
debug& operator<<(const T&) {
return *this;
}
};
using ll = long long;
template <typename T>
void min_self(T& a, T b) {
a = min(a, b);
}
template <typename T>
void max_self(T& a, T b) {
a = max(a, b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<vector<ll>> choose(n + 1, vector<ll>(k + 1));
choose[0][0] = 1;
for (int i = 1; i <= n; i++) {
choose[i][0] = 1;
if (i <= k) {
choose[i][i] = 1;
}
for (int j = 1; j < min(i, k + 1); j++) {
choose[i][j] = choose[i - 1][j] + choose[i - 1][j - 1];
}
}
vector<int> der{1, 0, 1, 2, 9};
ll ans = 0;
for (int i = n - k; i <= n; i++) {
ans += choose[n][n - i] * der[n - i];
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3 * 100000 + 10;
int a[maxn];
long long c(long long a, long long b) {
if (b == 0) return 1;
if (a - b < b) b = a - b;
long long sum1 = 1;
for (int i = a; i > a - b; i--) {
sum1 = sum1 * i;
}
long long sum2 = 1;
for (int i = b; i >= 1; i--) {
sum2 = sum2 * i;
}
return sum1 / sum2;
}
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
long long ans = 0;
a[1] = 0;
a[2] = 1;
a[3] = 2;
a[4] = 9;
for (int i = 1; i <= k; i++) {
ans += c(n, i) * a[i];
}
ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, i = 0, j = 0, k = 0, l = 0, m = 0, a = 0, b = 0, sum = 0, x = 0,
y = 0, z = 0, c, p;
cin >> n >> k;
long long d[5], fac[5];
d[0] = 1;
d[1] = 0;
d[2] = 1;
d[3] = 2;
d[4] = 9;
fac[0] = fac[1] = 1;
fac[2] = (n * (n - 1)) / 2;
fac[3] = (n * (n - 1) * (n - 2)) / 6;
fac[4] = (n * (n - 1) * (n - 2) * (n - 3)) / 24;
for (i = 0; i <= k; i++) {
sum += fac[i] * d[i];
}
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
const double PI = acos(-1.0);
const long long mod = 1000000007;
const long long INF = 1e9;
const long long MAXN = 1000001;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, k;
cin >> n >> k;
long long zero = 1;
long long one = 0;
long long two = n * (n - 1) / 2;
long long three = n * (n - 1) * (n - 2) / 3;
long long four = 0;
if (k == 1)
cout << 1;
else {
if (k == 2)
cout << (1 + two);
else {
if (k == 3) {
cout << (1 + two + three);
} else {
long long ans = 1 + two + three;
four = n * (n - 1) * (n - 2) * (n - 3) / 24;
four *= 9;
ans += four;
cout << ans;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T binpow(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
long long int MOD = 1000000007;
long double EPS = 1e-9;
long long int countbits(long long int n) {
long long int count = 0;
while (n) {
n = n & (n - 1);
count++;
}
return count;
}
long long int tolli(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
vector<long long int> tobinary(long long int n) {
vector<long long int> bin;
while (n) {
bin.emplace_back(n % 2);
n /= 2;
};
reverse((bin).begin(), (bin).end());
return bin;
}
long long int fact[10000];
void pre() {
fact[0] = 1;
for (long long int i = 1; i < 10000; i++) fact[i] = fact[i - 1] * i;
}
long long int ncr(long long int n, long long int r) {
if (r == 2)
return n * (n - 1) / 2;
else if (r == 3)
return n * (n - 1) * (n - 2) / 6;
else
return n * (n - 1) * (n - 2) * (n - 3) / 24;
}
void solve() {
long long int n, k;
cin >> n >> k;
cout << 9 * ncr(n, 4) * (k >= 4) + 2 * ncr(n, 3) * (k >= 3) +
ncr(n, 2) * (k >= 2) + 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
pre();
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
int main() {
long long int n, k, m, z, y;
while (scanf("%lld%lld", &n, &k) == 2) {
m = 1 + n * (n - 1) / 2;
z = m + n * (n - 1) * (n - 2) / 6 * 2;
y = z + n * (n - 1) * (n - 2) * (n - 3) / 24 * 9;
if (k == 1) {
printf("1\n");
} else if (k == 2) {
printf("%lld\n", m);
} else if (k == 3) {
printf("%lld\n", z);
} else if (k == 4) {
printf("%lld\n", y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fact(int n) {
if (n < 2) return 1;
return fact(n - 1) * n;
}
long long C(int n, int k) {
long long ans = 1;
for (int i = n - k + 1; i <= n; i++) ans *= i;
return ans / fact(k);
}
long long mess(int n) {
long long fn = fact(n);
long long ans = 0;
for (int i = 0; i <= n; i++) ans = ans + fn / fact(i) * (1 - (i % 2) * 2);
return ans;
}
long long per(int n, int k) {
long long ans = 0;
for (int i = 1; i <= k; i++) ans += C(n, i) * mess(i);
ans++;
return ans;
}
int main() {
int n, k;
cin >> n >> k;
cout << per(n, k) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
int main() {
long long int n, k, i;
cin >> n >> k;
long long int arr[5] = {0, 0, 1, 2, 9};
long long int prod = n;
long long int ans = 0;
for (i = 1; i <= k; i++) {
ans += prod * arr[i];
prod *= (n - i);
prod /= (i + 1);
}
cout << ans + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<long long> v = {1, 0, 1, 2, 9};
long long ans = 0;
for (long long i = k; i >= 0; i--) {
long long tem = i;
long long te = n;
long long res = 1;
while (tem--) {
res *= te;
res /= (i - tem);
te--;
}
res *= v[i];
ans += res;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = 2e6 + 30;
const int MAXN = 1e3 + 2;
const long long INF = 1e9 + 7;
const long long BINF = 1e15;
const int MOD = 1e9 + 7;
const long double EPS = 1e-15;
const long long dx[] = {0, 0, 1, -1};
const long long dy[] = {1, -1, 0, 0};
long long n, k;
long long cnt = 1;
long long ans[MXN];
vector<long long> v;
long long cnk(long long n, long long k) {
if (k == 2) {
return n * (n - 1) / k;
}
if (k == 3) {
return n * (n - 1) * (n - 2) / 6LL;
}
if (k == 4) {
return n * (n - 1) * (n - 2) * (n - 3) / 24LL;
}
}
int main() {
cin >> n >> k;
ans[2] = 1;
ans[4] = 9;
for (int i = 3; i <= 3; i++) {
v.clear();
for (int j = 1; j <= i; j++) {
v.push_back(j);
}
while (next_permutation(v.begin(), v.end())) {
int q = 1;
for (int j = 1; j <= i; j++) {
if (v[j] == j) q = 0;
}
if (q) ans[i]++;
}
}
for (int i = 2; i <= k; i++) {
cnt += cnk(n, i) * 1LL * ans[i];
}
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long der[5];
der[0] = 1;
der[1] = 0;
for (long long i = 2; i < 5; i++)
der[i] = (i - 1) * (der[i - 1] + der[i - 2]);
long long c[1001][1001];
for (long long i = 0; i <= 1000; i++) {
c[i][0] = c[i][i] = 1;
for (long long j = 1; j < i; j++) {
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
}
}
long long n, k;
cin >> n >> k;
long long ans = 0;
for (long long i = 0; i <= k; i++) {
ans += c[n][i] * der[i];
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int cc[5] = {1, 0, 1, 2, 9};
long long c[1010][1010];
int main(int argc, char const *argv[]) {
for (int i = 1; i <= 1000; i++) {
c[i][0] = 1;
c[i][1] = i;
c[i][i] = 1;
}
for (int i = 2; i <= 1000; i++) {
for (int j = 2; j <= 4; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
}
}
scanf("%d%d", &n, &k);
long long ans = 0;
for (int i = 0; i <= k; i++) {
ans += c[n][i] * cc[i];
}
std::cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long res = binpow(a, b / 2);
if (b % 2)
return (res * res) * a;
else
return (res * res);
}
int mpow(int base, int exp, int mod) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((long long)result * base) % mod;
base = ((long long)base * base) % mod;
exp >>= 1;
}
return result % mod;
}
int binarysearch(vector<pair<int, int>>& vec, int key) {
int mid, best = -1;
int l = 0, r = vec.size() - 1;
while (l <= r) {
mid = l + (r - l) / 2;
if (vec[mid].first <= key) {
best = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
return best;
}
int lowsearch(int a[], int q, int l, int r) {
int ans = 0;
int mid = (l + r) / 2;
while (r >= l) {
if (a[mid] >= q) {
r = mid - 1;
ans = mid;
} else {
l = mid + 1;
ans = mid + 1;
}
}
return ans + 1;
}
int upsearch(int a[], int q, int l, int r) {
int ans = 0;
int mid = (l + r) / 2;
while (r >= l) {
if (a[mid] <= q) {
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
ans = mid + 1;
}
}
return ans + 1;
}
long long nprimes(long long n) {
vector<char> is_prime(n + 1, true);
is_prime[0] = is_prime[1] = false;
for (int i = 2; i <= n; i++) {
if (is_prime[i] && (long long)i * i <= n) {
for (int j = i * i; j <= n; j += i) is_prime[j] = false;
}
}
long long cnt = 0;
for (int i = 0; i < n + 1; i++) {
if (is_prime[i] == true) {
cnt++;
}
}
return cnt;
}
int countDivisors(int n) {
int cnt = 0;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
cnt++;
else
cnt = cnt + 2;
}
}
return cnt;
}
vector<long long> trial_division1(long long n) {
vector<long long> factorization;
if (n == 1) {
factorization.push_back(1);
}
for (long long d = 2; d * d <= n; d++) {
if (n % d == 0) {
factorization.push_back(d);
while (n % d == 0) {
n /= d;
}
}
}
if (n > 1) factorization.push_back(n);
return factorization;
}
int phi(int n) {
float result = n;
for (int p = 2; p * p <= n; ++p) {
if (n % p == 0) {
while (n % p == 0) n /= p;
result *= (1.0 - (1.0 / (float)p));
}
}
if (n > 1) result *= (1.0 - (1.0 / (float)n));
return (int)result;
}
bool palindrome(const string& s) {
int n = s.length();
for (int i = 0; i < n; i++) {
if (s[i] != s[n - i - 1]) return false;
}
return true;
}
vector<int> adj[1000004];
int d[100003];
bool visited[100003];
void visit(int vertex) {
d[vertex] = 0;
visited[vertex] = 1;
for (int child : adj[vertex]) {
if (!visited[child]) {
visit(child);
}
d[vertex] = max(d[vertex], 1 + d[child]);
}
}
int main() {
ios::sync_with_stdio(false);
int t = 1;
while (t--) {
long long n, k;
cin >> n >> k;
if (k == 1) {
cout << 1 << endl;
}
if (k == 3) {
cout << 1 + (n * (n - 1) / 2) + 2 * (n * (n - 1) * (n - 2)) / 6 << endl;
}
if (k == 2) {
cout << 1 + (n * (n - 1) / 2) << endl;
}
if (k == 4) {
cout << 1 + (n * (n - 1) / 2) + (2 * (n * (n - 1) * (n - 2)) / 6) +
(9 * (n) * (n - 1) * (n - 2) * (n - 3)) / 24
<< endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int nck(long long int n, long long int k) {
long long int ans = 1;
for (int i = 0; i < k; i++) {
ans = ans * (n - i);
}
for (int i = 1; i <= k; i++) {
ans = ans / i;
}
return ans;
}
int main() {
int n, k;
cin >> n >> k;
long long int ans = 1, f[] = {0, 0, 1, 2, 9};
for (int i = 1; i <= k; i++) {
ans = ans + nck(n, i) * f[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const long long INF = 2000000005;
const long long BIG_INF = 2000000000000000005;
const long long mod = 1000000007;
const long long P = 31;
const long double PI = 3.141592653589793238462643;
const double eps = 1e-9;
using namespace std;
vector<pair<long long, long long> > dir = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
bool valid(long long x, long long y, long long n, long long m) {
return x >= 0 && y >= 0 && x < n && y < m;
}
mt19937 rng(1999999973);
long long c[1005][5], col[5], n, k;
vector<long long> per;
void precalc() {
for (long long k = 1; k <= 4; k++) {
per.push_back(k);
sort(per.begin(), per.end());
do {
bool good = true;
for (long long i = 0; i < k; i++) {
if (per[i] == i + 1) good = false;
}
if (good) col[k]++;
} while (next_permutation(per.begin(), per.end()));
}
col[0] = 1;
c[0][0] = 1;
for (long long n = 1; n <= 1000; n++) {
for (long long k = 0; k <= 4; k++) {
c[n][k] = c[n - 1][k];
if (k != 0) c[n][k] += c[n - 1][k - 1];
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
precalc();
cin >> n >> k;
long long ans = 0;
for (long long i = 0; i <= k; i++) {
ans += col[i] * c[n][i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int M = 1e9 + 7;
long long int n, k, m;
long long int z, q, u, a1, l, r, ax, cx, ay, by, cy, ql, qr, d, x, y;
multimap<long long int, long long int, greater<long long int>> s;
long long int a[1000007];
long long int gh[15][100007];
long long int b[107];
long long int f[1000007];
char ch[1007][1007];
long long int dp[1007][1007];
double T;
long long int dp1[1007][1007];
char pre1[1007][1007];
unordered_map<long long int, long long int> mp;
long long int solve(string s) {
if (s[0] > s[s.length() - 1]) {
stringstream ss(s);
long long int d;
ss >> d;
while (1) {
d--;
s = to_string(d);
if (s[0] == s[s.length() - 1]) break;
}
}
long long int c = s.length();
if (c == 1) {
c = stoi(s);
return c;
} else if (c == 2) {
c = 10;
} else {
c = pow(10, c - 2) + 8LL;
}
c += pow(10, s.length() - 2) * (s[0] - 49);
for (int j = 1; j < s.length() - 1; j++) {
if (j < s.length() - 2)
c += pow(10, s.length() - j - 2) * (s[j] - 48);
else
c += s[j] - 47;
}
return c;
}
vector<long long int> v;
bool check(long long int m) {
unordered_map<long long int, long long int> mp1;
for (int i = 1; i <= n; i++) {
mp1[a[i]] = 1;
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
long long int c = mp[a[i]] / mp1[a[i]];
if (c >= m) {
mp1[a[i]]++;
ans++;
}
}
mp1.clear();
if (ans >= k) return true;
return false;
}
int main() {
cin >> n >> k;
long long int dp[5];
if (k == 1)
return cout << 1, 0;
else {
dp[1] = 1;
dp[2] = ((n * (n - 1)) / 2LL) + dp[1];
dp[3] = ((n * (n - 1) * (n - 2)) / 6LL) * (2LL) + dp[2];
dp[4] = ((n * (n - 1) * (n - 2) * (n - 3)) / 24LL) * (9LL) + dp[3];
if (k == 2)
cout << dp[2];
else if (k == 3)
cout << dp[3];
else
cout << dp[4];
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long C[1010][1010];
void dabiao() {
C[0][0] = 1;
for (int i = 1; i < 1010; ++i) {
C[i][0] = 1;
for (int j = 1; j <= i; ++j) C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
int main() {
dabiao();
int n, k;
cin >> n >> k;
if (k == 1)
cout << 1 << endl;
else if (k == 2)
cout << C[n][2] + 1 << endl;
else if (k == 3)
cout << C[n][3] * 2 + C[n][2] + 1 << endl;
else if (k == 4)
cout << C[n][4] * 9 + C[n][3] * 2 + C[n][2] + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ncr(long long n, long long r) {
long long num = 1;
for (int i = n; i > max(r, n - r); i--) num *= i;
long long deno = 1;
for (int i = 1; i <= min(r, n - r); i++) deno *= i;
return num / deno;
}
void solve() {
int n, k;
cin >> n >> k;
long long ans = 0;
if (k == 1) ans = 1;
if (k == 2) ans = 1 + ncr(n, 2);
if (k == 3) ans = 1 + ncr(n, 2) + ncr(n, 3) * 2;
if (k == 4) ans = 1 + ncr(n, 2) + ncr(n, 3) * 2 + ncr(n, 4) * 9;
cout << ans << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const int N = 1e3 + 5;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
long long n, k;
long long d[] = {1, 0, 1, 2, 9};
long long binom[N][N];
long long ans;
int main() {
scanf("%lld %lld", &n, &k);
ans += d[0];
if (k >= 1) ans += d[1] * n;
if (k >= 2) ans += d[2] * (n * (n - 1)) / 2;
if (k >= 3) ans += d[3] * (n * (n - 1) * (n - 2)) / 6;
if (k >= 4) ans += d[4] * (n * (n - 1) * (n - 2) * (n - 3)) / 24;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1 * 1e5 + 100;
const long long INF = 1e18;
int N, M, k;
int arr[MX];
int cnt[33];
char s[MX];
long long nCk(long long n, long long k) {
long long ans = 1;
int kk = 0;
while (kk != k) {
ans = ans * (n - kk);
kk++;
}
long long dd = 1;
for (int i = 1; i <= k; i++) dd *= i;
return (long long)ans / dd;
}
long long fact(long long n) {
if (n == 3) return 2;
if (n == 4) return 9;
return 1;
}
int main() {
cin >> N >> k;
if (k == 1) {
cout << 1;
} else if (1) {
long long ans = 0;
while (k > 1) {
ans += nCk(N, k) * fact(k);
k--;
}
cout << ++ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void boost() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
boost();
long long n, k, t_cnt = 0;
cin >> n >> k;
long long k_value[5] = {0, 0, 1, 2, 9};
while (k) {
if (k == 1) {
t_cnt += 1;
break;
}
long long ans = 1;
for (int i = n; i > n - k; i--) ans *= i;
for (int i = 2; i <= k; ++i) ans /= i;
t_cnt += ans * k_value[k];
k--;
}
cout << t_cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
if (k == 1) {
cout << 1;
return 0;
}
if (n == k) {
cout << 24;
return 0;
}
long long f2 = 1;
for (int i = n - 2 + 1; i <= n; i++) {
f2 *= i;
}
f2 /= 2;
long long f3 = 1;
for (int i = n - 3 + 1; i <= n; i++) {
f3 *= i;
}
f3 /= 6;
f3 *= 2;
long long f4 = 1;
for (int i = n - 4 + 1; i <= n; i++) {
f4 *= i;
}
f4 /= 24;
f4 *= 9;
if (k == 2) {
cout << f2 + 1;
} else if (k == 3) {
cout << 1LL * f3 + f2 + 1;
} else if (k == 4) {
cout << 1LL * f4 + f3 + f2 + 1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cuo[] = {1, 0, 1, 2, 9};
long long C[1100][5];
void init() {
C[0][0] = 1;
for (int i = 1; i <= 1000; i++) {
C[i][0] = 1;
for (int j = 1; j <= i && j <= 4; j++)
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
int main() {
int n, k;
init();
while (scanf("%d%d", &n, &k) != EOF) {
long long ans = 0;
for (int i = 0; i <= k; i++) {
ans += C[n][i] * cuo[i];
}
printf("%I64d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
clock_t time_p = clock();
void rtime() {
time_p = clock() - time_p;
cout << "\nTime Taken : " << fixed << (float)(time_p) / CLOCKS_PER_SEC
<< "s\n";
}
inline long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
inline long long lcm(long long a, long long b) { return (a / gcd(a, b) * b); }
inline bool prime(long long n) {
long long i;
for (i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return false;
}
return true;
}
template <class T>
ostream& operator<<(ostream& os, string V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, set<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class T>
ostream& operator<<(ostream& os, multiset<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class T, class T1>
ostream& operator<<(ostream& os, map<T, T1> S) {
os << "{ ";
for (auto s : S) os << "(" << s.first << "," << s.second << ") ";
return os << "}";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long modx = 1e9 + 7;
const long long mod = modx;
inline long long add(long long x, long long y, long long mod = modx) {
x += y;
if (x >= mod) return x - mod;
return x % mod;
}
inline long long sub(long long x, long long y, long long mod = modx) {
x -= y;
if (x < 0) return x + mod;
return x;
}
inline long long mul(long long x, long long y, long long mod = modx) {
return (x * 1ll * y) % mod;
}
inline long long expo(long long x, long long y, long long mod = modx) {
long long ans = 1;
while (y) {
if (y & 1) ans = mul(ans, x, mod);
x = mul(x, x, mod);
y >>= 1;
}
return ans % mod;
}
inline long long inv(long long x, long long mod = modx) {
return expo(x, mod - 2, mod);
}
long long rr[] = {0, 1, 1, 1, 0, -1, -1, -1};
long long cc[] = {1, 1, 0, -1, -1, -1, 0, 1};
const long long MAXN = 2e5 + 10, MAX2N = 2e3 + 10, LG = 20, INF = 2e18,
base = 33;
const long long N = 1e7 + 10;
long long n, m, p, k, x, q, y, z, a[MAXN], b[MAXN];
long long ncr(long long n, long long r) {
if (r <= 1) return 1;
if (r == 2) return n * (n - 1) / 2;
if (r == 3) return n * (n - 1) * (n - 2) / 3;
if (r == 4) return 3 * n * (n - 1) * (n - 2) * (n - 3) / 8;
return 1;
}
void solve() {
cin >> n >> k;
long long ans = 0;
for (long long i = 1; i <= k; i++) {
ans += ncr(n, i);
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
t = 1;
for (long long i = 1; i <= t; i++) {
solve();
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.