bzoj 3851: 2048 dp优化

3851: 2048

Time Limit: 2 Sec  Memory Limit: 64 MB
Submit: 22  Solved: 9
[Submit][Status]

Description

Teacher Mai is addicted to game 2048. But finally he finds it's too hard to get 2048. So he wants to change the rule:

You are given some numbers. Every time you can choose two numbers
of the same value from them and merge these two numbers into their sum.
And these two numbers disappear meanwhile.

  

If we can get 2048 from a set of numbers with this operation, Teacher Mai think this multiset is good.

You have n numbers, A1,...,An. Teacher Mai ask you how many subsequences of A are good.

The number can be very large, just output the number modulo 998244353.

 

Input

There are multiple test cases, terminated by a line "0".

For each test case, the first line contains an integer n
(1<=n<=10^5), the next line contains n integers ai
(0<=ai<=2048).

Output

For each test case, output one line "Case #k: ans", where k is the
case number counting from 1, ans is the number module 998244353.

Sample Input

4
1024 512 256 256
4
1024 1024 1024 1024
5
1024 512 512 512 1
0

Sample Output

Case #1: 1
Case #2: 11
Case #3: 8

HINT

In the first case, we should choose all the numbers.

In the second case, all the subsequences which contain more than one number are good.

 

　　sro卡常数orz。。。。。。我也不知道为什么，网上比我慢几倍的程序都能秒过。。。。

　　题解什么的可以参见hdu4945，我用的是组合数，逆元什么的，具体来说，只有2^i的数是有用的（这个地方有点坑，如果用x==x&(-x)判定，则会把0算进去）然后我是枚举每一个数x选了多少个，顶多2048/x个，用组合数优化背包。但是这个办法还是很慢，经过面目全非的常数优化，八中2500ms过的，hdu就根本过不了了。

　　这个方法实在太渣，优化后卡时过的，童鞋们最好用其他方法额。 　　

顺便总结一下这道题用的常数优化技巧：

1. register 这次我实践证明register是有作用的
2. [2][n]的二维数组改成两个数组。
3. 数组下标索引改成指针。
4. 如果会多次调用几个数的乘积，可以提前预处理出来。
5. 改变for语句嵌套顺序，省略for内部的条件判断。
6. 读入优化x*10可改成 (x<<3)+(x<<2)
7. 少用取模才是终极目标。

/**************************************************************
    Problem: 3851
    User: mhy12345
    Language: C++
    Result: Accepted
    Time:2520 ms
    Memory:17536 kb
****************************************************************/

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define MOD 998244353
#define MAXN 510000
#define deal(x,y) \
        (x)=((x)+(y))%MOD;
inline int nextInt()
{
        register int x=;
        register char ch;
        while (ch=getchar(),ch<'' || ch>'');
        while (x=(x<<)+(x<<)+ch-'',ch=getchar(),ch<='' && ch>='');
        return x;
}
const int mod=MOD;
typedef long long qword;
qword pow_mod(qword x,qword y)
{
        qword ret=;
        while (y)
        {
                if (y&)ret=ret*x%MOD;
                x=x*x%MOD;
                y>>=;
        }
        return ret;
}
qword dp[][];
qword fact[MAXN];
int tot[];
qword inv[MAXN];
qword val[MAXN];
pair<int,int> pl[MAXN];
int topp=-;
int main()
{
        //freopen("input.txt","r",stdin);
        register int i,j,k,k2;
        int x,y,z,n,m;
        int nn;
        fact[]=;
        for (i=;i<MAXN;i++)
                fact[i]=fact[i-]*i%MOD;
        inv[]=;
        for (i=;i<MAXN;i++)
                inv[i]=pow_mod(fact[i],MOD-);
        int cnt=;
        register qword *dp1,*dp2;
        register qword a=;
        while (scanf("%d",&n),cnt++,n)
        {
                printf("Case #%d: ",cnt);
                memset(dp[],,sizeof(dp[]));
                memset(tot,,sizeof(tot));
                dp[][]=;
                for (i=;i<=n;i++)
                {
                        x=nextInt();
                        tot[x]++;
                }
                int ttr=;
                for (i=;i<=;i++)
                        if (!i || i!=(i&(-i)))
                                ttr+=tot[i];
                int cnt=;
                bool flag=false;
                for (i=;i<=;i<<=,cnt^=flag)
                {
                        memset(dp[cnt^],,sizeof(dp[cnt^]));
                        dp1=dp[cnt];
                        dp2=dp[cnt^];
                        flag=false;
                        if (!tot[i])continue;
                        flag=true;
                        for (j=;j<=tot[i];j++)
                                val[j]=*(fact+*(tot+i)) * *(inv+j)%MOD * *(inv+tot[i]-j)%MOD;
                        for (a=,j=/i+(%i!=);j<=tot[i];j++)
                                a=(a+ * (val+j))%MOD;
                        for (k=;k>=;k--)
                                if (dp1[k])
                                {
                                        for (j=,k2=k;j<=tot[i] && k2<;j++,k2+=i)
                                                        deal(dp2[k2],*(dp1+k) * *(val+j));
                                        qword &b=dp2[];
                                        k2-=k;
                                        for (;k2< && j<=tot[i];j++,k2+=i)
                                                        deal(b,*(dp1+k)* *(val+j));
                                        if (j<=tot[i])
                                                deal(b,*(dp1+k)*a);
                                }
                }
                printf("%lld\n",dp[cnt][]*pow_mod(,ttr)%MOD);
        }
}

