HDU2838Cow Sorting（树状数组）

题目意思是说给你一列数，每次可以将相邻的两个数交换，这一步的代价是这两个数的和，求将所有数排好序的最少代价。

题解：

我们可以这么思考，由于每次都是交换相邻的两个数，所以将一个数放到它自己的位置去后，其他的数的相对位置没变，那么排序其他的数所需要消耗的代价将与这个数没关系，所以排序过程将相当于是冒泡排序。

这样的话我们用树状数组可以记录第i个数之前有多少个比它小的的数x

再记录这些比它小的数的和是多少sum

然后这个数移动到他自己的位置的代价就是

　　x*a[i]+sum。

最后的复杂度就是nlogn

以后排序和求和的题应该多想想树状数组~恩恩

 #include <map>
 #include <set>
 #include <stack>
 #include <queue>
 #include <cmath>
 #include <ctime>
 #include <vector>
 #include <cstdio>
 #include <cctype>
 #include <cstring>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 #define INF 0x3f3f3f3f
 #define MAX(a,b) (a > b ? a : b)
 #define MIN(a,b) (a < b ? a : b)
 #define mem0(a) memset(a,0,sizeof(a))
 #define mem1(a) memset(a,-1,sizeof(a))
 #define lson k<<1, L, mid
 #define rson k<<1|1, mid+1, R

 typedef long long LL;
 const double eps = 1e-;
 const int MAXN = ;
 const int MAXM = ;

 struct NODE
 {
     int num;//记录个数
     __int64 sum;//记录比它小的数的和
 }c[MAXN];
 int N;

 void init()
 {
     mem0(c);
 }

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

 void edit(int k, int num)
 {
     while(k <= )
     {
         c[k].num += ;
         c[k].sum += num;
         k += lowbit(k);
     }
 }

 int getnum(int k)//得到比当前数小的数的个数
 {
     int num = ;
     while(k > )
     {
         num += c[k].num;
         k -= lowbit(k);
     }
     return num;
 }

 __int64 getsum(int k)//得到比当前数小的数的和
 {
     __int64 sum = ;
     while(k>)
     {
         sum += c[k].sum;
         k-=lowbit(k);
     }
     return sum;
 }

 int main()
 {
     while(~scanf("%d", &N))
     {
         init();
         int num;
         __int64 ans = ;
         for(int i=;i<=N;i++)
         {
             scanf("%d", &num);
             edit(num, num);
             int cnt = i - getnum(num);//有cnt的数比num大
             if(cnt != )
             {
                 ans += (__int64)cnt*num + getsum()-getsum(num);
             }
         }
         printf("%I64d\n", ans);
     }
     return ;
 }