C++博客-心如止水-随笔分类-题目分类：数据结构

HDU 3397 Sequence operation

lee1r — Mon, 22 Aug 2011 10:57:00 GMT

线段树维护区间取反、区间覆盖。
拿日华哥哥的代码对拍了好久终于AC啦。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/21 10:04:48
* File Name: hdu3397.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) ((x)<<1|1)
#define Half(x) ((x)>>1)
#define Lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-8);
typedef unsigned int uint;
typedef long long int64;
typedef unsigned long long uint64;

int scanf(int &num)
{
    char in;
    while((in=getchar())!=EOF && (in>'9' || in<'0'));
    if(in==EOF) return 0;
    num=in-'0';
    while(in=getchar(),in>='0' && in<='9') num*=10,num+=in-'0';
    return 1;
}

const int kMaxn(100007);

struct Node
{
    int a,b;
    int max0,lmax0,rmax0;
    int max1,lmax1,rmax1;
    int cnt0,cnt1;
    int cover,reverse;
};

int N,M;
bool r[kMaxn];
Node tree[kMaxn<<2];

void PushDown(int node)
{
    if(tree[node].cover!=-1)
    {
        tree[L(node)].reverse=tree[R(node)].reverse=0;
        tree[L(node)].cover=tree[R(node)].cover=tree[node].cover;
        if(tree[node].cover==0)
        {
            tree[L(node)].cnt0=tree[L(node)].max0=tree[L(node)].lmax0=tree[L(node)].rmax0=(tree[L(node)].b-tree[L(node)].a+1);
            tree[L(node)].cnt1=tree[L(node)].max1=tree[L(node)].lmax1=tree[L(node)].rmax1=0;
            tree[R(node)].cnt0=tree[R(node)].max0=tree[R(node)].lmax0=tree[R(node)].rmax0=(tree[R(node)].b-tree[R(node)].a+1);
            tree[R(node)].cnt1=tree[R(node)].max1=tree[R(node)].lmax1=tree[R(node)].rmax1=0;
        }
        else
        {
            tree[L(node)].cnt0=tree[L(node)].max0=tree[L(node)].lmax0=tree[L(node)].rmax0=0;
            tree[L(node)].cnt1=tree[L(node)].max1=tree[L(node)].lmax1=tree[L(node)].rmax1=(tree[L(node)].b-tree[L(node)].a+1);
            tree[R(node)].cnt0=tree[R(node)].max0=tree[R(node)].lmax0=tree[R(node)].rmax0=0;
            tree[R(node)].cnt1=tree[R(node)].max1=tree[R(node)].lmax1=tree[R(node)].rmax1=(tree[R(node)].b-tree[R(node)].a+1);
        }
        tree[node].cover=-1;
    }
    if(tree[node].reverse)
    {
        tree[node].reverse=0;
        swap(tree[L(node)].max0,tree[L(node)].max1);
        swap(tree[L(node)].lmax0,tree[L(node)].lmax1);
        swap(tree[L(node)].rmax0,tree[L(node)].rmax1);
        swap(tree[L(node)].cnt0,tree[L(node)].cnt1);
        swap(tree[R(node)].max0,tree[R(node)].max1);
        swap(tree[R(node)].lmax0,tree[R(node)].lmax1);
        swap(tree[R(node)].rmax0,tree[R(node)].rmax1);
        swap(tree[R(node)].cnt0,tree[R(node)].cnt1);

        tree[L(node)].reverse=!tree[L(node)].reverse;
        tree[R(node)].reverse=!tree[R(node)].reverse;
    }
}

void PushUp(int node)
{
    tree[node].max0=max(tree[L(node)].max0,tree[R(node)].max0);
    tree[node].max0=max(tree[node].max0,tree[L(node)].rmax0+tree[R(node)].lmax0);
    if(tree[L(node)].lmax0==tree[L(node)].b-tree[L(node)].a+1)
        tree[node].lmax0=tree[L(node)].lmax0+tree[R(node)].lmax0;
    else
        tree[node].lmax0=tree[L(node)].lmax0;
    if(tree[R(node)].rmax0==tree[R(node)].b-tree[R(node)].a+1)
        tree[node].rmax0=tree[R(node)].rmax0+tree[L(node)].rmax0;
    else
        tree[node].rmax0=tree[R(node)].rmax0;

    tree[node].max1=max(tree[L(node)].max1,tree[R(node)].max1);
    tree[node].max1=max(tree[node].max1,tree[L(node)].rmax1+tree[R(node)].lmax1);
    if(tree[L(node)].lmax1==tree[L(node)].b-tree[L(node)].a+1)
        tree[node].lmax1=tree[L(node)].lmax1+tree[R(node)].lmax1;
    else
        tree[node].lmax1=tree[L(node)].lmax1;
    if(tree[R(node)].rmax1==tree[R(node)].b-tree[R(node)].a+1)
        tree[node].rmax1=tree[R(node)].rmax1+tree[L(node)].rmax1;
    else
        tree[node].rmax1=tree[R(node)].rmax1;

    tree[node].cnt0=tree[L(node)].cnt0+tree[R(node)].cnt0;
    tree[node].cnt1=tree[L(node)].cnt1+tree[R(node)].cnt1;
}

void Build(int node,int x,int y)
{
    tree[node].a=x;
    tree[node].b=y;
    tree[node].cover=-1;
    tree[node].reverse=0;
    if(x==y)
    {
        tree[node].cnt0=tree[node].max0=tree[node].lmax0=tree[node].rmax0=!r[x];
        tree[node].cnt1=tree[node].max1=tree[node].lmax1=tree[node].rmax1=r[x];
    }
    else
    {
        int m(Half(x+y));
        Build(L(node),x,m);
        Build(R(node),m+1,y);
        PushUp(node);
    }
}

void Modify(int node,int x,int y,int type)
{
    if(x<=tree[node].a && tree[node].b<=y)
    {
        if(type==0)
        {
            tree[node].reverse=0;
            tree[node].cover=0;
            tree[node].cnt0=tree[node].max0=tree[node].lmax0=tree[node].rmax0=tree[node].b-tree[node].a+1;
            tree[node].cnt1=tree[node].max1=tree[node].lmax1=tree[node].rmax1=0;
        }
        else if(type==1)
        {
            tree[node].reverse=0;
            tree[node].cover=1;
            tree[node].cnt0=tree[node].max0=tree[node].lmax0=tree[node].rmax0=0;
            tree[node].cnt1=tree[node].max1=tree[node].lmax1=tree[node].rmax1=tree[node].b-tree[node].a+1;
        }
        else if(type==2)
        {
            tree[node].reverse=!tree[node].reverse;
            swap(tree[node].cnt0,tree[node].cnt1);
            swap(tree[node].max0,tree[node].max1);
            swap(tree[node].lmax0,tree[node].lmax1);
            swap(tree[node].rmax0,tree[node].rmax1);
        }
    }
    else
    {
        PushDown(node);
        int m(Half(tree[node].a+tree[node].b));
        if(m>=x)
            Modify(L(node),x,y,type);
        if(m<y)
            Modify(R(node),x,y,type);
        PushUp(node);
    }
}

int Query1(int node,int x,int y)
{
    if(x<=tree[node].a && tree[node].b<=y)
        return tree[node].cnt1;
    PushDown(node);
    int m(Half(tree[node].a+tree[node].b)),re(0);
    if(m>=x)
        re+=Query1(L(node),x,y);
    if(m<y)
        re+=Query1(R(node),x,y);
    return re;
}

int Query2(int node,int x,int y)
{
    if(x<=tree[node].a && tree[node].b<=y)
        return tree[node].max1;
    PushDown(node);
    int m(Half(tree[node].a+tree[node].b));
    if(m>=y)
        return Query2(L(node),x,y);
    if(m<x)
        return Query2(R(node),x,y);
    return max(max(Query2(L(node),x,m),Query2(R(node),m+1,y)),min(tree[L(node)].rmax1,m-x+1)+min(tree[R(node)].lmax1,y-m));
}

