题解 HDU - 6682 Rikka with Mista （折半+桶排序枚举）

题解 HDU - 6682 Rikka with Mista （折半+桶排序枚举）

题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=6682

题意

给你$N$个数，每个数的值为$X_i$ ,现在要求其每个子集之和中4出现的个数之和。

数据范围： $1\le N\le 40；1\le X_i\le 4444444$

---

思路

看到了 $N\le 40$ ,又有每个子集的和，那么我们不难想到可以使用折半枚举的方法，来枚举小于20的子集个数

那么我们又该如何求出4的个数出现了几遍呢？这点也不是很难，如果我们从单个位上的x去考虑4出现的情况，发现一共有两种：

1. 左边集合当前枚举的数中第$i$位的单个数字 与 右边集合当前枚举的数中第$i$位的单个数字相加没有进位。
2. 左边集合当前枚举的数中第$i$位的单个数字 与 右边集合当前枚举的数中第$i$位的单个数字相加进位了。

那么如果判断能否进位呢？我们可以开一个Vector，来保存所有以当前位，及当前位以下的所有位数。如果进位了，那么我们就直接去访问其恰好能够进位的位置，二分即可。

不过这种算法的复杂度为$O(10\ast (\frac{N}{2}{)}^{2}log(\frac{N}{2}))$

我们发现其中二分的过程是造成log的主要原因，那么能否消去log，我们可以不用sort，而是采用桶排序， 仔细想一想其中的过程我们便可以知道，我们需要先计算个位上的数，再逐渐向高位计算，这就是桶排序的算法，先排序第一位的数，再排序第二位的数，这个算法过程惊人的重合了，所有我们完全可以再计算过程中顺便维护了桶排序.这样的复杂度就将为了 $O(10\ast (\frac{N}{2}{)}^2)$

---

代码

#include <bits/stdc++.h>
using namespace std;
#define rep(i,j,k) for(int i = (int)j;i <= (int)k;i ++)
#define debug(x) cerr<<#x<<":"<<x<<endl
#define pb push_back
void test(){cerr<<"\n";}
template<typename T,typename... Args>void test(T x,Args... args){cerr<<x<<" ";test(args...);}

typedef long long ll;
typedef pair<int,int> pi;
const int MAXN = (int)1e6+7;

struct Node{
    ll l,r;
    Node(ll l=0,ll r=0):l(l),r(r){}
};

int N;
int a[MAXN];
vector<Node> x,y,A[10],B[10];

inline void dfs(int l,int r,ll sum,vector<Node>&vp) {
    if (l >= r+1) {
        vp.pb(Node(sum,0));
        return;
    }
    dfs(l+1,r,sum,vp);
    dfs(l+1,r,sum+a[l],vp);
}

inline ll get0(int v1,int v2,ll base) {
    ll res = 0;
    int p = B[v2].size()-1;
    rep(r,0,A[v1].size()-1) {
        while (p >= 0 && B[v2][p].r + A[v1][r].r >= base) p--;
        res += p+1;
    }
    return res;
}

inline ll get1(int v1,int v2,ll base) {
    ll res = 0;
    int p = 0;
    for(int r = A[v1].size()-1;r >= 0;r --) {
        while (p < B[v2].size() && B[v2][p].r + A[v1][r].r < base) p++;
        res += B[v2].size()-p;
    }
    return res;
}

int main()
{
    int T;
    scanf("%d",&T);
    while (T --) {
        scanf("%d",&N);
        rep(i,1,N) scanf("%d",&a[i]);
        x.clear();y.clear();
        dfs(1,N/2,0,x);
        dfs(N/2+1,N,0,y);

        ll ans = 0;
        ll base = 1;
        rep(i,1,10) {
            rep(i,0,9) A[i].clear(),B[i].clear();
            for(Node e:x) A[e.l%10].pb(Node(e.l/10,e.r));
            for(Node e:y) B[e.l%10].pb(Node(e.l/10,e.r));

            rep(i,0,9) {
                int k1 = (14-i)%10,k2 = (13-i)%10;
                ans += get0(i,k1,base) + get1(i,k2,base);
            }

            x.clear();y.clear();
            rep(i,0,9) {
                ll ex = base*i;
                for(Node e:A[i]) {
                    x.pb(Node(e.l,e.r+ex));
                }
            }
            rep(i,0,9) {
                ll ex = base*i;
                for(Node e:B[i]) {
                    y.pb(Node(e.l,e.r+ex));
                }
            }
            base *= 10;
        }
        printf("%lld\n",ans);
    }
}