hdu - 6125 Free from square (状态压缩+分组背包)

最新推荐文章于 2020-11-16 22:16:37 发布

fly_tzf

最新推荐文章于 2020-11-16 22:16:37 发布

阅读量373

点赞数 1

CC 4.0 BY-SA版权

分类专栏： dp

本文链接：https://blog.youkuaiyun.com/fly_tzf/article/details/77256596

dp 专栏收录该内容

8 篇文章

订阅专栏

本文介绍了一种解决特定组合问题的方法，利用质因数分解将问题转化为二进制表示，并采用分组背包算法求解。适用于n不超过500的情况，通过将数字分为小于sqrt(n)的质因子和大于sqrt(n)的质因子两部分来优化搜索过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

思路：考虑到n最多为500，小于sqrt（n）的素因子有八个，可以用二进制表示，而大于sqrt（n）的质因子每个数只可能出现一次，即一个数分为两部分，小于sqrt（n）的质因子状压，大于sqrt（n）的质因子至多有一个用分组背包。那么含有大于sqrt（n）的素因子的数可以分组。例如71，142，213，355，426，497为一组，因为任意两个选了之后都能被71整除。组与组之间是不冲突的，因为其中小于sqrt（n）的素因子可以通过二进制表示。

用dp[j][s]表示选j个数状态为s的方案数，假设选第i组中的某个数k，那么if(state[k] & u == 0) dp[j+1][s | state[k]] += dp[j][s].

#include<cstdio>
#include<cstring>
#include<cctype>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<sstream>
#include<iterator>
#include<algorithm>
#include<string>
#include<vector>
#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#define pr(x) cout << #x << " : " << x << "   "
#define prln(x) cout << #x << " : " << x << endl
#define Size(x) (int)((x).size())
#define fi(x) ((x).first)
#define se(x) ((x).second)
#define Z(x) (*(x))
typedef long long LL;
typedef unsigned long long ULL;
const int INT_INF = 0x3f3f3f3f;
const int INT_M_INF = 0x7f7f7f7f;
const LL LL_INF = 0x3f3f3f3f3f3f3f3f;
const LL LL_M_INF = 0x7f7f7f7f7f7f7f7f;
const double pi = acos(-1.0);
using namespace std;
inline void debug(char ch){for(int __ii = 0; __ii < 20; ++__ii)putchar(ch);printf("\n");}
const double eps = 1e-8;
inline int dcmp(double a, double b) {
    if(fabs(a - b) < eps)  return 0;
    return a < b ? -1 : 1;
}
#define fin freopen("in.txt", "r", stdin)
#define fout freopen("out.txt", "w", stdout)
const int dr[] = {0, 0, -1, 1, -1, -1, 1, 1};
const int dc[] = {-1, 1, 0, 0, -1, 1, -1, 1};
const int MAXN = 500 + 50;
const int MAXT = 10000 + 10;

const int MOD = 1e9 + 7;
int state[MAXN];
bool flag[MAXN];
int n, k, d[2][MAXN][(1 << 8) + 100];
int r[8] = {2, 3, 5, 7, 11, 13, 17, 19};
vector<int> g[MAXN];
int f[MAXN];
void init(){
    memset(state, 0, sizeof state);
    memset(flag, false, sizeof flag);
    for(int i = 1; i <= 500; ++i) f[i] = i;
    for(int num = 1; num <= 500; ++num) {
        int u = num;
        for(int j = 0; j < 8; ++j)
            if(u % r[j] == 0) {
                int tmp = 0;
                while(u % r[j] == 0) {
                    u /= r[j];
                    ++tmp;
                }
                if(tmp >= 2) {
                    flag[num] = true;
                    break;
                }
                else if(tmp == 1)  {
                    f[num] = u;
                    state[num] |= (1 << j);
                }
            }
    }
    for(int i = 1; i <= 500; ++i){
        if(!flag[i]){
            if(f[i] == 1) g[i].push_back(i);
            else g[f[i]].push_back(i);
        }
    }
}

int solve() {
    memset(d, 0, sizeof d);
    d[0][0][0] = 1;
    int now = 0;
    for(int i = 1; i <= n; ++i) {
        if(flag[i] || g[i].size() == 0)  continue;
        int nex = now ? 0 : 1;
        for(int j = k; j >= 0; --j) {
            for(int u = 0; u < (1 << 8); ++u) {
                for(int l = 0; l < g[i].size(); ++l){
                    d[nex][j][u] = d[now][j][u];
                    int x = g[i][l];
                    if(x > n) continue;
                    if(!(state[x] & u)) {
                        d[nex][j + 1][u | state[x]] += d[now][j][u];
                        if(d[nex][j + 1][u | state[x]] >= MOD)
                            d[nex][j + 1][u | state[x]] -= MOD;
                    }
                }

            }
        }
        now = nex;
    }
    int ans = 0;
    for(int i = 1; i <= k; ++i)
        for(int j = 0; j < (1 << 8); ++j) {
            ans += d[now][i][j];
            if(ans >= MOD) ans -= MOD;
        }
    return ans;
}

int main() {
    init();
    int T;  scanf("%d", &T);
    while(T--) {
        scanf("%d%d", &n, &k);
        printf("%d\n", solve());
    }
    return 0;
}