int main()
{
    int T;
    scanf(T);
    while(T--)
    {
        scanf(N);
        scanf(M);
        for(int i=1;i<=N;i++)
        {
            int t;
            scanf(t);
            if(t)
                r[i]=true;
            else
                r[i]=false;
        }
        //  Input

        Build(1,1,N);
        //  Build

        while(M--)
        {
            int c,a,b;
            scanf(c);
            scanf(a);
            scanf(b);
            a++;b++;
            if(c<=2)
                Modify(1,a,b,c);
            else if(c==3)
                printf("%d\n",Query1(1,a,b));
            else
                printf("%d\n",Query2(1,a,b));
        }
    }

    return 0;
}

lee1r 2011-08-22 18:57 发表评论

POJ 3667 Hotel

lee1r — Wed, 17 Aug 2011 12:02:00 GMT

经典的区间合并题。
参考这篇文章学习的，http://www.notonlysuccess.com/?p=978
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/4 18:38:40
* File Name: poj3667.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) ((x)<<1|1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-11);
typedef long long int64;
typedef unsigned long long uint64;

const int kMaxn(50007);

struct Node
{
    int a,b;
    int max,lmax,rmax;
    bool cover;
};

int n,m;
Node tree[kMaxn<<2];

void Build(int node,int x,int y)
{
    tree[node].a=x;
    tree[node].b=y;
    tree[node].max=tree[node].lmax=tree[node].rmax=y-x+1;
    tree[node].cover=false;
    if(x<y)
    {
        int m(Half(x+y));
        Build(L(node),x,m);
        Build(R(node),m+1,y);
    }
}

void PushDown(int node)
{
    if(!tree[node].cover)
        return;
    tree[node].cover=false;
    tree[L(node)].cover=tree[R(node)].cover=true;
    if(tree[node].max)
    {
        tree[L(node)].max=tree[L(node)].lmax=tree[L(node)].rmax=tree[L(node)].b-tree[L(node)].a+1;
        tree[R(node)].max=tree[R(node)].lmax=tree[R(node)].rmax=tree[R(node)].b-tree[R(node)].a+1;
    }
    else
    {
        tree[L(node)].max=tree[L(node)].lmax=tree[L(node)].rmax=0;
        tree[R(node)].max=tree[R(node)].lmax=tree[R(node)].rmax=0;
    }
}

void PushUp(int node)
{
    tree[node].max=max(tree[L(node)].max,tree[R(node)].max);
    tree[node].max=max(tree[node].max,tree[L(node)].rmax+tree[R(node)].lmax);
    if(tree[L(node)].max==tree[L(node)].b-tree[L(node)].a+1)
        tree[node].lmax=tree[L(node)].max+tree[R(node)].lmax;
    else
        tree[node].lmax=tree[L(node)].lmax;
    if(tree[R(node)].max==tree[R(node)].b-tree[R(node)].a+1)
        tree[node].rmax=tree[L(node)].rmax+tree[R(node)].max;
    else
        tree[node].rmax=tree[R(node)].rmax;
}

void Modify(int node,int x,int y,int sign)
{
    int len(tree[node].b-tree[node].a+1);
    if(x<=tree[node].a && tree[node].b<=y)
    {
        tree[node].cover=true;
        if(sign==0)
            tree[node].max=0;
        else
            tree[node].max=len;
        tree[node].lmax=tree[node].rmax=tree[node].max;
        return;
    }
    PushDown(node);
    int m(Half(tree[node].a+tree[node].b));
    if(m>=x)
        Modify(L(node),x,y,sign);
    if(m<y)
        Modify(R(node),x,y,sign);
    PushUp(node);
}

int Query(int node,int need)
{
    if(tree[node].max<need)
        return 0;
    if(tree[node].a==tree[node].b)
        return tree[node].a;
    PushDown(node);
    if(tree[node].lmax>=need)
        return tree[node].a;
    if(tree[L(node)].max>=need)
        return Query(L(node),need);
    if(tree[L(node)].rmax+tree[R(node)].lmax>=need)
        return tree[L(node)].b-tree[L(node)].rmax+1;
    return Query(R(node),need);
}

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d%d",&n,&m)==2)
    {
        Build(1,1,n);

        while(m--)
        {
            int cmd;
            scanf("%d",&cmd);
            if(cmd==1)
            {
                int a,result;
                scanf("%d",&a);
                result=Query(1,a);
                printf("%d\n",result);
                if(result)
                    Modify(1,result,result+a-1,0);
            }
            else
            {
                int a,b;
                scanf("%d%d",&a,&b);
                Modify(1,a,a+b-1,1);
            }
        }
    }

    return 0;
}

lee1r 2011-08-17 20:02 发表评论

POJ 3253 Fence Repair

lee1r — Fri, 05 Aug 2011 15:59:00 GMT

哈夫曼树。使用堆来维护。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/5 23:46:40
* File Name: poj3253.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-8);
typedef long long int64;
typedef unsigned long long uint64;

const int kMaxn(20007);

int n;
int64 ans;

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d",&n)==1)
    {
        priority_queue< int,vector<int>,greater<int> > q;

        for(int i=1;i<=n;i++)
        {
            int t;
            scanf("%d",&t);
            q.push(t);
        }

        ans=0;
        while(q.size()>1)
        {
            int t(q.top());q.pop();
            t+=q.top();q.pop();
            q.push(t);
            ans+=t;
        }
        //ans+=q.top();

        cout<<ans<<endl;
    }

    return 0;
}

lee1r 2011-08-05 23:59 发表评论

POJ 2299 Ultra-QuickSort

lee1r — Fri, 05 Aug 2011 15:44:00 GMT

求逆序对个数。我是用离散化+树状数组做的。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/5 23:33:01
* File Name: poj2299.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-8);
typedef long long int64;
typedef unsigned long long uint64;

const int kMaxn(500007);

struct Type
{
    int id,value,num;
};

bool cmp1(const Type &a,const Type &b)
{
    return a.value<b.value;
}

bool cmp2(const Type &a,const Type &b)
{
    return a.id<b.id;
}

int n,bit[kMaxn];
Type r[kMaxn];
int64 ans;

void Add(int x,int delta)
{
    for(int i=x;i<=n;i+=lowbit(i))
        bit[i]+=delta;
}

int Sum(int x)
{
    int re(0);
    for(int i=x;i>0;i-=lowbit(i))
        re+=bit[i];
    return re;
}

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d",&n)==1 && n)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&r[i].value);
            r[i].id=i;
        }
        sort(r+1,r+n+1,cmp1);
        for(int i=1;i<=n;i++)
            r[i].num=i;
        sort(r+1,r+n+1,cmp2);

        ans=0;
        memset(bit,0,sizeof(bit));
        for(int i=1;i<=n;i++)
        {
            Add(r[i].num,1);
            ans+=i-Sum(r[i].num-1)-1;
        }

        cout<<ans<<endl;
    }

    return 0;
}

lee1r 2011-08-05 23:44 发表评论

POJ 3468 A Simple Problem with Integers

lee1r — Tue, 02 Aug 2011 03:15:00 GMT

线段树，区间增减，区间求和。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/2 10:51:34
* File Name: poj3468.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
typedef long long int64;
typedef unsigned long long uint64;
const int kMaxn(100007);

struct Node
{
    int a,b;
    int64 sum,add;
};

int n,Q,r[kMaxn];
Node tree[kMaxn<<2];

