codeforce1558B

# codeforce1558B

### 题意

题意是一个点的位置为x,则它分别可以向$x-z$($ 1 \le z \le x-1 $ )跳转

以及可以向$\lfloor \frac{x}{z} \rfloor$($ 2 \le z \le x$ )跳转

询问1到n到底有多少条路径

### 解法1：

显然$ dp $可解,令$f(x)$表示$1$到$x$的路径数,则令$f(1) = 1$,则可以得到$dp$转移的公式为$f(x)  = \sum_{i=1}^{x-1} f(i) + \sum_{i=2}^x f( \lfloor \frac{x}{z} \rfloor)$ ,对于$\sum_{i=1}^{x-1}f(i)$,可以使用前缀和优化,复杂度为$O(1)$,对于$\sum_{i=2}^x f( \lfloor \frac{x}{z} \rfloor)$,使用数论分块,时间复杂度为$O(\sqrt n)$,最后总的时间复杂度为$O(n\sqrt n)$,代码如下:

```c++
#include<bits/stdc++.h>
#define int long long
using namespace std;

const int maxn = 2e5+5;
int dp[maxn];
signed main(){
  int n,m;
  cin >> n >> m;
  int sum = 1; 
  dp[1] = 1;
  for(int i=2;i<=n;i++){
    dp[i] = sum;
    for(int k = 2,j;k<=i;k=j+1){
      j = i/(i/k);
      dp[i] = (dp[i] + (j-k+1)*dp[i/(k)]%m)%m;
    }
    (sum+=dp[i])%=m;
  }
  cout << dp[n] << endl;
}
```

### 解法2:

$O(n \sqrt n)$对于hard版显然不够更优,下面一给出一种更优的解法,经过观察可以发现,每个$f(x)$其实可以视为一个多重集合,里面总共包含$2x-2$个元素,其中对于$f(x+1)$,它与$f(x)$的不同主要是以下两部分:

- 首先对于新增的两个元素,可以观察到是$f(x)$(由$f(x+1)$减去$1$转移而来)和$f(1)$(由$f(x+1)$除以$x+1$转移而来).
- 再者是数论分块的部分,因为分母改变了$\sum_{z=2}^x f( \lfloor \frac{x}{z} \rfloor) -> \sum_{z=2}^{x+1} f( \lfloor \frac{x+1}{z} \rfloor)$.

这样的话当我们从$f(x)$到$f(x+1)$,转移时,仅仅需要考虑这两部分的变化,这样的话就可以提升效率,总复杂度大约是$ \frac{n}{1} + \frac{n}{2} + \cdots +\frac{n}{n} \approx nln(n) + c$.这样的话时间复杂度就可以降到$O(nlogn)$.

对于第二部分的处理,我们可以使用直接求出每个数的所有因子,代码如下:

```c++
#include<bits/stdc++.h>
#define int long long 
#define io ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
using namespace std;

const int maxn = 2e5+5;
bitset<maxn> num;
vector<int> d[maxn];
int dp[maxn];
void init(void){
    for(int i=2;i<maxn;i++){
        for(int j=i*2;j<maxn;j+=i){
            d[j].push_back(i);
        }
    }
}
signed main(){
    io;init();
    int n,m;cin >> n >> m;
    dp[2] = 2;
    dp[1] = 1;
    for(int i=3;i<=n;i++){
        dp[i] = dp[i-1]*2LL+dp[1];
        dp[i]%=m;
        for(int j = 0;j<d[i].size();j++){
            dp[i] = dp[i] + dp[i/d[i][j]] - dp[(i-1LL)/d[i][j]];
            (dp[i] += m)%=m;
        }
    }
    cout << dp[n] << endl;
}
```

 这份代码效率很高,解法一需要用$3000ms$,而解法二只需要$300ms$不到.如果不用vector甚至可以低于100ms.

但是它对于hard版,又有了个致命问题,它会MLE.原因是存储每个数的所有因子实在是太花空间了,那有没有更好的方法呢?

显然是有的,就是用在求因子的过程中,顺便求出dp数组的值,过程有点类似于筛法,这样的话就可以省出存储因子的那部分空间,这个hard版也终于可以顺利的AC了!

代码如下:

```c++
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
LL n,mod,dp[4000005],sum[4000005];
int main(){
    scanf("%lld %lld",&n,&mod);
    for(LL i=1;i<=n;i++){
        dp[i] = (dp[i-1]*2 + sum[i])%mod;
        if(i==1)dp[1]=1;
        if(i==2)dp[2]=2;
            for(LL j=2;j*i<=n;++j){
          (sum[j*i]+=dp[i])%=mod;
          (sum[min(j*(i+1),n+1)]+=mod-dp[i])%=mod;
        }
    }
    printf("%lld",dp[n]);
    return 0;
}
```

这道题的质量很高,包括对空间的优化和对时间的优化,不愧是tourist出的题.