min25筛学习总结

最新推荐文章于 2020-11-25 21:42:21 发布
最新推荐文章于 2020-11-25 21:42:21 发布
阅读量218 收藏
点赞数
原文链接：http://www.cnblogs.com/heyuhhh/p/11421209.html
版权

前言

杜教筛学了，顺便把min25筛也学了吧= =刚好多校也有一道题需要补。
下面推荐几篇博客，我之后写一点自己的理解就是了。
传送门1
传送门2
传送门3

这几篇写得都还是挺好的，接下来我就写下自己对min25筛的理解吧 。

正文

简介：

min25筛同杜教筛类似，是用来解决一类积性函数的前缀和，即\(\sum_{i=1}^nF(i)\)，并且这里的\(n\)可以达到\(10^{10}\)的规模。
但所求积性函数要求满足以下条件：

  • \(F(p)\)可以表示为简单多项式的形式，比如\(p_1^{k_1}+p_2^{k_2}+p_3^{k_3}\)，\(p\)为质数；
  • \(F(p^e)\)的值要较容易求得。

为什么是这样？往下看就知道啦。

求解：

我们可以将上面说的多项式拆成的每项单独来算前缀和，最后加起来即可。
设\(f(p)=p^k\)，我们现在就来求\(f(i)\)的前缀和。注意这里\(f\)函数是完全积性函数，后面我们需要用到这一性质。

Part 1:
首先设\(g(n,j)\)表示：\(1,2...n\)中，满足条件的\(f\)之和，满足条件是指要么为质数，要么其最小质因子大于第\(j\)个质数。
为什么要这么设？后面就知道啦。
之后我们考虑递推求解：

  • 若\(p_j^2>n\)，根据定义，\(g(n,j)=g(n,j-1)\)；
  • 否则，我们要减去最小质因子为\(p_j\)的数，那么就有递推式：\(g(n,j)=g(n,j-1)-f(p_j)*(g(\frac{n}{p_j},j-1)-sum_{j-1})\)。
  • 解释一下上式，就相当于首先提取一个\(p_j\)出来，那么只要减去剩下的质因子大于等于\(p_j\)的就行啦；但根据定义，\(g\)中还包含了\(\sum_{i=1}^{j-1}f(p_i)\)，我们减去就行了。另外上式还利用了完全积性函数的性质。

这里是min25筛的关键。

我们还可以用筛法的思想去考虑，我们从\(p_{j-1}\)递推到\(p_j\)的过程，其实就是在埃氏筛中，把\(p_j\)的倍数筛去。每次得到的\(g(n,j)\)，其实就是利用前\(j\)个素数来进行埃氏筛，剩下的数以及所有质数的\(f\)之和。
这也是为啥min25后面有个“筛”的原因~

从筛法的角度来考虑，那么初始化时我们将所有的数都看作素数，然后一个一个来筛求解即可（1除外，我们先不考虑1，最后考虑即可）。

Q:那为什么要求出这个呢？
A:求出\(g\)之后，我们可以方便地求出\(\sum_pf(p)\)的值，即\(g(n,|P|)\)，其中\(|P|\)为素数集大小。

那合数怎么办？

Part 2:
上面我们把质数的情况考虑了，利用了类似埃氏筛的思想递推得到了\(g\)函数。
接下来我们考虑合数的情况，因为\(F\)为积性函数，那么我们直接枚举最小质因子以及其次数来求解即可。
类似地，定义\(S(n,j)\)表示\(1,2,\cdots,n\)中，满足条件的\(F\)之和，满足条件是指最小质因子大于等于(这里有个等于，其实也可以没有~)第\(j\)个质数。
那么可以直接暴力求解\(S\):
\[ S(i,j)=g(i,|P|)-sum_{j-1}+\sum_{k\geq j}\sum_{e}F(p_k^e)(S(\frac{i}{p_k^e},k+1)+[e\not ={1}]) \]

稍微解释一下：前面部分就相当于我们求出了满足条件的\(F\)之和，这里的条件指的是大于等于\(p_j\)的质数。
接下来我们就相当于暴力枚举最小的质因子以及其次方，并且根据其积性函数的性质，将枚举值提出来，然后递归求解子问题。
但我们对于\(p_k^e\)这种数没有统计到，所以后面加上就行了。
那么最终答案就为\(S(n,1)+F(1)\)。

