「hdu6682」Rikka with Mista【基数排序+单调优化】

Rikka with Mista

Time Limit: 12000/6000 MS (Java/Others) Memory Limit: 524288/524288 K (Java/Others) Total Submission(s): 522 Accepted Submission(s): 135

Problem Description

$Rikka$ is a fervent fan of $JoJ{o}^{\prime }s$ Bizarre Adventure. As the last episode of Golden Wind has been aired, $Rikka$, with the help of $Yuta$, sets up this problem to express the love to $Mista$.

$Mist{a}^{\prime }s$ lucky number is 4. Today, $Mista$ wants to test his luck with n magic cards: For each card, there is a non-negative integer on each side. The two numbers on the $i-th$ card are $w_i$ and $0$.

Firstly, $Mista$ puts these $n$ cards to table one by one. For each card, the probability of the $w_i$ side to be upward is $12$, and these probabilities are independent with each other. As a result, there are $n$ integers on the table. Mista then sums up all these integers and counts the number of $4s$ in the decimal representation of this sum: He uses this result to measure his luckiness.

Since it’s possible for each side of each card to be upward, there are $2^n$ possible states in total. You are required to calculate the sum of the results for all these situations.

Input

The first line of the input contains a single integer $T(4\le T\le 4)$, the number of test cases.

For each test case, the first line contains a single integer $n(4\le n\le 40)$, the number of the cards.

The second line contains $n$ integers $w_1,\dots ,w_n(4\le w_i\le 44444444)$, the positive numbers on the cards.

Output

For each test case, output a single line with a single integer, the answer.

Hint

There are 44 4s in the sample input. Mista would like this sample input.

In the first test case, there is 1 state with the sum equal to 0; 4 states with the sum equal to 4; 6 states with the sum equal to 8; 4 states with the sum equal to 12 and 1 state with the sum equal to 16.

Therefore, there are only 4 situations with the result equal to 1 while on other cases, the result is 0. So the answer should be 4.

Sample Input

4
4
4 4 4 4
4
4 4 44 44
4
4 44 44 4444
4
444 44444 44444 4444444

Sample Output

4
10
24
38

Source

2019 Multi-University Training Contest 9

题意

• 就是给你$n$个数，每个数可选可不选，所以一共有$2^n$的方案，设第$i$个方案中所有数字的和$k$的数位中$4$的出现次数为$cn{t}_i$，求
  $$\sum _{i=1}^{2^n}cn{t}_i$$

题解

• 首先很容易想到的无脑做法是先$meetinmiddle$将所有数分成两半分别暴力算出所有可能的$su{m}_l,su{m}_r$，然后考虑每一位算贡献，比如算第$i$位时，先把所有的$su{m}_l$与$su{m}_r$模上$10^{i+1}$然后枚举$su{m}_l$，在$su{m}_r$中找出区间$[4\times 10^i-suml,5\ast 10^i-suml)$内的数量加到$ans$里，还需要找出区间$[10^{i+1}+4\times 10^i-suml,10^{i+1}+5\times 10^i-suml)$，这里酸的是进位后产生的$4$，比如$7+7$，对于找区间内的数，可能需要排序然后$lower\_bound$，所以时间复杂度$O(T\ast 10\ast 2^{\frac{n}{2}}\ast \frac{n}{2})$，而且常数巨大。。显然就炸了
• 容易想到$4$的产生要么是加上进位后产生要么就是无低位进位相加产生，那么分类计算，对于每一个$su{m}_l$，假设$su{m}_l,su{m}_r$是按照最低的$i$位排好序，那么显然在统计的时候枚举$su{m}_l$的话，可行的$su{m}_r$的$pos$是单调的，所以就可以$O(2^n)$找出所有答案，对于按照最低的$i$位排序，实际上就是从低位开始的基数排序过程
• 算法复杂度$O(T\times n\times 2^n)$

代码

#pragma GCC optimize ("Ofast")
#include<bits/stdc++.h>

using namespace std;
const int maxn=2e6+10;
struct node{
    long long l,r;
};
vector<node> a,b,c[10],d[10];
int n,val[maxn];

void solve(int *a,int k,vector<node>&b)
{
    for(int i=0;i<(1<<k);i++) {
        long long s=0;
        for(int j=0;j<k;j++) if(i&(1<<j)) s+=a[j];
        b.push_back(node{s,0});
    }
}

long long get_jin0(vector<node>&a,vector<node>&b,long long base) //处理没有进位的答案
{
    int point=b.size()-1;long long ans=0;
    for(int i=0;i<a.size();i++) {
        while(point>=0&&a[i].r+b[point].r>=base) point--;
        ans+=(point+1);
    }
    return ans;
}

long long get_jin1(vector<node>&a,vector<node>&b,long long base) //处理进位为1的使当前位为4的答案
{
    int point=0;long long ans=0;
    int siz=b.size();
    for(int i=a.size()-1;i>=0;i--) {
        while(point<=siz-1&&a[i].r+b[point].r<base) point++;
        ans+=(b.size()-point);
    }
    return ans;
}


int main()
{
    int t;scanf("%d",&t);
    while(t--) {
        a.clear();b.clear();
        scanf("%d",&n);
        for(int i=1;i<=n;i++) scanf("%d",&val[i]);
        solve(val+1,n/2,a);
        solve(val+1+n/2,n-(n/2),b);
        long long base=1,ans=0;
        for(int w=0;w<=8;w++) {
            for(int i=0;i<10;i++) c[i].clear(),d[i].clear();
            for(int i=0;i<a.size();i++) c[a[i].l%10].push_back(node{a[i].l/10,a[i].r});
            for(int i=0;i<b.size();i++) d[b[i].l%10].push_back(node{b[i].l/10,b[i].r});
            for(int i=0;i<10;i++) {              //枚举左半边的和的当前位的数
                int k1=(14-i)%10,k2=(13-i)%10;   //求右半边对应的和的当前位的数，k1表示在不进位的情况下的值，k2表示在后面有进位的情况下的需要的值
                ans+=get_jin0(c[i],d[k1],base)+get_jin1(c[i],d[k2],base);
            }
            int now=0;
            for(int i=0;i<10;i++) for(int j=0;j<c[i].size();j++) a[now++]=node{c[i][j].l,c[i][j].r+i*base};
            now=0;
            for(int i=0;i<10;i++) for(int j=0;j<d[i].size();j++) b[now++]=node{d[i][j].l,d[i][j].r+i*base};
            base*=10;
        }
        printf("%lld\n",ans);    
    }
}