NOI2015 寿司晚宴

题目大意

给出$2$到$n$共$n-1,nle 500$个数字，求从中选出两个集合使得从两个集合内各取任意一个数字互质的方案数。

简要题解

要满足题中的条件，其实就是要求两个集合中出现的质因子不同。注意到$n,nle 500$以内的数字，要么只存在一个大于$sqrt{n}$的质因子，要么可以由前$8$个质数分解。对于后者，拉出来用$8$位$bit$表示质因子情况压位DP出$f[i][j][k]$表示从前$i$个数字中取出两个集合内质因子状态分别为$j,k$的方案数；再考虑把前者加到DP中去，对于前者中的数，只需要确定把它放在哪个集合即可，而不需要去记录在状态中，因为我们一次性考虑完所有带这个大于$sqrt{n}$的质因子的数：要么不选，要么只能放到同一个集合中去，这样就可以减少状态同时避免了后效性。

想的时候确实考虑到所有的合数可以由前$8$个素数筛完，但没有进一步想到如何利用这个性质来简化状态。

然后就是喜闻乐见地打错下标WA了一发。。

#include <bits/stdc++.h>
using namespace std;
namespace my_header {
#define pb push_back
#define mp make_pair
#define pir pair<int, int>
#define vec vector<int>
#define pc putchar
#define clr(t) memset(t, 0, sizeof t)
#define pse(t, v) memset(t, v, sizeof t)
#define bl puts("")
#define wn(x) wr(x), bl
#define ws(x) wr(x), pc(' ')
    const int INF = 0x3f3f3f3f;
    typedef long long LL;
    typedef double DB;
    inline char gchar() {
        char ret = getchar();
        for(; (ret == '
' || ret == '
' || ret == ' ') && ret != EOF; ret = getchar());
        return ret; }
    template<class T> inline void fr(T &ret, char c = ' ', int flg = 1) {
        for(c = getchar(); (c < '0' || '9' < c) && c != '-'; c = getchar());
        if (c == '-') { flg = -1; c = getchar(); }
        for(ret = 0; '0' <= c && c <= '9'; c = getchar())
            ret = ret * 10 + c - '0';
        ret = ret * flg; }
    inline int fr() { int t; fr(t); return t; }
    template<class T> inline void fr(T&a, T&b) { fr(a), fr(b); }
    template<class T> inline void fr(T&a, T&b, T&c) { fr(a), fr(b), fr(c); }
    template<class T> inline char wr(T a, int b = 10, bool p = 1) {
        return a < 0 ? pc('-'), wr(-a, b, 0) : (a == 0 ? (p ? pc('0') : p) : 
            (wr(a/b, b, 0), pc('0' + a % b)));
    }
    template<class T> inline void wt(T a) { wn(a); }
    template<class T> inline void wt(T a, T b) { ws(a), wn(b); }
    template<class T> inline void wt(T a, T b, T c) { ws(a), ws(b), wn(c); }
    template<class T> inline void wt(T a, T b, T c, T d) { ws(a), ws(b), ws(c), wn(d); }
    template<class T> inline T gcd(T a, T b) {
        return b == 0 ? a : gcd(b, a % b); }
    template<class T> inline T fpw(T b, T i, T _m, T r = 1) {
        for(; i; i >>= 1, b = b * b % _m)
            if(i & 1) r = r * b % _m;
        return r; }
};
using namespace my_header;

const int MAXN = 500 + 10;
const int PNUM = 8;
const int SNUM = 1 << 8;
const int PRI[] = {2, 3, 5, 7, 11, 13, 17, 19};
int n, mod;
int fac[MAXN], rem[MAXN];
int f[2][2][MAXN][MAXN], d[2][MAXN][MAXN], (*g)[MAXN];

void add(int &x, int y) {
    x += y;
    if (x >= mod)
        x -= mod;
}

int main() {
#ifdef lol
    freopen("129.in", "r", stdin);
    freopen("129.out", "w", stdout);
#endif

    fr(n, mod);
    for (int i = 2; i <= n; ++i) {
        rem[i] = i;
        for (int j = 0; j < PNUM; ++j)
            if (rem[i] % PRI[j] == 0) {
                fac[i] |= 1 << j;
                while (rem[i] % PRI[j] == 0)
                    rem[i] /= PRI[j];
            }
    }
    int cur = 0, lst = 1;
    d[cur][0][0] = 1;
    for (int i = 2; i <= n; ++i)
        if (rem[i] == 1) {
            swap(cur, lst);
            memcpy(d[cur], d[lst], sizeof d[cur]);
            for (int j = 0; j < SNUM; ++j)
                for (int k = 0; k < SNUM; ++k) {
                    if (!(k & fac[i]))
                        add(d[cur][j | fac[i]][k], d[lst][j][k]);
                    if (!(j & fac[i]))
                        add(d[cur][j][k | fac[i]], d[lst][j][k]);
                }
        }
    g = d[cur];

    //for (int i = 0; i < 4; ++i) {
    //    for (int j = 0; j < 4; ++j)
    //        ws(g[i][j]);
    //    bl;
    //}

    for (int i = 2; i <= n; ++i)
        if (rem[i] != 1) {
            cur = 0, lst = 1;
            memcpy(f[0][cur], g, sizeof f[0][cur]);
            memcpy(f[1][cur], g, sizeof f[1][cur]);
            for (int y = rem[i], x = y; x <= n; x += y) {
                rem[x] = 1;
                swap(cur, lst);
                memset(f[0][cur], 0, sizeof f[0][cur]);
                memset(f[1][cur], 0, sizeof f[1][cur]);
                for (int j = 0; j < SNUM; ++j)
                    for (int k = 0; k < SNUM; ++k) {
                        add(f[0][cur][j][k], f[0][lst][j][k]);
                        add(f[1][cur][j][k], f[1][lst][j][k]);
                        if (!(k & fac[x]))
                            add(f[0][cur][j | fac[x]][k], f[0][lst][j][k]);
                        if (!(j & fac[x]))
                            add(f[1][cur][j][k | fac[x]], f[1][lst][j][k]);
                    }
            }
            for (int j = 0; j < SNUM; ++j)
                for (int k = 0; k < SNUM; ++k)
                    g[j][k] = ((f[0][cur][j][k] + f[1][cur][j][k] - g[j][k]) % mod + mod) % mod;
        }
    int ans = 0;
    for (int j = 0; j < SNUM; ++j)
        for (int k = 0; k < SNUM; ++k)
            add(ans, g[j][k]);
    wt(ans);

    return 0;
}