所以...min25筛就这么完了。似乎也不是很难。
但我还想加个

Part 3:
虽然min25筛的思想说得差不多了，但我还想说一下其实现的一些细节。毕竟代码也是很重要的。
下面以模板题为例：

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e6 + 5, MOD = 1e9 + 7, inv3 = 333333336;
ll n;
ll sum1[N], sum2[N], prime[N];
ll w[N], ind1[N], ind2[N];
ll g1[N], g2[N];
bool chk[N];
int tot, cnt;
void pre(int n) { //  \sqrt
    chk[1] = 1;
    for(int i = 1; i <= n; i++) {
        if(!chk[i]) {
            prime[++tot] = i;
            sum1[tot] = (sum1[tot - 1] + i) % MOD;
            sum2[tot] = (sum2[tot - 1] + 1ll * i * i % MOD) % MOD;
        }
        for(int j = 1; j <= tot && prime[j] * i <= n; j++) {
            chk[i * prime[j]] = 1;
            if(i % prime[j] == 0) break;
        }
    }
}
void calc_g() {
    int z = sqrt(n);
    for(ll i = 1, j; i <= n; i = j + 1) {
        j = n / (n / i);
        w[++cnt] = n / i;
        g1[cnt] = w[cnt] % MOD;
        g2[cnt] = g1[cnt] * (g1[cnt] + 1) / 2 % MOD * (2 * g1[cnt] + 1) % MOD * inv3 % MOD - 1;
        g1[cnt] = g1[cnt] * (g1[cnt] + 1) / 2 % MOD - 1;
        if(n / i <= z) ind1[n / i] = cnt;
        else ind2[n / (n / i)] = cnt;
    }
    for(int i = 1; i <= tot; i++) {
        for(int j = 1; j <= cnt && prime[i] * prime[i] <= w[j]; j++) {
            ll tmp = w[j] / prime[i], k;
            if(tmp <= z) k = ind1[tmp]; else k = ind2[n / tmp];
            (g1[j] -= prime[i] * (g1[k] - sum1[i - 1] + MOD) % MOD) %= MOD;
            (g2[j] -= prime[i] * prime[i] % MOD * (g2[k] - sum2[i - 1] + MOD) % MOD) %= MOD;
            if(g1[j] < 0) g1[j] += MOD;
            if(g2[j] < 0) g2[j] += MOD;
        }
    }
}
ll S(ll x, int y) { // 2~x >= P_y
    if(x <= 1 || prime[y] > x) return 0;
    ll z = sqrt(n);
    ll k = x <= z ? ind1[x] : ind2[n / x];
    ll ans = (g2[k] - g1[k] + MOD - (sum2[y - 1] - sum1[y - 1]) + MOD) % MOD;
    for(int i = y; i <= tot && prime[i] * prime[i] <= x ; i++) {
        ll pe = prime[i], pe2 = prime[i] * prime[i];
        for(int e = 1; pe2 <= x; ++e, pe = pe2, pe2 *= prime[i]) {
            ans = (ans + pe % MOD * ((pe - 1) % MOD) % MOD * S(x / pe, i + 1) + pe2 % MOD * ((pe2 - 1) % MOD) % MOD) % MOD;
        }
    }
    return ans % MOD;
}
int main() {
    cin >> n;
    int tmp = sqrt(n);
    pre(tmp);
    calc_g();
    cout << (S(n, 1) + 1) % MOD ;
    return 0;
}

接下来我会说说代码里面的一些要点：

  • 预处理部分

没什么好说的，不同的问题预处理也不同。

  • 求\(g\)部分

