2^k进制数 vijos1315 NOIP2006提高组T4

题面在最下方。

从题意中可以获取灵感：k与w是有关系的。

当这个2^k进制数转化为2进制时，原来的每一位（可以相对于十进制中的每一位来理解）都对应了二进制数中长为k的一个区段。

举个栗子，对于一个16（2^4）进制的数 ABCD （即 10 11 12 13）

打开windows自带的计算器就能看到：，其中 A对应二进制下的1010，B对应1011，以此类推。

所以这就体现出了阶段性的特点，可以考虑采用DP解答。 

首先要做的准备工作：

根据题意“在2^k进制下的这个数的位数要大于等于2，数字严格上升”，所以不可能有任何有效位取0的情况(可以有前导零)。

设当前推导位（第i位）取值范围为[1,maxx]，令x=w%n，对于maxx讨论如下：

若 x==0 ， 则所有位的取值范围都是[1,(1<<k)-1]。

若 x!=0 ，则在最高位上可取的值为 [1,(1<<x)-1]，其他位是[1,(1<<k)-1]。

从低位向高位推导，令 F[i][j] 是第i位上放数字j后满足条件的总方案数

则转移方程为 F[i][j]=∑F[i-1][k](j<k<=maxx)

同时由于w限制的是最大位数而非必需位数，所以在每次转移过后，都要 ans+=F[i][j]

如何优化？

第一个简单的优化，每一次状态转移的求和可以用后缀数组进行优化。

第二个优化是可以用滚动数组的思想，把F[i][j]优化为一维的F[i]，具体可看代码实现。

其他要说的

高精度的模版是我从网上扒下来的，至今不会写高精度（逃）

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
using namespace std;
template<class T> inline void read(T &_a){
    bool f=0;int _ch=getchar();_a=0;
    while(_ch<'0' || _ch>'9'){if(_ch=='-')f=1;_ch=getchar();}
    while(_ch>='0' && _ch<='9'){_a=(_a<<1)+(_a<<3)+_ch-'0';_ch=getchar();}
    if(f)_a=-_a;
}
const int maxn = 300;    
    
struct bign{    
    int d[maxn], len;    
    void clean() { while(len > 1 && !d[len-1]) len--; }    
    
    bign()    { memset(d, 0, sizeof(d)); len = 1; }    
    bign(int num)     { *this = num; }     
    bign(char* num) { *this = num; }    
    bign operator = (const char* num){    
    memset(d, 0, sizeof(d)); len = strlen(num);    
    for(int i = 0; i < len; i++) d[i] = num[len-1-i] - '0';    
    clean();    
    return *this;    
    }    
    bign operator = (int num){    
    char s[20]; sprintf(s, "%d", num);    
    *this = s;    
    return *this;    
    }    
    
    bign operator + (const bign& b){    
    bign c = *this; int i;    
    for (i = 0; i < b.len; i++){    
    c.d[i] += b.d[i];    
    if (c.d[i] > 9) c.d[i]%=10, c.d[i+1]++;    
    }    
    while (c.d[i] > 9) c.d[i++]%=10, c.d[i]++;    
    c.len = max(len, b.len);    
    if (c.d[i] && c.len <= i) c.len = i+1;    
    return c;    
    }    
    bign operator - (const bign& b){    
    bign c = *this; int i;    
    for (i = 0; i < b.len; i++){    
    c.d[i] -= b.d[i];    
    if (c.d[i] < 0) c.d[i]+=10, c.d[i+1]--;    
    }    
    while (c.d[i] < 0) c.d[i++]+=10, c.d[i]--;    
    c.clean();    
    return c;    
    }    
    bign operator * (const bign& b)const{    
    int i, j; bign c; c.len = len + b.len;     
    for(j = 0; j < b.len; j++) for(i = 0; i < len; i++)     
    c.d[i+j] += d[i] * b.d[j];    
    for(i = 0; i < c.len-1; i++)    
    c.d[i+1] += c.d[i]/10, c.d[i] %= 10;    
    c.clean();    
    return c;    
    }    
    bign operator / (const bign& b){    
    int i, j;    
    bign c = *this, a = 0;    
    for (i = len - 1; i >= 0; i--)    
    {    
    a = a*10 + d[i];    
    for (j = 0; j < 10; j++) if (a < b*(j+1)) break;    
    c.d[i] = j;    
    a = a - b*j;    
    }    
    c.clean();    
    return c;    
    }    
    bign operator % (const bign& b){    
    int i, j;    
    bign a = 0;    
    for (i = len - 1; i >= 0; i--)    
    {    
    a = a*10 + d[i];    
    for (j = 0; j < 10; j++) if (a < b*(j+1)) break;    
    a = a - b*j;    
    }    
    return a;    
    }    
    bign operator += (const bign& b){    
    *this = *this + b;    
    return *this;    
    }    
    
