CF1559E Mocha and Stars（dp+莫比乌斯反演）

最新推荐文章于 2024-09-20 15:09:03 发布

_九磅十五便士_

最新推荐文章于 2024-09-20 15:09:03 发布

阅读量285

点赞数

分类专栏：算法题解分类文章标签：算法动态规划 c++

本文链接：https://blog.csdn.net/m0_51841071/article/details/126594567

版权

算法题解分类专栏收录该内容

6 篇文章 0 订阅

订阅专栏

求有多少长 $n$ 的序列 $a$ 满足：

$l_i\le a_i\le r_i$
$\sum_{i=1}^{n}a_i\le m$
$\gcd(a_1,\dots,a_n)=1$

答案对 $998244353$ 取模。

样例输入 #1

2 4
1 3
1 2

样例输出 #1

只看前两个条件，我们发现就直接是一个背包问题，枚举 $a_i$ ，枚举背包状态，然后遍历所有的位置，时间复杂度是 $O(m^2n)$ ,很显然，这个时间复杂度不能满足我们的要求，需要注意的是，题目问的是 $<= m$ 。

dp[0]=1;//意义是：恰好等于下标的种类数
for(int i=1;i<=n;i++){
    memset(f,0,sizeof f);
    for(int j=l[i];j<=r[i];j++){
        for(int k=j;k<=m;j++){
            f[k]+=dp[k-j];
        }
    }
    dp[0]=0;
    for(int j=1;j<=m;j++)dp[i]=dp[i]+f[i];
}

但是其实我们发现，中间的状态转移，用前缀和就可以完美解决

for(int i=0;i<=m;i++)dp[i]=1;//意义是：小于等于下标的种类数（因此使用前缀和）
for(int i=1;i<=n;i++){
    memset(f,0,sizeof f);
    for(int j=l[i];j<=m;j++){
        f[j]+=dp[j-l[i]];
        if(j>r[i]){
            f[j]-=dp[j-r[i]-1];//要[l[i],r[i]]区间的数，大于r[i]的数无法转移，因此减掉
        }
    }
    dp[0]=0;
    for(int j=1;j<=m;j++)dp[i]=dp[i-1]+f[i];
}

时间复杂度是 $O (nm)$ 还可以~

于是现在求的问题就是

$\displaystyle\sum_{a_1=l[1]}^{r[1]}\displaystyle\sum_{a_2=l[2]}^{r[2]}...\displaystyle\sum_{a_n=l[n]}^{r[n]}f(a_1,a_2...a_n)*[gcd(a_1,a_2...a_n)=1]$

转换一下

$\displaystyle\sum_{a_1=l[1]}^{r[1]}\displaystyle\sum_{a_2=l[2]}^{r[2]}...\displaystyle\sum_{a_n=l[n]}^{r[n]}f(a_1,a_2...a_n)*ε(gcd(a_1,a_2...a_n)=1)$

展开

$\displaystyle\sum_{a_1=l[1]}^{r[1]}\displaystyle\sum_{a_2=l[2]}^{r[2]}...\displaystyle\sum_{a_n=l[n]}^{r[n]}f(a_1,a_2...a_n)*\displaystyle\sum_{d|gcd(a_1,a_2...a_n)}^{}μ(d)$

交换枚举顺序

$\displaystyle\sum_{d=1}^{m}μ(d)\displaystyle\sum_{a_1=l[1]/d}^{r[1]/d}\displaystyle\sum_{a_2=l[2]/d}^{r[2]/d}...\displaystyle\sum_{a_n=l[n]/d}^{r[n]/d}f(a_1*d,a_2*d...a_n*d)$

枚举倍数是调和级数，时间复杂度是 $O (l nm)$ ，枚举 $n$ 个数，那么时间复杂度是 $n l nm$ ，前面的 $d$ 枚举起来是 $m$ ，因此时间复杂度是 $O (nm l nm)$

#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
const int mod = 998244353;
int check[N + 5], n, m;
int mu[N + 5], p[N + 5];
bool flg[N + 5];
int dp[N];
int l[N];
int r[N];
void mobius()
{
    int tot = 0;
    mu[1] = 1;
    for (int i = 2; i <= N; ++i)
    {
        if (!flg[i])
        {
            p[++tot] = i;
            mu[i] = -1;
        }
        for (int j = 1; j <= tot && i * p[j] <= N; ++j)
        {
            flg[i * p[j]] = 1;
            if (i % p[j] == 0)
            {
                mu[i * p[j]] = 0;
                break;
            }
            mu[i * p[j]] = -mu[i];
        }
    }
}
signed main()
{
    mobius();
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        cin >> l[i] >> r[i];
    int ans = 0;

    for (int d = 1; d <= m; d++)
    {
        if (!mu[d])
            continue;
        int tot = 0;
        int sum = m / d;
        vector<int> dp(sum + 1, 1);
        for (int i = 1; i <= n; i++)
        {
            vector<int> f(sum + 1);
            for (int j = (l[i] + d - 1) / d; j <= sum; j++)
            {
                f[j] = dp[j - (l[i] + d - 1) / d];
                if (j >= r[i] / d + 1)
                    f[j] = (f[j] - dp[j - r[i] / d - 1] + mod) % mod;
            }
            dp[0] = 0;
            for (int j = 1; j <= sum; j++)
                dp[j] = (dp[j - 1] + f[j]) % mod;
        }
        ans = ((ans + dp[sum] * mu[d]) % mod + mod) % mod;
    }
    cout << ans << endl;
}