void Build(int node,int x,int y)
{
    tree[node].a=x;
    tree[node].b=y;
    tree[node].add=0;
    if(x==y)
        tree[node].sum=r[x];
    else
    {
        int m(Half(x+y));
        Build(L(node),x,m);
        Build(R(node),m+1,y);
        tree[node].sum=tree[L(node)].sum+tree[R(node)].sum;
    }
}

void Update(int node)
{
    if(tree[node].add)
    {
        tree[L(node)].add+=tree[node].add;
        tree[R(node)].add+=tree[node].add;
        tree[L(node)].sum+=(tree[L(node)].b-tree[L(node)].a+1)*tree[node].add;
        tree[R(node)].sum+=(tree[R(node)].b-tree[R(node)].a+1)*tree[node].add;
        tree[node].add=0;
    }
}

void Add(int node,int x,int y,int delta)
{
    if(x<=tree[node].a && tree[node].b<=y)
    {
        tree[node].add+=delta;
        tree[node].sum+=(tree[node].b-tree[node].a+1)*delta;
    }
    else
    {
        Update(node);
        int m(Half(tree[node].a+tree[node].b));
        if(x<=m)
            Add(L(node),x,y,delta);
        if(y>m)
            Add(R(node),x,y,delta);
        tree[node].sum=tree[L(node)].sum+tree[R(node)].sum;
    }
}

int64 Sum(int node,int x,int y)
{
    if(x<=tree[node].a && tree[node].b<=y)
        return tree[node].sum;
    else
    {
        Update(node);
        int64 re(0);
        int m(Half(tree[node].a+tree[node].b));
        if(x<=m)
            re+=Sum(L(node),x,y);
        if(y>m)
            re+=Sum(R(node),x,y);
        return re;
    }
}

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d%d",&n,&Q)==2)
    {
        for(int i=1;i<=n;i++)
            scanf("%d",&r[i]);

        Build(1,1,n);

        while(Q--)
        {
            string cmd;
            int a,b,c;
            cin>>cmd;
            if(cmd=="C")
            {
                scanf("%d%d%d",&a,&b,&c);
                Add(1,a,b,c);
            }
            else
            {
                scanf("%d%d",&a,&b);
                cout<<Sum(1,a,b)<<endl;
            }
        }
    }

    return 0;
}

lee1r 2011-08-02 11:15 发表评论

HDU 2838 Cow Sorting

lee1r — Tue, 02 Aug 2011 02:23:00 GMT

用三个树状数组维护一下：比a[i]小的数有多少、前i个数之和是多少、比a[i]小的数之和是多少。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/2 9:33:01
* File Name: hdu2838.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define lowbit(x) ((x)&(-(x)))
using namespace std;
typedef long long int64;
typedef unsigned long long uint64;
const int kMaxn(100007);

int n;
int64 ans,bit[kMaxn],bit2[kMaxn],bit3[kMaxn];

void Add(int64 *a,int x,int delta)
{
    for(int i=x;i<=n;i+=lowbit(i))
        a[i]+=delta;
}

int64 Sum(int64 *a,int x)
{
    int64 re(0);
    for(int i=x;i>0;i-=lowbit(i))
        re+=a[i];
    return re;
}

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d",&n)==1)
    {
        ans=0;
        memset(bit,0,sizeof(bit));
        memset(bit2,0,sizeof(bit2));
        memset(bit3,0,sizeof(bit3));

        for(int i=1;i<=n;i++)
        {
            int t;
            scanf("%d",&t);
            Add(bit,t,1);
            Add(bit2,i,t);
            Add(bit3,t,t);
            ans+=(i-Sum(bit,t-1)-1)*t;
            ans+=Sum(bit2,i-1);
            ans-=Sum(bit3,t-1);
        }

        cout<<ans<<endl;
    }

    return 0;
}

lee1r 2011-08-02 10:23 发表评论

HDU 1556 Color the ball

lee1r — Mon, 01 Aug 2011 14:42:00 GMT

树状数组的简单题。
以下是我的代码：

#include<cstdio>
#include<cstring>
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kMaxn(100007);

int n,bit[kMaxn];

void Add(int x,int delta)
{
    for(int i=x;i<=n;i+=lowbit(i))
        bit[i]+=delta;
}

int Value(int x)
{
    int re(0);
    for(int i=x;i>0;i-=lowbit(i))
        re+=bit[i];
    return re;
}

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d",&n)==1 && n)
    {
        memset(bit,0,sizeof(bit));
        for(int i=1;i<=n;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            Add(a,1);
            Add(b+1,-1);
        }

        for(int i=1;i<=n;i++)
        {
            if(i!=1)
                printf(" ");
            printf("%d",Value(i));
        }
        printf("\n");
    }

    return 0;
}

lee1r 2011-08-01 22:42 发表评论

HDU 3333 Turing Tree

lee1r — Mon, 01 Aug 2011 10:36:00 GMT

和HDU 3874类似，只不过数字的范围大了不少，不能直接开数组记录每个数字最后出现的位置，使用map记录。
以下是我的代码：

#include<iostream>
#include<map>
#include<algorithm>
#include<cstdio>
#include<cstring>
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kMaxn(30007);
const int kMaxm(100007);

struct Interval
{
    int a,b;
    int id;
};
bool operator<(const Interval &a,const Interval &b)
{
    return (a.b<b.b);
}

int n,m,r[kMaxn];
Interval query[kMaxm];
long long bit[kMaxn],ans[kMaxm];

void Add(int x,int delta)
{
    for(int i=x;i<=n;i+=lowbit(i))
        bit[i]+=delta;
}

long long Sum(int x)
{
    long long re(0);
    for(int i=x;i>0;i-=lowbit(i))
        re+=bit[i];
    return re;
}

int main()
{
    //freopen("data.in","r",stdin);

    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
            scanf("%d",&r[i]);
        scanf("%d",&m);
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&query[i].a,&query[i].b);
            query[i].id=i;
        }
        //  Input

        sort(query+1,query+m+1);
        memset(bit,0,sizeof(bit));

        map<int,int> pos;
        for(int i=1,j=1;i<=n && j<=m;i++)
        {
            Add(i,r[i]);
            if(pos.count(r[i]))
                Add(pos[r[i]],-r[i]);
            pos[r[i]]=i;

            while(i==query[j].b)
            {
                ans[query[j].id]=Sum(query[j].b)-Sum(query[j].a-1);
                j++;
            }
        }

        for(int i=1;i<=m;i++)
            printf("%I64d\n",ans[i]);
    }

    return 0;
}

lee1r 2011-08-01 18:36 发表评论

HDU 3874 Necklace

lee1r — Mon, 01 Aug 2011 03:56:00 GMT

树状数组的应用。
采用离线算法：先按询问的右端点排序，然后依次把数字插入到树状数组里面，pos[i]记录数字i上一次在数组里面出现的位置，如果i已经出现过，删除之前的，添加到当前的位置。遇到可以处理的询问则处理，同时存储结果。
以下是我的代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kMaxn(50007);
const int kMaxm(200007);
const int kMaxv(1000007);

struct Interval
{
    int a,b;
    int id;
};
bool operator<(const Interval &a,const Interval &b)
{
    return (a.b<b.b);
}

int n,m,r[kMaxn];
Interval query[kMaxm];
long long bit[kMaxn],ans[kMaxm];
int pos[kMaxv];

void Add(int x,int delta)
{
    for(int i=x;i<=n;i+=lowbit(i))
        bit[i]+=delta;
}

long long Sum(int x)
{
    long long re(0);
    for(int i=x;i>0;i-=lowbit(i))
        re+=bit[i];
    return re;
}

