bzoj 5185 Lifeguards - 动态规划 - 贪心

题目传送门

　　传送点I

　　传送点II

题目大意

　　给定$n$个区间，问恰好删去其中$k$个，剩下的区间的并的最大总长度。

　　显然被包含的区间一定不优。再加上被包含的区间对计数不友好。直接把它删掉。

　　注意到题目说恰好，其实是骗人的。多删几个也不会影响（删太多了就有影响了）。

　　按照右端点排序，然后用$f[i][j]$表示考虑前$i$个区间，已经选了删掉$j$个。

　　考虑转移，第一种情况是第$i$个区间不选，直接通过$i - 1$转移。

　　第二种情况是要选$i$。然后要计算贡献。这时考虑上一个选择的是什么？

• 如果和第$i$个区间有相交，那么显然选择左端点最小的一个和当前区间相交的线段作为上一个。然后中间的线段全部删掉（因为它们被包含了。）。答案补上这个区间覆盖不到的但当前区间能够覆盖的地方。（如果上一个不是选的这个区间也无妨，因为这样一定没有下面这样的转移优）
• 否则从左端点最小的一个区间的前一个区间转移。答案加上当前区间长度。

Code

 /**
  * bzoj
  * Problem#5185
  * Accepted
  * Time: 1140ms
  * Memory: 43876k
  */
 #include <bits/stdc++.h>
 using namespace std;
 typedef bool boolean;

 typedef class Segment {
     public:
         int l, r;

         boolean operator < (Segment b) const {
             if (r ^ b.r)    return r < b.r;
             return l < b.l;
         }
 }Segment;

 const int N = 1e5 + , K = ;

 int n, m, k;
 Segment* bs;
 Segment* ss;
 int f[N][K];

 inline void init() {
     scanf("%d%d", &n, &k);
     bs = new Segment[(n + )];
     ss = new Segment[(n + )];
     for (int i = ; i <= n; i++)
         scanf("%d%d", &bs[i].l, &bs[i].r);
 }

 inline void solve() {
     sort(bs + , bs + n + );
     for (int i = ; i <= n; i++) {
         if (i ==  || bs[i].r != bs[i - ].r)
             ss[++m] = bs[i];
         else
             k--;
     }

     int mil = (signed) (~0u >> );
     n = ;
     for (int i = m; i; i--) {
         if (ss[i].l < mil)
             bs[++n] = ss[i], mil = ss[i].l;
         else
             k--;
     }
     sort(bs + , bs + n + );
     k = max(k, );
     memset(f, 0x80, sizeof(f[]) * (m + ));
     int p = ;
     f[][] = ;
     for (int i = ; i <= n; i++) {
         while (p <= i && bs[p].r < bs[i].l)
             p++;
         assert(p <= i);
         for (int j = ; j <= k; j++)
             f[i][j] = max(f[i][j], f[i - ][j - ]);
         f[i][k] = max(f[i][k], f[i - ][k]);

         for (int j = ; j <= k; j++) {
             int cj = min(j + i - p - , k);
             if (p ^ i)
                 f[i][cj] = max(f[i][cj], f[p][j] + bs[i].r - bs[p].r);
             cj = min(cj + , k);
             f[i][cj] = max(f[i][cj], f[p - ][j] + bs[i].r - bs[i].l);
         }
     }
     printf("%d\n", f[n][k]);
 }

 int main() {
     init();
     solve();
     return ;
 }