NOJ/HUST 1095 校赛 Just Go 线段树模板题

Description

There is a river, which contains n stones from left to right. These stones are magic, each

one has a magic number Ai which means if you stand on the ith stone, you can jump to (i +1)th stone, (i+2)th stone, ..., (i+Ai)th stone(when i+Ai > n, you can only reach as far as n), you want to calculate the number of ways to reach the nth stone.

Notice: you can not jump from right to left! 

 

Input

Input starts with an integer T(1 <= T <= 10), denoting the number of test cases. Each test case contains an integer n(1 <= n <= 105), denoting the number stones. Next line contains n integers Ai(1 <= Ai <= 108). 

Output

For each test case, print the number of way to reach the nth stone module 109+7. 

Sample Input

3
5
1 2 3 4 5
1
10
2
2 1

Sample Output

3
1
1

题意：给你n个数，对于ai表示可以跳到i+1,i+2,i+3 …i + ai的位置，问到达最后一个位置有几种方法。
思路：第一次接触线段树。由于转移的关系，刚开始想使用DP，但是需要转移的数是一个区间，后来想到因为修改的是一个区间的值，想到用树状数组，但是区间修改的操作好像很烦阿
　　　最终被告知是线段树。

 #include <stdio.h>
 #include <iostream>
 #include <algorithm>
 #include <string.h>
 #define nods(x) tree[x]
 #define lefs(x) tree[x << 1]
 #define rigs(x) tree[x << 1 | 1]
 using namespace std;

 const int INF = 0x3f3f3f3f;
 const int MAX = ;
 const int MOD = 1e9 + ;

 struct segtree
 {
     int l, r, ans; //区间范围
     int add;       //懒惰标记
 }tree[MAX << ];

 //单点修改
 void change(int &bep, int val)
 {
     bep += val;
     bep = (bep % MOD + MOD) % MOD;
 }
  //父节点更新
 void pushup(int pos)
 {
     change(nods(pos).ans, lefs(pos).ans + rigs(pos).ans);
 }
  //构造线段树
 void build(int p, int l, int r)
 {
     nods(p).l = l;
     nods(p).r = r;
     nods(p).ans = nods(p).add = ;
     if(l == r && l == )
         nods(p).ans = ;
     if(l == r)
         return ;

     int mid = (l + r) >> ;
     build( p << , l, mid  );
     build( p <<  | , mid + , r);
     pushup(p);
 }
  //向下更新叶 通过延迟标记更新
 void pushdown(int p)
 {
     if(nods(p).add)
     {
         change(lefs(p).add, nods(p).add);
         change(rigs(p).add, nods(p).add);
         change(lefs(p).ans, nods(p).add);
         change(rigs(p).ans, nods(p).add);
         nods(p).add = ;
     }
 }
 //询问
 int query(int p, int bor)
 {
     if(nods(p).l == nods(p).r)//递归到最小叶，直接返回
         return nods(p).ans;
     pushdown(p);              //先应用标记 再查询

     int mid = (nods(p).l + nods(p).r) >> ;
     if(bor <= mid)
         return query(p << , bor);        //查询下一层左儿子
     else return query(p <<  | , bor);   //查询下一层右儿子
 }
  //区间修改
 void update(int p, int l, int r, int val)
 {
     if(nods(p).l >= l && nods(p).r <= r) //完全包含
     {
         change(nods(p).add, val);        //延迟标记
         change(nods(p).ans, val);        //更新该点
         return ;
     }
     pushdown(p);                         //向下更新
     int mid = (nods(p).l + nods(p).r) >> ;
     if(r <= mid)                         //[l,r] 被包含于 [pl,mid]
         update(p << , l, r , val);
     else if(l > mid)                     //[l,r] 被包含于 [mid,pr]
         update(p <<  | , l, r, val);
     else                                 //中间截断
     {
         update(p << , l, mid, val);
         update(p <<  | , + mid, r, val);
     }
     pushup(p);
 }

 int main()
 {
     int T, t;
     int ans, ss, ee, n;
     cin >> T;
     while(T--)
     {
         scanf("%d", &n);
         build(, , n);
         for(int i = ; i <= n; i++)
         {
             scanf("%d", &t);
             ss = i + ;
             ee = min(i+t, n);
             ans = query(, i);
             if(i!=n)
                 update(, ss, ee, ans);
         }
         printf("%d\n", query(, n));
     }
 }