int main()
{
    //freopen("data.in","r",stdin);

    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
            scanf("%d",&r[i]);
        scanf("%d",&m);
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&query[i].a,&query[i].b);
            query[i].id=i;
        }

        //  Input

        sort(query+1,query+m+1);
        memset(bit,0,sizeof(bit));
        memset(pos,-1,sizeof(pos));

        for(int i=1,j=1;i<=n && j<=m;i++)
        {
            Add(i,r[i]);
            if(pos[r[i]]!=-1)
                Add(pos[r[i]],-r[i]);
            pos[r[i]]=i;

            while(i==query[j].b)
            {
                ans[query[j].id]=Sum(query[j].b)-Sum(query[j].a-1);
                j++;
            }
        }

        for(int i=1;i<=m;i++)
            printf("%I64d\n",ans[i]);
    }

    return 0;
}

lee1r 2011-08-01 11:56 发表评论

HDU 3584 Cube

lee1r — Mon, 01 Aug 2011 01:57:00 GMT

树状数组更新区间查询点的题目。
以下是我的代码：

#include<cstdio>
#include<cstring>
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kMaxn(107);

int n,m,bit[kMaxn][kMaxn][kMaxn];

void Add(int x,int y,int z,int delta)
{
    for(int i=x;i>0;i-=lowbit(i))
        for(int j=y;j>0;j-=lowbit(j))
            for(int k=z;k>0;k-=lowbit(k))
                bit[i][j][k]+=delta;
}

int Value(int x,int y,int z)
{
    int re(0);
    for(int i=x;i<=n;i+=lowbit(i))
        for(int j=y;j<=n;j+=lowbit(j))
            for(int k=z;k<=n;k+=lowbit(k))
                re+=bit[i][j][k];
    return re;
}

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d%d",&n,&m)==2)
    {
        memset(bit,0,sizeof(bit));

        for(int i=1;i<=m;i++)
        {
            int cmd,x1,y1,z1,x2,y2,z2;
            scanf("%d",&cmd);
            switch(cmd)
            {
                case 1:
                    scanf("%d%d%d%d%d%d",&x1,&y1,&z1,&x2,&y2,&z2);
                    Add(x2,y2,z2,1);
                    Add(x1-1,y2,z2,-1);
                    Add(x2,y1-1,z2,-1);
                    Add(x2,y2,z1-1,-1);
                    Add(x1-1,y1-1,z2,1);
                    Add(x1-1,y2,z1-1,1);
                    Add(x2,y1-1,z1-1,1);
                    Add(x1-1,y1-1,z1-1,-1);
                    break;
                case 0:
                    scanf("%d%d%d",&x1,&y1,&z1);
                    printf("%d\n",Value(x1,y1,z1)%2);
                    break;
            }
        }
    }

    return 0;
}

lee1r 2011-08-01 09:57 发表评论

HDU 3743 Frosh Week

lee1r — Mon, 01 Aug 2011 01:55:00 GMT

树状数组求逆序对的简单应用。
以下是我的代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kMaxn(1000007);

struct Type
{
    int value,num,weight;
};

bool cmp1(const Type &a,const Type &b)
{
    return (a.value<b.value);
}

bool cmp2(const Type &a,const Type &b)
{
    return (a.num<b.num);
}

int n,bit[kMaxn];
Type r[kMaxn];
long long ans;

void Add(int pos,int delta)
{
    for(int i=pos;i<=n;i+=lowbit(i))
        bit[i]+=delta;
}

int Sum(int pos)
{
    int re(0);
    for(int i=pos;i>0;i-=lowbit(i))
        re+=bit[i];
    return re;
}

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d",&n)==1)
    {
        for(int i=1;i<=n;i++)
        {
            r[i].num=i;
            scanf("%d",&r[i].value);
        }
        sort(r+1,r+n+1,cmp1);
        for(int i=1;i<=n;i++)
            r[i].weight=i;
        sort(r+1,r+n+1,cmp2);

        ans=0ll;
        memset(bit,0,sizeof(bit));
        for(int i=1;i<=n;i++)
        {
            ans+=i-Sum(r[i].weight-1)-1;
            Add(r[i].weight,1);
        }

        cout<<ans<<endl;
    }

    return 0;
}

lee1r 2011-08-01 09:55 发表评论

HDU 2689 Sort it

lee1r — Sun, 31 Jul 2011 03:58:00 GMT

序列中有多少个逆序对冒泡排序就需要多少次交换。
以下是我的代码：

#include<cstdio>
#include<cstring>
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kMaxn(1007);

int n,ans,bit[kMaxn];

void Add(int pos,int delta)
{
    for(int i=pos;i<=n;i+=lowbit(i))
        bit[i]+=delta;
}

int Sum(int pos)
{
    int re(0);
    for(int i=pos;i>0;i-=lowbit(i))
        re+=bit[i];
    return re;
}

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d",&n)==1)
    {
        ans=0;
        memset(bit,0,sizeof(bit));

        for(int i=1;i<=n;i++)
        {
            int t;
            scanf("%d",&t);
            Add(t,1);
            ans+=i-Sum(t-1)-1;
        }

        printf("%d\n",ans);
    }

    return 0;
}

lee1r 2011-07-31 11:58 发表评论

HDU 1892 See you~

lee1r — Sun, 31 Jul 2011 02:55:00 GMT

二维树状数组问题。
以下是我的代码：

#include<iostream>
#include<string>
#include<algorithm>
#include<cstdio>
#include<cstring>
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kMaxn(1001);

int bit[kMaxn+7][kMaxn+7],book[kMaxn+7][kMaxn+7];

void Add(int x,int y,int delta)
{
    for(int i=x;i<=kMaxn;i+=lowbit(i))
        for(int j=y;j<=kMaxn;j+=lowbit(j))
            bit[i][j]+=delta;
}

int Sum(int x,int y)
{
    int re(0);
    for(int i=x;i>0;i-=lowbit(i))
        for(int j=y;j>0;j-=lowbit(j))
            re+=bit[i][j];
    return re;
}

int main()
{
    int T;
    scanf("%d",&T);
    for(int case_num=1;case_num<=T;case_num++)
    {
        printf("Case %d:\n",case_num);
        memset(bit,0,sizeof(bit));
        memset(book,0,sizeof(book));

        for(int i=1;i<=kMaxn;i++)
            for(int j=1;j<=kMaxn;j++)
            {
                Add(i,j,1);
                book[i][j]=1;
            }

        int Q;
        scanf("%d",&Q);
        while(Q--)
        {
            string cmd;
            cin>>cmd;
            if(cmd=="S")
            {
                int x1,y1,x2,y2;
                scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
                x1++;y1++;x2++;y2++;
                if(x1>x2)
                    swap(x1,x2);
                if(y1>y2)
                    swap(y1,y2);
                printf("%d\n",Sum(x2,y2)-Sum(x1-1,y2)-Sum(x2,y1-1)+Sum(x1-1,y1-1));
            }
            else if(cmd=="A")
            {
                int x,y,n1;
                scanf("%d%d%d",&x,&y,&n1);
                x++;y++;
                Add(x,y,n1);
                book[x][y]+=n1;
            }
            else if(cmd=="D")
            {
                int x,y,n1;
                scanf("%d%d%d",&x,&y,&n1);
                x++;y++;
                Add(x,y,(book[x][y]-n1<0?-book[x][y]:-n1));
                book[x][y]=(book[x][y]-n1<0?0:book[x][y]-n1);
            }
            else if(cmd=="M")
            {
                int x1,y1,x2,y2,n1;
                scanf("%d%d%d%d%d",&x1,&y1,&x2,&y2,&n1);
                x1++;y1++;x2++;y2++;
                if(book[x1][y1]>n1)
                {
                    Add(x1,y1,-n1);
                    Add(x2,y2,n1);
                    book[x1][y1]-=n1;
                    book[x2][y2]+=n1;
                }
                else
                {
                    Add(x1,y1,-book[x1][y1]);
                    Add(x2,y2,book[x1][y1]);
                    book[x2][y2]+=book[x1][y1];
                    book[x1][y1]=0;
                }
            }
        }
    }

    return 0;
}

