UVa 1471 Defense Lines - 线段树 - 离散化

---

　　题意是说给一个序列，删掉其中一段连续的子序列(貌似可以为空)，使得新的序列中最长的连续递增子序列最长。

　　网上似乎最多的做法是二分查找优化，然而不会，只会值域线段树和离散化。。。

　　先预处理出所有的点所能延伸到最左端的长度，和到最右端的长度，然后离散化，然后对于当前的点，就交给值域线段树去查出前面最大的符合条件的向左延伸的长度，加上当前位置最大向右延伸的长度，更新答案即可。

Code

 /**
  * UVa
  * Problem#1471
  * Accepted
  * Time:1190ms
  */
 #include<iostream>
 #include<cstdio>
 #include<cctype>
 #include<ctime>
 #include<cstring>
 #include<cstdlib>
 #include<fstream>
 #include<sstream>
 #include<algorithm>
 #include<map>
 #include<set>
 #include<stack>
 #include<queue>
 #include<vector>
 #include<stack>
 using namespace std;
 typedef bool boolean;
 #define inf 0xfffffff
 #define smin(a, b) a = min(a, b)
 #define smax(a, b) a = max(a, b)
 template<typename T>
 inline void readInteger(T& u){
     char x;
     int aFlag = ;
     while(!isdigit((x = getchar())) && x != '-');
     if(x == '-'){
         x = getchar();
         aFlag = -;
     }
     for(u = x - ''; isdigit((x = getchar())); u = (u << ) + (u << ) + x - '');
     ungetc(x, stdin);
     u *= aFlag;
 }

 typedef class SegTreeNode {
     public:
         int val;
         SegTreeNode *l, *r;
         SegTreeNode(int val = , SegTreeNode* l = NULL, SegTreeNode* r = NULL):val(val), l(l), r(r) {        }

         inline void pushUp() {
             val = max(l->val, r->val);
         }
 }SegTreeNode;

 typedef class SegTree {
     public:
         SegTreeNode* root;
         SegTree():root(NULL) {        }
         SegTree(int s) {
             build(root, , s);
         }

         void build(SegTreeNode*& node, int l, int r) {
             node = new SegTreeNode();
             if(l == r)    return;
             int mid = (l + r) >> ;
             build(node->l, l, mid);
             build(node->r, mid + , r);
         }

         void update(SegTreeNode*& node, int l, int r, int idx, int val) {
             if(l == idx && r == idx) {
                 smax(node->val, val);
                 return;
             }
             int mid = (l + r) >> ;
             if(idx <= mid)    update(node->l, l, mid, idx, val);
             else    update(node->r, mid + , r, idx, val);
             node->pushUp();
         }

         int query(SegTreeNode*& node, int l, int r, int ql, int qr) {
             if(qr < ql)    return -inf;
             if(l == ql && r == qr) {
                 return node->val;
             }
             int mid = (l + r) >> ;
             if(qr <= mid)    return query(node->l, l, mid, ql, qr);
             if(ql > mid)    return query(node->r, mid - , r, ql, qr);
             int sl = query(node->l, l, mid, ql, mid);
             int sr = query(node->r, mid + , r, mid + , qr);
             return max(sl, sr);
         }

         inline void clear(SegTreeNode*& node) {
             if(node == NULL)    return;
             clear(node->l);
             clear(node->r);
             delete[] node;
         }
 }SegTree;

 int T;
 int n;
 int len;
 int* lis;
 int* buf;
 SegTree st;

 inline void init() {
     readInteger(n);
     lis = new int[(const int)(n + )];
     buf = new int[(const int)(n + )];
     for(int i = ; i <= n; i++)
         readInteger(lis[i]);
 }

 inline void descreate(int* a) {
     memcpy(buf, a, sizeof(int) * (n + ));
     sort(buf + , buf + n + );
     len = unique(buf + , buf + n + ) - buf;
     for(int i = ; i <= n; i++)
         a[i] = lower_bound(buf + , buf + len, a[i]) - buf;
 }

 int *tol, *tor;
 inline void dp() {
     tol = new int[(const int)(n + )];
     tor = new int[(const int)(n + )];
     tol[] = ;
     for(int i = ; i <= n; i++)
         tol[i] = (lis[i] > lis[i - ]) ? (tol[i - ] + ) : ();
     tor[n] = ;
     for(int i = n - ; i > ; i--)
         tor[i] = (lis[i] < lis[i + ]) ? (tor[i + ] + ) : ();
 }

 int result;
 inline void solve() {
     result = ;
     descreate(lis);
     st = SegTree(len);
     dp();
 //    st.update(st.root, 1, len, lis[1], tol[1]);
     for(int i = ; i <= n; i++) {
         int c = st.query(st.root, , len, , lis[i] - );
         smax(result, c + tor[i]);
         st.update(st.root, , len, lis[i], tol[i]);
     }
     printf("%d\n", result);
     delete[] tol;
     delete[] tor;
     delete[] buf;
     delete[] lis;
     st.clear(st.root);
 }

 int main() {
     readInteger(T);
     while(T--) {
         init();
         solve();
     }
     return ;
 }