8.8线段树和树状数组

 题目链接   http://acm.hust.edu.cn/vjudge/contest/view.action?cid=28619#overview

密码 acmore

还是感觉不怎么会线段树，还是得给自己另外多找点题目练练

Problem A HDU 3874

Necklace

树状数组+离线操作见http://www.cnblogs.com/gj-Acit/p/3249827.html

Problem B HDU 2227

Find the nondecreasing subsequences

见http://www.cnblogs.com/gj-Acit/p/3258508.html

Problem C HDU 1541

Stars

题目意思是说给出一些星星的坐标，他们每个星星的等级是按照每个星星左下方星星的数目来定的，即所有点中满足x<x0,y<y0的点的数目就是这个店的等级。求每个等级的星星有多少个。

由于题目给出的坐标中y是按照升序给出的，所以我们只需要每输入一个坐标，就先查询它的x坐标的前方有多少个点，再将这个点插入到坐标轴中去，这样的话就可以保证每次查询的都是当前点的左下方的点的数目。这样的话就可以用树状数组来记录从1~x的区间内有多少个已经被标记的点。

#include <stdio.h>
#include <string.h>
#define mem(a) memset(a,0,sizeof(a))
#define MAX(a , b) ((a) > (b) ? (a) : (b))

int TreeArray[32005], N;
int ans[32005];
int X[15005], Y;

int LowBit(int x)
{
    return x&(-x);
}

int GetSum(int k)//返回区间1~k有多少个点
{
    int sum = 0;
    while(k>=1)
    {
        sum += TreeArray[k];
        k -= LowBit(k);
    }
    return sum;
}

void Edit(int k,int Len)//插入一个点
{
    while(k<=Len)
    {
        TreeArray[k] += 1;
        k += LowBit(k);
    }
}

int main()
{
    while(~scanf("%d", &N))
    {
        mem(ans); mem(TreeArray);
        mem(X);
        int Max = 0;
        for(int i=1;i<=N;i++)
        {
            scanf("%d%d", &X[i], &Y);//其实不用吧每个点记录下来，可以每次都直接在区间1~32000内查找
            X[i]+=1;//由于题目说x有可能为0，而树状数组不可以记录点0，所以全部的x都+1
            Max = MAX(X[i], Max);//我是想要找出区间最大坐标，然后在1到最大区间内查询
        }
        for(int i=1;i<=N;i++)
        {
            ans[GetSum(X[i])]++;//先查询
            Edit(X[i], Max);//后把点插入到坐标中去
        }
        for(int i=0;i<N;i++)
        {
            printf("%d
", ans[i]);
        }
    }
    return 0;
}

Problem D HDU 1754

I Hate It

线段树的基本操作，区间查询和节点修改

虽然此题比较简单，但是有一点学到的就是代码风格，要学会尽量让代码清晰易懂

#include <stdio.h>
#include <string.h>
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define mem(a) memset(a, 0, sizeof(a))
#define lson k<<1, l, mid
#define rson k<<1|1, mid+1, r
#define MAXN 200005

int Max[MAXN<<2], N, M;

void edit(int k, int l,int r, int num, int v)
{
    if(l == r)
    {
        Max[k] = v;
        return ;
    }
    int mid = (l+r)>>1;
    if(num <= mid)edit(lson, num, v);
    else edit(rson, num, v);
    Max[k] = MAX(Max[k<<1], Max[k<<1|1]);
}

int query(int k,int l,int r,int L,int R)
{
    if(L<=l && r<=R)return Max[k];
    int mid = (l+r)>>1, Lans=0, Rans =0;
    if(L <= mid) Lans = query(lson, L, R);
    if(R > mid) Rans = query(rson, L, R);
    return MAX(Lans, Rans);
}

int main()
{
    while(~scanf("%d %d", &N, &M))
    {
        int A, B;
        char ch; mem(Max);
        for(int i=1;i<=N;i++)
        {
            scanf("%d%*c", &A);
            edit(1,1,N,i,A);
        }
        for(int i=0;i<M;i++)
        {
            scanf("%c %d %d%*c", &ch, &A, &B);
            if(ch == 'Q') printf("%d
", query(1,1,N,A,B));
            else edit(1,1,N,A,B);
        }
    }
    return 0;
}

Problem E POJ 3264

Balanced Lineup

一样都是基本操作

#include <stdio.h>
#include <string.h>
#define INF 1000010
#define mem(a) memset(a,0,sizeof(a))
#define lson k<<1, l, mid
#define rson k<<1|1,mid+1, r
#define MAX(a,b) (a>b?a:b)
#define MIN(a,b) (a<b?a:b)
#define MAXN 50005

int minH[MAXN<<2], maxH[MAXN<<2];
int N, M;

void init()
{
    for(int i=0;i<=(N<<2);i++)
    {
        minH[i] =  INF;
        maxH[i] = -INF;
    }
}

void edit(int k,int l,int r,int num, int val)
{
    if(l==r){
        minH[k] = maxH[k] = val;
        return ;
    }
    int mid = (l+r)>>1;
    if(num <= mid) edit(lson, num, val);
    else edit(rson,num,val);
    minH[k] = MIN(minH[k<<1], minH[k<<1|1]);
    maxH[k] = MAX(maxH[k<<1], maxH[k<<1|1]);
}

int query(int k,int l,int r,int L,int R,int IsMin)
{
    if(L<=l && r<=R) return IsMin ? minH[k] : maxH[k];
    int mid = (l+r)>>1, Lval=INF, Rval=INF;
    if(L <= mid) Lval = query(lson,L,R,IsMin);
    if(R > mid) Rval = query(rson,L,R,IsMin);
    if(IsMin) return MIN(Lval, Rval);
    return MAX((Lval==INF?-INF:Lval), (Rval==INF?-INF:Rval));
}

int main()
{
    while(~scanf("%d%d", &N, &M))
    {
        init();  int h;
        for(int i=1;i<=N;i++)
        {
            scanf("%d", &h);
            edit(1,1,N,i,h);
        }
        int  A, B;
        for(int i=0;i<M;i++)
        {
            scanf("%d %d", &A, &B);
            printf("%d
", query(1,1,N,A,B,0) - query(1,1,N,A,B,1));
        }
    }
    return 0;
}

Problem G POJ 2299

Ultra-QuickSort

见http://www.cnblogs.com/gj-Acit/p/3250525.html