The 15th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple（部分）

D - Sequence Swapping

题意：
$\ \ \ \ $给你一个括号序列$s$，每个括号有一个固定的权值$v$，每次操作你可以选定一个$k(1 \leqslant k < n)$，$s_k$为左括号且$s_{k+1}$为右括号，交换$s_k,s_{k+1}$，获得$v_{s_k} * v_{s_{k+1}}$(可能为负)的分数，问最大能得到多少分。

思路：
$\ \ \ \ $从右往左考虑每个左括号，对于第$i + 1$个左括号，不可能交换到第$i$个左括号的右边，而且可以知道如果一个左括号和一个右括号交换了，不可能再次交换他们两，而且左括号不可能往左交换，那么可以设dp[i][j]：从右往左第i个左括号交换了j次的最大得分，那么会有$dp[i][j] = \max\{dp[i - 1][k] + sum[i][j]\ | \ k \geqslant j - d\}$ （其中$d$是第$i$个左括号和第$i-1$个左括号之间的右括号的数量，$sum[i][j]$是第$i$个左括号向右交换$j$次的前缀和，只能和靠近它的最近$j$个交换）， $k \geqslant j - d$是因为如果第$i$个左括号能交换j次，那么第$i-1$个左括号必定至少交换了$j - d$次(第$i$个左括号不可能在第$i-1$个左括号的右边)，然后只需要对$i-1$的求出的状态求一个后缀最大值即可。

#include<bits/stdc++.h>
typedef long long ll;
const int maxn = 1e3 + 10;
const ll INF = 4e18 + 10;
const ll mod = 1e9;
using namespace std;

int n, m, T, kase = 1;
char s[maxn];
ll dp[maxn][maxn];
ll sum[maxn][maxn];
ll val[maxn], max_dp[maxn];
int pres[maxn], idx[maxn];
int main() {
    scanf("%d", &T);
    while(T--) {
        scanf("%d %s", &n, s + 1);
        int cnt = 0;
        for(int i = 1; i <= n; i++) scanf("%lld", &val[i]);
        for(int i = 1; i <= n; i++) {
            sum[i][0] = 0; int t = 1;
            if(s[i] == '(') idx[cnt++] = i;
            for(int j = 1; j <= n; j++) {
                dp[i][j] = -INF;
                if(s[i] == '(' && j > i && s[j] == ')') {
                    sum[i][t] = sum[i][t - 1] + (ll)val[i] * val[j];
                    t++;
                }
            }
            pres[i] = t - 1;
        }
        idx[cnt++] = n + 1;
        dp[n + 1][0] = 0;
        for(int i = 1; i <= n; i++) dp[n + 1][i] = -INF;
        ll ans = 0;
        for(int i = n; i >= 1; i--) {
            if(s[i] == ')') continue;
            int id = upper_bound(idx, idx + cnt, i) - idx;
            int now = i, las = idx[id];
            int ds = las - now - 1;
            max_dp[n + 1] = -INF;
            for(int j = n; j >= 0; j--) max_dp[j] = max(max_dp[j + 1], dp[las][j]);
            for(int j = 0; j <= pres[i]; j++) {
                int res = max(0, j - ds);
                dp[i][j] = sum[i][j] + max_dp[res];
                ans = max(ans, dp[i][j]);
            }
        }
        printf("%lld\n", ans);
    }
    return 0;
}

E - LIS

题意：
$\ \ \ \ $定义$F_i$：在数组$a$中以第$i$个元素结尾的最长严格上升子序列的长度。现在有一个$n$个数的$a$数组，给出其$F$数组，再给出$a$数组中每个元素$a_i$的范围$l_i, r_i$$(l_i \leqslant a_i \leqslant r_i)$，要求构造出$a$数组。