\[ g(n,j)=g(n,j-1)-f(p_j)(g(\frac{n}{p_j},j-1)-sum_{j-1}) \]
我先把式子抄下来...懒得翻上去了。
观察这个式子可以发现，第二维每次都是从\(j-1\)优化过来，所以我们可以直接滚动掉一维。并且，每次递推时，都是从\(\frac{n}{p_j}\)转移过来，我们联想到了\(\lfloor\frac{n}{i}\rfloor\)这个形式。
显然，因为\(n\)可能会很大，我们不能直接将\(n\)求出来，质数也是，筛那么大的数，线性筛也会超时。
下面有两个观察：

  • 观察1：递推中，有用的素数只有不超过\(\sqrt{n}\)的部分；
  • 观察2：因为\(\lfloor\frac{n}{i}\rfloor\)只有\(\sqrt{n}\)个不同的值，所以我们只需要预处理这\(\sqrt{n}\)个值就行了。

因为有了观察1，我们递推到\(\sqrt{n}\)就相当于算出了当\(j=|P|\)的情况。
但可能某些值还是很大，怎么办？
首先我们肯定需要一个数组\(w\)来储存所有的\(\lfloor\frac{n}{i}\rfloor\)，之后用了两个\(ind\)数组来存储下标，如果\(\lfloor\frac{n}{i}\rfloor<\sqrt{n}\)，那么直接存储；否则就在另外一个数组存储\(\lfloor\frac{n}{\lfloor\frac{n}{i}\rfloor}\rfloor\)的下标。
那么之后我们就可以通过\(\lfloor\frac{n}{i}\rfloor\)的形式来访问相关值了。
这里类似于新加了一个映射关系。\(w\)数组映射到\(\lfloor\frac{n}{i}\rfloor\)，而\(ind\)数组用了点trick把\(\lfloor\frac{n}{i}\rfloor\)映射回\(w\)数组。

  • 求\(S\)部分

\[ S(i,j)=g(i,|P|)-sum_{j-1}+\sum_{k\geq j}\sum_{e}f(p_k^e)(S(\frac{i}{p_k^e},k+1)+[e\not ={1}]) \]

有一个问题是，这里怎么得到\(|P|\)。
因为我们把\(g\)滚动了的，最后虽然求出的是为\(\sqrt{n}\)的情况，但稍加思考就会发现，其值等于\(|P|\)下的值。
怎么得到\(i\)的下标？注意我们是从\(n\)开始递推，每次会除以一个数，并且有这样一个形式：\(\lfloor\frac{\lfloor\frac{n}{a}\rfloor}{b}\rfloor=\lfloor\frac{n}{ab}\rfloor\)，那么每次的\(i\)都一定可以表示为\(\lfloor\frac{n}{k}\rfloor\)的形式。所以直接根据刚才的映射关系来找就行啦。这也是为什么需要映射关系的原因

感觉代码部分也说得差不多了，可能有些地方我理解的有问题或者有点复杂，各位看官也不要太过于纠结字眼...自己理解也是不错的办法。
反正我感觉这里利用\(\lfloor\frac{n}{i}\rfloor\)的性质来求解很关键，优化了代码时间复杂度以及编写难度（求\(g\)和\(S\)都用到了它相关性质）。十分巧妙。

时间复杂度：(我也不会)O(感觉能过)\(O(\frac{n^\frac{3}{4}}{log_n})\)。

例题：

LOJ#6053. 简单的函数

思路：
因为有\(f(p^c)=p^c\)，注意到除开\(2\)以外的素数都为奇数，那么其余\(f(p)=p-1\)。我们处理的时候将\(f(2)\)的值也当作\(1\)来算，最后加回来就行。
基本上也是一道模板题吧~

Code

