（线段树）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 = 100005;

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

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

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 = 0;

    if(L==R) return ;

    BuildTree(Lson, L, a[r].Mid());
    BuildTree(Rson, a[r].Mid()+1, 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+1)
        return a[r].len;
    if(a[r].L==L && a[r].R==R)
    {
        a[r].len = R-L+1;
        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()+1, R);
    }

    UpDate(r);

    return a[r].len;
}

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

        BuildTree(1, 1, n);

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

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


        int sum = 0, z=0, w=0;
        for(int i=m+1; i>0; i--)
        {
            w = z;
            z = Insert(1, 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.
", k++, sum);

    }
    return 0;
}

代码：

#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 = 100005;

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

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<<1].isCover == 1 && tree[root<<1|1].isCover == 1)
        tree[root].isCover = 1;
}
int  Insert(int root, int L, int R)
{
    if(tree[root].isCover == 1)return 0;

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

    int ans = 0;

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

    Up(root);

    return ans;
}

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

    scanf("%d", &T);

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

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

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

        int ans = N;

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

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

    return 0; }