C++博客-purplest-随笔分类-线段树

HDU 4267 A Simple Problem with Integers 2012 ACM/ICPC Asia Regional Changchun Online 1001

purplest — Sun, 09 Sep 2012 13:47:00 GMT

这道题即区间更新，单点查询，所以只需要维护区间的增加量即可。

因为1<=k<=10，所以对于不同的起始区间不同的k，一共有55种情况，所以，用开个55的数组即可维护。

利用ZKW线段树思想，标记永久化，每次查到根就over。。

这题方法很多的说，维护10棵树状数组也行，sqrt(n)的方法也行。。。

不过比赛时没想到怎么解决不同的起始区间的k值，算了下还可能MLE，没敢写。。。郁闷。。

#include
#include
#include
#define L(x) (x<<1)
#define R(x) (x<<1|1)

using namespace std;

int n, q, num;
int add[1<<17][55];
int left[1<<17], right[1<<17];
int arr[50100];

void init()
{
    memset(add,0,sizeof(add));
    for ( int i = 0 ; i < num ; i++ )
        left[i+num]=right[i+num]=i;
    for ( int i = num-1 ; i ; i-- )
    {
        left[i]=left[L(i)];
        right[i]=right[R(i)];
    }
}

void update(int s, int t, int k, int val)
{
    int tag = s%k;
    for ( int i = 1 ; i < k ; i++ )
        tag+=i;
    for ( s=s+num-1, t=t+num+1 ; s^t^1 ; s>>=1, t>>=1 )
    {
        if (~s&1)
            add[s^1][tag]+=val;
        if (t&1)
            add[t^1][tag]+=val;
    }
}

int query(int m)
{
    int ans=0, start=m;
    for ( m+=num ; m ; m>>=1 )
        for ( int k = 1 ; k <= 10 ; k++ )
        {
            int tag=start%k;
            for ( int i = 1 ; i < k ; i++ )
                tag+=i;
            ans+=add[m][tag];
        }
    return ans;
}

int main()
{
//    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
    while (EOF!=scanf("%d", &n))
    {
        for ( int i = 1; i <= n ; i++ )
            scanf("%d", arr+i);
        scanf("%d", &q);
        int cmd, l,r,k,val;
        for (num=1;num<(n+2);num<<=1);
        init();
        while (q--)
        {
            scanf("%d", &cmd);
            if (1==cmd)
            {
                scanf("%d%d%d%d", &l, &r, &k, &val);
                update(l,r,k,val);
            }
            else if (2==cmd)
            {
                scanf("%d", &k);
                printf("%d\n", arr[k]+query(k));
            }
        }
    }
    return 0;
}

purplest 2012-09-09 21:47 发表评论

poj 1177 Picture

purplest — Wed, 05 Oct 2011 16:14:00 GMT

把矩形求面积做完后就弄这求周长的题了，其实求周长只比求面积多了几个标记而已了，这里的flag判断入边出边的标记比起求面积的代码写的精炼多了，各种小技巧啊~困扰N久不想看的题总算给搞定了~

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

const int N=5100;

struct Node
{
    int l, r, cover, num, len;
    bool leftc, rightc;
}tree[N<<2];

struct Line
{
    int x, y1, y2, flag;
}line[N<<1];

int temp[N<<1], yline[N<<1];
int n;

int cmpt(const void *a, const void *b)
{
    return *(int *)a - *(int *)b;
}

int cmpL(const void *a, const void *b)
{
    return (*(Line *)a).x - (*(Line *)b).x;
}

int myabs(int a)
{
    return a>0?a:-a;
}

void build(int l, int r, int p)
{
    tree[p].l= l;
    tree[p].r= r;
    tree[p].cover= 0;
    tree[p].len= 0;
    tree[p].num= 0;
    tree[p].leftc=tree[p].rightc= 0;
    if ( r-l > 1 )
    {
        int mid= l+r >> 1;
        build(l, mid, 2*p);
        build(mid, r, 2*p+1);
    }
}