思路：
$\ \ \ \ $假设$F$值为$1$的是$a$数组中的下标为$i_1, i_2, i_3 ...i_m$$(i_1 < i_2 < ... < i_m)$的元素，$F$值为$2$的是$a$数组中的下标为$j_1, j_2, j_3 ...j_k(j_1 < j_2 < ... < j_k)$的元素…..那么依据要求一定有：
$\ \ \ \ $$a_{i_1} \geqslant a_{i_2} \geqslant ... \geqslant a_{i_m}$
$\ \ \ \ $$a_{j_1} \geqslant a_{j_2} \geqslant ... \geqslant a_{j_k}$
$\ \ \ \ ........$
$\ \ \ \ $如果上述条件不满足， 比如$a_{i_1} < a_{i_2}$，那么$F_{i_2}$的值就是$2$而不是$1$了。所以首先满足上述条件，上述式子每个式子从右往左考虑，对于长度为$1$的，$a_{i_m}$可以直接取$l_{i_m}$（取的越小越好），因为这样对于约束条件才有更优的选择，然后$a_{i_x}$取$l_{i_x}$和$a_{i_{x+1}}$的最大值即可，这样确定了$F$值为$1$的下标的元素值。
$\ \ \ \ $对于$F$值大于$1$的，假设现在考虑到$F$值为$t$中的下标$为x_i$的元素，那么$a_{x_i}$的值是这样取的：
对于$idx \in [1, x_i-1]$，选择$F_{idx}=t-1$的元素的最小值 $\min\{a_{idx}\}$ $+ 1$，这个就是$a_{x_i}$的下限值，然后再和$l_{x_i}, a_{x_{i+1}}$取个最大值就是$a_{x_i}$的答案了。 取前缀的最小值可用树状数组，然后更新长度为$t$的元素值的时候，要把前面$t-1$所有元素值的更新删除，对于对于$t$他能取的元素只能是$t-1$的元素的最小值，删除更新可以记录之前的所有更新操作，删除的时候相当于恢复下就好了。

#include<bits/stdc++.h>
typedef long long ll;
const int maxn = 1e5 + 10;
const int INF = 2e9 + 10;
using namespace std;

typedef pair<int, int> pa;
int F[maxn], l[maxn], r[maxn];
int n, m, T, kase = 1;
int a[maxn];
pa res[maxn];
int C[maxn], rec[maxn * 30], ct;

void update(int x, int val) { for( ; x <= n; x += x & -x) { C[x] = min(C[x], val); rec[ct++] = x; }  }
int get_min(int x) { int ans = INF; for( ; x; x -= x & -x) ans = min(ans, C[x]); return ans; }

bool cmp(pa a, pa b) {
    if(a.first != b.first) return a.first < b.first;
    return a.second > b.second;
}

int main() {
    scanf("%d", &T);
    while(T--) {
        ct = 0;
        scanf("%d", &n); int cnt = 0;
        for(int i = 1; i <= n; i++) {
            scanf("%d", &F[i]);
            res[cnt++] = pa(F[i], i);
            C[i] = INF;
        }
        for(int i = 1; i <= n; i++) scanf("%d %d", &l[i], &r[i]);
        sort(res, res + cnt, cmp);
        a[res[0].second] = l[res[0].second];
        update(res[0].second, l[res[0].second]);
        int id = cnt;
        for(int i = 1; i < cnt; i++) {
            if(res[i].first == 1) {
                int kk = res[i].second;
                a[kk] = max(l[kk], a[res[i - 1].second]);
                update(kk, a[kk]);
            } else {
                id = i; break;
            }
        }
        for(int from; id < cnt; id++) {
            from = id;
            while(from < cnt && res[id].first == res[from].first) {
                int tt = get_min(res[from].second - 1) + 1;
                int kk = res[from].second;
                int kn = res[from - 1].second;
                if(kk == res[id].second) a[kk] = max(tt, l[kk]);
                else a[kk] = max(a[kn], max(tt, l[kk]));
                from++;
            }
            for(int i = 0; i < ct; i++) C[rec[i]] = INF; ct = 0;
            while(id < from) { update(res[id].second, a[res[id].second]); id++; }
            id--;
        }
        for(int i = 1; i <= n; i++) printf("%d%c", a[i], i < n ? ' ' : '\n');
    }
    return 0;
}

