BZOJ1828 [Usaco2010 Mar]balloc 农场分配

直接贪心，我们把线段按照右端点从小到大排序，然后一个个尝试插入即可。。。

来证明贪心的正确性：

不妨设贪心得到的答案集合为$S$，最优解的答案集合为$T$

若$S$不是最优解，那么$S \not= T$，不妨设按照右端点排序后，第一个不同的位置为$i$

则$S_i \not= T_i$，分情况讨论：

(1)$S_i$的左端点在$T_i$的右端点后，由于贪心的步骤这是不可能的

(2)$S_i$的右端点在$T_i$的右端点之前：

(2.1)$S_i$的右端点在$T_i$的左端点之前，即$S_i$、$T_i$不相交，我们发现存在$S' = \{S_1, S_2, ..., S_i\} \cup \{T_i, T_{i + 1}, ..., T_n\}$，且$|S'| = |T| + 1$，矛盾

(2.2)$S_i$的右端点在$T_i$的左端点之后，即$S_i$、$T_i$相交，我们直接令$S' = T - \{T_i\} + \{S_i\}$，于是有$|S'| = |T|$，即$S'$也是最优解

故可以证明贪心的正确性

于是每次模拟的时候利用线段树即可，时间复杂度$O(mlogm + mlogn)$

 /**************************************************************
     Problem: 1828
     User: rausen
     Language: C++
     Result: Accepted
     Time:772 ms
     Memory:5708 kb
 ****************************************************************/

 #include <cstdio>
 #include <algorithm>

 using namespace std;
 const int N = 1e5 + ;
 const int M = 1e5 + ;
 const int inf = 1e9;

 int read();

 struct data {
     int l, r;

     inline void get() {
         l = read(), r = read();
     }
     inline bool operator < (const data &d) const {
         return r < d.r;
     }
 } a[M];

 struct seg {
     seg *ls, *rs;
     int mn, tag;

     #define Len (1 << 16)
     inline void* operator new(size_t) {
         static seg *mempool, *c;
         if (mempool == c)
             mempool = (c = new seg[Len]) + Len;
         c -> ls = c -> rs = NULL, c -> mn = c -> tag = ;
         return c++;
     }
     #undef Len

     inline void update() {
         mn = min(ls -> mn, rs -> mn);
     }
     inline void push() {
         ls -> tag += tag, rs -> tag += tag;
         ls -> mn -= tag, rs -> mn -= tag;
         tag = ;
     }

     #define mid (l + r >> 1)
     void build(int l, int r) {
         if (l == r) {
             mn = read();
             return;
         }
         (ls = new()seg) -> build(l, mid), (rs = new()seg) -> build(mid + , r);
         update();
     }

     void modify(int l, int r, int L, int R) {
         if (L <= l && r <= R) {
             ++tag, --mn;
             return;
         }
         push();
         if (L <= mid) ls -> modify(l, mid, L, R);
         if (mid < R) rs -> modify(mid + , r, L, R);
         update();
     }

     int query(int l, int r, int L, int R) {
         if (L <= l && r <= R) return mn;
         push();
         int res = inf;
         if (L <= mid) res = min(res, ls -> query(l, mid, L, R));
         if (mid < R) res = min(res, rs -> query(mid + , r, L, R));
         update();
         return res;
     }
     #undef mid
 } *T;

 int n, m, ans;

 int main() {
     int i;
     n = read(), m = read();
     (T = new()seg) -> build(, n);
     for (i = ; i <= m; ++i) a[i].get();
     sort(a + , a + m + );
     for (i = ; i <= m; ++i)
         if (T -> query(, n, a[i].l, a[i].r))
             T -> modify(, n, a[i].l, a[i].r), ++ans;
     printf("%d\n", ans);
     return ;
 }

 inline int read() {
     static int x;
     static char ch;
     x = , ch = getchar();
     while (ch < '' || '' < ch)
         ch = getchar();
     while ('' <= ch && ch <= '') {
         x = x *  + ch - '';
         ch = getchar();
     }
     return x;
 }