Codeforces Round #740 (Div. 2, based on VK Cup 2021 - Final (Engine))

D1 题

题目陈述

• 题目大致就是对于$1n$每个位置都可以转移到比他小的位置，两种转换方式，一种是直接转移$1-(n-1)$，一种是转移到$\lfloor \frac{n}{z}\rfloor ,z\in [2,n]$，有n个位置，总有有多少种方案，答案取模m

算法思路

• 既然涉及到向下取整，又有区间，这不很显然？整除分块！！
• dp的思想来看，$1-(x-1）$的任何一个状态都可以转移到$x$，因为是线性递推的，故我们可以使用一个前缀和数组sum[]来记录这个
• 对于第二种转移方式，就是整除，不过值得注意的是，$z\in [2,x]$，所以我们整除分块$l$的初始值应该为$2$
• 知道了$l$，就可以通过性质推出$r=\frac{i}{\lfloor \frac{i}{l}\rfloor }$
• 对于一整块区间$i\in [l,r]$，他们$\lfloor \frac{n}{i}\rfloor$的值都是一样的，所以这一整段区间的值，都可以由$dp[n/i]$转移过来
• 故，我们可以得到状态转移方程为$dp[x]={\sum }_{i=1}^{x-1}dp[i]+\sum dp[\lfloor \frac{x}{l}\rfloor ]$
• 当然，此题目有两种，写法，一种是逆序，一种是顺序，顺序的话用的是dp思维，逆序的话理解起来就是题意，从n到1，把每一片长条移动过去，某一个位置可以放几块，最后1这个位置总得有几块。
• 时间复杂度$O(n\sqrt{n})$

代码实现

#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;

#define debug(x) cerr << #x << ": " << x << '\n'
#define bd cerr << "----------------------" << el
#define el '\n'
#define cl putchar('\n')
#define pb push_back
#define eb emplace_back
#define x first
#define y second
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define loop(i, a, b) for (int i = (a); i < (b); i++)
#define dwn(i, a, b) for (int i = (a); i >= (b); i--)
#define ceil(a, b) (a + (b - 1)) / b
#define ms(a, x) memset(a, x, sizeof(a))
#define inf 0x3f3f3f3f
#define db double

typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<db, db> PDD;
typedef vector<int> vci;
typedef map<int, int> mii;
typedef mii::iterator mii_it;

const int N = 2e6 + 2, M = 2e6 + 10, E = 1e3 + 10, md = 1e9 + 7;
const double PI = acos(-1), eps = 1e-8;

// int T, n, m;
LL ans, n, m, dp[N], suf[N], f[N], sum[N];
int main()
{
    cin.tie(0);
    cout.tie(0);
    cin >> n >> m;
    f[1] = sum[1] =1;
    rep(i, 2, n)
    {
        f[i] = (sum[i - 1] + f[i]) % m;
        for (int l = 2, r; l <= i; l = r + 1)
        {
            r = i / (i / l);
            f[i] = (f[i] + (r - l + 1) * f[i / l]) % m;
        }
        sum[i] = (sum[i - 1] + f[i]) % m;
    }
    cout << f[n] <<el;
    // dp[n] = 1; 逆序做法
    // dwn(i, n, 1)
    // {
    //     dp[i] = dp[i] + suf[i + 1];
    //     dp[i] %= m;
    //     suf[i] = dp[i] + suf[i + 1];//suf代表后缀和
    //     suf[i] %= m;
    //     for (int l = 2, r; l <= i; l = r + 1)//代表选取的z
    //     {
    //         r = i / (i / l);
    //         dp[i / l] = (dp[i / l] + (r - l + 1) * dp[i]) % m;
    //     }
    // }
    // cout << dp[1] << el;
}

D2题

算法思路

• 这边理解起来，得用题意的逆序，比较好理解，就是上面的代码注释掉的，不过其实差别也不大，就是转移方程反过来
• D2比D1数据范围大了20倍，其实先做D1很容易被整除分块给带偏，我们上面考虑的事因数（商），这边我们反过来想，考虑倍数。
• 对于一个数$i$，那么某种倍数$j$，会让$[i\times j,i\times j+j)$的长条都移动到$i$位置
• 当然，考虑边界$j\ast i<=n$且$j\ast i+j\le n+1$
• 注意此处不是$j\ast i+i$而是$j\ast i+j$，因为对于$x$来说的话,这个区间内的一个数是$k$，则$\lfloor \frac{k}{i}\rfloor =j$，所以区间长度应该是$j$
• 枚举倍数的时间复杂度是$O(\log n)$，所以总得时间复杂度为$O(n\log n)$
• 即状态转移方程为
  

代码实现

#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;

#define debug(x) cerr << #x << ": " << x << '\n'
#define bd cerr << "----------------------" << el
#define el '\n'
#define cl putchar('\n')
#define pb push_back
#define eb emplace_back
#define x first
#define y second
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define loop(i, a, b) for (int i = (a); i < (b); i++)
#define dwn(i, a, b) for (int i = (a); i >= (b); i--)
#define ceil(a, b) (a + (b - 1)) / b
#define ms(a, x) memset(a, x, sizeof(a))
#define inf 0x3f3f3f3f
#define db double

typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<db, db> PDD;
typedef vector<int> vci;
typedef map<int, int> mii;
typedef mii::iterator mii_it;

const int N = 4e6 + 10, M = 2e6 + 10, E = 1e3 + 10;
const double PI = acos(-1), eps = 1e-8;
LL md = 1e9 + 7;
int T, n, m;
LL suf[N], f[N];


int main()
{
    cin.tie(0);
    cout.tie(0);
    cin >> n >> md;
    f[n] = suf[n] = 1;
    dwn(i, n - 1, 1)//复杂度为调和级数
    {
        f[i] = suf[i + 1];//操作一的贡献
        for(int j = 2; j * i <= n; j ++ )
        {
            f[i] = (f[i] + suf[j * i] - suf[min(j * i + j, n + 1)]) % md;
            //区间[j * i, j * i + j - 1]的贡献，操作二
        }
        suf[i] = (suf[i + 1] + f[i]) % md;
    }
    cout << f[1] << el;
}