void update(int p)
{
    if ( tree[p].cover > 0 )
    {
        tree[p].num= tree[p].leftc = tree[p].rightc = 1;
        tree[p].len= yline[tree[p].r] - yline[tree[p].l];
    }
    else if ( tree[p].r - tree[p].l <= 1)
        tree[p].len= tree[p].leftc= tree[p].rightc= tree[p].num= 0;
    else
    {
        tree[p].rightc= tree[(p<<1)+1].rightc;
        tree[p].leftc= tree[p<<1].leftc;
        tree[p].len= tree[p<<1].len+tree[(p<<1)+1].len;
        tree[p].num= tree[p<<1].num+tree[(p<<1)+1].num-tree[(p<<1)+1].leftc*tree[p<<1].rightc;
    }
}

void insert(int l, int r, int p, int flag)
{
    if ( l <= yline[tree[p].l] && yline[tree[p].r] <= r )
    {
        tree[p].cover+=flag;
        update(p);
        return;
    }
    if ( tree[p].r - tree[p].l <= 1 )
        return;
    int mid= tree[p].l+tree[p].r >> 1;
    if ( l <= yline[mid] )
        insert(l, r, p<<1, flag);
    if ( yline[mid] < r )
        insert(l, r, (p<<1)+1, flag);
    update(p);
}

int main()
{
    while ( ~scanf("%d", &n) )
    {
        int i, m= 0;
        int x1, x2, y1, y2;
        for ( i = 0 ; i < n ; i++ )
        {
            scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
            line[2*i].x= x1;
            line[2*i].y1= y1;
            line[2*i].y2= y2;
            line[2*i].flag= 1;
            line[2*i+1].x= x2;
            line[2*i+1].y1= y1;
            line[2*i+1].y2= y2;
            line[2*i+1].flag= -1;
            temp[2*i]= y1;
            temp[2*i+1]= y2;
        }
        n <<= 1;
        qsort(temp, n, sizeof(int), cmpt);
        qsort(line, n, sizeof(Line), cmpL);
        yline[0]= temp[0];
        for ( i = 1 ; i < n ; i++ )
            if ( yline[m] != temp[i] )
                yline[++m]= temp[i];
        build(0, m, 1);
        int ans, last, lines;
        insert(line[0].y1, line[0].y2, 1, line[0].flag);
        last= ans=tree[1].len;
        lines=tree[1].num;
        for ( i = 1 ; i < n ; i++ )
        {
            insert(line[i].y1, line[i].y2, 1, line[i].flag);
            ans+=2*lines*(line[i].x-line[i-1].x);
            ans+=myabs(tree[1].len-last);
            last= tree[1].len;
            lines=tree[1].num;
        }
        printf("%d\n", ans);
    }
    return 0;
}

purplest 2011-10-06 00:14 发表评论

poj 1151 Atlantis

purplest — Wed, 05 Oct 2011 13:29:00 GMT

卡了我很久的题了，今天下决心弄，总算弄过了

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

const int N=110;
const double eps= 1e-8;
struct Node
{
    int l, r, cover;
    double len;
}tree[N*8];

struct Line
{
    double x, y1, y2;
    bool flag;
}line[N*2];

double temp[N*2], yline[N*2];
int n;

int cmpdy(double a, double b)
{
    return (a-b) > eps ? 1 : -1;
}

bool dd(double a, double b)
{
    return fabs(a-b)<eps ? 1 : 0;
}

bool dy(double a, double b)
{
    return a-b>eps ? 1 : 0;
}

int cmpt(const void *a , const void *b)
{
    return cmpdy(*(double *)a, *(double *)b);
}

int cmpL(const void *a, const void *b)
{
    return cmpdy((*(Line *)a).x, (*(Line *)b).x);
}

