（线段树）Just a Hook -- hdu -- 1689

链接：

http://acm.hdu.edu.cn/showproblem.php?pid=1698

思路：

我的想法很简单，像上一题一样从后面向前面来算，前面已经覆盖的，后面自然不能再来计算了，具体是每次都计算覆盖的总长度，然后用这次的总长度减上次的总长度，自然就得到了这次覆盖的长度，可能我的方法不是很好吧！不过这是自己想出来的，再去借鉴一下别人的代码，多种想法是好的，毕竟是自己做的，因为数据不是很大所以不用离散化就可以

代码：

 #include<stdio.h>
 #include<algorithm>
 #include<stdlib.h>
 #include<string.h>
 using namespace std;

 #define Lson r<<1
 #define Rson r<<1|1

 const int N = ;

 struct Node
 {
     int L, R, e;
 } s[N<<];

 struct node
 {
     int L, R;
     int len; //len里面要记录被覆盖的长度
     int Mid()
     {
         return (L+R)>>;
     }
 } a[N<<];

 void UpDate(int r)
 {
     if(a[r].L != a[r].R)
         a[r].len = a[Lson].len + a[Rson].len;
 }

 void BuildTree(int r, int L, int R)
 {
     a[r].L = L, a[r].R = R;
     a[r].len = ;

     if(L==R) return ;

     BuildTree(Lson, L, a[r].Mid());
     BuildTree(Rson, a[r].Mid()+, R);
 }

 int Insert(int r, int L, int R)
 {
     if(a[r].L<=L && a[r].R>=R && a[r].len == a[r].R-a[r].L+)
         return a[r].len;
     if(a[r].L==L && a[r].R==R)
     {
         a[r].len = R-L+;
         return a[r].len;
     }

     if(R<=a[r].Mid())
         Insert(Lson, L, R);
     else if(L>a[r].Mid())
         Insert(Rson, L, R);
     else
     {
         Insert(Lson, L, a[r].Mid());
         Insert(Rson, a[r].Mid()+, R);
     }

     UpDate(r);

     return a[r].len;
 }

 int main()
 {
     int t, k=;
     scanf("%d", &t);
     while(t--)
     {
         int n, m;
         scanf("%d%d", &n, &m);

         BuildTree(, , n);

         for(int i=; i<=m+; i++)
             scanf("%d%d%d", &s[i].L, &s[i].R, &s[i].e);

         s[].L = , s[].R = n, s[].e = ;

         int sum = , z=, w=;
         for(int i=m+; i>; i--)
         {
             w = z;
             z = Insert(, s[i].L, s[i].R);

             sum += (z-w)*s[i].e;

             if(z==n)
                 break;
         }

         printf("Case %d: The total value of the hook is %d.\n", k++, sum);

     }
     return ;
 }

代码：

 #include<stdio.h>
 #include<math.h>
 #include<string.h>
 #include<algorithm>
 using namespace std;
 #define Lson root<<1,L,tree[root].Mid()
 #define Rson root<<1|1,tree[root].Mid()+1,R

 const int maxn = ;

 struct Hook{int l, r, z;}hook[maxn];
 struct Tree{
     int L, R;
     int isCover;//等于1的时候被覆盖，等于2的时候区间下面有被覆盖的
     int Mid(){return (L+R)/;}
     int Len(){return (R-L+);}
 }tree[maxn*];

 void Build(int root, int L, int R)
 {
     tree[root].L = L, tree[root].R = R;
     tree[root].isCover = false;

     if(L == R)return ;

     Build(Lson);
     Build(Rson);
 }
 void Up(int root)
 {
     if(tree[root].L != tree[root].R)
     if(tree[root<<].isCover ==  && tree[root<<|].isCover == )
         tree[root].isCover = ;
 }
 int  Insert(int root, int L, int R)
 {
     if(tree[root].isCover == )return ;

     if(tree[root].L == L && tree[root].R == R && !tree[root].isCover)
     {
         tree[root].isCover = ;
         return tree[root].Len();
     }
     tree[root].isCover = ;

     int ans = ;

     if(R <= tree[root].Mid())
         ans = Insert(root<<, L, R);
     else if(L > tree[root].Mid())
         ans = Insert(root<<|, L, R);
     else
         ans = Insert(Lson)+Insert(Rson);

     Up(root);

     return ans;
 }

 int main()
 {
     int i, T, t=;

     scanf("%d", &T);

     while(T--)
     {
         int N, M;

         scanf("%d%d", &N, &M);
         Build(, , N);

         for(i=; i<=M; i++)
             scanf("%d%d%d", &hook[i].l, &hook[i].r, &hook[i].z);

         int ans = N;

         for(i=M; i>; i--)
         {
             int len = Insert(, hook[i].l, hook[i].r);
             ans = ans - len + len * hook[i].z;
         }

         printf("Case %d: The total value of the hook is %d.\n", t++, ans);
     }

     return ; }