lee1r 2011-07-31 10:55 发表评论

HDU 1541 Stars

lee1r — Sun, 31 Jul 2011 02:19:00 GMT

题目已经说明了按Y值递增的顺序给出，Y值相同则按X递增给出。如果不是这样可以先排序，然后用树状数组解决。
以下是我的代码：

#include<cstdio>
#include<cstring>
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kMaxn(15007);
const int kMaxx(32001);

int bit[kMaxx+7],level[kMaxn];

void Add(int pos,int delta)
{
    for(int i=pos;i<=kMaxx;i+=lowbit(i))
        bit[i]+=delta;
}

int Sum(int pos)
{
    int re(0);
    for(int i=pos;i>0;i-=lowbit(i))
        re+=bit[i];
    return re;
}

int main()
{
    int n;
    while(scanf("%d",&n)==1)
    {
        memset(bit,0,sizeof(bit));
        memset(level,0,sizeof(level));

        for(int i=1;i<=n;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            level[Sum(x+1)]++;
            Add(x+1,1);
        }

        for(int i=0;i<n;i++)
            printf("%d\n",level[i]);
    }

    return 0;
}

lee1r 2011-07-31 10:19 发表评论

HDU 2642 Stars

lee1r — Sun, 31 Jul 2011 01:29:00 GMT

二维树状数组的应用。每次在某个点上增加一个值，或是询问某块区域内的和。
以下是我的代码：

#include<iostream>
#include<string>
#include<algorithm>
#include<cstdio>
#include<cstring>
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int n(1001);

int bit[n+7][n+7];
bool bright[n+7][n+7];

void Add(int x,int y,int delta)
{
    for(int i=x;i<=n;i+=lowbit(i))
        for(int j=y;j<=n;j+=lowbit(j))
            bit[i][j]+=delta;
}

int Sum(int x,int y)
{
    int re(0);
    for(int i=x;i>0;i-=lowbit(i))
        for(int j=y;j>0;j-=lowbit(j))
            re+=bit[i][j];
    return re;
}

int main()
{
    memset(bit,0,sizeof(bit));
    memset(bright,false,sizeof(bright));

    int m;
    cin>>m;
    while(m--)
    {
        string cmd;
        cin>>cmd;
        if(cmd=="B")
        {
            int x,y;
            scanf("%d%d",&x,&y);
            x++;y++;
            if(!bright[x][y])
                Add(x,y,1);
            bright[x][y]=true;
        }
        else if(cmd=="D")
        {
            int x,y;
            scanf("%d%d",&x,&y);
            x++;y++;
            if(bright[x][y])
                Add(x,y,-1);
            bright[x][y]=false;
        }
        else if(cmd=="Q")
        {
            int x1,y1,x2,y2;
            scanf("%d%d%d%d",&x1,&x2,&y1,&y2);
            x1++;y1++;x2++;y2++;
            if(x1>x2)
                swap(x1,x2);
            if(y1>y2)
                swap(y1,y2);
            printf("%d\n",Sum(x2,y2)-Sum(x1-1,y2)-Sum(x2,y1-1)+Sum(x1-1,y1-1));
        }
    }

    return 0;
}

lee1r 2011-07-31 09:29 发表评论

HDU 1698 Just a Hook

lee1r — Sun, 31 Jul 2011 01:24:00 GMT

此题AC了不止一次，用线段树和树状数组都实现过。
以下是我的代码：

#include
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)^1)
using namespace std;
const int kMaxn(100007);

struct Node
{
    int a,b,kind,sum;
};

int N,Q;
Node tree[kMaxn<<2];

void Build(int node,int x,int y)
{
    tree[node].a=x;
    tree[node].b=y;
    tree[node].kind=0;
    if(x==y)
        tree[node].sum=1;
    else
    {
        int m((x+y)>>1);
        Build(L(node),x,m);
        Build(R(node),m+1,y);
        tree[node].sum=tree[L(node)].sum+tree[R(node)].sum;
    }
}

void Modify(int node,int x,int y,int z)
{
    if(x<=tree[node].a && tree[node].b<=y)
    {
        tree[node].kind=z;
        tree[node].sum=(tree[node].b-tree[node].a+1)*z;
    }
    else
    {
        if(tree[node].kind)
        {
            tree[L(node)].kind=tree[R(node)].kind=tree[node].kind;
            tree[node].kind=0;
            tree[L(node)].sum=(tree[L(node)].b-tree[L(node)].a+1)*tree[L(node)].kind;
            tree[R(node)].sum=(tree[R(node)].b-tree[R(node)].a+1)*tree[R(node)].kind;
        }
        int m((tree[node].a+tree[node].b)>>1);
        if(x<=m)
            Modify(L(node),x,y,z);
        if(m+1<=y)
            Modify(R(node),x,y,z);
        tree[node].sum=tree[L(node)].sum+tree[R(node)].sum;
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    for(int case_num=1;case_num<=T;case_num++)
    {
        scanf("%d%d",&N,&Q);

        Build(1,1,N);

        while(Q--)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            Modify(1,x,y,z);
        }

        printf("Case %d: The total value of the hook is %d.\n",case_num,tree[1].sum);
    }

    return 0;
}

lee1r 2011-07-31 09:24 发表评论

HDU 1166 敌兵布阵

lee1r — Sun, 31 Jul 2011 01:22:00 GMT

此题是第三次AC了。第一次高二的时候刚开始学线段树，然后前端时间复习线段树，然后就是这次用树状数组实现。
以下是我的代码：

#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#define lowbit(x) ((x)&(-(x))) // 2^k
using namespace std;
const int kMaxn(50007);

int n,bit[kMaxn];

void Add(int pos,int delta)
{
    while(pos<=n)
    {
        bit[pos]+=delta;
        pos+=lowbit(pos);
    }
}

int Sum(int pos)
{
    int re(0);
    while(pos>0)
    {
        re+=bit[pos];
        pos-=lowbit(pos);
    }
    return re;
}

int main()
{
    int T;
    scanf("%d",&T);
    for(int case_num=1;case_num<=T;case_num++)
    {
        scanf("%d",&n);
        memset(bit,0,sizeof(bit));
        for(int i=1;i<=n;i++)
        {
            int t;
            scanf("%d",&t);
            Add(i,t);
        }
        printf("Case %d:\n",case_num);
        string cmd;
        while(cin>>cmd && cmd!="End")
        {
            if(cmd=="Add")
            {
                int a,b;
                scanf("%d%d",&a,&b);
                Add(a,b);
            }
            else if(cmd=="Sub")
            {
                int a,b;
                scanf("%d%d",&a,&b);
                Add(a,-b);
            }
            else if(cmd=="Query")
            {
                int a,b;
                scanf("%d%d",&a,&b);
                printf("%d\n",Sum(b)-Sum(a-1));
            }
        }
    }

    return 0;
}

lee1r 2011-07-31 09:22 发表评论

UVa 10132 File Fragmentation

lee1r — Fri, 20 May 2011 07:44:00 GMT

题目大意：一些相同的01串被打碎成两半，现在给出这些打碎了之后的串，要求求出原串。
首先，原串的长度一定是打碎了之后的串中最长的长度加上最短的长度。设打碎之后的串中最长串组成集合S，最短串组成集合T，那么原串肯定为ST或TS中的某种。由于S、T中元素个数必定小于等于2，所以可能的结果最多只有8种。枚举这8种结果，然后检测是否符合要求即可。
检测的时候，对于某个长度为L的串，要快速检索到长度为（maxlength+minlength-L）的串，使用multimap可以很方便地做到。
以下是我的代码：

