Crime HDU - 4623(等价类+变进制哈希+状压 dp)

题目连接

题意

1. 让我们求 1~n （n <= 28）的排列中相邻元素互质的排列有多少个？

思路

1. 很不错的一题，一个间的状压 dp，当 n 的值太的时候，使用了等价类进行优化，有使用了变进制哈希，去减少状态状态枚举个数。
2. 如果我们先不考虑 n 的大小的时候，如果我们用状压 dp 去做的话，只需设状态转移数组为：dp [sta][x] 在状态为 sta，且最后一个数字 x 的时候，相邻元素互质的的排列的方案数，
3. 其实 dp [sta][x] 已经能够完美的表示我们状态转移所需要的信息了，我们可以 从 sta 中得知接下来还有哪些数字可以去选择，并且要和当前排列的最后一个元素互质，就可用状压 dp 的套路进行状态转移了。
4. 但是 n 最大可以为 28， 肯定不可以直接装状压了，这里用到的神奇的 “等价类” ，这题通过把 拥有相同质因子的一些数当成同一种数去使用，例如：6，12，24，首先我们要明白两个是的质因子相同的，那么这两个数的对外与其他的数的是否互质关系也是相同的，
5. 同理我们也可以报 1、17、19、23 因为所有的数都和它们互质所有我们也可以把它们当成一类数，这样我们枚举的状态状态会少一点。
6. 我们在讲一讲什么是变进制 hash ，正常的 某个进制的数，改进制数的每一位的都是的表示的数字范围相同，比如十进制数的个位和十位的取值范围都是 0~9.
7. 而变进制的 hash，用一个变进制数表示状态，这个变进制数的每个进制位数字的取值范围不同，
8. 而我们的在 进行等价类操作之后每个等价类的数字数量可能是不同的，这正好与我们的 变进制 hash 相契合。
9. 有了上面的优化就和真正的状压 dp 了！！！
   10. 实现变进制数的操作具体看代码吧。

代码

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;
const int be[29] = {0, 0, 1, 2, 1, 3, 4, 5, 1, 2, 6, 7, 4, 8, 9, 10, 1, 0, 4, 0, 6, 11, 12, 0, 4, 3, 13, 2, 9};
//                  0  1  2  3  4  5  6  7  8  9  10 11 12 13 13 15 16 17 18 19 20  21  22  23 24 25 26 27 28
//                  // be数组表示第 i 个数所属的等价类为 be[i]
const int maxn = 2 * 1e6 + 5;
int f[14] = { 1, 2, 3, 5, 6, 7, 10, 11, 13, 14, 15, 21, 22, 26 };       //在第 i 个等价类中，选择一个在这个类中的代表的数 f[i]
int N, mod, bit[16], dp[maxn][16];
bool ok[16][16];

int idx(int* c)
{
    int ret = 0;
    for (int i = 0; i <= N; i++)            
        ret = ret * bit[i] + c[i];

    /* 把一个变进制数：2 3 5
     * 每一位的进制为：x y z  
     * 需要需要注意这个变进制数： 左边为最高位，右边为最低位
     * 把这个变进制数转换成十进制的方法类似于：把一个 2 进制数转换为 10 进制数的过程
     * ret = [(2 * y) + 3] * z + 5
     */

    return ret;
}

void ridx(int n, int* c)    
{
    for (int i = N; i >= 0; i--)        //分解这个变进制数的时候：从最低为向最高位依次进行分解
    {
        c[i] = n % bit[i];
        n /= bit[i];
    }
}

int solve (int ed) {

    int c[16], suf[16];
    memset(c,  0, sizeof(c));
    memset(dp, 0, sizeof(dp));

    suf[N] = 1;
    for (int i = N-1; i >= 0; i--)
        suf[i] = suf[i+1] * bit[i+1];

    for (int i = 0; i <= N; i++) {
        c[i]++;
        dp[idx(c)][i] = bit[i]-1;
        c[i]--;
    }

    for (int s = 1; s < ed; s++)
    {
        ridx(s, c);
        for (int i = 0; i <= N; i++) 
        {
            for (int j = 0; j <= N; j++) if (ok[i][j])      // i 等价类可以和 j 等价类相邻的话
            {
                int k = bit[j] - c[j] - 1;
                if (k == 0) continue;
                int v = s + suf[j];                         // s 状态的第 j 为 +1 ,  这里要明白变进制的最低位是最右边的那一位，所以加的是一个后缀 suf[j]
                dp[v][j] = (dp[v][j] + dp[s][i] * k) % mod;
            }
        }
    }

    int ret = 0;
    for (int i = 0; i <= N; i++)
        ret = (ret + dp[ed][i]) % mod;
    return ret;
}

int gcd(int a, int b) { return b == 0 ? a : gcd(b, a%b); }

int main () {
    for (int i = 0; i < 14; i++) {
        for (int j = i; j < 14; j++)
            ok[i][j] = ok[j][i] = (gcd(f[i], f[j]) == 1);
    }

    int cas, m, c[16];
    scanf("%d", &cas);
    while (cas--) 
    {
        N = 0;
        memset(c, 0, sizeof(c));
        scanf("%d%d", &m, &mod);
        for (int i = 1; i <= m; i++) 
        {
            N = max(N, be[i]);
            c[be[i]]++;
        }
        for (int i = 0; i <= N; i++)
            bit[i] = c[i] + 1;
        printf("%d\n", solve(idx(c)));
    }
    return 0;
}