思路
这道题真的是一道不太好想的dp…真的太菜了
首先状态转移分成两种情况
- 区间长度相等的情况,如
这种情况就是看看你现在的区间有几个约数,那么代表有几种这样的situation
记为v[i]
- 包含情况,如
dp[i]+=dp[i-1]
dp[i]+=dp[i-1]
这样的就是dp[i]+=dp[i-1]+dp[i-2]
当然还有这样的
这样的就是,两个区间交替,外层区间谁也没有包谁那么就是
dp[i]+=dp[i-2]
那么状态转移方程就是
d
p
[
i
]
=
d
p
[
i
−
1
]
+
d
p
[
i
−
2
]
+
.
.
.
+
d
p
[
2
]
+
d
p
[
1
]
+
v
[
i
]
dp[i]=dp[i-1]+dp[i-2]+...+dp[2]+dp[1]+v[i]
dp[i]=dp[i−1]+dp[i−2]+...+dp[2]+dp[1]+v[i]
#include<iostream>
using namespace std;
typedef long long ll;
ll dp[2102100];
ll v[2102100];
const ll modd=998244353;
int main(){
ll n;
cin>>n;
for(ll i=1;i<=n;i++){
for(ll j=i;j<=n;j+=i) v[j]++;
}
dp[1]=1;
ll sum=dp[1];
for(ll i=2;i<=n;i++){
dp[i]+=sum;
dp[i]%=modd;
dp[i]+=v[i];
sum+=dp[i];
sum%=modd;
dp[i]%=modd;
}
cout<<dp[n]<<endl;
}
重做笔记
#include<iostream>
#include<cstring>
using namespace std;
typedef long long ll;
const ll N=998244353;
ll dp[2102100];
ll s[2102100];
ll sum;
int main(){
int n;
cin>>n;
//memset(s,1,sizeof s);
//s[1]=1;
for(int i=1;i<=n;i++)
for(int j=1;j<=n/i;j++)
s[i*j]++,s[i*j]%=N;
//cout<<s[2]<<endl;
for(int i=1;i<=n;i++){
dp[i]=sum+s[i];
sum+=dp[i];
dp[i]%=N;
sum%=N;
}
cout<<dp[n]<<endl;
}
枚举那块千万要优化,否则时间复杂度让你难以想象!!!(就是s数组)
UPD:2021/10/28
这个题的思路其实这块不难推:
d
p
[
i
]
=
d
p
[
i
−
1
]
+
d
p
[
i
−
2
]
+
d
p
[
i
−
3
]
+
.
.
.
.
d
p
[
1
]
+
?
dp[i]=dp[i-1]+dp[i-2]+dp[i-3]+....dp[1]+?
dp[i]=dp[i−1]+dp[i−2]+dp[i−3]+....dp[1]+?
当前的状态一定是前面的状态的前缀和,但是如何想到枚举因数?我们通过分析每一个状态其实不难得到,当前dp其实就是继承前面的每一个状态,而当前的状态也一定可以排列出一种非继承的状态,也就是没有外部包装的状态,那么我们就可以进行下面的递推,那就是将这n个点,可以分成多少个整数组,这个整数组则就是新的衍生状态,每一个组之间的线对不相互影响,每一组刚好就是一个答案,素以我们在最后加上当前的枚举的i包含多少个因子即可。
#include<iostream>
using namespace std;
#define int long long
const int mod=998244353;
int v[2102100];
int dp[2102100];
signed main(){
int n;
dp[1]=1;
for(int i=1;i<=1000000;i++){
for(int j=1;j*i<=1000000;j++){
v[j*i]++;
}
}
int tot=1;
for(int i=2;i<=1000000;i++){
dp[i]+=(v[i]+tot)%mod;
tot+=dp[i];
tot%=mod;
}
cin>>n;
cout<<dp[n]<<endl;
}