[ACM] hdu 1698 Just a Hook （线段树，成段更新，懒惰标记）

Just a Hook

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 14942    Accepted Submission(s): 7409

Problem Description

 

In the game of DotA, Pudge’s meat hook is actually the most horrible thing for most of the heroes. The hook is made up of several consecutive metallic sticks which are of the same length.



Now Pudge wants to do some operations on the hook.

Let us number the consecutive metallic sticks of the hook from 1 to N. For each operation, Pudge can change the consecutive metallic sticks, numbered from X to Y, into cupreous sticks, silver sticks or golden sticks.
The total value of the hook is calculated as the sum of values of N metallic sticks. More precisely, the value for each kind of stick is calculated as follows:

For each cupreous stick, the value is 1.
For each silver stick, the value is 2.
For each golden stick, the value is 3.

Pudge wants to know the total value of the hook after performing the operations.
You may consider the original hook is made up of cupreous sticks.

 

 

Input

 

The input consists of several test cases. The first line of the input is the number of the cases. There are no more than 10 cases.
For each case, the first line contains an integer N, 1<=N<=100,000, which is the number of the sticks of Pudge’s meat hook and the second line contains an integer Q, 0<=Q<=100,000, which is the number of the operations.
Next Q lines, each line contains three integers X, Y, 1<=X<=Y<=N, Z, 1<=Z<=3, which defines an operation: change the sticks numbered from X to Y into the metal kind Z, where Z=1 represents the cupreous kind, Z=2 represents the silver kind and Z=3 represents the golden kind.

 

 

Output

 

For each case, print a number in a line representing the total value of the hook after the operations. Use the format in the example.

 

 

Sample Input

 

1
10
2
1 5 2
5 9 3

 

 

Sample Output

 

Case 1: The total value of the hook is 24.

 

 

Source

 

2008 “Sunline Cup” National Invitational Contest

 

解题思路：

今天做区间更新的线段树，这个稍微难一点，一开始不太好理解。成段更新就是把从几到几这一段都进行相同的操作，比如改为一个数，或增加一个数。本题是把一段区间改为一个数，然后查询总区间的和。再说一下懒惰标记，也也可以说是延迟标记，一开始所有的节点都没有被标记，后来在成端更新的时候，比如要更新【2,4】这个区间的值，首先在树中找到的是一个节点（不是叶子节点），维护着【2,4】这一区间元素的和，先把这个节点更新，按理说父节点更新了，子节点也应该跟着更新，这样的话会对大量的子节点进行操作，为了避免这个，用到了懒惰标记，就是只更新父节点的值，并对此进行标记，子节点先不更新，这样在查询的时候如果只要找【2,4】的最大值，只要查找到维护【2,4】这个区间的父节点就可以了，不用再向下查找。这就是懒惰标记的巧妙之处。等到以后需要更新区间或者查询的时候，如果找到被标记的节点，但不是我们要找的那个，就要对该节点的儿子节点进行更新了，并且父节点的标记状态改为未标记，而儿子节点的状态改为标记。

参考博客（讲的特别好）：

http://blog.sina.com.cn/s/blog_a2dce6b30101l8bi.html

代码：

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

#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
const int maxn=100002;
int col[maxn<<2];//用来标记每个节点，为0则表示没有标记，否则为标记，以颜色的价值作为标记。
int sum[maxn<<2];//求和

void PushUp(int rt)//向上更新和
{
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}

void PushDown(int rt,int m)//对某一个区间进行改变，如果被标记了，在查询的时候就得把改变传给子节点，因为查询的并不一定是当前区间
{//m为区间长度
    if(col[rt])//已经标记过，该区间被改变过
    {
        col[rt<<1]=col[rt<<1|1]=col[rt];//标记子节点
        sum[rt<<1]=(m-(m>>1))*col[rt];//更新左儿子的和
        sum[rt<<1|1]=(m>>1)*col[rt];//更新右儿子的和
        col[rt]=0;
    }
}

void build(int l,int r,int rt)
{
    col[rt]=0;//初始化为所有节点均未标记
    sum[rt]=1;//初始值为1
    if(l==r)
        return;
    int m=(l+r)>>1;
    build(lson);
    build(rson);
}

void update(int L,int R,int c,int l,int r,int rt)
{
    if(L<=l&&r<=R)
    {
        col[rt]=c;
        sum[rt]=c*(r-l+1);//更新代表某个区间的节点和，该节点不一定是叶子节点
        return ;
    }
    PushDown(rt,r-l+1);//向下传递
    int m=(l+r)>>1;
    if(L<=m)
        update(L,R,c,lson);//更新左儿子
    if(R>m)
        update(L,R,c,rson);//更新右儿子
    PushUp(rt);//向上传递更新和
}
int main()
{
    int k;cin>>k;
    int n,c,add,a,b;
    for(int i=1;i<=k;i++)
    {
        scanf("%d",&n);
        build(1,n,1);
        scanf("%d",&c);
        for(int j=1;j<=c;j++)
        {
            scanf("%d%d%d",&a,&b,&add);
            update(a,b,add,1,n,1);
        }
        printf("Case %d: The total value of the hook is %d.\n",i,sum[1]);
    }
    return 0;
}