void build(int l, int r, int p)
{
    tree[p].l= l;
    tree[p].r= r;
    tree[p].cover= 0;
    tree[p].len= 0;
    if ( r-l > 1 )
    {
        int mid= l+r >> 1;
        build(l, mid, 2*p);
        build(mid, r, 2*p+1);
    }
}

void update(int p)
{
    if ( tree[p].cover > 0 )
        tree[p].len= yline[tree[p].r-1] - yline[tree[p].l-1];
    else if ( tree[p].r - tree[p].l <= 1)
        tree[p].len= 0;
    else tree[p].len= tree[2*p].len+tree[2*p+1].len;
}

void insert(int l, int r, int p)
{
    if ( l <= tree[p].l && tree[p].r <= r )
    {
        tree[p].cover++;
        update(p);
        return;
    }
    if ( tree[p].r - tree[p].l <= 1 )
        return;
    int mid= tree[p].l+tree[p].r >> 1;
    if ( l < mid )
        insert(l, r, 2*p);
    if ( mid < r )
        insert(l, r, 2*p+1);
    update(p);
}

void del(int l, int r, int p)
{
    if ( l <= tree[p].l && tree[p].r <= r )
    {
        tree[p].cover--;
        update(p);
        return;
    }
    if ( tree[p].r - tree[p].l <= 1 )
        return;
    int mid= tree[p].l+tree[p].r >> 1;
    if ( l < mid )
        del(l, r, 2*p);
    if ( mid < r )
        del(l, r, 2*p+1);
    update(p);
}

int getindex(int n, double num)
{
    int left= 0, right= n-1, mid;
    while ( left < right )
    {
        mid= left+right>>1;
        if ( dy(num, yline[mid]) )
            left= mid+1;
        else right= mid;
    }
    return right + 1;
}

int main()
{
    int icase= 1;
    while ( scanf("%d", &n), n )
    {
        int i, m= 1;
        double x1, x2, y1, y2;
        for ( i = 0 ; i < n ; i++ )
        {
            scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
            line[2*i].x= x1;
            line[2*i].y1= y1;
            line[2*i].y2= y2;
            line[2*i].flag= 1;
            line[2*i+1].x= x2;
            line[2*i+1].y1= y1;
            line[2*i+1].y2= y2;
            line[2*i+1].flag= 0;
            temp[2*i]= y1;
            temp[2*i+1]= y2;
        }
        n <<= 1;
        qsort(temp, n, sizeof(double), cmpt);
        qsort(line, n, sizeof(Line), cmpL);
        yline[0]= temp[0];
        for ( i = 1 ; i < n ; i++ )
            if ( !dd(yline[m-1], temp[i]) )
                yline[m++]= temp[i];
        build(1, m, 1);
        double area= 0;
        for ( i = 0 ; i < n-1 ; i++ )
        {
            int l= getindex(m, line[i].y1), r= getindex(m, line[i].y2);
            if ( line[i].flag )
                insert(l, r, 1);
            else
                del(l, r, 1);
            area+=tree[1].len*(line[i+1].x-line[i].x);
        }
        printf("Test case #%d\nTotal explored area: %.2f\n\n", icase++, area);
    }
    return 0;
}

purplest 2011-10-05 21:29 发表评论

poj 3468 A Simple Problem with Integers

purplest — Wed, 14 Sep 2011 07:27:00 GMT

果的线段树，需要用到lazy-tag的方法，朴素果断超时

朴素线段树

#include <stdio.h>

const int N= 105100;

struct Node
{
    int left, right;
    __int64 sum, add;
}node[4*N];

int num, n, q;
__int64 data[N];
char str[1];

void swap(int &a, int &b)
{
    int t= a;
    a= b;
    b= t;
}

void build_tree(int left, int right, int p)
{
    node[p].left=left;
    node[p].right=right;
    node[p].add=0;
    if ( left < right )
    {
        int mid= left+right>>1;
        build_tree(left, mid, 2*p);
        build_tree(mid+1, right, 2*p+1);
        node[p].sum= node[2*p].sum+node[2*p+1].sum;
    }
    else if ( left == right )
        node[p].sum= data[left];
}

