這場一共就打了26pts，這要是NOIP不得完事
隨機遊走 10pts
首先給出結論：對兒子序列排序，$ cmp $ 函式為 $ sum_b \times w_a < sum_a \times w_b $，其中 $ sum_x $ 代表 $ x $ 的子樹內的點權和，$ w_x $ 代表 $ x $ 的子樹內的邊權和（包括 $ (u, fa_u) $ 這條邊）， $ a $ 在待排序序列中先於 $ b $；
然後我們排序一遍兒子序列，正常 $ dfs $ 即可；
對兒子序列進行排序還是不難想的，因為我們要確定一個遍歷順序，但是對於 $ cmp $ 函式就不是太好想，賽時可能就是猜一下把（但是我沒猜到）；
下面我們對於這個結論進行一個證明；
首先我們要明確的是證明方向，那麼我們只需證明對於 $ i, i + 1 $ 這兩個相鄰的兒子節點滿足上述結論，然後依據氣泡排序即可得到證明；
考慮如果 $ i $ 先於 $ i + 1 $，那麼我們只考慮 $ i, i + 1 $ 這兩個點的貢獻，其它點的貢獻是不變的，設 $ f_i $ 表示 $ i $ 子樹內到 $ i $ 的答案，那麼它們兩個的貢獻為：
\[f_i + f_{i + 1} + \sum_{j = 1}^{i - 1} w_j \times sum_i + \sum_{j = 1}^{i} w_j \times sum_{i + 1}
\]
如果 $ i + 1 $ 先於 $ i $ 的話，那麼它們兩個的貢獻為：
\[f_{i} + f_{i + 1} + \sum_{j = 1}^{i - 1} w_j \times sum_{i + 1} + (\sum_{j = 1}^{i - 1} w_j + w_{i + 1}) \times sum_{i}
\]
\[= f_{i} + f_{i + 1} + \sum_{j = 1}^{i - 1} w_j \times sum_{i + 1} + \sum_{j = 1}^{i - 1} w_j \times sum_i + w_{i + 1} \times sum_{i}
\]
我們要讓下式小於上式，所以：
\[f_i + f_{i + 1} + \sum_{j = 1}^{i - 1} w_j \times sum_i + \sum_{j = 1}^{i} w_j \times sum_{i + 1} > f_{i} + f_{i + 1} + \sum_{j = 1}^{i - 1} w_j \times sum_{i + 1} + \sum_{j = 1}^{i - 1} w_j \times sum_i + w_{i + 1} \times sum_{i}
\]
移項可得：
\[sum_{i + 1} \times w_i < sum_i \times w_{i + 1}
\]
證畢；
點選檢視程式碼
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
int n;
vector<pair<int, long long> > v[500005];
long long a[500005], w[500005], sum[500005];
void dfs(int x) {
sum[x] = a[x];
for (int i = 0; i < v[x].size(); i++) {
int u = v[x][i].first;
dfs(u);
sum[x] += sum[u];
w[u] += v[x][i].second;
w[x] += w[u];
}
}
bool cmp(pair<int, long long> a, pair<int, long long> b) {
return sum[b.first] * w[a.first] < sum[a.first] * w[b.first];
}
long long now, ans;
void cfs(int x) {
for (int i = 0; i < v[x].size(); i++) {
int u = v[x][i].first;
now += v[x][i].second;
ans += (now * a[u]);
cfs(u);
}
}
int main() {
freopen("walk.in", "r", stdin);
freopen("walk.out", "w", stdout);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
int x;
long long y;
for (int i = 2; i <= n; i++) {
cin >> x >> y;
v[x].push_back({i, y});
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dfs(1);
for (int i = 1; i <= n; i++) {
sort(v[i].begin(), v[i].end(), cmp);
}
cfs(1);
cout << ans;
return 0;
}
分發獎勵 16pts
首先求出原樹的 $ DFS $ 序，然後發現每次最多隻會修改兩個區間，於是我們先將這些區間綁到所在子樹的根節點上，然後對樹進行 $ DFS $，每進入一個節點就將其對應的區間加入線段樹中，返回時撤銷，然後就做完了；
對於操作，我們可以把它理解為區間加減 $ 1 $，然後這樣我們直接查詢全域性 $ 0 $ 的個數即可知道答案；
對於查詢，我們維護最小值以及最小值的個數，這樣就間接知道了全域性 $ 0 $ 的個數；
時間複雜度：$ \Theta(n \log n) $，常數較大；
點選檢視程式碼
#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
int n, q;
struct sss{
int t, ne;
}e[1000005];
int h[1000005], cnt;
void add(int u, int v) {
e[++cnt].t = v;
e[cnt].ne = h[u];
h[u] = cnt;
}
vector<int> v[500005];
int dcnt;
pair<int, int> a[500005];
int ans[500005];
bool vis[500005];
namespace SEG{
inline int ls(int x) {
return x << 1;
}
inline int rs(int x) {
return x << 1 | 1;
}
struct sss{
int l, r, mi, sum, lz;
}tr[3000005];
inline void push_up(int id) {
if (tr[ls(id)].mi < tr[rs(id)].mi) {
tr[id].sum = tr[ls(id)].sum;
} else if (tr[ls(id)].mi > tr[rs(id)].mi) {
tr[id].sum = tr[rs(id)].sum;
} else {
tr[id].sum = tr[ls(id)].sum + tr[rs(id)].sum;
}
tr[id].mi = min(tr[ls(id)].mi, tr[rs(id)].mi);
}
inline void push_down(int id) {
if (tr[id].lz != 0) {
tr[ls(id)].lz += tr[id].lz;
tr[rs(id)].lz += tr[id].lz;
tr[ls(id)].mi += tr[id].lz;
tr[rs(id)].mi += tr[id].lz;
tr[id].lz = 0;
}
}
void bt(int id, int l, int r) {
tr[id].l = l;
tr[id].r = r;
if (l == r) {
tr[id].sum = 1;
return;
}
int mid = (l + r) >> 1;
bt(ls(id), l, mid);
bt(rs(id), mid + 1, r);
push_up(id);
}
void add(int id, int l, int r, int d) {
if (tr[id].l >= l && tr[id].r <= r) {
tr[id].mi += d;
tr[id].lz += d;
return;
}
push_down(id);
int mid = (tr[id].l + tr[id].r) >> 1;
if (l <= mid) add(ls(id), l, r, d);
if (r > mid) add(rs(id), l, r, d);
push_up(id);
}
}
void afs(int x) {
a[x].first = ++dcnt;
for (int i = h[x]; i; i = e[i].ne) {
int u = e[i].t;
afs(u);
}
a[x].second = dcnt;
}
void dfs(int x) {
for (int i = 0; i < v[x].size(); i++) {
SEG::add(1, a[v[x][i]].first, a[v[x][i]].second, 1);
}
if (SEG::tr[1].mi == 0) ans[x] = n - SEG::tr[1].sum - 1;
else ans[x] = n - 1;
for (int i = h[x]; i; i = e[i].ne) {
int u = e[i].t;
dfs(u);
}
for (int i = 0; i < v[x].size(); i++) {
SEG::add(1, a[v[x][i]].first, a[v[x][i]].second, -1);
}
}
int main() {
freopen("reward.in", "r", stdin);
freopen("reward.out", "w", stdout);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
int x;
for (int i = 2; i <= n; i++) {
cin >> x;
add(x, i);
}
int y;
for (int i = 1; i <= q; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
vis[x] = vis[y] = true;
}
for (int i = 1; i <= n; i++) {
if (vis[i]) v[i].push_back(i);
}
afs(1);
SEG::bt(1, 1, dcnt);
dfs(1);
for (int i = 1; i <= n; i++) cout << max(0, ans[i]) << ' ';
return 0;
}
卡路里 0pts
這個題有點意思；
考慮我們要求的是一段區間，滿足這段區間 $ [l, r] $ 內點權減去 $ l, r $ 的距離最大；
所以我們獲得了一個 $ \Theta(m^2 n) $ 的暴力；
考慮怎麼最佳化這個東西，發現列舉區間找最大值沒什麼前途，所以我們考慮每個點的貢獻；
考慮到每種點只能選一個，所以我們可以處理出每個點的管轄區間，即每個點在一段區間 $ [l, r] $ 內為最大值，我們需要找出這個區間，這個可以單調棧一次求出，然後再這個區間內加上這個點的點權；
但是又考慮到原資料中有重複的點權，如果直接這樣求的話我們兩邊的區間會被算多次，所以我們考慮兩次單調棧，一次正序維護嚴格，一次逆序維護不嚴格（當然反過來也行），這樣就解決了這個問題；
然後我們就轉化成了有若干個區間加的形式，求每個區間和的最大值；
我們可以遍歷每個區間，這個是 $ \Theta(m^2) $ 的，現在關鍵是怎樣 $ \Theta(1) $ 處理區間加，不難想到二維差分；
具體來講，我們將 $ l $ 看作 $ x $ 軸，將 $ r $ 看作 $ y $ 軸，然後我們區間加就是矩形加，查詢就是單點查，直接上差分即可；
時間複雜度：$ \Theta(m^2 + nm) $；
點選檢視程式碼
#include <iostream>
#include <cstdio>
using namespace std;
int n, m;
long long d[5005], a[5005][205], su[5005], sum[5005][5005];
int s[5005], cnt;
int l[5005], r[5005];
int main() {
freopen("calorie.in", "r", stdin);
freopen("calorie.out", "w", stdout);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 2; i <= m; i++) {
cin >> d[i];
su[i] = su[i - 1] + d[i];
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
}
}
for (int j = 1; j <= n; j++) {
cnt = 0;
s[0] = 0;
for (int i = 1; i <= m; i++) {
while(cnt > 0 && a[i][j] > a[s[cnt]][j]) cnt--;
l[i] = s[cnt] + 1;
s[++cnt] = i;
}
cnt = 0;
s[0] = m + 1;
for (int i = m; i >= 1; i--) {
while(cnt > 0 && a[i][j] >= a[s[cnt]][j]) cnt--;
r[i] = s[cnt] - 1;
s[++cnt] = i;
}
for (int i = 1; i <= m; i++) {
sum[l[i]][i] += a[i][j];
sum[l[i]][r[i] + 1] -= a[i][j];
sum[i + 1][i] -= a[i][j];
sum[i + 1][r[i] + 1] += a[i][j];
}
}
long long ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= m; j++) {
sum[i][j] += (sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1]);
if (i <= j) ans = max(ans, sum[i][j] - (su[j] - su[i]));
}
}
cout << ans;
return 0;
}