2015 CCC - 01 统计数对

源：CNUOJ-0384 http://oj.cnuschool.org.cn/oj/home/problem.htm?problemID=354

题目分析：当时拿到这道题第一个想法就是排序后n^2暴力枚举，充分利用好有序这一特性随时“短路”。

 read(n);read(m);
     int temp;

     for(int i = ; i < n; i++)
     {
         read(temp);
         if(temp <= m)
         {
               p[tot].v = temp;
               p[tot++].num = i;
         }
     }

     sort(p, p + tot);

     for(int i = ; i < tot - ; i++)
     {
         for(int j = i + ; j < tot; j++)
         {
             if(p[i].v + p[j].v > m) break;
             else if(p[i].num < p[j].num) ans++;
         }
         ans %= ;
     }

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

     return ;

算法1

然后很高兴的简单一测试就哭了……为什么答案始终不对呢……

如上图就是一个十分典型的例子（下标为序号），不难发现当我们手算时，我们是算的“2 + 1”，但排完序后计算机执行的是“1 + 2”，序号不符合题意就被砍掉了……

那么怎么解决呢？第一个想法便是优化一下 j 的循环，从头到尾全来一遍，保证不漏解：

 read(n);read(m);
     int temp;

     for(int i = ; i < n; i++)
     {
         read(temp);
         if(temp <= m)
         {
               p[tot].v = temp;
               p[tot++].num = i;
         }
     }

     sort(p, p + tot);

     for(int i = ; i < tot; i++)
     {
         for(int j = ; j < tot; j++)
         {
             if(i == j) continue;
             if(p[i].v + p[j].v > m) break;
             else if(p[i].num < p[j].num) ans++;
         }
         ans %= ;
     }

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

算法2

排序是nlogn，枚举是n^2，对于十万的数据量无法吐槽……只能有50分……

好的，接下来我们来分析一下这个算法干了些什么，比如对于3 2 1这个序列：

可以看到，1 -> 2, 2 -> 1 分别别计算过一次，其中红色的一次失败了，蓝色的成功了。（在红色中3 > 2，而在蓝色中是2 < 3满足题意）

也不难得出：每一对数字都被正着计算了一次，反着计算了一次；一次失败，一次成功。

那么：反正判断不判断都是ans++ 一次（仅成功一次，失败的时候不会更新），那为什么要判断呢？

于是，我们编出了下面没有判断编号只判断了大小的程序：

 for(int i = ; i < tot - ; i++)
     {
         for(int j = i + ; j < tot; j++)
         {
             if(p[i].v + p[j].v > m) break;
             ans++;
         }
         ans %= ;
     }

算法3

这个算法常数可以几乎砍掉一半多，但复杂度仍然是n^2的，它的表现……呵呵

进一步的优化就要从查询方法开始了：用十分常见的二分法效果怎么样呢？于是我们终于得到了标程：

 #include <iostream>   //第一题标程
 #include <cstdio>
 #include <cmath>
 #include <algorithm>
 using namespace std;

 const int maxn =  + ;
 int n, m;

 int p[maxn];
 int ans = ;

 int tot = ;

 int A[maxn];

 void read(int& x)
 {
     x = ;
     char ch = getchar();
     int sig = ;
     while(!isdigit(ch))
     {
         if(ch == '-') sig = -;
         ch = getchar();
     }
     while(isdigit(ch))
     {
           x = x *  + ch - '';
           ch = getchar();
     }
     x *= sig;
     return ;
 }

 int main()
 {
     read(n);read(m);
     int temp;

     for(int i = ; i < n; i++)
     {
         read(temp);
         if(temp <= m) p[tot++] = temp;
     }

     sort(p, p + tot);

     int L, R, M;

     for(int i = ; i < tot - ; i++)
     {
         L = i;
         R = tot - ;

         if(p[R] + p[i] <= m)
         {
             ans += R - i;
             continue;
         }

         while(L < R)
         {
             M = L + R >> ;
             //printf("L:%d M:%d R:%d\n", L, M, R);
             if(p[i] + p[M] <= m) L = M + ;
             else R = M;
         }

         if(L - i > ) ans += L - i - ;

         //cout << ans << endl;
         ans %= ;
     }

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

     return ;
 }

从n^2到nlogn是不小的进步，十万的数据专为nlogn而生：

这道题就这样被干掉了……

当然了，其实还可以用treap瞎搞啦：

 #include <cstdio>
 #include <iostream>
 #include <algorithm>
 #include <ctime>
 using namespace std;
 const int maxn =  + ;
 struct Node{
     int r, v, s;
     Node* ch[];
     Node() {}
     void maintain(){
         s = ch[] -> s + ch[] -> s + ;
         return ;
     }
 }nodes[maxn], *null = &nodes[];
 int tot = , n, m, A[maxn];
 void read(int& x){
     x = ; int sig = ; char ch = getchar();
     while(!isdigit(ch)) { if(ch == '-') sig = -; ch = getchar(); }
     while(isdigit(ch)) x =  * x + ch - '', ch = getchar();
     x *= sig; return ;
 }
 void rotate(Node* &o, int d){
     Node* k = o -> ch[d ^ ];
     o -> ch[d ^ ] = k -> ch[d];
     k -> ch[d] = o;
     o -> maintain();
     k -> maintain();
     o = k;
     return ;
 }
 void init(Node* &o, int v){
     o -> ch[] = null;
     o -> ch[] = null;
     o -> s = ;
     o -> r = rand();
     o -> v = v;
     return ;
 }
 void insert(Node* &o, int v){
     if(o == null){
         o = &nodes[++ tot];
         init(o, v);
     }
     else{
         int d = v < o -> v ?  : ;
         insert(o -> ch[d], v); //你大爷
         if(o -> ch[d] -> r > o -> r) rotate(o, d ^ );
     }
     o -> maintain();
     return ;
 }
 void remove(Node* &o, int v){
     if(o == null) return ;
     if(o -> v == v){
         if(o -> ch[] == null) o = o -> ch[];
         else if(o -> ch[] == null) o = o -> ch[];
         else{
             int d = o -> ch[] -> r < o -> ch[] -> r ?  : ;
             rotate(o, d);
             remove(o -> ch[d ^ ], v);
         }
     }
     if(o != null) o -> maintain();
     return ;
 }
 /*int find(Node* &o, int v){
     if(o == null) return -1;
     if(o -> v == v){
         if(o -> ch[0] != null) return o -> ch[0] -> s;
         else return 1;
     }
     int d = v < o -> v ? 0 : 1;
     return find(o -> ch[d], v);
 }//*/
 int rank(Node* &o, int v){
     if(o == null) return ;
     if(o -> v > v) return rank(o -> ch[], v);
     else return rank(o -> ch[], v) + o -> ch[] -> s + ;
 }
 Node* root = null;
 long long ans = ;
 void Init(){
     srand(time());
     null -> s = ;
     read(n); read(m);
     for(int i = ; i < n; i ++){
         read(A[i]);
         ans += rank(root, m - A[i]);
         //printf("%d ", rank(root, m - A[i]));
         insert(root, A[i]);
     }
     return ;
 }

 void print(Node* &o){
     if(o == null) return ;
     print(o -> ch[]);
     printf("%d ", o -> v);
     print(o -> ch[]);
     return ;
 }

 int main(){
     Init();
     printf("%lld\n", ans % );
     return ;
 }
 /*
 5 100000
 1 2 3 4 5
 */

小结：本题一定要好好读条件，仔细分析哪些可以优化。

考点：二分，坑题