#include<iostream>
#include<vector>
#include<string>
#include<map>
#include<algorithm>
#include<cstdio>
using namespace std;

bool cmp(const string &a,const string &b)
{
    return (a.size()<b.size() ||(a.size()==b.size() && a<b));
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif

    int T;
    cin>>T;
    cin.get();
    cin.get();
    bool first(true);
    while(T--)
    {
        int minl(0x7f7f7f7f),maxl(0);
        vector<string> a;
        string t;
        while(getline(cin,t) && !t.empty())
        {
            a.push_back(t);
            minl=min(minl,(int)(t.size()));
            maxl=max(maxl,(int)(t.size()));
        }

        sort(a.begin(),a.end(),cmp);
        a.erase(unique(a.begin(),a.end()),a.end());

        multimap<int,string> r;
        for(int i=0;i<a.size();i++)
            r.insert(make_pair(a[i].size(),a[i]));

        string ans;
        multimap<int,string>::iterator
            ibegin=r.begin(),
            iend=r.upper_bound(minl),
            jend=r.end(),
            jbegin=r.lower_bound(maxl);
        for(multimap<int,string>::iterator i=ibegin;i!=iend;i++)
            for(multimap<int,string>::iterator j=jbegin;j!=jend;j++)
            {
                string now(i->second+j->second);
                bool success(true);
                for(multimap<int,string>::iterator k=r.begin();k!=r.end();k++)
                {
                    multimap<int,string>::iterator
                        pbegin=r.lower_bound(minl+maxl-k->first),
                        pend=r.upper_bound(minl+maxl-k->first);
                    bool can(false);
                    for(multimap<int,string>::iterator l=pbegin;l!=pend;l++)
                    {
                        if(k->second+l->second==now || l->second+k->second==now)
                            can=true;
                    }
                    if(!can)
                    {
                        success=false;
                        break;
                    }
                }
                if(success)
                    ans=now;

                now=j->second+i->second;
                success=true;
                for(multimap<int,string>::iterator k=r.begin();k!=r.end();k++)
                {
                    multimap<int,string>::iterator
                        pbegin=r.lower_bound(minl+maxl-k->first),
                        pend=r.upper_bound(minl+maxl-k->first);
                    bool can(false);
                    for(multimap<int,string>::iterator l=pbegin;l!=pend;l++)
                    {
                        if(k->second+l->second==now || l->second+k->second==now)
                            can=true;
                    }
                    if(!can)
                    {
                        success=false;
                        break;
                    }
                }
                if(success)
                    ans=now;
            }

        if(first)
            first=false;
        else
            cout<<endl;
        cout<<ans<<endl;
    }

    return 0;
}

lee1r 2011-05-20 15:44 发表评论

UVa 10763 Foreign Exchange

lee1r — Mon, 16 May 2011 09:29:00 GMT

题目大意：给出一些整数对(a,b)，判断是否每个(a,b)都有(b,a)与之配对。
使用map即可快速地查找。
以下是我的代码：

#include<map>
#include<cstdio>
using namespace std;

struct Type
{
    Type(int a,int b):a_(a),b_(b) {}
    int a_,b_;
};
bool operator<(const Type &a,const Type &b)
{
    return (a.a_<b.a_ || (a.a_==b.a_ && a.b_<b.b_));
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif

    int n;
    while(scanf("%d",&n)==1 && n)
    {
        map<Type,int> r;
        for(int i=1;i<=n;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            r[Type(a,b)]++;
        }

        bool success(true);
        for(map<Type,int>::iterator i=r.begin();i!=r.end();i++)
        {
            int a(i->first.a_),b(i->first.b_);
            if(i->second!=r[Type(b,a)])
            {
                success=false;
                break;
            }
        }

        if(success)
            printf("YES\n");
        else
            printf("NO\n");
    }

    return 0;
}

lee1r 2011-05-16 17:29 发表评论

UVa 141 The Spot Game

lee1r — Mon, 09 May 2011 03:40:00 GMT

题目大意是：在一个n×n棋盘上不断执行加入棋子或移除棋子的操作，判断在哪一步出现了之前出现过的局面（通过旋转可以得到的认为是同一个局面）。
用一个set来存储已经出现过的局面，每次得到一个新局面，把这个新局面的各种旋转一起加入到set中。
以下是我的代码：

#include<set>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(57);

int n;

struct Type
{
    bool r[kMaxn][kMaxn];
};
bool operator<(const Type &a,const Type &b)
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(a.r[i][j]<b.r[i][j])
                return true;
            else if(a.r[i][j]>b.r[i][j])
                return false;
    return false;
}

void rotate(Type &x)
{
    Type t;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            t.r[j][n-i+1]=x.r[i][j];
    x=t;
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif

    while(scanf("%d",&n)==1 && n)
    {
        int ans(-1);
        Type g;
        set<Type> used;
        memset(g.r,false,kMaxn*kMaxn*sizeof(bool));

        for(int i=1;i<=2*n;i++)
        {
            int x,y;
            char ch;
            scanf("%d%d %c",&x,&y,&ch);
            if(ans!=-1)
                continue;
            if(ch=='+')
                g.r[x][y]=true;
            else
                g.r[x][y]=false;
            if(used.count(g))
            {
                ans=i;
                continue;
            }
            Type t(g);
            for(int j=1;j<=4;j++)
            {
                used.insert(t);
                rotate(t);
            }
        }

        if(ans==-1)
            printf("Draw\n");
        else if(ans&1)
            printf("Player 2 wins on move %d\n",ans);
        else
            printf("Player 1 wins on move %d\n",ans);
    }

    return 0;
}

lee1r 2011-05-09 11:40 发表评论

UVa 673 Parentheses Balance

lee1r — Thu, 14 Apr 2011 10:58:00 GMT

和上午做的某一题类似，比那一题还简单点。不过我却犯了同样的错误！
最终成功的条件不仅是没有遇到匹配失误，栈还必须为空！
以下是我的代码：

#include<iostream>
#include<stack>
#include<string>
#include<cstdio>
using namespace std;

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int n;
    cin>>n;
    cin.get();
    for(int i=1;i<=n;i++)
    {
        string t;
        getline(cin,t);

        stack<char> s;
        bool fail(false);
        for(int j=0;j<t.size();j++)
            if(t[j]=='(' || t[j]=='[')
                s.push(t[j]);
            else if(t[j]==')')
            {
                if(s.empty() || s.top()!='(')
                {
                    fail=true;
                    break;
                }
                else
                    s.pop();
            }
            else if(t[j]==']')
            {
                if(s.empty() || s.top()!='[')
                {
                    fail=true;
                    break;
                }
                else
                    s.pop();
            }

        if(!fail && s.empty())
            cout<<"Yes"<<endl;
        else
            cout<<"No"<<endl;
    }

    return 0;
}

lee1r 2011-04-14 18:58 发表评论

UVa 540 Team Queue

lee1r — Thu, 14 Apr 2011 08:41:00 GMT

思路相当简单，主要在于实现！
team[i]表示编号为i的人所在的队；
last[i]表示第i个队的、在队列中最靠后的人的位置。
这样一来，就需要支持快速插入和删除的数据结构：链表。
正在我苦恼不知道如何用list::iterator、insert和pop_front处理的时候，郁闷难道还要自己实现链表的时候，我翻翻书，发现insert是有返回值的函数，这样就OK了。
依然不晓得迭代器如何像指针赋值NULL一样表示无效，另外开了一个list，无效则指向这个list的end()。
以下是我的代码：

#include<list>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(1007);
const char kEnqueue[]="ENQUEUE";
const char kDequeue[]="DEQUEUE";
const char kStop[]="STOP";

