【SPOJ-LCM】The Time of Day【计数DP】【离散化】

题意：

从1到n这n个数中选出一些数，使得它们的lcm不小于M。（n <= 40，M <= 2^63-1）

暴力枚举O(2^n)肯定不行，所以用质因数分解优化一下。

先预处理出lcm(1, 2, ..., 40)的质因数分解情况，发现2有6种取值，3有4种，5有3种，7有2种，11有2种，...，37有2种。

所以lcm一共有36864种取值（但是取值非常大，所以先离散化），于是按离散化后的lcm的取值进行计数dp。

设dp[i][j]表示 只考虑前i个数，lcm的取值为j时（已经离散化的）的方案数。

考虑第i个数，有两种决策。

（1）不选这个数，dp[i][j] += dp[i - 1][j]

（2）选这个数，dp[i][lcm(j, i)] += dp[i - 1][j]

求出dp后，做个后缀和就好了。

看代码吧。

#include <cstdio>
#include <algorithm>

using namespace std;

typedef unsigned long long ULL;

const int maxn = 45, maxs = 40005;

int prime[] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}, cnt = 12;
int p[] = {0, 5, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int tot;
ULL hash[maxs], dp[maxn][maxs];

void dfs(ULL x, int d) {
	if(d > cnt) {
		hash[++tot] = x;
		return;
	}
	for(int i = 0; i <= p[d]; i++) {
		dfs(x, d + 1);
		x *= prime[d];
	}
}

inline ULL gcd(ULL a, ULL b) {
	for(; b; b ^= a ^= b ^= a %= b);
	return a;
}

inline ULL lcm(ULL a, ULL b) {
	return a / gcd(a, b) * b;
}

inline int getid(ULL x) {
	int l = 1, r = tot;
	while(l <= r) {
		int mid = l + r >> 1;
		if(hash[mid] < x) l = mid + 1;
		else r = mid - 1;
	}
	return l;
}

int main() {
	dfs(1, 1);
	sort(hash + 1, hash + 1 + tot);

	for(int i = 1; i <= 40; i++) dp[i][i] = 1;
	for(int i = 2; i <= 40; i++) for(int j = 1; j <= tot; j++) if(dp[i - 1][j]) {
		dp[i][j] += dp[i - 1][j];
		dp[i][getid(lcm(hash[j], hash[i]))] += dp[i - 1][j];
	}
	for(int i = 1; i <= 40; i++) for(int j = tot - 1; j >= 1; j--) dp[i][j] += dp[i][j + 1];

	int T; scanf("%d", &T);
	for(int cas = 1; cas <= T; cas++) {
		int n; ULL m; scanf("%d%llu", &n, &m);
		printf("Case #%d: %llu\n", cas, dp[n][getid(m)]);
	}

	return 0;
}