Divide and conquer:Subset(POJ 3977)

　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　子序列

　　题目大意：给定一串数字序列，要你从中挑一定个数的数字使这些数字和绝对值最小，求出最小组合数

　　题目的数字最多35个，一看就是要数字枚举了，但是如果直接枚举，复杂度就是O(2^35)了，显然行不通，所以我们把它的组合拆成两半（前n/2个数字和后n-n/2个数字），然后给前部分和或者后部分和的组合排序，然后再用另一半在其二分查找，看最接近的和，这就是折半枚举的思想

　　不过这一题有很多细节：

　　1.和是不固定的，要左右各查找1个，如果有重复元素，一定要越过重复元素再找(lower_bound和upper_bound找就好了)，同时还要防止空子列

　　2.这一题要找的数组合数最小的和个组合，所以排序的那一个组合，当两个组合的和一样时，要按照nums的升序排列，这样也会让1的查找顺利

　　

#include <iostream>
#include <algorithm>
#include <functional>

using namespace std;

typedef long long LL_INT;
static struct _set
{
    int nums;
    LL_INT sum;
    bool operator <(const _set&x) const
    {
        if (sum != x.sum)
            return sum < x.sum;
        else
            return nums < x.nums;//如果相等则按nums排序，那样只用看upper_bound就可以了
    }
}sum_set1[262149], sum_set2[262149];
static LL_INT input[36];
static int search_bound[3] = { -1, 0 };

LL_INT ABS(LL_INT);
int Min(const int, const int);
void Solve(const int, LL_INT &, int &);
struct _set *Binary_Search_Lower(const int, LL_INT);
struct _set *Binary_Search_Upper(const int, LL_INT);

int main(void)
{
    int ans2, n;
    LL_INT ans1;

    while (~scanf("%d",&n))
    {
        if (n == 0)break;
        for (int i = 0; i < n; i++)
            scanf("%lld", &input[i]);

        for (int i = 0; i < 1 << (n / 2); i++)//枚举左半边元素
        {
            sum_set1[i].nums = 0; sum_set1[i].sum = 0;
            for (int pos = 0; pos < n / 2; pos++)
            {
                if (((i >> pos) & 1) == 1)
                {
                    sum_set1[i].sum += input[pos];
                    sum_set1[i].nums++;
                }
            }        
        }
        for (int i = 0; i < 1 <<(n - (n / 2)); i++)//枚举右半边元素
        {
            sum_set2[i].nums = 0; sum_set2[i].sum = 0;
            for (int pos = 0; pos < (n - (n / 2)); pos++)
            {
                if (((i >> pos) & 1) == 1)
                {
                    sum_set2[i].sum += input[pos + n / 2];
                    sum_set2[i].nums++;
                }
            }
        }
        sort(sum_set2, sum_set2 + (1 << (n - (n / 2))));
        Solve(n, ans1, ans2);
        printf("%lld %d
", ans1, ans2);
    }
    return EXIT_SUCCESS;
}

LL_INT ABS(LL_INT x)
{
    return x > 0 ? x : -x;
}

int Min(const int x, const int y)
{
    return x > y ? y : x;
}

void Solve(const int n, LL_INT &ans1, int &ans2)
{
    struct _set *pos = NULL, *pos_up = NULL;
    int tmp_pos, up;
    ans1 = LLONG_MAX; ans2 = -1;

    for (int i = 0; i < 1 << (n / 2); i++)
    {
        pos = Binary_Search_Lower(1 << (n - (n / 2)), -sum_set1[i].sum);
        pos_up = Binary_Search_Upper(1 << (n - (n / 2)), -sum_set1[i].sum);
        //一定要记得在找到的范围附近再寻找看还有没有绝对值更接近的
        for (int j = 0; j < 2; j++)
        {
            tmp_pos = (int)(pos - sum_set2) + search_bound[j];
            if (0 <= tmp_pos && tmp_pos < 1 << (n - (n / 2))
                && (sum_set2[tmp_pos].nums || i)//不同时为0（避免空子串）
                )
            {
                if (ABS(sum_set2[tmp_pos].sum + sum_set1[i].sum) < ans1)
                {
                    ans1 = ABS(sum_set2[tmp_pos].sum + sum_set1[i].sum);
                    ans2 = sum_set2[tmp_pos].nums + sum_set1[i].nums;
                }
                else if (ABS(sum_set2[tmp_pos].sum + sum_set1[i].sum) == ans1)
                    ans2 = Min(sum_set2[tmp_pos].nums + sum_set1[i].nums, ans2);
            }
        }
        up = (int)(pos - sum_set2) + 1;
        if (sum_set2[up].nums || i)//避免空子串,导致后面失效
        {
            if (ABS(sum_set2[up].sum + sum_set1[i].sum) < ans1)
            {
                ans1 = ABS(sum_set2[up].sum + sum_set1[i].sum);
                ans2 = sum_set2[up].nums + sum_set1[i].nums;
            }
            else if (ABS(sum_set2[up].sum + sum_set1[i].sum) == ans1)
                ans2 = Min(sum_set2[up].nums + sum_set1[i].nums, ans2);
        }
        up = (int)(pos_up - sum_set2);
        if (sum_set2[up].nums || i)//不同时为0（避免空子串）
        {
            if (ABS(sum_set2[up].sum + sum_set1[i].sum) < ans1)
            {
                ans1 = ABS(sum_set2[up].sum + sum_set1[i].sum);
                ans2 = sum_set2[up].nums + sum_set1[i].nums;
            }
            else if (ABS(sum_set2[up].sum + sum_set1[i].sum) == ans1)
                ans2 = Min(sum_set2[up].nums + sum_set1[i].nums, ans2);
        }
    }
}

struct _set *Binary_Search_Lower(const int n, LL_INT sum1)
{
    int lb = 0, mid, count1 = n, count2;
    while (count1 > 0)
    {
        count2 = count1 >> 1;
        mid = lb + (count1 >> 1);
        if (sum_set2[mid].sum < sum1)
        {
            lb = ++mid;
            count1 -= count2 + 1;
        }
        else count1 = count2;
    }
    return &sum_set2[lb];
}

struct _set *Binary_Search_Upper(const int n, LL_INT sum1)
{
    int lb = 0, mid, count1 = n, count2;
    while (count1 > 0)
    {
        count2 = count1 >> 1;
        mid = lb + (count1 >> 1);
        if (sum_set2[mid].sum <= sum1)
        {
            lb = ++mid;
            count1 -= count2 + 1;
        }
        else count1 = count2;
    }
    return &sum_set2[lb];
}

　　

　　最后尼玛，我wa很多次，发现原来是我的min函数写错了。。。写成了max函数。。。。。

　　参考了一下http://www.cnblogs.com/hyxsolitude/p/3642053.html