hdu5681 zxa and wifi

这道题目是不太好想的，尽管很容易看出来应该是dp，但是状态转移总觉得无从下手。

其实我们可以将状态分层，比如设$dp(i, j)$为用$i$个路由器覆盖前$j$个点所需的最小代价

我们先不考虑状态，而是考虑在每个位置上的决策对状态的影响，考虑在位置j的决策

1.如果在此处放置网线，有$dp(i, j) = min(dp(i, j), dp(i, j - 1) + b(i))$

2.如果在此处放置路由器，有$dp(i, r(j)) = min(dp(i, r(j)), dp(i - 1, l(j) - 1) + a(i))$

当然此处可以什么都不放，但是这种决策对状态没有影响，因此我们不考虑它。

$[l(i), r(i)]$表示$i$位置路由器的覆盖区间

注意到固定$i$，$dp(i, j)$应该是非降的，因此条件2的更新应该适用于所有$dp(i, k): k \leq r(j)$

用两重循环依次计算状态，用stl中的vector储存i位置满足$r(k) = i$的所有$k$，先用式2从后往前更新，再用式1从前往后更新即可

复杂度$O(n * max(k, log(n))$

代码如下：

 #include <algorithm>
 #include <cstdio>
 #include <cstring>
 #include <string>
 #include <queue>
 #include <map>
 #include <set>
 #include <ctime>
 #include <iostream>
 using namespace std;
 typedef long long ll;
 const int int_inf = 0x3f3f3f3f;
 const ll ll_inf = (ll) << ;
 const int mod = 1e9 + ;
 const double double_inf = 1e30;
 typedef unsigned long long ul;
 #define max(a, b) ((a) > (b) ? (a) : (b))
 #define min(a, b) ((a) < (b) ? (a) : (b))
 #define mp make_pair
 #define st first
 #define nd second
 #define lson (u << 1)
 #define rson (u << 1 | 1)
 #define pii pair<int, int>
 #define pb push_back
 #define type(x) __typeof(x.begin())
 #define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
 #define FOR(i, s, t) for(int i = s; i <= t; i++)
 #define ROF(i, t, s) for(int i = t; i >= s; i--)
 #define dbg(x) cout << x << endl
 #define dbg2(x, y) cout << x << " " << y << endl
 #define clr(x, i) memset(x, (i), sizeof(x))
 #define maximize(x, y) x = max((x), (y))
 #define minimize(x, y) x = min((x), (y))
 inline int readint(){
     bool neg = ; char ch, t[];
     int k = ;
     while((ch = getchar()) == ' ' || ch == '\n') ;
     neg = ch == '-';
     ch == '-' ? neg =  : t[k++] = ch;
     while((ch = getchar()) >= '' && ch <= '') t[k++] = ch;
     int x = , y = ;
     while(k) x += (t[--k] - '') * y, y *= ;
     return neg ? -x : x;
 }

 inline int readstr(char *s){
     char ch;
     int len = ;
     while((ch = getchar()) == ' ' || ch == '\n') ;
     *(s++) = ch, ++len;
     while((ch = getchar()) != ' ' && ch != '\n') *(s++) = ch, ++len;
     *s = '\0';
     return len;
 }
 inline void writestr(const char *s){
     while(*s != '\0') putchar(*(s++));
     putchar('\n');
 }

 inline int add(int x, int y){
     if(x < ) x += mod;
     if(y < ) y += mod;
     return (x + y) % mod;
 }

 inline int mult(int x, int y){
     if(x < ) x += mod;
     if(y < ) y += mod;
     ll tem = (ll)x * y;
     return tem % mod;
 }

 int debug = ;
 //-------------------------------------------------------------------------
 const int maxn = 2e4 + ;
 int a[maxn], x[maxn], b[maxn], d[maxn];
 ll dp[][maxn];
 vector<int> c[maxn];
 int l[maxn], r[maxn];
 int n, k;
 //-------------------------------------------------------------------------

 ll solve(){
     d[] = d[] = ;
     FOR(i, , n) d[i] += d[i - ];
     FOR(i, , maxn - ) c[i].clear();
     FOR(i, , n){
         int len = x[i];
         int L = , R = i;
         while(R - L > ){
             int mid = (R + L) >> ;
             if(d[i] - d[mid] <= len) R = mid;
             else L = mid;
         }
         l[i] = R;
         L = i, R = n + ;
         while(R - L > ){
             int mid = (R + L) >> ;
             if(d[mid] - d[i] <= len) L = mid;
             else R = mid;
         }
         r[i] = L;
         c[L].pb(i);
     }
     dp[][] = ;
     FOR(i, , n) dp[][i] = dp[][i - ] + b[i];
     FOR(i, , k){
         dp[i][n + ] = ll_inf;
         ROF(j, n, ){
             int sz = c[j].size();
             dp[i][j] = dp[i][j + ];
             FOR(u, , sz - ) minimize(dp[i][j], dp[i - ][l[c[j][u]] - ] + a[c[j][u]]);
         }
         dp[i][] = ;
         FOR(j, , n) minimize(dp[i][j], dp[i][j - ] + b[j]);
     }
     ll ans = dp[][n];
     FOR(i, , k) minimize(ans, dp[i][n]);
     return ans;
 }

 int main(){
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
     if(debug) freopen("in.txt", "r", stdin);
     int T = readint();
     while(T--){
         n = readint();
         k = readint();
         FOR(i, , n - ) d[i + ] = readint();
         FOR(i, , n) a[i] = readint(), x[i] = readint(), b[i] = readint();
         ll ans = solve();
         printf("%lld\n", ans);
     }
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////
     return ;
 }