#include <bits/stdc++.h>
#define heyuhhh ok
using namespace std;
typedef long long ll;
const int N = 1e6 + 5, MOD = 1e9 + 7, inv2 = (MOD + 1) / 2;
ll n;
ll sum1[N], sum2[N], prime[N];
ll w[N], ind1[N], ind2[N];
ll g1[N], g2[N];
bool chk[N];
int tot, cnt;
void pre(int n) { //  \sqrt
    chk[1] = 1;
    for(int i = 1; i <= n; i++) {
        if(!chk[i]) {
            prime[++tot] = i;
            sum1[tot] = (sum1[tot - 1] + i) % MOD;
        }
        for(int j = 1; j <= tot && prime[j] * i <= n; j++) {
            chk[i * prime[j]] = 1;
            if(i % prime[j] == 0) break;
        }
    }
}
void calc_g() {
    int z = sqrt(n);
    for(ll i = 1, j; i <= n; i = j + 1) {
        j = n / (n / i);
        w[++cnt] = n / i;
        g2[cnt] = (w[cnt] - 1) % MOD;
        g1[cnt] = (w[cnt] % MOD) * ((w[cnt] + 1) % MOD) % MOD * inv2 % MOD; --g1[cnt];
        if(n / i <= z) ind1[n / i] = cnt;
        else ind2[n / (n / i)] = cnt;
    }
    for(int i = 1; i <= tot; i++) {
        for(int j = 1; j <= cnt && prime[i] * prime[i] <= w[j]; j++) {
            ll tmp = w[j] / prime[i], k;
            if(tmp <= z) k = ind1[tmp]; else k = ind2[n / tmp];
            (g1[j] -= prime[i] * (g1[k] - sum1[i - 1] + MOD) % MOD) %= MOD;
            (g2[j] -= (g2[k] - i + 1 + MOD) % MOD) %= MOD;
            if(g1[j] < 0) g1[j] += MOD;
            if(g2[j] < 0) g2[j] += MOD;
        }
    }
}
ll S(ll x, int y) { // 2~x >= P_y
    if(x <= 1 || prime[y] > x) return 0;
    ll z = sqrt(n);
    ll k = x <= z ? ind1[x] : ind2[n / x];
    ll ans = (g1[k] - sum1[y - 1] + MOD - g2[k] + y - 1 + MOD) % MOD;
    if(y == 1) ans += 2;
    for(int i = y; i <= tot && prime[i] * prime[i] <= x ; i++) {
        ll pe = prime[i];
        for(int e = 1; pe * prime[i] <= x; ++e, pe = pe * prime[i]) {
            ans = (ans + (prime[i] ^ e) * S(x / pe, i + 1) % MOD + (prime[i] ^ (e + 1))) % MOD;
        }
    }
    return ans;
}
int main() {
#ifdef heyuhhh
    freopen("input.in", "r", stdin);
#else
    ios::sync_with_stdio(false); cin.tie(0);
#endif
    cin >> n;
    int tmp = sqrt(n);
    pre(tmp);
    calc_g();
    cout << (S(n, 1) + 1) % MOD ;
    return 0;
}