F - Now Loading!!!

题意：
$\ \ \ \ $$n$个数$m$个查询，第$i$个查询给出一个数$p$, $z_i$=$\sum \limits_{j = 1} ^ n \lfloor \frac{a_j}{\lceil \log_pa_j \rceil} \rfloor$，求$(\sum \limits_{i=1}^m i \cdot z_i) \ mod \ 10^9$。

思路：
$\ \ \ \ $对于一个数$p$，我们知道$\lceil \log_px \rceil = k$的话， 这个$k$在题目给出的范围内是不会超过$32$的，可以枚举$k$，然后$x$就有一个范围，先对$a$数组排个序，可以知道$\lceil \log_pa_j \rceil = k$中$j$的范围$[l, r]$，这样对于$j \in [l, r]$就转化成$\lfloor \frac{a_j}{k} \rfloor$，对所有$k$来个预处理前缀和即可。

#include<bits/stdc++.h>
typedef long long ll;
const int maxn = 1e5 + 10;
const int INF = 1e9 + 10;
const ll mod = 1e9;
using namespace std;

int n, m, T, kase = 1;
ll a[maxn], p;
ll sum[35][maxn];

int main() {
    scanf("%d", &T);
    while(T--) {
        scanf("%d %d", &n, &m);
        for(int i = 1; i <= n; i++) scanf("%lld", &a[i]);
        sort(a + 1, a + n + 1);
        for(int i = 1; i < 33; i++) {
            sum[i][0] = 0;
            for(int j = 1; j <= n; j++) {
                sum[i][j] = sum[i][j - 1] + a[j] / i;
                if(sum[i][j] >= mod) sum[i][j] -= mod;
            }
        }
        ll ans = 0, ttt = 1;
        while(m--) {
            scanf("%lld", &p);
            ll x = 1, pw = 1, tt = 0;
            for( ; pw < INF; x++) {
                ll l = pw + 1, r = pw * p;
                pw = pw * p;
                int t1 = upper_bound(a + 1, a + n + 1, r) - a - 1;
                int t2 = upper_bound(a + 1, a + n + 1, l - 1) - a - 1;
                tt += sum[x][t1] - sum[x][t2];
                if(tt < 0) tt += mod;
                if(tt >= mod) tt -= mod;
            }
            ans += ttt * tt;
            ans %= mod;
            ttt++;
        }
        ans %= mod;
        if(ans < 0) ans += mod;
        printf("%lld\n", ans);
    }
    return 0;
}

H - Game on a Tree

题意：
$\ \ \ \ $一棵$n$个节点以$1$为根带边权的有根树，开始时一棋子在根节点，有四种操作：
$\ 1\ \ $棋子移动到当前所在节点(除了叶节点)的某个孩子节点，花费为其边权
$\ 2\ \ $棋子放回根节点，花费为$0$
$\ 3\ \ $设置棋子当前位置为保存点，保存点只能有一个，花费为$0$
$\ 4\ \ $棋子放回保存点，花费为$0$
$\ \ \ \ $现在棋子要遍历所有叶节点，求最小花费。

思路：
$\ \ \ \ $有个明显的性质就是：如果当前保存点在$v$，访问完一个叶节点后，棋子要么还在$v$的子树中，要么返回$1$。就是说，假如$x_1, x_2$是$x$的两棵子树的根节点，那么如果棋子在$x_1$这棵子树设置过保存点，后来要访问$x_2$的叶节点的话，棋子只能范围$1$，再经过$x$到达$x_2$去访问。那么其实也就是说明：根节点经过$x$这个节点$i$次的话，$x$这棵子树会有$i$个互不影响的保存点， 那么设$dp[x][i]：$
$\ \ \ \ $对于$x$这棵子树有$i$次设置保存点机会时必须遍历完$x$这棵子树的最小花费（花费只在$x$这棵子树内）。
$\ \ \ \ $可以知道这里$1 \leqslant i \leqslant size_x$， $size_x$是$x$这棵子树内叶节点的个数， 既然$x$有$i$次保留机会，那么$x$的每个孩子节点$v$的保留机会次数$j$的和也应该是$i$，但是对于孩子节点状态转移的时候保留次数$j$可以为0，这个时候相当于要每次访问完$v$的一个叶节点要返回$x$节点，那么状态转移就是：

