NOIP2006 2^k进制数

题目

Luogu P1066

给定 \(k,w\) ，设 \(r\) 是一个 \(2^k\) 进制数，求满足以下条件的 \(r\) 的个数

• \(r\) 至少是一个 \(2\) 位的 \(2^k\) 进制数
• 作为 \(2^k\) 进制数，除了最后一位外， \(r\) 的每一位严格小于它右边相邻的那一位
• 将 \(r\) 转换为二进制数 \(q\) 后， \(q\) 的总位数不超过 \(w\)

分析

易知这个 \(2^k\) 进制数的最大位数为 \(\lceil\frac{w}{k}\rceil\) ，接下来我们对位数为 \(2\sim\lfloor\frac{w}{k}\rfloor\) 和位数为 \(\lceil\frac{w}{k}\rceil\) 的 \(r\) 分类讨论：

• \(2\sim\lfloor\frac{w}{k}\rfloor\)

  题目中的第一个和第三个条件都已满足，只要进一步满足第二个，若位数为 \(i\) ，只要在 \(1\) 到 \(2^k-1\) 中按顺序取 \(i\) 个数即可，所以总数为：

  \[\sum_{i=2}^{\lfloor\frac{w}{k}\rfloor} \binom{2^k-1}{i} \]

• \(\lceil\frac{w}{k}\rceil\)

  可以发现， \(r\) 的最高位最多由 \(w \bmod k\) 位二进制数组成，所以最大值为 \(2^{w\bmod k}-1\) ，设最高位为 \(i\) ，确定了最高位后，还需要确定剩下 \(\lfloor\frac{w}{k}\rfloor\) 位数，为了满足第二个条件，只要在 \(i+1\) 到 \(2^k-1\) 中按顺序取 \(\lfloor\frac{w}{k}\rfloor\) 个数，所以总数为：

  \[\sum_{i=1}^{2^{w\bmod k}-1}\binom{2^k-i-1}{\lfloor\frac{w}{k}\rfloor} \]

所以答案即为：

\[\sum_{i=2}^{\lfloor\frac{w}{k}\rfloor} \binom{2^k-1}{i}+\sum_{i=1}^{2^{w\bmod k}-1}\binom{2^k-i-1}{\lfloor\frac{w}{k}\rfloor} \]

由于题目中说明，表示答案的整数不超过 \(200\) 位，所以需要用高精度计算大组合数并相加，关于计算大组合数，可以参考这篇博客

代码

#include<bits/stdc++.h>
using namespace std;

const int MAX_N = 600 + 5;
int prime[MAX_N];
bool is_prime[MAX_N];
int cnt = 0;
  
struct bint {
    vector<int> v;

    bint() {
        *this = 0;
    }
    
    bint(int x) {
        *this = x;
    }

    bint& operator=(int x) {
        v.clear();
        do {
            v.push_back(x % 10);
        } while (x /= 10);
        return *this;
    }

    bint& operator=(const bint& x) {
        v.resize(x.v.size());
        for(int i = v.size() - 1; i >= 0; i--)
            v[i] = x.v[i];
        return *this;
    }
};

ostream& operator<<(ostream& out, const bint& x)
{
    for(int i = x.v.size() - 1; i >= 0; i--)
        out << (char)(x.v[i] + '0');
    return out;
}

istream& operator>>(istream& in, bint& x)
{
    string str;
    in >> str;
    x.v.clear();
    for(int i = str.size() - 1; i >= 0; i--)
        x.v.push_back(str[i] - '0');
    return in;
}

bint operator+(const bint& a, const bint& b)
{
    bint res;
    res.v.clear();
    bool carry = false;
    int len = max(a.v.size(), b.v.size());
    for(int i = 0; i < len; i++) {
        int add = 0;
        if(i < (int)a.v.size()) add += a.v[i];
        if(i < (int)b.v.size()) add += b.v[i];
        if(carry) {
            add++;
            carry = false;
        }
        if(add >= 10) {
            add -= 10;
            carry = true;
        }
        res.v.push_back(add);
    }
    if(carry)
        res.v.push_back(1);
    return res;
}

bint operator*(const bint& a, const bint& b)
{
    bint res;
    res.v.resize(a.v.size() + b.v.size());
    for(int i = 0; i < (int)a.v.size(); i++) {
        for(int j = 0; j < (int)b.v.size(); j++) {
            res.v[i + j] += a.v[i] * b.v[j];
            res.v[i + j + 1] += res.v[i + j] / 10;
            res.v[i + j] %= 10;
        }
    }
    int siz = res.v.size();
    while(siz > 1 && res.v[siz - 1] == 0)
        siz--;
    res.v.resize(siz);
    return res;
}

void sieve(int n)
{
    memset(is_prime, 1, sizeof(is_prime));
    is_prime[1] = false;
    cnt = 0;
    for(int i = 2; i <= n; i++) {
        if(is_prime[i])
            prime[++cnt] = i;
        for(int j = 1; j <= cnt && i * prime[j] <= n; j++) {
            is_prime[i * prime[j]] = false;
            if(i % prime[j] == 0)
                break;
        }
    }
}

int get_cnt(int n, int p)
{
    int res = 0, t = p;
    while(t <= n) {
        res += (n / t);
        t *= p;
    }
    return res;
}

bint C(int n, int m)
{
    if(m > n)
        return bint(0);
    bint res = 1;
    for(int i = 1; i <= cnt && prime[i] <= n; i++) {
        int t = get_cnt(n, prime[i]) - get_cnt(n - m, prime[i]) - get_cnt(m, prime[i]);
        for(int j = 1; j <= t; j++)
            res = res * prime[i];
    }
    return res;
}

int main()
{
    sieve(600);
    int k, w;
    cin >> k >> w;
    int n = pow(2, k) - 1;
    bint ans = 0;
    for(int i = 2; i <= w / k; i++)
        if(i <= n)
            ans = ans + C(n, i);
    
    for(int i = 1; i <= pow(2, w % k) - 1; i++)
        if(w / k <= n - i)
            ans = ans + C(n - i, w / k);
    
    cout << ans << endl;
    return 0;
}