简要题解
这套题比较 (H_2O)
建议题目背景美文共赏
( ext{T1})
显然一个 (O(n^3)) 不能过的 (dp)
然而过了？！
用心在该卡时间的地方卡一卡
( ext{Code})
#include <cstdio>
#include <algorithm>
#define re register
using namespace std;
typedef long long LL;
const int N = 5005;
int n, m, C, lim[N], cnt, col[N];
LL f[N][N], g[N];
struct node{int v, w, c;}a[N];
inline bool cmp(node a, node b){return a.c < b.c;}
inline bool cmp1(node a, node b){return a.v > b.v;}
inline void solve()
{
sort(a + 1, a + n + 1, cmp1);
LL ans = 0;
for(re int i = 1; i <= n; i++)
{
if (!m) break;
if (lim[a[i].c]) ans += a[i].v, --lim[a[i].c], --m;
}
printf("%lld
", ans);
}
int main()
{
freopen("diversity.in", "r", stdin), freopen("diversity.out", "w", stdout);
scanf("%d%d%d", &n, &m, &C);
int bz1 = 1, bz2 = 1;
for(re int i = 1; i <= n; i++) scanf("%d%d%d", &a[i].v, &a[i].w, &a[i].c), bz2 = (bz2 && (a[i].w == 1));
sort(a + 1, a + n + 1, cmp);
for(re int i = 1; i <= C; i++) scanf("%d", &lim[i]), bz1 = (bz1 && lim[i] >= m), lim[i] = (lim[i] > m ? m : lim[i]);
if (bz2){solve(); return 0;}
int r;
for(re int l = 1; l <= n; l = r + 1)
{
r = l, col[++cnt] = a[l].c;
while (r < n && a[r + 1].c == a[l].c) ++r;
if (bz1) r = n;
for(re int i = 1; i <= r - l + 1; i++)
for(re int j = lim[a[l].c]; j >= a[i + l - 1].w; j--)
f[cnt][j] = max(f[cnt][j], f[cnt][j - a[i + l - 1].w] + a[i + l - 1].v);
}
if (bz1){printf("%lld
", f[1][m]); return 0;}
for(re int i = 1; i <= cnt; i++)
for(re int j = m; j >= 0; j--)
for(re int k = 0; k <= min(j, lim[col[i]]); k++)
g[j] = max(g[j], g[j - k] + f[i][k]);
printf("%lld
", g[m]);
}
( ext{T2})
二分答案，考虑如何 (check)
贪心的想，将 (a) 排序，一一对应要弄出的自然数序列 (b)
然后就是快速计算代价
考虑一个位置，前面的代价是 (b_i - a_i) 的形式，后面的是 (a_i - b_i) 的形式（连续性很明显）
二分这个位置的话是 (O(nlog^2n)) 的，常数优秀就可以过
实际上这个分割的位置有单调性，指针处理即可
( ext{Code})
#include <cstdio>
#include <iostream>
#include <algorithm>
#define re register
using namespace std;
typedef long long LL;
const int N = 1e6 + 5;
int n;
LL num, a[N], sum[N];
inline void read(int &x)
{
x = 0; char ch = getchar(); int f = 1;
for(; !isdigit(ch); f = (ch == '-' ? -1 : f), ch = getchar());
for(; isdigit(ch); x = (x<<3) + (x<<1) + (ch^48), ch = getchar());
x *= f;
}
inline LL cost(int l, int r)
{
if (l > r) return 0;
return 1LL * (r + l) * (r - l + 1) / 2;
}
inline int check(int mid)
{
LL res = num + 1; int r = mid + 1;
for(re int i = 1; i <= n - mid; i++)
{
while (r && r - 1 < a[i + r - 1]) --r;
res = min(res, cost(1, r - 1) - (sum[i + r - 1] - sum[i - 1]) + (sum[i + mid] - sum[i + r - 1]) - cost(r, mid));
}
return res <= num;
}
int main()
{
freopen("dream.in", "r", stdin), freopen("dream.out", "w", stdout);
read(n), scanf("%lld", &num);
for(re int i = 1, x; i <= n; i++) read(x), a[i] = x;
sort(a + 1, a + n + 1);
for(re int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
int l = 0, r = n - 1, mid, res = -1;
while (l <= r)
{
mid = l + r >> 1;
if (check(mid)) res = mid, l = mid + 1;
else r = mid - 1;
}
printf("%lld", res + 1);
}
( ext{T3})
题目理解后就很好做了
考虑答案的暴力形式，莫反一下
[ans = frac{sum_{d=1}^k d sum_{t=1}^{lfloor frac{k}{d}
floor} mu(t) lfloor frac{k}{dt}
floor ^n}{k^n}
]
发现是个数论分块套数论分块的形式
( ext{Code})
#include <cstdio>
#define re register
#define LL long long
using namespace std;
const int N = 1e6, P = 998244353, inv2 = 499122177;
int totp, n, k, T, pr[N], vis[N + 5], mu[N + 5], pw[N + 5];
inline int fpow(LL x, LL y)
{
if (x < k && pw[x]) return pw[x];
LL res = 1, xx = x;
for(; y; y >>= 1, x = x * x % P) if (y & 1) res = res * x % P;
if (xx < k) pw[xx] = res;
return res;
}
inline void Euler()
{
vis[1] = mu[1] = 1;
for(re int i = 2; i <= N; i++)
{
if (!vis[i]) pr[++totp] = i, mu[i] = -1;
for(re int j = 1; j <= totp && i * pr[j] <= N; j++)
{
vis[i * pr[j]] = 1;
if (!(i % pr[j])) break;
mu[i * pr[j]] = -mu[i];
}
}
for(re int i = 1; i <= N; i++) mu[i] += mu[i - 1];
}
inline LL F(int up)
{
int r; LL sum = 0;
for(re int l = 1; l <= up; l = r + 1)
{
r = up / (up / l);
sum = (sum + 1LL * (mu[r] - mu[l - 1] + P) % P * fpow(up / l, n) % P) % P;
}
return sum;
}
int main()
{
freopen("dance.in", "r", stdin), freopen("dance.out", "w", stdout);
Euler(), scanf("%d", &T);
for(; T; --T)
{
scanf("%d%d", &n, &k);
for(re int i = 0; i <= k; i++) pw[i] = 0;
LL ans = 0; int r;
for(re int l = 1; l <= k; l = r + 1)
{
r = k / (k / l);
ans = (ans + 1LL * (r + l) * (r - l + 1) % P * inv2 % P * F(k / l) % P) % P;
}
printf("%lld
", ans * fpow(fpow(k, n), P - 2) % P);
}
}
( ext{T4})
考虑一个坐标向下走的贡献
把一个坐标能左右延伸出的位置处理出来，可单调栈做到 (O(n)) 也可懒惰的 (O(n log n)) 二分 + (ST) 表
然后把坐标按 (y) 从小到大排序，扫过的点就满足了 (y) 的限制
先处理当前点可延伸区间的贡献再在树状数组上加入这个点
非常之简单
( ext{Code})
#include <iostream>
#include <cstdio>
#include <algorithm>
#define re register
using namespace std;
typedef long long LL;
const int N = 5e5 + 5, P = 998244353;
int n, m, mx[N][21], lg[N];
struct point{int x, y, w, l, r;}p[N];
inline bool cmpy(point a, point b){return a.y < b.y;}
inline void read(int &x)
{
x = 0; char ch = getchar(); int f = 1;
for(; !isdigit(ch); f = (ch == '-' ? -1 : f), ch = getchar());
for(; isdigit(ch); x = (x<<3) + (x<<1) + (ch^48), ch = getchar());
x *= f;
}
inline int query(int l, int r)
{
int k = lg[r - l + 1];
return max(mx[l][k], mx[r - (1 << k) + 1][k]);
}
inline void prepare()
{
for(re int j = 1; j <= lg[n]; j++)
for(re int i = 1; i + (1 << j) - 1 <= n; i++)
mx[i][j] = max(mx[i][j - 1], mx[i + (1 << j - 1)][j - 1]);
for(re int i = 1; i <= m; i++)
{
int l = 1, r = p[i].x, mid;
while (l <= r)
{
mid = l + r >> 1;
if (query(mid, p[i].x) < p[i].y) p[i].l = mid, r = mid - 1;
else l = mid + 1;
}
l = p[i].x, r = n;
while (l <= r)
{
mid = l + r >> 1;
if (query(p[i].x, mid) < p[i].y) p[i].r = mid, l = mid + 1;
else r = mid - 1;
}
}
}
struct node{LL s0, s1, s2;};
inline node operator - (const node a, const node b)
{
return node{(a.s0 - b.s0 + P) % P, (a.s1 - b.s1 + P) % P, (a.s2 - b.s2 + P) % P};
}
struct BIT{
LL c0[N], c1[N], c2[N];
inline int lowbit(int x){return x & (-x);}
inline void add(int x, LL v)
{
for(; x <= n; x += lowbit(x))
++c0[x], c1[x] = (c1[x] + v) % P, c2[x] = (c2[x] + v * v % P) % P;
}
inline node getsum(int x)
{
int s0 = 0, s1 = 0, s2 = 0;
for(; x; x -= lowbit(x)) s0 = (s0 + c0[x]) % P, s1 = (s1 + c1[x]) % P, s2 = (s2 + c2[x]) % P;
return node{s0, s1, s2};
}
inline node query(int l, int r){return getsum(r) - getsum(l - 1);}
}T;
int main()
{
freopen("flame.in", "r", stdin), freopen("flame.out", "w", stdout);
read(n), read(m), lg[0] = -1;
for(re int i = 1; i <= n; i++) read(mx[i][0]), lg[i] = lg[i >> 1] + 1;
for(re int i = 1; i <= m; i++) read(p[i].x), read(p[i].y), read(p[i].w);
prepare(), sort(p + 1, p + m + 1, cmpy); node t; LL ans = 0;
for(re int i = 1; i <= m; i++)
{
t = T.query(p[i].l, p[i].r), T.add(p[i].x, p[i].w);
ans = (ans + t.s0 * p[i].w % P * p[i].w % P - t.s1 * 2 * p[i].w % P + t.s2 + P) % P;
}
printf("%lld
", ans);
}