hdu 6406 Taotao Picks Apples （线段树）

Problem Description

There is an apple tree in front of Taotao's house. When autumn comes, n apples on the tree ripen, and Taotao will go to pick these apples.

When Taotao picks apples, Taotao scans these apples from the first one to the last one. If the current apple is the first apple, or it is strictly higher than the previously picked one, then Taotao will pick this apple; otherwise, he will not pick.

Given the heights of these apples h1,h2,⋯,hn, you are required to answer some independent queries. Each query is two integers p,q, which asks the number of apples Taotao would pick, if the height of the p-th apple were q (instead of hp). Can you answer all these queries?

 

Input

The first line of input is a single line of integer T (1≤T≤10), the number of test cases.

Each test case begins with a line of two integers n,m (1≤n,m≤105), denoting the number of apples and the number of queries. It is then followed by a single line of n integers h1,h2,⋯,hn (1≤hi≤109), denoting the heights of the apples. The next m lines give the queries. Each of these m lines contains two integers p (1≤p≤n) and q (1≤q≤109), as described in the problem statement.

 

Output

For each query, display the answer in a single line.

 

Sample Input

1
5 3

1 2 3 4 4

1 5

5 5

2 3

 

Sample Output

1
5
3

Hint

For the first query, the heights of the apples were 5, 2, 3, 4, 4, so Taotao would only pick the first apple.

For the second query, the heights of the apples were 1, 2, 3, 4, 5, so Taotao would pick all these five apples.

For the third query, the heights of the apples were 1, 3, 3, 4, 4, so Taotao would pick the first, the second and the fourth apples.

 

 

Solution

拿到题最开始想用前缀和维护答案，但是没有理清思路，后来就乱了。看到一篇大神的线段树直接维护答案的题解，简单理了一下思路

对于线段树，维护区间最大值以及区间从左往右上升长度（即答案），我们注意到一个区间的答案=左区间答案数+右区间在左区间最大值基础上的贡献

对于一个查询query(rt,v)表示将区间t之前的一个数改为v后的区间rt的对答案的贡献，

若rt->maxx<v直接返回0，总的区间最大值小于v，这个区间不可能贡献答案

否则若rt->lson->maxx>v 此时只需关注左区间，因为右区间此时的贡献值和v不相关，注意这时的返回答案应该是tr[rt].cnt-tr[lson].cnt+query(lson,v)，而不是tr[rson].cnt+query(lson,v)

这两者是不等价的，因为一个cnt表示的是当前区间从左到右的上升长度，而tr[rson].cnt仅仅关注的是右区间，没有和整体直接挂钩

再如果tr->lson->maxx<=v,此时左区间对答案无贡献，但右区间存在，查询右区间

大概就是这样，线段树维护答案很灵活感觉，唉本人垃圾是想不到了

贴一段大概理解之后写的ac代码吧

---

 #include <bits/stdc++.h>
 #define lson rt << 1
 #define rson rt << 1 | 1
 using namespace std;
 using ll = long long;
 using ull = unsigned long long;
 using pa = pair<int, int>;
 using ld = long double;
 int n, m, k;
 const int maxn = 1e5 + ;
 const int mod = ;
 int pre[maxn];
 template <class T>
 inline T read(T &ret)
 {
     int f = ;
     ret = ;
     char ch = getchar();
     while (!isdigit(ch))
     {
         if (ch == '-')
             f = -;
         ch = getchar();
     }
     while (isdigit(ch))
     {
         ret = (ret << ) + (ret << ) + ch - '';
         ch = getchar();
     }
     ret *= f;
     return ret;
 }
 template <class T>
 inline void write(T n)
 {
     if (n < )
     {
         putchar('-');
         n = -n;
     }
     if (n >= )
     {
         write(n / );
     }
     putchar(n %  + '');
 }
 int a[maxn];
 struct node
 {
     int l, r, cnt, maxx;
 } tr[maxn << ];
 int query(int rt, int v)
 {
     int l = tr[rt].l;
     int r = tr[rt].r;
     if (l == r)
         return tr[rt].maxx > v;
     if (tr[rt].maxx < v)
         return ;
     int mid = l + r >> ;
     if (tr[lson].maxx > v) //疑惑，为什么写出tr[rson].cnt+query(lson,v)答案不对
                            //啊左右区间和大区间并不相等，大区间=左区间+右区间贡献
         return tr[rt].cnt - tr[lson].cnt + query(lson, v);
     else
         return query(rson, v);
 }
 void pushup(int rt)
 {
     tr[rt].maxx = max(tr[lson].maxx, tr[rson].maxx);
     tr[rt].cnt = tr[lson].cnt + query(rson, tr[lson].maxx);
 }
 void build(int rt, int l, int r)
 {
     tr[rt].l = l;
     tr[rt].r = r;
     if (l == r)
     {
         tr[rt].cnt = ;
         tr[rt].maxx = a[l];
         return;
     }
     int mid = l + r >> ;
     build(lson, l, mid);
     build(rson, mid + , r);
     pushup(rt);
 }
 void update(int rt, int L, int v)
 {
     int l = tr[rt].l;
     int r = tr[rt].r;
     if (l == r && l == L)
     {
         tr[rt].maxx = v;
         return;
     }
     int mid = l + r >> ;
     if (L <= mid)
         update(lson, L, v);
     else
         update(rson, L, v);
     pushup(rt);
 }
 int main(int argc, char const *argv[])
 {
     ios::sync_with_stdio(false);
     cin.tie();
     cout.tie();
     int t;
     cin >> t;
     while (t--)
     {
         cin >> n >> m;
         for (int i = ; i <= n; i++)
             cin >> a[i];
         build(, , n);
         while (m--)
         {
             int p, q;
             cin >> p >> q;
             update(, p, q);
             cout << tr[].cnt << "\n";
             update(, p, a[p]);
         }
     }
     return ;
 }