POJ 1990 树状数组

MooFest

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 5269		Accepted: 2274

Description

Every year, Farmer John's N (1 <= N <= 20,000) cows attend "MooFest",a social gathering of cows from around the world. MooFest involves a variety of events including haybale stacking, fence jumping, pin the tail on the farmer, and of course, mooing. When the cows all stand in line for a particular event, they moo so loudly that the roar is practically deafening. After participating in this event year after year, some of the cows have in fact lost a bit of their hearing.

Each cow i has an associated "hearing" threshold v(i) (in the range 1..20,000). If a cow moos to cow i, she must use a volume of at least v(i) times the distance between the two cows in order to be heard by cow i. If two cows i and j wish to converse, they must speak at a volume level equal to the distance between them times max(v(i),v(j)).

Suppose each of the N cows is standing in a straight line (each cow at some unique x coordinate in the range 1..20,000), and every pair of cows is carrying on a conversation using the smallest possible volume.

Compute the sum of all the volumes produced by all N(N-1)/2 pairs of mooing cows.

Input

* Line 1: A single integer, N

* Lines 2..N+1: Two integers: the volume threshold and x coordinate for a cow. Line 2 represents the first cow; line 3 represents the second cow; and so on. No two cows will stand at the same location.

Output

* Line 1: A single line with a single integer that is the sum of all the volumes of the conversing cows.

Sample Input

4
3 1
2 5
2 6
4 3

Sample Output

57

Source

USACO 2004 U S Open

题意：在一维坐标上有若干奶牛，每个奶牛有一个坐标属性coor和听力值v，如果两只奶牛i, j想要通话，两只奶牛就会发出max(vi, vj)*abs(coori-coorj)，问奶牛两两能互相通话将要发出的声音总和。

n^2的暴力会超时，考虑如果能先将奶牛按听力属性排序，每次查询听力小于等于它的奶牛（假设有n头），那么这次通话产生的声音就等于该头奶牛的坐标coor乘以n减去坐标比它小的奶牛的坐标和，再加上比它大的奶牛（假设有m头）的坐标和减去coor乘上m。

维护两个树状数组C1, C2，一个记录声音<=Vi小的奶牛个数，一个记录坐标比coori小的奶牛个数，就能实现。

代码：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<vector>

using namespace std;

# pragma comment (linker,"/STACK:16777216")

const int MAXN = 20010;
const int INF = 2100000000;

int c1[MAXN*4], c2[MAXN*4];//c1存坐标，C2存个数；
int n;
int maxn;
class Node
{
  public:
  int coor, v;
};
Node node[MAXN];
inline bool operator < (Node a, Node b)
{
    return a.v < b.v;
}

int lowbit(int x)
{
    return x&(-x);
}
void update1(int x, int val)
{
    while(x <= maxn)
    {
        c1[x] += val;
        x += lowbit(x);
    }
}
void update2(int x)
{
    while(x <= maxn)
    {
        c2[x] += 1;
        x += lowbit(x);
    }
}
long long getSum1(int x)
{
    int res = 0;
    while(x > 0)
    {
        res += c1[x];
        x -= lowbit(x);
    }
    return res;
}
long long getSum2(int x)
{
    int res = 0;
    while(x > 0)
    {
        res += c2[x];
        x -= lowbit(x);
    }
    return res;
}
int main()
{
   //freopen("C:/Users/zts/Desktop/in.txt", "r", stdin);
   while(cin >> n)
   {
       maxn = 0;
       memset(c1, 0, sizeof(c1));
       memset(c2, 0, sizeof(c2));
       for(int i = 1; i <= n; i++)
       {
           cin >> node[i].v >> node[i].coor;
           maxn = max(maxn, node[i].coor);
       }

       sort(node+1, node+1+n);

       long long ans = 0;
       for(int i = 1; i <= n; i++)
       {
           long long smallsum = getSum1(node[i].coor);
           long long smallnum = getSum2(node[i].coor);
           long long allsum = getSum1(maxn);

           ans += node[i].v*(smallnum*node[i].coor - smallsum);
           ans += node[i].v*((allsum-smallsum)-(i-smallnum-1)*node[i].coor);

           update1(node[i].coor, node[i].coor);
           update2(node[i].coor);
       }

       printf("%lld\n", ans);



   }
   return 0;
}