$$dp[x][i] = \min \{ \sum \limits_{v \in son_x} (dp[v][j_v] + w_{xv}) \},(\sum\limits_{v \in son_x} j_v = i)$$
$\ \ \ \ $最终取根节点的所有保留次数的最小值就行了。

#include<bits/stdc++.h>
typedef long long ll;
const ll INF = 1e18;
const int maxn = 200 + 10;
using namespace std;

typedef pair<int, int> pa;
int T, n, m, kase = 1, vis[maxn], cnt;
ll dp[maxn][maxn], w[maxn][maxn];
vector<pa> G[maxn], nG[maxn];
int anc[maxn][maxn], pre[maxn], vt[maxn];
ll tot_w[maxn], sz[maxn];
ll dpw[maxn][maxn * 2];

void dfs(int x, int fa, int w) {
    pre[x] = fa; tot_w[x] = 0;
    nG[fa].push_back(pa(x, w));
    if(x != 1 && G[x].size() == 1) sz[x] = 1;
    else sz[x] = 0;
    for(int i = 0; i < G[x].size(); i++) {
        int to = G[x][i].first;
        if(to != fa) {
            dfs(to, x, G[x][i].second);
            sz[x] += sz[to];
            tot_w[x] += tot_w[to] + sz[to] * G[x][i].second;
        }
    }
}

void solve_dp(int x) {
    if(!nG[x].size()) { dp[x][1] = 0; return ; }
    for(int i = 0; i < nG[x].size(); i++) solve_dp(nG[x][i].first);
    int max_sz = sz[x], s = nG[x][0].first; ///最多需要max_sz次保留机会

    for(int i = 0; i <= max_sz; i++) {
        if(!i) dpw[0][i] = tot_w[s] + (ll)nG[x][0].second * sz[s];
        else dpw[0][i] = dp[s][i] + (ll)nG[x][0].second * i;
    }
    for(int i = 1; i < nG[x].size(); i++) {
        int to = nG[x][i].first;
        int w = nG[x][i].second;
        int son_to = sz[to];
        for(int j = max_sz; j >= 0; j--) dpw[i][j] = INF;
        for(int j = max_sz; j >= 0; j--) {
            for(int k = 0; k <= son_to; k++) {
                ll now_w = INF;
                int las = j - k;
                if(las < 0) break;
                if(!k) now_w = tot_w[to] + (ll)sz[to] * w; ///没有给保留机会
                else now_w = dp[to][k] + (ll)k * w; ///给了k次保留机会
                dpw[i][j] = min(dpw[i][j], dpw[i - 1][las] + now_w);
            }
        }
    }
    for(int i = 1; i <= max_sz; i++) dp[x][i] = dpw[nG[x].size() - 1][i];
}

int main() {
    scanf("%d", &T);
    while(T--) {
        scanf("%d", &n);
        for(int i = 0; i <= n; i++) {
            G[i].clear();
            nG[i].clear();
        }
        for(int i = 1; i < n; i++) {
            int u, v, c;
            scanf("%d %d %d", &u, &v, &c);
            G[u].push_back(pa(v, c));
            G[v].push_back(pa(u, c));
        }
        for(int i = 0; i <= n; i++) {
            for(int j = 0; j <= n; j++) {
                dp[i][j] = INF;
            }
        }
        dfs(1, 0, 0); solve_dp(1);
        ll ans = INF;
        for(int i = 1; i <= n; i++) ans = min(ans, dp[1][i]);
        printf("%lld\n", ans);
    }
    return 0;
}