2021牛客暑期多校训练营5
2021牛客暑期多校训练营5_ACM/NOI/CSP/CCPC/ICPC算法编程高难度练习赛_牛客竞赛OJ
D - Double Strings
给你两个字符串\(a\)，\(b\)，请你找出满足以下条件的字符串个数：
假设\(a\)，\(b\)的子串分别为\(s\)，\(t\)且\(|s|=|t|=k\)，存在任意一个\(i\)，使得：
\(\bullet\) \(s_1=t_1\)，\(s_2=t_2\)，\(\cdots\)，\(s_{i-1}=t_{i-1}\)。
\(\bullet\) \(s_i < t_i\)
\(\bullet\) \([i+1,k]\)不做限制
先求出\(dp\)数组，其中\(dp[i][j]\)表示\(a_1 \cdots a_i\)，\(b_1 \cdots b_j\)的公共子序列个数，关于\(dp\)数组的求法可以参考\(hdu5791\)。
我们考虑枚举每个\(a_i<b_j\)的位置，我们已经知道在这个位置之前公共子序列的个数，那么我们只需要求出后面的组合个数然后做乘法记录贡献即可。
设\(a\)还剩\(n\)个字符，\(b\)还剩\(m\)个字符，因为子序列长度要相等，所以方案个数就是\(C_n^0 \cdot C_m^0 + C_n^1 \cdot C_m^1 \cdots C_n^n \cdot C_m^n(n \leq m)=C_{n+m}^{n}\)。
关于等式的证明可以百度范德蒙恒等式。
#include <bits/stdc++.h>
using namespace std;
#define int long long
namespace Math {
const int MAXN = 1e4 + 5;
const int MOD = 1e9 + 7;
template<typename T>
T fpow(T a, int n, int p) {
T res = 1;
while (n) {
if (n & 1) {
res = (res * a) % p;
}
a = (a * a) % p;
n >>= 1;
}
return res;
}
int fact[MAXN], inv[MAXN];
void init() {
fact[0] = 1;
for (int i = 1; i < MAXN; ++i) {
fact[i] = fact[i - 1] * i % MOD;
}
inv[MAXN - 1] = fpow(fact[MAXN - 1], MOD - 2, MOD);
for (int i = MAXN - 2; i >= 0; --i) {
inv[i] = inv[i + 1] * (i + 1) % MOD;
}
}
int C(int n, int m) {
return fact[n] * inv[m] % MOD * inv[n - m] % MOD;
}
} // namespace Math
using Math::init, Math::C;
const int MAXN = 5e3 + 5;
const int MOD = 1e9 + 7;
int dp[MAXN][MAXN];
char a[MAXN], b[MAXN];
int32_t main(int32_t argc, char *argv[]) {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
Math::init();
cin >> a + 1 >> b + 1;
int n = strlen(a + 1), m = strlen(b + 1);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
dp[i][j] = (dp[i][j] + dp[i - 1][j]) % MOD;
dp[i][j] = (dp[i][j] + dp[i][j - 1]) % MOD;
dp[i][j] = (dp[i][j] - dp[i - 1][j - 1] + MOD) % MOD;
if (a[i] == b[j]) {
dp[i][j] = (dp[i][j] + dp[i - 1][j - 1] + 1) % MOD;
}
}
}
int res = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i] < b[j]) {
int x = n - i, y = m - j;
res = (res + (dp[i - 1][j - 1] + 1) * C(x + y, x)) % MOD;
}
}
}
cout << res << '\n';
system("pause");
return 0;
}
J - Jewels
带权二分图最大匹配裸题，对于每个珠宝，我们需要选择一个时刻\(t\)，那么我们让每个珠宝向每个时刻连边，权值为当前时刻珠宝坐标与\((0,0,0)\)的距离。再分别建立源点汇点，源点向每个珠宝连一条流量为\(1\)费用为\(0\)的边，每个时刻向汇点连一条流量为\(1\)费用为\(0\)的边，然后跑一遍最小费用最大流即可，因为这里用自己的板子超时了，所以用了\(atcoder\)的网络流板子。
#include <bits/stdc++.h>
using namespace std;
namespace atcoder {
namespace internal {
template <class T> struct simple_queue {
std::vector<T> payload;
int pos = 0;
void reserve(int n) { payload.reserve(n); }
int size() const { return int(payload.size()) - pos; }
bool empty() const { return pos == int(payload.size()); }
void push(const T& t) { payload.push_back(t); }
T& front() { return payload[pos]; }
void clear() {
payload.clear();
pos = 0;
}
void pop() { pos++; }
};
template <class E> struct csr {
std::vector<int> start;
std::vector<E> elist;
explicit csr(int n, const std::vector<std::pair<int, E>>& edges)
: start(n + 1), elist(edges.size()) {
for (auto e : edges) {
start[e.first + 1]++;
}
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
auto counter = start;
for (auto e : edges) {
elist[counter[e.first]++] = e.second;
}
}
};
} // namespace internal
template <class Cap, class Cost> struct mcf_graph {
public:
mcf_graph() {}
explicit mcf_graph(int n) : _n(n) {}
int add_edge(int from, int to, Cap cap, Cost cost) {
assert(0 <= from && from < _n);
assert(0 <= to && to < _n);
assert(0 <= cap);
assert(0 <= cost);
int m = int(_edges.size());
_edges.push_back({from, to, cap, 0, cost});
return m;
}
struct edge {
int from, to;
Cap cap, flow;
Cost cost;
};
edge get_edge(int i) {
int m = int(_edges.size());
assert(0 <= i && i < m);
return _edges[i];
}
std::vector<edge> edges() { return _edges; }
std::pair<Cap, Cost> flow(int s, int t) {
return flow(s, t, std::numeric_limits<Cap>::max());
}
std::pair<Cap, Cost> flow(int s, int t, Cap flow_limit) {
return slope(s, t, flow_limit).back();
}
std::vector<std::pair<Cap, Cost>> slope(int s, int t) {
return slope(s, t, std::numeric_limits<Cap>::max());
}
std::vector<std::pair<Cap, Cost>> slope(int s, int t, Cap flow_limit) {
assert(0 <= s && s < _n);
assert(0 <= t && t < _n);
assert(s != t);
int m = int(_edges.size());
std::vector<int> edge_idx(m);
auto g = [&]() {
std::vector<int> degree(_n), redge_idx(m);
std::vector<std::pair<int, _edge>> elist;
elist.reserve(2 * m);
for (int i = 0; i < m; i++) {
auto e = _edges[i];
edge_idx[i] = degree[e.from]++;
redge_idx[i] = degree[e.to]++;
elist.push_back({e.from, {e.to, -1, e.cap - e.flow, e.cost}});
elist.push_back({e.to, {e.from, -1, e.flow, -e.cost}});
}
auto _g = internal::csr<_edge>(_n, elist);
for (int i = 0; i < m; i++) {
auto e = _edges[i];
edge_idx[i] += _g.start[e.from];
redge_idx[i] += _g.start[e.to];
_g.elist[edge_idx[i]].rev = redge_idx[i];
_g.elist[redge_idx[i]].rev = edge_idx[i];
}
return _g;
}();
auto result = slope(g, s, t, flow_limit);
for (int i = 0; i < m; i++) {
auto e = g.elist[edge_idx[i]];
_edges[i].flow = _edges[i].cap - e.cap;
}
return result;
}
private:
int _n;
std::vector<edge> _edges;
// inside edge
struct _edge {
int to, rev;
Cap cap;
Cost cost;
};
std::vector<std::pair<Cap, Cost>> slope(internal::csr<_edge>& g,
int s,
int t,
Cap flow_limit) {
// variants (C = maxcost):
// -(n-1)C <= dual[s] <= dual[i] <= dual[t] = 0
// reduced cost (= e.cost + dual[e.from] - dual[e.to]) >= 0 for all edge
// dual_dist[i] = (dual[i], dist[i])
std::vector<std::pair<Cost, Cost>> dual_dist(_n);
std::vector<int> prev_e(_n);
std::vector<bool> vis(_n);
struct Q {
Cost key;
int to;
bool operator<(Q r) const { return key > r.key; }
};
std::vector<int> que_min;
std::vector<Q> que;
auto dual_ref = [&]() {
for (int i = 0; i < _n; i++) {
dual_dist[i].second = std::numeric_limits<Cost>::max();
}
std::fill(vis.begin(), vis.end(), false);
que_min.clear();
que.clear();
// que[0..heap_r) was heapified
size_t heap_r = 0;
dual_dist[s].second = 0;
que_min.push_back(s);
while (!que_min.empty() || !que.empty()) {
int v;
if (!que_min.empty()) {
v = que_min.back();
que_min.pop_back();
} else {
while (heap_r < que.size()) {
heap_r++;
std::push_heap(que.begin(), que.begin() + heap_r);
}
v = que.front().to;
std::pop_heap(que.begin(), que.end());
que.pop_back();
heap_r--;
}
if (vis[v]) continue;
vis[v] = true;
if (v == t) break;
// dist[v] = shortest(s, v) + dual[s] - dual[v]
// dist[v] >= 0 (all reduced cost are positive)
// dist[v] <= (n-1)C
Cost dual_v = dual_dist[v].first, dist_v = dual_dist[v].second;
for (int i = g.start[v]; i < g.start[v + 1]; i++) {
auto e = g.elist[i];
if (!e.cap) continue;
// |-dual[e.to] + dual[v]| <= (n-1)C
// cost <= C - -(n-1)C + 0 = nC
Cost cost = e.cost - dual_dist[e.to].first + dual_v;
if (dual_dist[e.to].second - dist_v > cost) {
Cost dist_to = dist_v + cost;
dual_dist[e.to].second = dist_to;
prev_e[e.to] = e.rev;
if (dist_to == dist_v) {
que_min.push_back(e.to);
} else {
que.push_back(Q{dist_to, e.to});
}
}
}
}
if (!vis[t]) {
return false;
}
for (int v = 0; v < _n; v++) {
if (!vis[v]) continue;
// dual[v] = dual[v] - dist[t] + dist[v]
// = dual[v] - (shortest(s, t) + dual[s] - dual[t]) +
// (shortest(s, v) + dual[s] - dual[v]) = - shortest(s,
// t) + dual[t] + shortest(s, v) = shortest(s, v) -
// shortest(s, t) >= 0 - (n-1)C
dual_dist[v].first -= dual_dist[t].second - dual_dist[v].second;
}
return true;
};
Cap flow = 0;
Cost cost = 0, prev_cost_per_flow = -1;
std::vector<std::pair<Cap, Cost>> result = {{Cap(0), Cost(0)}};
while (flow < flow_limit) {
if (!dual_ref()) break;
Cap c = flow_limit - flow;
for (int v = t; v != s; v = g.elist[prev_e[v]].to) {
c = std::min(c, g.elist[g.elist[prev_e[v]].rev].cap);
}
for (int v = t; v != s; v = g.elist[prev_e[v]].to) {
auto& e = g.elist[prev_e[v]];
e.cap += c;
g.elist[e.rev].cap -= c;
}
Cost d = -dual_dist[s].first;
flow += c;
cost += c * d;
if (prev_cost_per_flow == d) {
result.pop_back();
}
result.push_back({flow, cost});
prev_cost_per_flow = d;
}
return result;
}
};
} // namespace atcoder
using namespace atcoder;
#define int long long
const int MAXN = 3e2 + 5;
struct Point {
int x, y, z, v;
} p[MAXN];
int dist(int x, int y, int z) {
return x * x + y * y + z * z;
}
int32_t main(int32_t argc, char *argv[]) {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int x, y, z, v;
cin >> x >> y >> z >> v;
p[i] = {x, y, z, v};
}
atcoder::mcf_graph<int, int> G(n * 2 + 5);
int st = 0, ed = 2 * n + 1;
for (int i = 1; i <= n; ++i) {
G.add_edge(st, i, 1, 0);
}
for (int i = 1; i <= n; ++i) {
G.add_edge(i + n, ed, 1, 0);
}
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= n; ++j) {
G.add_edge(i + 1, n + j, 1, dist(p[j].x, p[j].y, p[j].z + i * p[j].v));
}
}
cout << G.flow(st, ed).second << '\n';
system("pause");
return 0;
}
K - King of Range
因为\(m\)很小，所以对于每次查询不用做到很优秀的复杂度，考虑\(O(n)\)的双指针做法，我们每次枚举左端点，并不断找到第一个满足条件的右端点，容易发现，\(l\)到\([r,n]\)的所有子序列都是满足条件的，至于维护区间最值，因为本题没有修改操作，可以使用查询\(O(1)\)的\(ST\)表。
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int n, m, a[MAXN];
int Log2[MAXN], mx[MAXN][32], mn[MAXN][32];
void build() {
for (int i = 1; i <= n; ++i) {
mx[i][0] = mn[i][0] = a[i];
Log2[i] = Log2[i - 1] + (1 << Log2[i - 1] == i);
}
for (int j = 1; (1 << j) <= n; ++j) {
for (int i = 1; i + (1 << (j - 1)) <= n; ++i) {
mx[i][j] = max(mx[i][j - 1], mx[i + (1 << (j - 1))][j - 1]);
mn[i][j] = min(mn[i][j - 1], mn[i + (1 << (j - 1))][j - 1]);
}
}
}
int Max(int l, int r) {
int k = Log2[r - l + 1] - 1;
return max(mx[l][k], mx[r - (1 << k) + 1][k]);
}
int Min(int l, int r) {
int k = Log2[r - l + 1] - 1;
return min(mn[l][k], mn[r - (1 << k) + 1][k]);
}
int query(int l, int r) {
return Max(l, r) - Min(l, r);
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
build();
while (m--) {
int k;
cin >> k;
long long res = 0;
for (int l = 1, r = 1; l <= n; ++l) { // 枚举左端点
while (r <= n && query(l, r) <= k) ++r;
res += n - r + 1; // [r, n]都会满足题目给定条件
}
cout << res << '\n';
}
system("pause");
return 0;
}
浙公网安备 33010602011771号