void update(int p)
{
    node[p<<1].sum+= node[p].add*(node[p<<1].right-node[p<<1].left+1);
    node[(p<<1)+1].sum+= node[p].add*(node[(p<<1)+1].right-node[(p<<1)+1].left+1);
    node[p<<1].add+= node[p].add;
    node[(p<<1)+1].add+= node[p].add;
    node[p].add= 0;
}

__int64 query(int s, int t, int p)
{
    __int64 sum= 0, i= 0, j= 0;
    if ( s <= node[p].left && node[p].right <= t)
        return node[p].sum;
    if ( node[p].add)
        update(p);
    int mid= node[p].right+node[p].left>>1;
    if ( s <= mid )
        i = query(s, t, p<<1);
    if ( t > mid )
        j = query(s, t, (p<<1)+1);
    return i+j;
}

void adds(int s, int t, __int64 add, int p)
{
    if ( s <= node[p].left && node[p].right <= t)
    {
        node[p].add+=add;
        node[p].sum+=add*(node[p].right-node[p].left+1);
        return;
    }
    if ( node[p].add)
        update(p);
    int mid= node[p].right+node[p].left>>1;
    if ( s <= mid )
        adds( s, t, add, p<<1);
    if ( t > mid )
        adds( s, t, add, (p<<1)+1);
    node[p].sum= node[p<<1].sum+node[(p<<1)+1].sum;
}

int main()
{
    scanf("%d%d", &n, &q);
    int i, left, right;
    __int64 value;
    data[0]= 0;
    for ( i = 1 ; i <= n ; i++ )
        scanf("%I64d", data+i);
    build_tree(1, n, 1);
    while ( q-- )
    {
        scanf("%s", str);
        if ( 'Q' == str[0] )
        {
            scanf("%d%d", &left, &right);
            printf("%I64d\n", query(left, right, 1));
        }
        else
        {
            scanf("%d%d%I64d", &left, &right, &value);
            if ( left > right )
                swap(left, right);
            if ( value )
                adds(left, right, value, 1);
        }
    }
    return 0;
}

zkw线段树

#include <stdio.h>

const int N= 105100;

struct Node
{
    int left, right;
    __int64 sum, add;
}node[4*N];

int num, n, q;
__int64 data[N];
char str[10];

void build_tree()
{
    int i;
    for ( i = 2*num-1 ; i >= num ; i-- )
    {
        if ( i-num > n)
            node[i].sum= 0;
        else
            node[i].sum= data[i-num];
        node[i].left= node[i].right= i-num;
        node[i].add= 0;
    }
    while ( i > 0 )
    {
        node[i].sum=node[i<<1].sum+node[(i<<1)+1].sum;
        node[i].left= node[i<<1].left;
        node[i].right= node[(i<<1)+1].right;
        node[i].add= 0;
        i--;
    }
}

__int64 query(int s, int t)
{
    __int64 sum= 0;
    int num_s= 0, num_t= 0;
    for ( s= s+num-1, t= t+num+1 ; s^t^1 ; s>>=1, t>>=1 )
    {
        if (~s&1)
        {
            sum+=node[s^1].sum;
            num_s+= node[s^1].right-node[s^1].left+1;
        }
        if ( t&1 )
        {
            sum+=node[t^1].sum;
            num_t+= node[t^1].right-node[t^1].left+1;
        }
        sum+=node[s>>1].add*num_s;
        sum+=node[t>>1].add*num_t;
    }
    for (s>>=1 ; s > 0 ; s>>=1 )
        sum+=node[s].add*(num_s+num_t);
    return sum;
}