面目全非版

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define MOD 998244353
#define MAXN 510000
#define deal(x,y) \
        (x)=((x)+(y))%MOD;
inline int nextInt()
{
        register int x=;
        register char ch;
        while (ch=getchar(),ch<'' || ch>'');
        while (x=(x<<)+(x<<)+ch-'',ch=getchar(),ch<='' && ch>='');
        return x;
}
const int mod=MOD;
typedef long long qword;
qword pow_mod(qword x,qword y)
{
        qword ret=;
        while (y)
        {
                if (y&)ret=ret*x%MOD;
                x=x*x%MOD;
                y>>=;
        }
        return ret;
}
qword dp[][];
qword fact[MAXN];
int tot[];
qword inv[];
pair<int,int> pl[MAXN];
int topp=-;
int main()
{
        freopen("input.txt","r",stdin);
        int i,j,k,x,y,z,n,m;
        int k2;
        int nn;
        fact[]=;
        for (i=;i<MAXN;i++)
                fact[i]=fact[i-]*i%MOD;
        inv[]=;
        for (i=;i<MAXN;i++)
                inv[i]=pow_mod(fact[i],MOD-);
        int a1,a2;
        int cnt=;
        while (scanf("%d",&n),cnt++,n)
        {
                printf("Case #%d: ",cnt);
                memset(dp,,sizeof(dp));
                memset(tot,,sizeof(tot));
                dp[][]=;
                for (i=;i<=n;i++)
                {
                        x=nextInt();
                        tot[x]++;
                }
                int ttr=;
                for (i=;i<=;i++)
                        if (!i || i!=(i&(-i)))
                                ttr+=tot[i];
                int cnt=;
                bool flag=false;
                for (i=;i<=;i<<=,cnt^=flag)
                {
                        memset(dp[cnt^],,sizeof(dp[cnt^]));
                        flag=false;
                        if (!tot[i])continue;
                        flag=true;
                        qword a=;
                        for (j=/i+(%i!=);j<=tot[i];j++)
                                a=(a+inv[j]*inv[tot[i]-j])%MOD;
                        a=a*fact[tot[i]]%MOD;
                        for (k=;k>=;k--)
                                if (dp[cnt][k])
                                {
                                        for (j=,k2=k;j<=tot[i] && k2<;j++,k2+=i)
                                                        deal(dp[cnt^][k2],dp[cnt][k]*fact[tot[i]]%MOD*inv[j]%MOD*inv[tot[i]-j]);
                                        qword &b=dp[cnt^][];
                                        k2-=k;
                                        for (;k2< && j<=tot[i];j++,k2+=i)
                                                        deal(b,dp[cnt][k]*fact[tot[i]]%MOD*inv[j]%MOD*inv[tot[i]-j]);
                                        if (j<=tot[i])
                                                deal(dp[cnt^][],dp[cnt][k]*a);
                                }
                }
                printf("%lld\n",dp[cnt][]*pow_mod(,ttr)%MOD);
        }
}

TLE版