【HDOJ】5657 CA Loves Math

1. 题目描述
对于给定的$a, n, mod, a in [2,11], n in [0, 10^9], mod in [1, 10^9]$求出在$[1, a^n]$内的所有$a$进制下的数并且不含重复数字。

2. 基本思路
这题比赛的时候，没人做出来，但是基本思路大家都有。显然可以直接将$n$改写为$min(n,a)$。
我比赛的代码TLE，思路是这样的：首先$mod$很小时，可以数位DP解；当$mod$很大时，可以先找到所有的排列然后，然后令$delta = fact(a)/fact(a-n)$，然后以这个作为循环间隔找到满足不重复的数字，然后再判断是否是$mod$的倍数。
hack的时候，其实可以直接以$mod$作为阈值解。题解也提到了这个思路。
这样原问题可以分两种情况：
（1） 大于阈值，枚举$mod$的倍数，然后判断是否包含重复数字；
（2） 小于等于阈值，数位DP。
然后，赛后交还是wa了几次。这里有几个特殊情况需要单独考虑：
（1） n = 0时，只能取1，直接判断是否为$mod$倍数。
（2） n = 1时，可以取[1, a]，同样需要判断是否为$mod$倍数。
并且，数位DP是累加DP的。即长度为$[1,n]$的满足条件的总和。

3. 代码

/*  */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1
#define INF                0x3f3f3f3f
#define mset(a, val)    memset(a, (val), sizeof(a))

#define LL __int64

const int bound = 23333;
const int maxn = 12;
int dp[1<<11][bound];
int Bits[1<<11];
vector<int> St[maxn];
int Sz[maxn];
int a, n, mod;

void solve();
void _solve();

inline int lowest(int x) {
    return -x & x;
}

inline int getBits(int x) {
    int ret = 0;
    
    while (x) {
        ++ret;
        x -= lowest(x);
    }
    return ret;
}

void init() {
    int mst = 1 << 11;
    
    rep(i, 0, mst) {
        Bits[i] = getBits(i);
        St[Bits[i]].pb(i);
    }
    
    rep(i, 0, maxn)
        Sz[i] = SZ(St[i]);
}

bool vis[12];
inline bool judge(LL x) {
    if (x == 0)    return false;
    
    memset(vis, false, sizeof(vis));
    while (x) {
        int tmp = x % a;
        if (vis[tmp])
            return false;
        x /= a;
        vis[tmp] = true;
    }
    return true;
}

void solve() {
    if (n == 0) {
        printf("%d
", 1%mod==0 ? 1:0);
        return ;
    }
    if (n == 1) {
        int ans = 0;
        rep(i, 1, a+1)
            ans += i%mod == 0 ? 1:0;
        printf("%d
", ans);
        return ;
    }
    
    n = min(n, a);
    if (mod > bound) {
        _solve();
        return ;
    }

    int mst = 1<<a;
    memset(dp, 0, sizeof(dp));
    
    rep(j, 1, a)
        ++dp[1<<j][j%mod];
    
    rep(l, 1, n) {
        rep(j, 0, Sz[l]) {
            const int st = St[l][j];
            if (st >= mst)
                continue;
            rep(k, 0, mod) {
                const int& cnt = dp[st][k];
                if (cnt == 0)
                    continue;
                
                rep(i, 0, a) {
                    if (st & (1<<i))
                        continue;
                    
                    int nst = st | (1<<i);
                    int nk = (k * a + i) % mod;
                    dp[nst][nk] += cnt;
                }
            }
        }
    }
    
    int ans = 0;
    
    rep(l, 1, n+1) {
        rep(j, 0, Sz[l]) {
            const int& st = St[l][j];
            ans += dp[st][0];
        }
    }
    
    printf("%d
", ans);
}

LL Pow(LL base, int n) {
    LL ret = 1;
    
    while (n) {
        if (n & 1)
            ret = ret * base;
        base = base * base;
        n >>= 1;
    }
    
    return ret;
}

void _solve() {
    LL tmp = mod, ubound = Pow(a, n);
    int ans = 0;
    
    while (tmp <= ubound) {
        if (judge(tmp))
            ++ans;
        tmp += mod;
    }
    
    printf("%d
", ans);
}

int main() {
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif

    int t;

    init();
    scanf("%d", &t);
    while (t--) {
        scanf("%d%d%d",&a,&n,&mod);
        solve();
    }

    #ifndef ONLINE_JUDGE
        printf("time = %ldms.
", clock());
    #endif

    return 0;
}