洛谷 CF414B Mashmokh and ACM

题目链接

题目大意

如果一个数列的每后一项都为前一项的倍数，那么这个数列为好数列，现在给出n和k，分别代表数列的最大值和数列的长度，求满足条件的好数列有多少种。

初步思路

首先这道题肯定是一道动态规划题，那我们想想该怎么规划，我一开始想到的是dp[i][j]表示最大数为i长度为j时的最优解，但是想了很久没想出状态转移方程 (可能是本龃龉太菜了) ，然后在那找规律，于是乎发现了新大陆 wu~ ，当我们在数列后加一个值为x的数时，他的贡献时多少呢？

我们重新在看一下题目，只有后一项为前一项的倍数的时候，这个数列才能依旧是好数列，那么我们往后加一个值为x的数，想要数列依旧保持好数列，那只能加在上一项是x的因子的数列上面，于是乎转移方程就出来了 wu hu~。

dp[i][j] = (dp[i][j] + dp[i-1][l]) % mod;//l是j的因子

于是乎我们可以用一个三重循环来计算答案：

for (int i = 2; i <= k; ++i) {
    for (int j = 1; j <= n; ++j) {
      for (int l = 1; l <= n; ++l) {
        if (j % l == 0) dp[i][j] = (dp[i][j] + dp[i-1][l]) % mod;
      }
    }
  }

但由于数据范围较大O(n^3)肯定是过不去的，所以我们可以根据倍数的性质优化最后一重循环。于是乎：

for (int i = 2; i <= k; ++i) {
    for (int j = 1; j <= n; ++j) {
      for (int l = 1; l <= n/j; ++l) {
        dp[i][j*l] = (dp[i][j*l] + dp[i-1][l]) % mod;
      }
    }
  }

最后 Σdp[k][i] 就可以AC了。

上代码！！！

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<stack>
#include<queue>
#include<map>
#define ll long long
#define pi acos(-1)
#define inf 0x3f3f3f3f
#define pii pair<int, int>
#define fi first
#define se second
#define l_son node<<1
#define r_son node<<1|1
#define mp(a, b) make_pair(a, b)
#define piii pair<pii, int>
#define uf(a, b, i) for (register int i = (a); i <= (b); ++i)
#define df(a, b, i) for (register int i = (a); i >= (b); --i)
using namespace std;
inline int read() {
	int x = 0, f = 1;
	char ch = getchar();
	while(ch < '0' || ch > '9') {
		if(ch == '-') f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9') {
		x = x * 10 + ch - '0';
		ch = getchar();
	}
	return x * f;
}
template<class T>
inline void print(T x) {
	if(x > 9) print(x/10);
	putchar(x%10 + '0');
}
template<class T>
T Max(T a, T b) {
  return a > b ? a : b;
}
template<class T>
T Min(T a, T b) {
  return a < b ? a : b;
}
const ll mod = 1e9 + 7;
int n, k, ans;
int dp[2003][2003];
void scan() {
  n = read(); k = read();
}
void work() {
  uf (1, n, i) {
    dp[1][i] = 1;
  }
  uf (2, k, i) {
    uf (1, n, j) {
      uf (1, n/j, l) {
        dp[i][l*j] = (dp[i][l*j] + dp[i-1][j]) % mod;
      }
    }
  }
  uf (1, n, i) {
    ans = (ans + dp[k][i]) % mod;
  }
  print(ans);
  putchar('\n');
}
int main() {
	scan();
	work();
	return 0;
}