int team[1000000];

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int T(0),n;
    while(scanf("%d",&n)==1 && n)
    {
        for(int i=1;i<=n;i++)
        {
            int t;
            scanf("%d",&t);
            for(int j=1;j<=t;j++)
            {
                int t2;
                scanf("%d",&t2);
                team[t2]=i;
            }
        }

        T++;
        printf("Scenario #%d\n",T);

        list<int> l,lt;
        list<int>::iterator last[kMaxn];
        for(int i=1;i<=n;i++)
            last[i]=lt.end();

        char cmd[17];
        while(scanf("%s",cmd) && strcmp(cmd,kStop))
        {
            if(strcmp(cmd,kEnqueue)==0)
            {
                int t;
                scanf("%d",&t);
                if(last[team[t]]==lt.end())
                    last[team[t]]=l.insert(l.end(),t);
                else
                {
                    last[team[t]]++;
                    last[team[t]]=l.insert(last[team[t]],t);
                }
            }
            else
            {
                int t(l.front());
                printf("%d\n",t);
                list<int>::iterator ti(l.begin());
                if(ti==last[team[t]])
                    last[team[t]]=lt.end();
                l.pop_front();
            }
        }
        printf("\n");
    }

    return 0;
}

lee1r 2011-04-14 16:41 发表评论

UVa 127 "Accordian" Patience

lee1r — Thu, 14 Apr 2011 03:37:00 GMT

不断地去寻找有没有可以移动的牌，直到不能移动。
以下是我的代码：

#include<iostream>
#include<string>
#include<stack>
#include<cstdio>
using namespace std;
const int kMaxn(57);

bool Match(const string &a,const string &b)
{
    return (a[0]==b[0] || a[1]==b[1]);
}

stack<string> s[kMaxn];

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int n(0);
    string t;
    while(cin>>t && t!="#")
    {
        s[n].push(t);
        n++;
        if(n>=52)
        {
            while(true)
            {
                int pos,sign;
                for(pos=0;pos<n;pos++)
                {
                    if(pos>=3 && Match(s[pos].top(),s[pos-3].top()))
                    {
                        sign=1;
                        break;
                    }
                    if(pos>=1 && Match(s[pos].top(),s[pos-1].top()))
                    {
                        sign=2;
                        break;
                    }
                }
                if(pos==n)
                    break;
                if(sign==1)
                    s[pos-3].push(s[pos].top());
                else
                    s[pos-1].push(s[pos].top());
                s[pos].pop();
                if(s[pos].empty())
                {
                    for(int i=pos;i<n-1;i++)
                        s[i]=s[i+1];
                    while(!s[n-1].empty())
                        s[n-1].pop();
                    n--;
                }
            }

            cout<<n;
            cout<<" pile";
            if(n>1)
                cout<<"s";
            cout<<" remaining:";
            for(int i=0;i<n;i++)
                cout<<" "<<s[i].size();
            cout<<endl;

            for(int i=0;i<n;i++)
                while(!s[i].empty())
                    s[i].pop();
            n=0;
        }
    }

    return 0;
}

lee1r 2011-04-14 11:37 发表评论

UVa 11111 Generalized Matrioshkas

lee1r — Thu, 14 Apr 2011 02:38:00 GMT

算法并不难，是需要用到栈就行了，一个元素记录两个值：自身的大小和剩余的容量。
当遇到一个负数的时候，如果当前栈顶元素可以容纳，直接压入栈中，否则则失败；
当遇到一个正数的时候，和栈顶元素比较，相加为0的话，弹出栈顶元素，同时修改当前栈顶元素的剩余容量，相加不为0，则失败。
注意：最终如果成功的话，栈应该为空。
以下是我的代码：

#include<iostream>
#include<sstream>
#include<string>
#include<stack>
#include<cstdio>
using namespace std;

struct Type
{
    Type(const int &a,const int &b):size_(a),capacity_(b) {}
    int size_,capacity_;
};

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    string line;
    while(getline(cin,line))
    {
        istringstream sin(line);
        stack<Type> s;
        bool success(true);
        int t;
        while(sin>>t)
        {
            if(t<0)
            {
                if(s.empty())
                    s.push(Type(t,t));
                else
                {
                    if(s.top().capacity_<t)
                        s.push(Type(t,t));
                    else
                    {
                        success=false;
                        break;
                    }
                }
            }
            else
            {
                if(s.empty())
                {
                    success=false;
                    break;
                }
                else
                {
                    if(s.top().size_+t!=0)
                    {
                        success=false;
                        break;
                    }
                    else
                    {
                        s.pop();
                        if(!s.empty())
                            s.top().capacity_+=t;
                    }
                }
            }
            /*
            stack st(s);
            while(!st.empty())
            {
                cout<                st.pop();
            }
            cout<            //*/
        }

        if(success && s.empty())
            cout<<":-) Matrioshka!"<<endl;
        else
            cout<<":-( Try again."<<endl;
    }

    return 0;
}

lee1r 2011-04-14 10:38 发表评论

UVa 133 The Dole Queue

lee1r — Wed, 13 Apr 2011 12:46:00 GMT

被这道水题郁闷了好久，就像脑子转不过来一样，大致思路有，但是一直不懂得如何实现。
Last(x)表示顺时针方向x位置的上一个有效位置；
Next(x)表示顺时针方向x位置的下一个有效位置（x位置的数字允许已经被删除）；
下面的代码中，即使只剩下一个元素也允许调用Last(x)、Next(x)，因为此时x位置的数字已经删除，Last(x)、Next(x)将返回仅剩的一个元素的位置；但是不存在元素的时候要及时break循环，否则调用Last(x)、Next(x)会死循环。最初就是这点没有反应过来，写了许多if来判断各种情况，越写越复杂。
以下是我的代码：

#include<cstdio>
using namespace std;
const int kMaxn(27);

int n,k,m,cnt;
int r[kMaxn];
bool sign[kMaxn];

int Last(int pos)
{
    int i(pos-1);
    if(i<1)
        i=n;
    while(!r[i])
    {
        i--;
        if(i<1)
            i=n;
    }
    return i;
}
int Next(int pos)
{
    int i(pos+1);
    if(i>n)
        i=1;
    while(!r[i])
    {
        i++;
        if(i>n)
            i=1;
    }
    return i;
}

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    while(scanf("%d%d%d",&n,&k,&m)==3 && (n || k ||m))
    {
        for(int i=1;i<=n;i++)
        {
            r[i]=i;
            sign[i]=false;
        }

        int i(n),j(1),ans[kMaxn];
        cnt=0;
        while(true)
        {
            for(int v=1;v<=k;v++)
                i=Next(i);
            for(int v=1;v<=m;v++)
                j=Last(j);
            if(i==j)
            {
                cnt++;
                ans[cnt]=r[i];
                if(cnt<n)
                    sign[cnt]=true;
                if(cnt>=n)
                    break;
                r[i]=0;
                i=Last(i);
                j=Next(j);
            }
            else
            {
                cnt++;
                ans[cnt]=r[i];
                cnt++;
                ans[cnt]=r[j];
                if(cnt<n)
                    sign[cnt]=true;
                if(cnt>=n)
                    break;
                r[i]=r[j]=0;
                i=Last(i);
                j=Next(j);
            }
        }

        for(int i=1;i<=n;i++)
        {
            printf("%3d",ans[i]);
            if(sign[i])
                printf(",");
        }
        printf("\n");
    }

    return 0;
}

lee1r 2011-04-13 20:46 发表评论

UVa 11234 Expressions

lee1r — Wed, 13 Apr 2011 04:06:00 GMT

题目要求重新写出给出的后缀表达式，使原后缀表达式的栈方法和新表达式的队列方法表示的表达式相同，也就是两种表达式对应的表达式树相等。
仔细想想表达式树和队列的结构，可以发现，输出为表达式树按层次遍历得到的序列的逆序。
以下是我的代码：

