思路

Part 1

这种题目应该能一眼看出是 DP。

我们令 \(dp_{i,j}\) 表示走到 \(j\) 这个位置，最后一步花了 \(i\) 的倍数。

那么，我们的方程就很好想了：\(dp_{i,j} = \sum_{k = 1}^{j - k \times i \geq 0}dp_{i - 1,j - k \times i}\)。

因为，我们走到 \(j\) 的位置只能走 \(i\) 的倍数，所以我们上一步一定是走了 \(k \times i(k > 0)\) 的位置。又由于，我们的步长（即每一次的 \(i\)）每一步都会加 \(1\)，所以上一次状态的步长一定是 \(i - 1\)。

然后我们再利用一下前缀和即可。

但是，会有人对这个时间复杂度有所疑惑，这表面上是 \(\Theta(N^2)\) 的，实际上这有 \(\Theta(N \sqrt N)\)。

我们不难发现，我们要枚举的步长是会产生一个上限的。

假如在最不利的情况下，初始步长为 \(1\)。

因为，我们要满足 \((\sum_{i = 1}^{i \leq x}i) \leq N\)（其中，\(x\) 为满足条件的任意数，也就是我们程序中代码外层循环的次数）

由等差数列可知，\((\sum_{i = 1}^{i \leq x}i) = \frac{x(x + 1)}{2}\)，因此，\(x \leq \sqrt {2N}\)。

综上，我们的时间复杂度为 \(\Theta(N \sqrt N)\)。

Part 2

虽然上述方法已经足矣通过此题，但是我们依旧可以对空间进行优化。

我们可以发现，每一次的状态只与它前面的位置有关，于是，我们只需要用前缀和记录上一个状态，再将新的状态覆盖到原位置上即可。

这样我们的空间复杂度由 \(\Theta(N \sqrt N)\) 降为了 \(\Theta(N)\)。

Code

#include <bits/stdc++.h>  
#define re register  
  
using namespace std;  
  
const int N = 2e5 + 10,mod = 998244353;  
int n,k,cnt;  
int s[N],ans[N];  
int dp[N] = {1};  
  
inline int read(){  
    int r = 0,w = 1;  
    char c = getchar();  
    while (c < '0' || c > '9'){  
        if (c == '-') w = -1;  
        c = getchar();  
    }  
    while (c >= '0' && c <= '9'){  
        r = (r << 3) + (r << 1) + (c ^ 48);  
        c = getchar();  
    }  
    return r * w;  
}  
  
int main(){  
    n = read();  
    k = read();  
    while (k <= n && cnt <= n){//需要判断总和是否大于 n   
        for (re int i = 0;i <= n;i++){  
            int t = (i - k >= 0 ? s[i - k] : 0);//需要判断一下是否越界   
            s[i] = (t + dp[i]) % mod;//更新前缀和 注意：这里的 dp[i] 还是未更新的值，所以请放心使用   
            dp[i] = t;//更新   
            ans[i] = (ans[i] + dp[i]) % mod;//每一次更新答案   
        }  
        cnt += k++;//每次更新总和   
    }  
    for (re int i = 1;i <= n;i++) printf("%d ",ans[i] % mod);  
    return 0;  
}