poj 3977 Subset（折半枚举+二进制枚举+二分）

Subset

Time Limit: 30000MS		Memory Limit: 65536K
Total Submissions: 5721		Accepted: 1083

Description

Given a list of N integers with absolute values no larger than 10¹⁵, find a non empty subset of these numbers which minimizes the absolute value of the sum of its elements. In case there are multiple subsets, choose the one with fewer elements.

Input

The input contains multiple data sets, the first line of each data set contains N <= 35, the number of elements, the next line contains N numbers no larger than 10¹⁵ in absolute value and separated by a single space. The input is terminated with N = 0

Output

For each data set in the input print two integers, the minimum absolute sum and the number of elements in the optimal subset.

Sample Input

1
10
3
20 100 -100
0

Sample Output

10 1
0 2

Source

Seventh ACM Egyptian National Programming Contest

题意：给你一个含n(n<=35)个数的数组,让你在数组中选出一个非空子集，使其元素和的绝对值最小，输出子集元素的个数以及元素和的绝对值，若两个子集元素和相等，输出元素个数小的那个。

思路：如果直接暴力枚举，复杂度O(2^n)，n为35时会超时，故可以考虑折半枚举，利用二进制将和以及元素个数存在两个结构体数组中，先预判两个结构体是否满足题意，再将其中一个元素和取相反数后排序，因为总元素和越接近零越好，再二分查找即可，用lower_bound时考虑查找到的下标和他前一个下标，比较元素和以及元素个数，不断更新即可。

详见代码注释

poj的long long abs要自己写

 #include<cstdio>
 #include<iostream>
 #include<algorithm>
 #include<cmath>
 using namespace std;
 struct Z
 {
     long long int x;
     int y;
     bool operator < (const Z& b)const
     {
         if (x != b.x)
             return x < b.x;
         return y<b.y;

     }
 }a[], b[];

 long long  int c[];

 long long int abs1(long long int x)
 {
     if (x<)
         return -x;
     return x;
 }

 int main()
 {
     int n;
     int i,j;
     while (cin >> n && n)
     {
         for (i = ; i < ; i++)
         {
             a[i].x = a[i].y = b[i].x = b[i].y = ;
         }
         long long sum = 1e17;
         int ans = ;
         for (i = ; i < n; i++)
         {
             cin >> c[i];
         }
         int n1 = n / ;
         for (i = ; i < ( << n1); i++)//二进制枚举一半，共2的n1次方种
         {
             for (j = ; j < n1; j++)
             {
                 if (i >> j& && (i !=  || j != ))//这一半中的所有情况列出来
                 {
                     a[i - ].x+= c[j];
                     a[i - ].y++;//记录这个数含有几个元素
                 }
             }
         }
         int n2 = n - n1;
         for (i = ; i < ( << n2); i++)//同理初始化
         {
             for (j = ; j < n2; j++)
             {
                 if (i >> j &  && (i !=  || j != ))
                 {
                     b[i - ].x += c[j + n1];
                     b[i - ].y++;
                 }
             }
         }
         //对这两半单独检查更新最小和sum和最小元素数ans
         for (i = ; i < ( << n1) - ; i++)//？
         {
             if (abs1(a[i].x) < sum)
             {
                 sum = abs1(a[i].x);
                 ans = a[i].y;
             }
             else if (abs1(a[i].x) == sum && a[i].y < ans)
             {
                 ans=a[i].y;
                 sum = abs1(a[i].x);
             }
         }

         for (i = ; i<( << n1) - ; i++)//前半部分变为相反数
             a[i].x = -a[i].x;
         for (i = ; i<( << n2) - ; i++) //另一半检查
         {
             if (abs1(b[i].x)<sum)
             {
                 sum = abs1(b[i].x);
                 ans = b[i].y;
             }
             else if (abs1(b[i].x) == sum && b[i].y<ans)
             {
                 ans = b[i].y;
                 sum = abs1(b[i].x);
             }
         }

         sort(a, a + ( << n1) - );
         sort(b, b + ( << n2) - );

         for (i = ; i < ( << n1)-; i++)//两半合起来检查
         {
             int t = lower_bound(b, b + ( << n2) - , a[i])- b;//t是序号
             if (t > )//查看该序号周围的数
             {
                 if (abs1(b[t - ].x - a[i].x) < sum)//和可以更小
                 {
                     sum = abs1(b[t - ].x - a[i].x);//更新最小绝对值和
                     ans = b[t - ].y + a[i].y;//更新元素个数
                 }
                 else if (abs1(b[t - ].x - a[i].x) == sum && b[t - ].y + a[i].y < ans)//元素个数可以更小
                 {
                     sum = abs1(b[t - ].x - a[i].x);
                     ans = b[t - ].y + a[i].y;
                 }
             }
             if (t < ( << n2) - )
             {
                 if (abs1(b[t].x - a[i].x) < sum)
                 {
                     sum = abs1(b[t].x - a[i].x);
                     ans = b[t].y + a[i].y;
                 }
                 else if (abs1(b[t].x - a[i].x) == sum && b[t].y + a[i].y<ans)
                 {
                     sum = abs1(b[t].x - a[i].x);
                     ans = b[t].y + a[i].y;
                 }
             }
         }
         cout << sum << " " << ans << endl;
     }
     return ;
 }