牛客多校第七场K.Function
题意：
求\(\sum_{i=1}^nf(i)\)，其中，\(f(i)\)为：
\[ \left\{ \begin{aligned} &3e+1,&i= p^e \ and\ p\%4=1\\ &1,&else \end{aligned} \right. \]

思路：
考虑\(min25\)筛求解。
我们不管1，2的存在，最后加上其贡献即可。
首先求出\(g_1,g_2\)，分别质数表示\(\% 4\)为1和3的情况总数，然后一个一个来筛。筛的时候要同时考虑当前质数模4的情况以及对\(g_1,g_2\)的影响，它们都会减去某个值。
然后就直接求和就行了，基本都是套用板子。
最主要的还是求\(g\)的思路。

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e6 + 5;
int T;
ll n;
ll sum1[N], sum2[N], prime[N];
ll w[N], ind1[N], ind2[N];
ll g1[N], g2[N];
bool chk[N];
int tot, cnt;
void pre(int n) { //  \sqrt
    chk[1] = 1;
    for(int i = 1; i <= n; i++) {
        if(!chk[i]) {
            prime[++tot] = i;
            sum1[tot] = sum1[tot - 1];
            sum2[tot] = sum2[tot - 1];
            if(i % 4 == 1) ++sum1[tot];
            if(i % 4 == 3) ++sum2[tot];
        }
        for(int j = 1; j <= tot && prime[j] * i <= n; j++) {
            chk[i * prime[j]] = 1;
            if(i % prime[j] == 0) break;
        }
    }
}
void calc_g() {
    int z = sqrt(n);
    for(ll i = 1, j; i <= n; i = j + 1) {
        j = n / (n / i);
        w[++cnt] = n / i;
        g1[cnt] = w[cnt] / 4 + (w[cnt] % 4 >= 1) - 1;
        g2[cnt] = w[cnt] / 4 + (w[cnt] % 4 >= 3);
        if(n / i <= z) ind1[n / i] = cnt;
        else ind2[n / (n / i)] = cnt;
    }
    for(int i = 1; i <= tot; i++) {
        for(int j = 1; j <= cnt && prime[i] * prime[i] <= w[j]; j++) {
            ll tmp = w[j] / prime[i], k;
            if(tmp <= z) k = ind1[tmp]; else k = ind2[n / tmp];
            if(prime[i] % 4 == 1) {
                g1[j] -= (g1[k] - sum1[i - 1]);
                g2[j] -= (g2[k] - sum2[i - 1]);
            } else if(prime[i] % 4 == 3) {
                g1[j] -= (g2[k] - sum2[i - 1]);
                g2[j] -= (g1[k] - sum1[i - 1]);
            }
        }
    }
}
int f(int p, int q) {
    if(p % 4 == 1) return 3 * q + 1;
    return 1;
}
ll S(ll x, int y) { // 2~x >= P_y
    if(x <= 1 || prime[y] > x) return 0;
    ll z = sqrt(n);
    ll k = x <= z ? ind1[x] : ind2[n / x];
    ll ans = 4 * g1[k] - 4 * sum1[y - 1] + g2[k] - sum2[y - 1];
    if(y == 1) ans++;
    for(int i = y; i <= tot && prime[i] * prime[i] <= x ; i++) {
        ll pe = prime[i], pe2 = prime[i] * prime[i];
        for(int e = 1; pe2 <= x; ++e, pe = pe2, pe2 *= prime[i]) {
            ans += f(prime[i], e) * S(x / pe, i + 1) + f(prime[i], e + 1);
        }
    }
    return ans;
}
int main() {
    freopen("input.in", "r", stdin);
    cin >> T;
    while(T--) {
        memset(chk, 0, sizeof(chk)); tot = cnt = 0;
        cin >> n;
        int tmp = sqrt(n);
        pre(tmp);
        calc_g();
        cout << S(n, 1) + 1 << '\n';
    }
    return 0;
}

后记

写得还是比较匆忙，感觉也没有很好地把心静下来，可能有些地方写得冗余、累赘或者有错误，请谅解。
总得来说，min25筛的思想以及代码实现部分都是很巧妙的~为什么会想到搞个\(g\)来啊？为什么这样复杂度就比较低啊？这些都是问题...
另外加一些我学习时的草稿：

因为转移的原因，所以有用的素数只有小于等于\(\sqrt{n}\)的。最后算出来的值就是\(g(n,|P|)\)啦。

处理\(g\)时，离散化\(\lfloor\frac{n}{i}\rfloor\)，因为第一维为\(n\)不会变，并且有个这样性质：\(\lfloor\frac{\lfloor\frac{n}{a}\rfloor}{b}\rfloor=\lfloor\frac{n}{ab}\rfloor\)，所以有用的值也就只有\(\lfloor\frac{n}{i}\rfloor\)这些。

离散化要点：利用\(w\)递减记录离散化的值，并且利用\(ind1,ind2\)来记录相关数的下标，不超过\(\sqrt{n}\)。涉及整除的性质。巧妙！

转载于:https://www.cnblogs.com/heyuhhh/p/11421209.html

dft539533
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Min_25筛总结
一只蒟蒻的博客
10-10 188
为了表述方便，下用P\mathbb PP表示素数集，并用p1<p2<⋯<pcp_1<p_2<\cdots<p_cp1​<p2​<⋯<pc​表示111到nnn内的所有质数，ttt表示第一个大于n\sqrt nn​的质数下标. 特别的，我们令p0=1p_0=1p0​=1. 算法介绍 一、简介 Min_25筛是一种能快速求出某些满足特殊条件的积性函数前缀和的亚线性筛法，在通常的递归实现中复杂度为 Θ(n1−ϵ)\Theta(n^{1-\epsilon})Θ(
polyfill.min.js
09-01
polyfill.min.js
min_25筛的学习笔记
天道酬勤
09-21 198
作用 min25筛可以在复杂度O(n34log⁡(n)\frac{n^{\frac{3}{4}}}{\log(n)}log(n)n43​​)是一种亚线性筛。求积性函数f(x)的前缀和。求和条件x属于质数，f(x)f(x)f(x)可以用多项式表示出来，则f(xc)f(x^c)f(xc)可以快速求出。 预备思想 对于小于n的数，要么是质数，要么这个数的最小质因子小于等于n\sqrt{n}n​,将所有数分为质数与合数，利用上述原理和埃氏筛法的类似思想可以快速统计。 求法 首先来计算x为质数的和。定义g（n，j）为
min_25筛学习
DJ的博客
02-22 268
min_25筛是用于处理可以快速算出某个质数的值的积性函数的前缀和问题的一种筛。 首先定义这样一个东西： g()
min25筛学习小结
RainbowCrown_CGH's blog
05-20 255
前言 这玩意儿听说其大名好久了，但一直没学。 那么这次就来补补课。 好久没写博客了（其实是懒得写 埃氏筛法 这个有什么用呢，其实也只是一个思想。 埃氏筛法其实就是用来筛质数的一个朴素方法（弱鸡我至今还在用 过程大概就是： 从2开始，把以后的2的倍数都打上标记，然后再找下一个没被标记的。 找到3，把以后的3的倍数都打上标记，然后再找下一个没被标记的。 …… 就没了。 min25筛 用处 这个东东其实就是用来算某个积性函数f(i)f(i)f(i)的前缀和。 可以在O(n34log n)O(\frac{
min_25筛详解
Lstdo的博客
01-16 645
扯淡 min_25筛是由min_25提出的求积性函数前缀和的亚线性算法，和一个叫“扩展埃氏筛”的东西有着微妙的关系。 至于是什么关系，我也不太清楚，反正有人说很像有人说就是一个东西（雾） 这段话并不是废话 约定 为了方便后面描述，这里写一些用到的约定和符号表示，以免产生恐惧 111被开除正整数籍 也就是说“前缀和”之类的都是从222开始，对答案所求的前缀和同样，最后手动加111 π(n)\pi(n...
d3.min.js学习安装包
06-05
d3是一个基于数据操作文档的JavaScript库。...D3对web标准的强调为您提供了现代浏览器的全部功能，而无需将自己绑定到一个专有的框架中，将强大的可视化组件和数据驱动的DOM操作方法...为了学习d3，我给大家上传了我的d3包
25min Tomato Life-crx插件
04-04
在每个小时中，您都可以听到：- 00:00播放C-G音符（升调），提醒您开始工作或学习- 25:00播放G-C音符（降调），提醒您放松5分钟- 30:00播放C-G音符（升调），提醒您开始工作或学习- 55:00播放G-C音符（降调），提醒...
axios.min.v0.17.1
03-19
axios.min.v0.17.1 需要配合 vue v2.6.12.js使用
ecStat.min.js
03-26
ecStat.min.js文件下载,辅助echarts插件开发 完整文件 下载可用
min25筛详解+如何推式子+杜教筛
cqbzcsq的博客
01-15 850
Part.1 min25筛 前情提要：应用特别广泛，代码难度一般，但理解难度较大 若f(i)为积性函数 求 主要思路就是将积性函数分为三个部分来求和，当 i 是质数，当 i 是合数，还有i等于1 它的思想类似DP 首先需要了解一下埃氏筛法（圈一个质数，划去它的倍数） 我们先不考虑1 先来考虑如何表示一个埃氏筛的状态 我们可以从筛子的范围与所圈质数的个数来表示一个筛子 ...
Min_25筛
CaptainChen的博客
03-07 3782
简介 求积性函数前缀和，线性筛需要把函数的每一位值都算出来，作了许多不必要的操作。 线性筛中，通过计算最小质因子幂的函数值，与之前已计算出的函数值相乘，得到新的函数值。 如果我们能批量执行上面的操作，即用最小质因子幂的函数值，与另一些函数值的和相乘，就可以得到更多的函数值的和。 我们还能发现，当我们要求前n项的和时，大于根号n的质因子都不能用于计算任何其它的积性...
杜教筛和 min_25 筛基础习题
Nitrogens的博客
10-01 1390
杜教筛和 min_25 筛基础习题 这篇博客记录了自己最近几个月所刷的数论函数题目，所以有些题目可能不需要用到杜教筛或者 min_25 筛。某些题需要一些乱搞的技巧。 感谢 tangjz 提供大量题目。 1. HDU - 5608 function 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5608 1.1 题意 定义： n2−3n+2=∑d∣n...
Min25筛应用
一位蒟蒻的小博客
04-16 531
Min25筛基本应用。
Min_25筛有关求解次小质因子
lifehappy
09-23 236
#188. 【UR #13】Sanrd 题意化简就是求次小质因子，这一步我们可以在Min_25筛的ans计算中得到， S(n, j)表示的是最小质因子大于等于primejprime_jprimej​的加上质数的答案贡献， 要满足次小质因子，一定有除去这个数之后只剩下质数了，显然当我们计算到S(n, j)时，我们可以计算primej−1prime_{j - 1}primej−1​对答案的贡献， 接着我们还需要加上质数的次方项对答案的贡献，最后我们就可以得到答案了。 /* Author : lifehapp
简单的函数——Min_25筛
weixin_34392906的博客
01-13 188
%%yyb %%zsy 就是实现一下Min-25筛筛积性函数的操作 首先要得到 $G(M,j)=\sum_{t=j}^{cnt} \sum_{e=1}^{p_t^{e+1}<=M} [\phi(p_t^e)*G([M/(p_t^e)],t+1)+\phi(p_t^{(e+1)})]$​ $+(F(M)-(F(p_{j-1})))$ 先要预处理后面的部分，得到$F(M)$和$F(p...
Min25筛详解
weixin_44203780的博客
11-25 1819
Min25筛详解 min25筛有什么用？ 目的： 求出∑i−1Nf(i)\sum_{i-1}^Nf(i)∑i−1N​f(i)的前缀和，其中前置条件为 f(i)f(i)f(i) 当i为素数时，能够用iki^kik表达，例如f(i)=i1+i2+i3f(i)=i^1+i^2+i^3f(i)=i1+i2+i3等形式，常见的有ϕμ\phi \quad \muϕμ函数。 f(i)f(i)f(i)是积性函数 怎么求？ 分两步走 处理素数 处理合数 处理素数 素数部分 ∑i=1N[i∈prime]f(i)
Min_25
weixin_30561425的博客
12-08 200
可以用来筛出一个积性函数的前缀和。这个积性函数要满足当\(x\)是质数时，\(f(x)\)可以快速求出，\(f(x^k)\)也可以快速算出。 首先我们要处理出一个\(g(x)=\sum_{x\in prime}f(x)\)，处理这个的主要思想和埃氏筛法差不多。我们只要\(x\)是质数时候的值，那么，我先假设所有的数是质数，然后一步步筛掉不是质数的\(x\)的函数值。 具体地，先把\(\sqrt{ ...
「学习笔记」Min25筛
weixin_30519071的博客
02-26 178
「学习笔记」Min25筛 前言 周指导今天模拟赛五分钟秒第一题，十分钟说第二题是 \(\text{Min25}​\) 筛板子题，要不是第三题出题人数据范围给错了，周指导十五分钟就 \(\text{AK}​\) 了，为了向 \(\text{AK}​\)王 学习，真诚的膜拜他，接受红太阳的指导，下午就学习了一下 \(\text{Min25}​\) 筛。 简介 如果 \(f(n)\) 是一个积性函数，且...
深度学习的argmin
最新发布
10-23
在深度学习中，argmin是一个常用的操作，它的作用是找到一个函数的最小值所对应的参数值。在深度学习中，我们通常使用argmin来计算损失函数的最小值，以便调整模型的参数。然而，argmin并不是可微的，这意味着我们无法使用反向传播算法来计算梯度。因此，一些新的方法被提出来，例如GCNet中的soft argmin，它使用softmax函数来代替argmin，使得我们可以使用反向传播算法来计算梯度。这样，我们就可以使用深度学习来解决更加复杂的问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值