树状数组题目---HDU 1541 stars 及其变形（降维思想）

1. HDU1541  Stars

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1541

题意：大概就是计算每颗星星左下方包括了多少颗星星，这个数值就是level。左下边不包括本身，不超过本身的x，y的坐标，可以等于。问每种level有多少颗星星。

题解：

这里用到一个降维的思想就是，我们可以先对这些点在进行双关键字排序，保证其有序性后，我们就只需要考虑一个维度即可。

这这里，题目已经给出星星的排列顺序是y为第一关键字升序，x为第二关键字升序。所以可以只考虑第二关键字，依次加入树状数组，每个点左下方的点就是当前树状数组中已经加入的点数之和。为什么？因为排序保证了在当前点加入的点一定是左下方的点。第一关键字此时相当于是自然有序的，肯定的，因为已经排过序了。

此题还可以有许多变形，比如求左上方，右上方，等。。。还可以将其他问题转化为坐标来求解。

还有注意树状数组中的点必须从1开始，不然会造成死循环。坐标不满足从一开始时，可以增加一偏移量。

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int MAX=32000+5;
typedef long long LL;
int bit[MAX];
int level[MAX];
int N=32001;
int sum(int x)
{
    int sum=0;
    while(x>0)
    {
        sum+=bit[x];
        x-=(x&(-x));
    }
    return sum;
}
void add(int x,int v)
{
    while(x<=N)
    {
        bit[x]+=v;
        x+=(x&(-x));
    }
}
int main()
{
    int n;
    while(scanf("%d",&n)==1)
    {
        memset(bit,0,sizeof(bit));
        memset(level,0,sizeof(level));
        for(int i=0;i<n;i++)
        {
            int x,y;
            scanf(" %d %d",&x,&y);
            level[sum(++x)]++;
            add(x,1);
        }
        for(int i=0;i<n;i++)
            printf("%d\n",level[i]);
    }
    return 0;
}

2. POJ 2481 Cows

题目链接：http://poj.org/problem?id=2481

题意：FJ有n头牛(编号为1~n)，每一头牛都有一个测验值[S, E]，如果对于牛i和牛j来说，它们的测验值满足下面的条件则证明牛i比牛j强壮：Si <= Sj and Ej <= Ei and Ei - Si > Ej - Sj。现在已知每一头牛的测验值，要求输出每头牛有几头牛比其强壮。

题解：其实就是在求每个区间的覆盖了多少个其他的区间，可以端点相等，但是不能两个端点全部相等。

可以转换成上一道题的模型，区间的起点和终点看成两个坐标，那么在区间【x，y】内的区间就是横坐标比x大，纵坐标比y小的点，也就是在右下方的点。这下就和上一道题一样了。

只需要排序规则变为x升序，y降序（两者顺序其实是无所谓的）即可。

此题没有保证没有重点，所以排序后用一个数组来记录每个点前面的重点，计算sum值的时候去点重点就行。

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
using namespace std;
const int MAX=1e5+5;
const int INF=0x3f3f3f3f;
typedef long long LL;
int ans[MAX],equ[MAX];
int bit[MAX];
int N;
struct node
{
    int x,y,pos;
    node(int _x = 0 , int _y = 0,int _pos=0):x(_x),y(_y),pos(_pos){};
    bool operator <(const node &a) const
    {
        return y>a.y||(y==a.y&&x<a.x);
    }
};
node a[MAX];
int sum(int x)
{
    int s=0;
    while(x>0)
    {
        s+=bit[x];
        x-=(x&(-x));
    }
    return s;
}
void add(int x,int v)
{
    while(x<=N)
    {
        bit[x]+=v;
        x+=(x&(-x));
    }
}
int main()
{
    int n;
    while(scanf("%d",&n)&&n)
    {
        N=0;
        memset(bit,0,sizeof(bit));
        for(int i=0;i<n;i++)
        {
            a[i].pos=i;
            scanf("%d%d",&a[i].x,&a[i].y);
            a[i].x++;a[i].y++;
            N=max(N,a[i].x);
            N=max(N,a[i].y);
        }
        sort(a,a+n);
        for(int i=1;i<n;i++)
        {
            if(a[i].x==a[i-1].x&&a[i].y==a[i-1].y) equ[i]=equ[i-1]+1;
            else equ[i]=0;
        }
        for(int i=0;i<n;i++)
        {
            ans[a[i].pos]=sum(a[i].x)-equ[i];
            add(a[i].x,1);
        }
        for(int i=0;i<n;i++)
        {
            printf("%d%c",ans[i],i==n-1?'\n':' ');
        }
    }
    return 0;
}

3. POJ 3067 Japan

题目链接：http://poj.org/problem?id=3067

题意：左边有n个城市，右边有m个城市，建k条道路，问有这k条道路中有多少个交点。起点和终点相同不算相交。

题解：可以想到两条边交叉的条件就是，起点和终点的大小关系相反，即与(ni，mi)相交的边满足（x，y）（x<=ni,y>=mi或x>=ni,y<=mi）。其实看成坐标的话也就是左上角或者右下角的点。

所以，对该数组先按 x 从小到大排序，若 x 相等，则按 y 从小到大排序。

从前往后扫描各条高速公路，对路（xi,yi）其与前面点的交点数目为其左上角路的个数，即所有的(xj,yj),其中xj<xi,yj>yi.

咦？这个排序规则怎么和前面的有点不一样。不应该两个关键字顺序相反？

因为这里起点或终点相同是不计数的。所以考虑下面一种情况：

（1,4）（2,2）（2,3）（2,4）（3,1）（4,2）

我们按照x升序，y降序排序的话就是（1,4）（2,4）（2,3）（2,2）（3,1）（4,2），我们在对（2,3）计数的（2,4）被计算了进去，so，被错误地多计了一次。

从这里可以看出其实第二关键字的顺序是无所谓的因为用树状数组我可以计比他小数sum（a[i]-1），也可以计比他大的数sum(N)-sum(a[i])。

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
using namespace std;
const int MAX=1000+5;
typedef long long LL;
struct node
{
    int x,y;
    bool  operator <(const node & a) const
    {
        return x<a.x||(x==a.x&&y<a.y);
    }
};
node a[MAX*MAX];
int bit[MAX];
int N,M;
LL sum(int x)
{
    LL s=0;
    while(x>0)
    {
        s+=bit[x];
        x-=(x&(-x));
    }
    return s;
}
void add(int x)
{
    while(x<=M)
    {
        bit[x]++;
        x+=(x&(-x));
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    for(int tcase=1;tcase<=T;tcase++)
    {
        int k;
        scanf("%d%d%d",&N,&M,&k);
        for(int i=0;i<k;i++)
        {
            scanf("%d%d",&a[i].x,&a[i].y);
        }
        sort(a,a+k);
        memset(bit,0,sizeof(bit));
        LL ans=0;
        for(int i=0;i<k;i++)
        {
            ans=ans+(i-sum(a[i].y));
            add(a[i].y);
        }
        printf("Test case %d: ",tcase);
        cout<<ans<<endl;
    }
    return 0;
}