基础算法（1）、有技巧的枚举

实际上，枚举是计算机科学中最常使用的一种算法，几乎所有问题都可以通过枚举来解决。

那为什么我们还要发明别的算法呢？因为CPU的运算速度有限，内存容量有限。

如果计算速度无限快，内存无限大，那么我们发明算法就没有任何必要了。

本文谈论的枚举是在基础枚举之上，通过一些特殊的技巧，给我们的枚举剪枝，从而

达到优化时间复杂度或空间复杂度的目的。

枚举的技巧有折半枚举、树上差分等，今天主要讲折半枚举的使用。

以下是例题：

Subset

  POJ - 3977 

题意：给定n（n≤35）个元素组成的集合，求一个非空子集使得该子集内元素之和的绝对值最小。

分析：明显能看出，对于每个元素，可以选择将其放入或不放入子集，暴力枚举的话时间复杂度最高为O(2^35)。

这种做法显然会T。

于是我们使用二分答案+贪心检验。即枚举前一半的元素，然后在后一半贪心地检验答案。

时间复杂度可降为O(2^18)。

贪心策略：找到不大于当前的和的相反数的数，在它的附近寻找答案。

另：本题可采用map，且poj不支持long long int的abs函数，所以需要自己手写。

代码如下：

#include<iostream>
#include<cmath>
#include<algorithm>
#include<map>
#include<utility>
#include<cstdlib>
#define ll long long int
using namespace std;

int n;
ll a[37];
const int INF=0x7fffffff;

ll Abs(ll x){
    return x>0?x:(-x);
}

int main(){
    while(cin>>n&&n){
        for(int i=0;i<n;i++)
            cin>>a[i];
        map<ll,int>dp;//此为当前集合元素之和->当前集合元素个数的映射
        pair<ll,int>res;//此为需要维护的答案，是一个<绝对值最小的和,元素个数>的对
        res.first=Abs(a[0]);//初始化答案为第一对<和，元素个数>
        res.second=1;
        int n2=n/2;
        for(int i=0;i<(1<<n2);i++){//折半枚举的过程
            ll sum=0;
            int num=0;
            for(int j=0;j<n2;j++){
                if((i>>j)&1){//这儿使用了二进制枚举，即取出i的第j位，如果枚举到第j个元素则让sum+=a[j]
                    sum+=a[j];
                    num++;
                }
            }
            if(num==0)//当前子集没有选取任何数字
                continue;
            res=min(res,make_pair(Abs(sum),num));//维护答案res，按题意使得排序条件为按元素和的绝对值递减，若相同，则按元素个数的绝对值递减
            map<ll,int>::iterator it=dp.find(sum);//寻找map中是否存在first值为sum的映射
            if(it!=dp.end())//存在则维护元素个数最小
                it->second=min(it->second,num);
            else dp[sum]=num;//不存在则加入map
        }
        for(int i=0;i<(1<<n-n2);i++){//寻找后一半元素
            ll sum=0;
            int num=0;
            for(int j=0;j<n-n2;j++){
                if((i>>j)&1){
                    sum+=a[n2+j];
                    num++;
                }
            }
            if(num==0) continue;
            res=min(res,make_pair(Abs(sum),num));//维护答案res最小
            map<ll,int>::iterator it=dp.lower_bound(-sum);//找到不大于sum相反数的位置
            if(it!=dp.end())
                res=min(res,make_pair(Abs(sum+it->first),num+it->second));
            if(it!=dp.begin()){//在这附近维护res的最小
                it--;
                res=min(res,make_pair(Abs(sum+it->first),num+it->second));
            }
        }
        cout<<res.first<<" "<<res.second<<endl;
    }
    return 0;
}

总结一下本题可以学到的几个东西：

1、折半枚举

2、贪心策略

3、map的使用

4、位运算与位操作
相似的例题请参见WinterTraining5。