    bool operator <(const bign& b) const{    
    if(len != b.len) return len < b.len;    
    for(int i = len-1; i >= 0; i--)    
    if(d[i] != b.d[i]) return d[i] < b.d[i];    
    return false;    
    }    
    bool operator >(const bign& b) const{return b < *this;}    
    bool operator<=(const bign& b) const{return !(b < *this);}    
    bool operator>=(const bign& b) const{return !(*this < b);}    
    bool operator!=(const bign& b) const{return b < *this || *this < b;}    
    bool operator==(const bign& b) const{return !(b < *this) && !(b > *this);}    
    
    string str() const{    
    char s[maxn]={};    
    for(int i = 0; i < len; i++) s[len-1-i] = d[i]+'0';    
    return s;    
    }    
};

int k,w,deg,maxx;
bign f[1<<10],sum[1<<10],ans;

int main()
{
    read(k); read(w);
    deg=(1<<k)-1;
    for (register int i=0;i<=deg;++i) f[i]=1;
    while(w>=k)
    {
        w-=k;
        if(w>=k) maxx=deg;
            else maxx=(1<<w)-1;
        for (register int i=deg;i;--i) sum[i]=sum[i+1]+f[i];
        for (register int i=1;i<=maxx;++i) f[i]=sum[i+1],ans+=f[i];
    }
    printf("%s",ans.str().begin());
    return 0;
}

描述

设r是个2^k 进制数，并满足以下条件：
（1）r至少是个2位的2^k 进制数。

（2）作为2^k 进制数，除最后一位外，r的每一位严格小于它右边相邻的那一位。

（3）将r转换为2进制数q后，则q的总位数不超过w。

在这里，正整数k（1≤k≤9）和w（k＜W≤30000）是事先给定的。

问：满足上述条件的不同的r共有多少个？
我们再从另一角度作些解释：设S是长度为w 的01字符串（即字符串S由w个“0”或“1”m组成），S对应于上述条件（3）中的q。将S从右起划分为若干个长度为k 的段，每段对应一位2^k进制的数，如果S至少可分成2段，则S所对应的二进制数又可以转换为上述的2^k 进制数r。

例：设k=3，w=7。则r是个八进制数（23=8）。由于w=7，长度为7的01字符串按3位一段分，可分为3段（即1，3，3，左边第一段只有一个二进制位），则满足条件的八进制数有：
2位数：高位为1：6个（即12，13，14，15，16，17），高位为2：5个，…，高位为6：1个（即67）。共6+5+…+1=21个。

3位数：高位只能是1，第2位为2：5个（即123，124，125，126，127），第2位为3：4个，…，第2位为6：1个（即167）。共5+4+…+1=15个。

所以，满足要求的r共有36个。

格式

输入格式

输入文件只有1行，为两个正整数，用一个空格隔开：
k W

输出格式

输出文件为1行，是一个正整数，为所求的计算结果，即满足条件的不同的r的个数（用十进制数表示），要求最高位不得为0，各数字之间不得插入数字以外的其他字符（例如空格、换行符、逗号等）。

（提示：作为结果的正整数可能很大，但不会超过200位）

样例1

样例输入1

3 7

样例输出1

36

限制

1s