void add(int s, int t, __int64 d)
{
    int num_s= 0, num_t= 0;
    for ( s= s+num-1, t= t+num+1 ; s^t^1 ; s>>=1, t>>=1 )
    {
        if (~s&1)
        {
            node[s^1].add+= d;
            node[s^1].sum+=(node[s^1].right-node[s^1].left+1)*d;
            num_s+= node[s^1].right-node[s^1].left+1;
        }
        if ( t&1 )
        {
            node[t^1].add+= d;
            node[t^1].sum+=(node[t^1].right-node[t^1].left+1)*d;
            num_t+= node[t^1].right-node[t^1].left+1;
        }
        node[s>>1].sum+=d*num_s;
        node[t>>1].sum+=d*num_t;
    }
    for (s>>=1 ; s > 0 ; s>>=1 )
        node[s].sum+=d*(num_s+num_t);
}

int main()
{
    scanf("%d%d", &n, &q);
    int i, left, right;
    __int64 value;
    data[0]= 0;
    for ( i = 1 ; i <= n ; i++ )
        scanf("%I64d", data+i);
    for ( num = 1 ; num < (n+2) ; num<<=1 );
    build_tree();
    while ( q-- )
    {
        scanf("%s", str);
        if ( 'Q' == str[0] )
        {
            scanf("%d%d", &left, &right);
            printf("%I64d\n", query(left, right));
        }
        else
        {
            scanf("%d%d%I64d", &left, &right, &value);
            if ( value )
                add(left, right, value);
        }
    }
    return 0;
}

purplest 2011-09-14 15:27 发表评论

poj 2528 Mayor's posters

purplest — Wed, 03 Aug 2011 09:41:00 GMT

果的线段树，结合离散化

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

struct node
{
    int l, r, color;
}tree[80010];
int n;
int x[10010], y[10010], t[10000010];
int point[20010], v[10010];

int cmp(const void *a, const void *b)
{
    return *(int *)a-*(int *)b;
}

void build(int l, int r, int p)
{
    tree[p].l= l;
    tree[p].r= r;
    tree[p].color= 0;
    if ( l < r )
    {
        int mid=(l+r)>>1;
        build(l, mid, 2*p);
        build(mid+1, r, 2*p+1);
    }
}

void insert(int l , int r , int p, int color)
{
    if ( tree[p].l == l && tree[p].r == r)
    {
        tree[p].color=color;
        return;
    }
    if (tree[p].color)
    {
        tree[2*p].color= tree[2*p+1].color=tree[p].color;
        tree[p].color=0;
    }
    int mid= (tree[p].l+tree[p].r)>>1;
    if (r <= mid) insert(l, r, 2*p, color);
    else if (l > mid) insert(l, r, 2*p+1, color);
    else
    {
        insert(l, mid, 2*p, color);
        insert(mid+1, r, 2*p+1, color);
    }
}

void find(int l, int r, int p)
{
    if (tree[p].color)
    {
        v[tree[p].color]=1;
        return;
    }
    int mid= (tree[p].l+tree[p].r)>>1;
    find(l, mid, 2*p);
    find(mid+1, r, 2*p+1);
}

int c;
int main()
{
    scanf("%d", &c);
    while ( c-- )
    {
        scanf("%d", &n);
        memset(t, 0, sizeof(t));
        int i, k=0;
        for ( i = 1; i <= n; i++ )
        {
            scanf("%d%d", x+i, y+i);
            if ( !t[x[i]] )
            {
                t[x[i]]=1;
                point[++k]=x[i];
            }
            if ( !t[y[i]] )
            {
                t[y[i]]=1;
                point[++k]=y[i];
            }
        }
        qsort( point+1, k, sizeof(int), cmp );
        for( i= 1; i <= k; i++)
            t[point[i]]=i;
        build(1, k, 1);
        for ( i = 1; i <= n; i++)
        {
            insert(t[x[i]], t[y[i]], 1, i);
        }
        memset(v, 0, sizeof(v));
        find(1, k ,1);
        int sum=0;
        for ( i = 1; i <=n ; i++)
            if(v[i]) sum++;
        printf("%d\n", sum);
    }
    return 0;
}

purplest 2011-08-03 17:41 发表评论