poj3977 Subset（折半枚举）

题目大意：

给定N个整数组成的数列(N<=35)，从中选出一个子集，使得这个子集的所有元素的值的和的绝对值最小，如果有多组数据满足的话，选择子集元素最少的那个。

思路：

如果单纯的枚举的话，这N个数分别有选和不选两种，所以一共有2^35个子集。很明显，会超时，但是我们可以将这个整数数列分成两半，可得每边最多18个，如果分别进行枚举的话，复杂度可以降到O((N/2)²)，即最多2^18，在可接受范围内。然后枚举其中一个子集，二分查找与他组成绝对值最小的子集。在这里我们使用了stl::map这个类库，里面封装了红黑树，所以复杂度可以继续降低。

枚举的话采用二进制的枚举方法，这一题也让我练习了一下。

编程的时候遇到了几个问题，导致各种WA,RE和CE以后注意：

1.poj的编译器好像不能识别__int64的abs，所以这个abs要自己写，否则会CE；

2.map这个类里面，第一个键值的值只能有一个，多了会被覆盖，所以在添加的时候要特判，因为不熟悉map，因为这个WA了好几次。

3.空集的情况要单独判断，这一点WA了我好久。

下面上代码：

代码君：

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <map>
#define max_n 1e16;
using namespace std;
map <__int64,int> sum;
__int64 data[100];
pair<__int64,int>result(1e16,1);
int n;

__int64 ll_abs(__int64 a)
{
    if(a<0)
        return -a;
    else
        return a;
}

int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        result.first=1e16;
        result.second=1;
        sum.clear();
        if(n==0)
            break;
        for(int i=1;i<=n;i++)
        {
            scanf("%I64d",&data[i]);
        }
        for(int i=1;i<1<<(n/2);i++)
        {
            __int64 sums=0;
            int sumn=0;
            for(int j=0;j<n/2;j++)
            {
                if((i>>j)&1)
                {
                    sums+=data[j+1];
                    sumn++;
                }
            }
            map<__int64,int>::iterator it;
            it=sum.find(sums);
            if(sumn!=0)
            {
                if(result.first>ll_abs(sums))
                {
                    result.first=ll_abs(sums);
                    result.second=sumn;
                }
                else
                    if(result.first==ll_abs(sums))
                    {
                        if(result.second>sumn)
                        {
                            result.second=sumn;
                        }
                    }
            }
            if(it!=sum.end())
            {
                if(it->second>sumn)
                    it->second=sumn;
            }
            else
                sum[sums]=sumn;
        }
        for(int i=1;i<1<<(n-n/2);i++)
        {
            __int64 sums=0;
            int sumn=0;
            for(int j=0;j<(n-n/2);j++)
            {
                if((i>>j)&1)
                {
                    sums+=data[j+n/2+1];
                    sumn++;
                }
            }
            map<__int64,int>::iterator it;
            it=sum.lower_bound(-sums);
            if(sumn!=0)
            {
                if(result.first>ll_abs(sums))
                {
                    result.first=ll_abs(sums);
                    result.second=sumn;
                }
                else
                    if(result.first==ll_abs(sums))
                    {
                        if(result.second>sumn)
                        {
                            result.second=sumn;
                        }
                    }
            }
            if(sumn+it->second==0)
                continue;
            int flag;
            for(flag=0;flag<2;it--,flag++)
            {
                if(it==sum.end())
                {
                    if(it==sum.begin())
                        break;
                    continue;
                }
                if(result.first>ll_abs(it->first+sums))
                {
                    result.first=ll_abs(it->first+sums);
                    result.second=sumn+it->second;
                }
                else
                    if(result.first==ll_abs(it->first+sums))
                    {
                        if(result.second>sumn+it->second)
                        {
                            result.second=sumn+it->second;
                        }
                    }
                if(it==sum.begin())
                    break;
            }
        }
        printf("%I64d %d\n",result.first,result.second);
    }
    return 0;
}