#include<stack>
#include<queue>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxl(10007);

struct Node
{
    int father,left,right;
};

char r[kMaxl];
Node tree[kMaxl];
int ans[kMaxl];

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%s",r);

        int n(strlen(r));
        stack<int> s;
        memset(tree,-1,kMaxl*sizeof(Node));
        for(int i=0;i<n;i++)
        {
            if(r[i]>='a' && r[i]<='z')
                s.push(i);
            else
            {
                int x,y;
                y=s.top();
                s.pop();
                x=s.top();
                s.pop();
                tree[i].left=x;
                tree[i].right=y;
                tree[x].father=tree[y].father=i;
                s.push(i);
            }
        }

        /*
        for(int i=0;i            printf("%d %d %d\n",tree[i].father,tree[i].left,tree[i].right);
        //*/

        int root;
        for(int i=0;i<n;i++)
            if(tree[i].father==-1)
            {
                root=i;
                break;
            }
        queue<int> q;
        int len=0;
        memset(ans,0,kMaxl*sizeof(int));
        q.push(root);
        while(!q.empty())
        {
            int t(q.front());
            q.pop();
            ans[len++]=t;
            if(tree[t].left!=-1)
                q.push(tree[t].left);
            if(tree[t].right!=-1)
                q.push(tree[t].right);
        }
        for(int i=len-1;i>=0;i--)
            printf("%c",r[ans[i]]);
        printf("\n");
    }

    return 0;
}

lee1r 2011-04-13 12:06 发表评论

UVa 442 Matrix Chain Multiplication

lee1r — Tue, 12 Apr 2011 14:34:00 GMT

用栈，每次遇到右括号就把从左括号到右括号之间的部分全部计算。要在读取字符串的时候左边加一个左括号，右边加一个右括号（一开始没有这么做依然AC了，数据太弱了）。
以下是我的代码：

#include<iostream>
#include<string>
#include<stack>
#include<cstdio>
using namespace std;
const int kMaxn(27);

struct Type
{
    Type():a(0),b(0) {}
    Type(int aa,int bb):a(aa),b(bb) {}
    int a,b;
};
bool operator!=(const Type &a,const Type &b)
{
    return (a.a!=b.a || a.b!=b.b);
}

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int n;
    cin>>n;
    Type r[kMaxn];
    for(int i=1;i<=n;i++)
    {
        char ch;
        int x,y;
        cin>>ch>>x>>y;
        r[ch-'A'].a=x;
        r[ch-'A'].b=y;
    }

    string s;
    while(cin>>s)
    {
        s.insert(0,"(");
        s.append(")");
        stack<Type> q;
        int ans(0);
        bool success(true);
        for(int i=0;i<s.size();i++)
        {
            if(s[i]=='(')
                q.push(Type(-1,0));
            else if(s[i]==')')
            {
                Type t;
                if(!q.empty() && q.top()!=Type(-1,0))
                {
                    t.a=q.top().a;
                    t.b=q.top().b;
                }
                while(!q.empty() && q.top()!=Type(-1,0))
                {
                    q.pop();
                    if(!q.empty() && q.top()!=Type(-1,0))
                    {
                        if(q.top().b!=t.a)
                        {
                            success=false;
                            break;
                        }
                        else
                        {
                            ans+=q.top().a*q.top().b*t.b;
                            t.a=q.top().a;
                        }
                    }
                }
                q.pop();
                q.push(t);
            }
            else
                q.push(Type(r[s[i]-'A'].a,r[s[i]-'A'].b));
        }
        if(success)
            cout<<ans<<endl;
        else
            cout<<"error"<<endl;
    }

    return 0;
}

lee1r 2011-04-12 22:34 发表评论

UVa 10420 List of Conquests

lee1r — Fri, 08 Apr 2011 15:35:00 GMT

女孩们的名字没有什么用，用map对象记录每个国家出现的次数即可。
以下是我的代码：

#include<iostream>
#include<string>
#include<map>
#include<cstdio>
using namespace std;
const int kMaxn(2007);

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int n;
    cin>>n;
    map<string,int> r;
    for(int i=1;i<=n;i++)
    {
        string country,t;
        cin>>country;
        r[country]++;
        getchar();
        getline(cin,t);
    }

    for(map<string,int>::iterator i=r.begin();i!=r.end();i++)
        cout<<i->first<<" "<<i->second<<endl;

    return 0;
}

lee1r 2011-04-08 23:35 发表评论

UVa 644 Immediate Decodability

lee1r — Thu, 07 Apr 2011 12:07:00 GMT

题目没有给出具体的规模，因此没有用枚举。我的做法是维护一棵Trie，把01串按长度从大到小的次序插入，这样就可以在插入时判断是否为之前某个长度更大串的前缀。尽管如此，依然用了0.408s的时间，可能与用cin/cout输入输出有关。
以下是我的代码：

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cstdio>
using namespace std;
const int kMaxn(10007);

bool cmp(const string &sa,const string &sb)
{
    return (sa.size()>sb.size() || (sa.size()==sb.size() && sa<sb));
}

struct TreeNode
{
    TreeNode():left_(NULL),right_(NULL) {}

    TreeNode *left_,*right_;
};
class Trie
{
    public:
        Trie()
        {
            father_=new TreeNode;
        }
        bool Insert(const string &s)
        {
            bool re(false);
            TreeNode *p(father_);
            for(int i=0;i<s.size();i++)
            {
                if(s[i]=='0' && !p->left_)
                {
                    p->left_=new TreeNode;
                    if(i==s.size()-1)
                        re=true;
                }
                else if(s[i]=='1' && !p->right_)
                {
                    p->right_=new TreeNode;
                    if(i==s.size()-1)
                        re=true;
                }
                if(s[i]=='0')
                    p=p->left_;
                else
                    p=p->right_;
            }
            return re;
        }

    private:
        TreeNode *father_;
};

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int T(0);
    string t;
    while(cin>>t)
    {
        vector<string> r;
        while(t!="9")
        {
            r.push_back(t);
            cin>>t;
        }

        sort(r.begin(),r.end(),cmp);
        Trie trie;
        bool success(true);
        for(vector<string>::iterator i=r.begin();i!=r.end();i++)
            if(!trie.Insert(*i))
            {
                success=false;
                break;
            }

        T++;
        if(success)
            cout<<"Set "<<T<<" is immediately decodable"<<endl;
        else cout<<"Set "<<T<<" is not immediately decodable"<<endl;
    }

    return 0;
}

lee1r 2011-04-07 20:07 发表评论

HDU 1247 Hat’s Words

lee1r — Sun, 06 Mar 2011 11:13:00 GMT

是题目没有说清楚，还是我E文不够好？一开始以为组成一个单词的两个部分不能相同，后来删除这个检测之后AC了。
很简单，枚举每个单词分成哪两个部分，看着两个单词在不在字典中。
具体做法，使用STL中的set即可。
以下是我的代码：

#include<iostream>
#include<string>
#include<vector>
#include<set>
#include<algorithm>
#include<cstdio>
using namespace std;

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    set<string> words_set;
    string s;
    while(cin>>s)
        words_set.insert(s);

    vector<string> ans;
    for(set<string>::const_iterator i=words_set.begin();i!=words_set.end();i++)
    {
        string t(*i);
        for(int pos=1;pos<t.size();pos++)
        {
            string part1(t.begin(),t.begin()+pos);
            if(!words_set.count(part1))
                continue;
            string part2(t.begin()+pos,t.end());
            if(!words_set.count(part2))
                continue;
            ans.push_back(t);
            break;
        }
    }
    sort(ans.begin(),ans.end());

    for(vector<string>::const_iterator i=ans.begin();i!=ans.end();i++)
        cout<<*i<<endl;

return 0;
}

lee1r 2011-03-06 19:13 发表评论