Codeforces 1063D Candies for Children

本文深入解析了一道复杂的数学竞赛题目,通过巧妙的数学思维和严谨的逻辑推导,将问题转化为可解决的形式。文章详细介绍了如何利用代数方程和数论知识找到未知数x的最大值,适用于对数学竞赛和数论感兴趣的读者。

题目大意

给定整数 $n, k, l, r$,$1\le n, k \le 10^{11}$,$1\le l, r \le n$ 。
令 $ m = r - l + 1$,若 $m \le 0$,$m\gets m + n$ 。
未知数 $x\in \mathbb{Z}$ 满足 $ 0 \le x \le n$,且满足
$ k \bmod (n + x) = 0$ 且 $m = n$ ;或者
$ k \bmod (n + x) \ne 0$ 且 $0 \le k \bmod (n + x) - m \le \min(m, x) $

求 $x$ 的最大值,若不存在符合条件的 $x$ 则输出 -1。


换一种思路,基本上是用自己的话将官方题解描述了一遍。

Note, that basically, we have two parts of the circle — the part between $[l;r]$ which gets candies one time more than the other part.

为了便于描述,将 $[l;r]$ 称作第一段,其余的称作第二段。注意:第一段长度一定大于零,而第二段长度可能等于零。

另外假设 $r$ 最后一次取糖时,恰取到了他想要的数量的糖(换言之若 $r$ 是 sweet tooth,那么他最后一次得到 2 块糖)。如果不是这种情况,只要将 $k$ 变成 $k+1$ 并且保证第一段内至少有 $1$ 个 sweet tooth。

设第一段长度为 $x$,其中有 $a$ 个 sweet tooth,第二段长度为 $y$ 且其中有 $b$ 个 sweet tooth,设第二段经历了 $t$ 次分糖,则第一段经历了 $t+1$ 次分糖。可以建立如下的不定方程:

$ (2a + (x- a)) (t + 1) + (2b + (y - b) ) t = k$
化简得

\begin{equation}
(a + x) (t + 1) + (b + y) t = k \label{E:1}
\end{equation}

约束条件:$ 0\le a \le x$,$0\le b \le y$ 。

(下面是这道题最精髓的地方。)

当 $n$ 比较小时,我们可以暴力枚举 $a$,$b$,看方程 \eqref{E:1} 是否有解,复杂度 $O(n^2)$

当 $n$ 比较大时,我们可以暴力枚举 $t$,显然有 $0 \le t \le k / n$ 。此时方程 \eqref{E:1} 变成了关于 $a,b$ 不定方程,确切地说是丢番图方程(Diophantine equation)
\begin{equation}
(t+ 1) a + tb = \gamma \label{E:2}
\end{equation}
其中 $\gamma = k - nt - x$ 。
方程 \eqref{E:2} 的通解
$ a = a_0 - tz, b = b_0 + (t+1) z$
其中 $a_0, b_0$ 是方程 \eqref{E:2} 的一组特解,可以由扩展欧几里得算法得到,$z$ 是任意整数。
由 $0 \le a \le x$,$0\le b \le y$ 可得到 $z$ 的取值范围 $[z_1, z_2]$ 。显然,$z = z_2$ 时 $a+ b$ 最大。

事实上,我们有 $\gcd(t+1, t) = 1$,此时可取特解 $a_0 = \gamma, b_0 = - \gamma$ 。

Implementation

#include <bits/stdc++.h>
using namespace std;

using ll = long long;

ll ple(ll fz, ll fm) { // fz >= 0, fm > 0
    return fz / fm;
}

ll pge(ll fz, ll fm) { //fz >= 0, fm > 0
    return (fz + fm - 1) / fm;
}


ll le (ll fz, ll fm) {
    return fz >= 0 ? ple(fz, fm) : -pge(-fz, fm); // 别忘了pge(-fz, fm)前面的负号!
}
ll ge(ll fz, ll fm) {
    return fz >= 0 ? pge(fz, fm) : -ple(-fz, fm);
}


int main() {
    ios::sync_with_stdio(false);
//    cin.tie(nullptr);
#ifdef LOCAL
    freopen("main.in", "r", stdin);
//    freopen("main.out", "w", stdout);
#endif


    ll n, l, r, k;
    cin >> n >> l >> r >> k;
    ll x = r - l + 1;
    if (x <= 0) x += n;
    ll y = n - x;
    ll ans = -1;

    if (n <= (ll)cbrt(k)) {
        for (ll a = 0; a <= x; a++) {
            for (ll b = 0; b <= y; b++) {
                ll s = a + x + b + y;
                ll bb = k - a - x;
                if (bb >= 0 && bb % s == 0) {
                    ans = max(ans, a + b);
                }
                if (a > 0 && (bb + 1) >= 0 && (bb+1)%s == 0) {
                    ans = max(ans, a + b);
                }
            }
        }
    }
    else {
        for (ll t = 0; t <= k / n; t++) {
            ll bb = k - n * t - x;
            if (bb >= 0) {
                // a = bb - tz , b = (t + 1) z - bb;
                if (t == 0) { // a = bb, b可任意取值
                    if (bb <= x) ans = max(ans, bb + y);
                    if (bb + 1 <= x) ans = max(ans, bb + 1 + y);
                }
                else {
                    // bb - tz >= 0 => z <= bb / t, bb - tz <= x => z >= (bb - x) / t
                    // (t + 1) z - bb >= 0 => z >= bb / (t + 1), (t + 1) z - bb <= y -> z <= (bb + y) / (t + 1)
                    ll minz = max(ge(bb - x, t), ge(bb, t + 1));
                    ll maxz = min(le(bb, t), le(bb + y, t + 1));
                    if (maxz >= minz) {
                        ans = max(ans, maxz);
                    }
                    // bb - tz >= 1 => z <= (bb - 1)/t
                    bb++;
                    minz = max(ge(bb - x, t), ge(bb, t + 1));
                    maxz = min(le(bb - 1, t), le(bb + y, t + 1));
                    if (maxz >= minz) {
                        ans = max(ans, maxz);
                    }
                }
            }
        }
    }
    cout << ans << endl;


#ifdef LOCAL
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    return 0;
}

转载于:https://www.cnblogs.com/Patt/p/9789235.html

【语音分离】基于平均谐波结构建模的无监督单声道音乐声源分离(Matlab代码实现)内容概要:本文介绍了基于平均谐波结构建模的无监督单声道音乐声源分离方法,并提供了相应的Matlab代码实现。该方法通过对音乐信号中的谐波结构进行建模,利用音源间的频率特征差异,实现对混合音频中不同乐器或人声成分的有效分离。整个过程无需标注数据,属于无监督学习范畴,适用于单通道录音场景下的语音与音乐分离任务。文中强调了算法的可复现性,并附带完整的仿真资源链接,便于读者学习与验证。; 适合人群:具备一定信号处理基础和Matlab编程能力的高校学生、科研人员及从事音频处理、语音识别等相关领域的工程师;尤其适合希望深入理解声源分离原理并进行算法仿真实践的研究者。; 使用场景及目标:①用于音乐音频中人声与伴奏的分离,或不同乐器之间的分离;②支持无监督条件下的语音处理研究,推动盲源分离技术的发展;③作为学术论文复现、课程项目开发或科研原型验证的技术参考。; 阅读建议:建议读者结合提供的Matlab代码与网盘资料同步运行调试,重点关注谐波建模与频谱分解的实现细节,同时可扩展学习盲源分离中的其他方法如独立成分分析(ICA)或非负矩阵分解(NMF),以加深对音频信号分离机制的理解。
内容概要:本文系统介绍了新能源汽车领域智能底盘技术的发展背景、演进历程、核心技术架构及创新形态。文章指出智能底盘作为智能汽车的核心执行层,通过线控化(X-By-Wire)和域控化实现驱动、制动、转向、悬架的精准主动控制,支撑高阶智能驾驶落地。技术发展历经机械、机电混合到智能三个阶段,当前以线控转向、线控制动、域控制器等为核心,并辅以传感器、车规级芯片、功能安全等配套技术。文中还重点探讨了“智能滑板底盘”这一创新形态,强调其高度集成化、模块化优势及其在成本、灵活性、空间利用等方面的潜力。最后通过“2025智能底盘先锋计划”的实车测试案例,展示了智能底盘在真实场景中的安全与性能表现,推动技术从研发走向市场验证。; 适合人群:汽车电子工程师、智能汽车研发人员、新能源汽车领域技术人员及对智能底盘技术感兴趣的从业者;具备一定汽车工程或控制系统基础知识的专业人士。; 使用场景及目标:①深入了解智能底盘的技术演进路径与系统架构;②掌握线控技术、域控制器、滑板底盘等关键技术原理与应用场景;③为智能汽车底盘研发、系统集成与技术创新提供理论支持与实践参考。; 阅读建议:建议结合实际车型和技术标准进行延伸学习,关注政策导向与行业测试动态,注重理论与实车验证相结合,全面理解智能底盘从技术构想到商业化落地的全过程。
【顶级EI复现】计及连锁故障传播路径的电力系统 N-k 多阶段双层优化及故障场景筛选模型(Matlab代码实现)内容概要:本文介绍了名为《【顶级EI复现】计及连锁故障传播路径的电力系统 N-k 多阶段双层优化及故障场景筛选模型(Matlab代码实现)》的技术资源,重点围绕电力系统中连锁故障的传播路径展开研究,提出了一种N-k多阶段双层优化模型,并结合故障场景筛选方法,用于提升电力系统在复杂故障条件下的安全性与鲁棒性。该模型通过Matlab代码实现,具备较强的工程应用价值和学术参考意义,适用于电力系统风险评估、脆弱性分析及预防控制策略设计等场景。文中还列举了大量相关的科研技术支持方向,涵盖智能优化算法、机器学习、路径规划、信号处理、电力系统管理等多个领域,展示了广泛的仿真与复现能力。; 适合人群:具备电力系统、自动化、电气工程等相关背景,熟悉Matlab编程,有一定科研基础的研究生、高校教师及工程技术人员。; 使用场景及目标:①用于电力系统连锁故障建模与风险评估研究;②支撑高水平论文(如EI/SCI)的模型复现与算法验证;③为电网安全分析、故障传播防控提供优化决策工具;④结合YALMIP等工具进行数学规划求解,提升科研效率。; 阅读建议:建议读者结合提供的网盘资源,下载完整代码与案例进行实践操作,重点关注双层优化结构与场景筛选逻辑的设计思路,同时可参考文档中提及的其他复现案例拓展研究视野。
<think>我们正在处理Codeforces 1775D题目的解析和解题思路。根据用户要求,我们需要参考站内引用,但注意到这些引用可能与题目并不直接相关。不过,我们可以从引用中提取一些思路,比如莫比乌斯反演(引用1提到gcd计数)和优化时间复杂度(引用2提到预处理和更新)的思想。 题目1775D是"Friends and the Restaurant",但根据Codeforces题库,1775D实际上是"Friendly Spiders"。因此,我们需要调整主题。 题目描述(摘要): - 有n个蜘蛛,编号1到n,每个蜘蛛的腿数为a_i。 - 两个蜘蛛i和j是朋友当且仅当gcd(a_i, a_j)>1(即它们的腿数的最大公约数大于1)。 - 需要从蜘蛛s到蜘蛛t,每一步只能移动到朋友蜘蛛,求最短路径(如果存在)。 解题思路: 1. 建图:直接对每对蜘蛛检查gcd会超时(O(n^2))。需要优化。 2. 思路:利用因子分解。对于每个蜘蛛,将其与它的质因数关联。然后,具有相同质因数的蜘蛛可以通过该质因数连接(因为如果两个蜘蛛共享一个质因数,那么它们之间的gcd至少为该质因数(>1))。 3. 具体步骤: a. 预处理每个数的质因数。 b. 创建一张图,包括n个蜘蛛节点和额外的质因数节点(为了避免重复,可以用质因数作为虚拟节点,编号从n+1开始)。 c. 对于每个蜘蛛i,将其与它的每个质因数p(用虚拟节点表示)连接一条无向边(双向边)。 d. 这样,两个蜘蛛如果有公共质因数,就会通过同一个虚拟节点相连(距离为2)。注意,蜘蛛节点之间不直接相连,而是通过质因数节点间接相连。 e. 在这样构建的图上,从s到t的最短路径(以边数计)除以2(因为实际路径中每两个蜘蛛之间经过一个虚拟节点,但虚拟节点不计入答案的路径节点)?注意:我们要求的是蜘蛛节点的路径,但路径中经过的虚拟节点不能出现在最终路径中,因此我们需要在BFS后重构路径。 4. 路径长度计算:由于图中加入了虚拟节点(质因数节点),实际路径长度为(真实路径的边数)/2(因为每两个蜘蛛节点之间隔着1个质因数节点,而质因数节点不算在最终路径里)。但注意,我们要求的是蜘蛛节点的序列,所以最终路径中的节点数 = (整个路径的节点数+1)//2(因为路径是蜘蛛-质因数-蜘蛛-...-蜘蛛,所以蜘蛛节点在奇数位置,且首尾都是蜘蛛)。 5. 具体步骤: - 使用BFS(因为边权为1)从s开始搜索,直到t。注意图中节点包括蜘蛛节点(1到n)和质因数节点(n+1到max_id)。我们需要记录每个节点的前驱节点,以便重构路径。 - 重构路径时,我们只取蜘蛛节点(即跳过质因数节点)。 6. 注意:如果s和t相同,则路径为0(但题目要求从s到t,如果s=t,那么路径长度为0,节点序列只包含s)。 7. 复杂度:每个蜘蛛连接它的质因数(每个数的质因数个数为O(log a_i)),所以总边数O(n*log(max(a_i))),可以接受。 8. 代码实现关键点: - 质因数分解:预处理每个数的质因数(可以不用筛,直接分解)。 - 建图:图的大小为n+质因数节点总数(质因数节点只需要出现一次,所以用一个map来记录质因数对应的虚拟节点编号)。 - BFS:注意节点编号范围。 现在,我们根据上述思路编写解析和代码。 注意:由于虚拟节点的存在,在BFS中,我们记录路径时,虚拟节点不放入最终答案路径。因此,当我们回溯路径时,只保留蜘蛛节点(编号在1到n之间)。 例子:假设蜘蛛1(质因数2,3)和蜘蛛2(质因数2,5)和蜘蛛3(质因数3,5)。 建图: - 蜘蛛1连接质因数2和3。 - 蜘蛛2连接质因数2和5。 - 蜘蛛3连接质因数3和5。 那么蜘蛛1到蜘蛛3的路径:1->2->2(蜘蛛2)->5->3(蜘蛛3)?不对,实际上通过质因数节点: 路径:蜘蛛1 -> 质因数2 -> 蜘蛛2 -> 质因数5 -> 蜘蛛3(这不是最短的,因为还有另一条:蜘蛛1->质因数3->蜘蛛3,更短)。 在图上BFS:从1(蜘蛛1)出发,到达质因数2和3,然后从质因数2可以到蜘蛛2,从质因数3可以到蜘蛛3。所以从1到3的路径:1 -> 质因数3 -> 3(蜘蛛3)。然后重构路径时,我们只取蜘蛛节点:1和3,所以路径长度为1(边数)?不对,实际路径是1-3(中间有一个虚拟节点,但最终路径只包含1和3,所以边数为1,即1->3,但实际上它们不是直接朋友,但通过质因数3连接,所以是朋友关系,路径长度为1步)。 所以最终路径的边数等于(BFS得到的路径边数)除以2?不对,因为BFS路径中每一步都是从一个节点到另一个节点(包括虚拟节点)。例如:1->质因数3->3,这有两条边,但实际蜘蛛节点之间只经过一步(从1到3)。所以最终路径的节点数应该是BFS路径中蜘蛛节点的序列。 在BFS过程中,我们记录每个节点的前驱。当我们到达终点t(蜘蛛节点)时,我们回溯前驱,但跳过虚拟节点。然而,虚拟节点在路径中连接两个蜘蛛节点,所以回溯时,我们每遇到一个虚拟节点,它的前驱和后继都是蜘蛛节点。因此,我们可以这样重构: 路径:t -> 前一个节点(可能是虚拟节点)-> 再前一个节点(蜘蛛节点)-> ... -> s 我们只取蜘蛛节点,并反转。 具体步骤: 1. 从t开始回溯,将t加入路径。 2. 当前节点为t,它的前驱节点记为prev。如果prev是虚拟节点(编号>n),那么继续找prev的前驱(应该是蜘蛛节点)。所以每次回溯一个蜘蛛节点后,下一个节点是虚拟节点,再下一个节点是蜘蛛节点。因此,我们每次回溯两步来跳过虚拟节点?不对,因为虚拟节点和蜘蛛节点交替出现(除了起点和终点是蜘蛛节点)。 实际上,在BFS树中,路径是:s -> p1(质因数节点)-> u1(蜘蛛节点)-> p2(质因数节点)-> u2(蜘蛛节点)-> ... -> t 所以,从t回溯:t的前驱是一个质因数节点,质因数节点的前驱是一个蜘蛛节点(即路径中t的前一个蜘蛛节点)。因此,我们可以: path = [] cur = t while cur != s: path.append(cur) cur = pre[cur] # pre[cur]是当前节点的前驱(在BFS树中) # 此时cur是虚拟节点,那么再取一次前驱得到上一个蜘蛛节点 cur = pre[cur] # 现在cur是上一个蜘蛛节点 path.append(s) path.reverse() 但是注意:从s到第一个虚拟节点,s的前驱是空(因为s是起点)。所以我们需要调整:在BFS过程中,我们记录每个节点的前驱(包括虚拟节点)。然后重构路径时,我们跳过虚拟节点。 另一种方法:在BFS过程中,我们记录每个节点的前驱节点(无论是蜘蛛还是质因数)。然后重构路径时,我们只取蜘蛛节点。那么从t开始,将t加入路径,然后找t的前驱(一定是虚拟节点),再找这个虚拟节点的前驱(一定是蜘蛛节点),将这个蜘蛛节点加入路径,然后继续找这个蜘蛛节点的前驱(虚拟节点)...直到到达s。 步骤: path = [] cur = t while cur is not None: if cur <= n: # 蜘蛛节点 path.append(cur) cur = pre[cur] # 移动到前驱(可能是虚拟节点或None) # 这样得到的是从t到s的路径(逆序),然后反转 path.reverse() 但是这样会包括虚拟节点吗?注意:我们在加入路径时只加入蜘蛛节点(cur<=n),所以虚拟节点被跳过。但是,我们回溯时,每次从蜘蛛节点找到它的前驱(虚拟节点)然后继续再找前驱(上一个蜘蛛节点)?不对,因为pre[t]是一个虚拟节点,然后pre[虚拟节点]是一个蜘蛛节点(即路径中t的前一个蜘蛛节点),然后我们加入这个蜘蛛节点,然后找这个蜘蛛节点的前驱(另一个虚拟节点)...直到s。 所以循环内部: 第一次:cur=t(蜘蛛节点)->加入 然后cur = pre[t] (虚拟节点,不加入) 然后cur = pre[虚拟节点] (上一个蜘蛛节点,在下一次循环加入) 这样会交替加入蜘蛛节点。所以最终路径中只有蜘蛛节点,且顺序正确。 但是,注意起点s:当回溯到s时,s是蜘蛛节点,加入。然后找pre[s],如果s是起点,那么pre[s]应该是None,循环终止。 因此,代码: path = [] cur = t while cur is not None: if cur <= n: path.append(cur) cur = pre[cur] # 移动到前驱(如果cur是s,pre[s]为None,则退出) path.reverse() 这样得到的路径就是蜘蛛节点的序列。 但是,我们如何保证pre[虚拟节点]一定指向蜘蛛节点?在建图时,我们只建立了蜘蛛节点与质因数节点之间的边,没有质因数节点到质因数节点的边。所以图中边只存在于蜘蛛节点和质因数节点之间。因此,在BFS树中,路径一定是交替的:蜘蛛-质因数-蜘蛛-质因数-...-蜘蛛。 因此,上述重构路径方法是正确的。 9. 特殊情况:s==t,则路径只有[s];如果没有路径,则输出-1。 代码实现(Python)可能如下: </think> ### Codeforces 1775D - Friendly Spiders 解析 #### 题目概述 有 $n$ 只蜘蛛,每只蜘蛛 $i$ 有腿数 $a_i$。两只蜘蛛 $i$ 和 $j$ 是“朋友”当且仅当 $\gcd(a_i, a_j) > 1$。给定起点 $s$ 和终点 $t$,求从 $s$ 到 $t$ 的最短路径(每次移动到朋友蜘蛛),并输出路径。若不可达,返回 $-1$。 #### 核心难点 直接暴力建图(检查每对蜘蛛的 $\gcd$)的复杂度为 $O(n^2)$,无法通过 $n \leq 3 \times 10^5$ 的数据规模。 #### 优化思路:质因数分解建图 1. **关键观察**: - 若两只蜘蛛有公共质因数 $p$,则 $\gcd(a_i, a_j) \geq p > 1$,它们可通过 $p$ 间接相连。 - 为每个质因数 $p$ 创建**虚拟节点**(编号从 $n+1$ 开始),蜘蛛 $i$ 与其所有质因数 $p \mid a_i$ 连边。 2. **建图策略**: - **真实节点**:蜘蛛 $1$ 到 $n$。 - **虚拟节点**:质因数 $p$(用 $\text{id}_p \geq n+1$ 表示)。 - **连边规则**: - 蜘蛛 $i$ 连接其所有质因数虚拟节点 $\text{id}_p$(双向边)。 - 例:蜘蛛 $a_i=12$(质因数 $2,3$)连向 $\text{id}_2$ 和 $\text{id}_3$。 3. **路径性质**: - 路径格式:蜘蛛 $\to$ 质因数 $\to$ 蜘蛛 $\to \cdots \to$ 蜘蛛。 - 实际路径长度 = BFS 路径边数 $/ 2$(虚拟节点不计入最终路径)。 #### 算法步骤 1. **预处理质因数**: - 对每个 $a_i$ 分解质因数,用字典记录质因数对应的虚拟节点编号。 2. **BFS 求最短路**: - 从 $s$ 开始 BFS,记录每个节点的前驱 $\text{pre}[u]$。 - 队列同时处理真实节点和虚拟节点。 3. **路径重构**: - 从 $t$ 回溯前驱,只保留真实节点(跳过虚拟节点)。 - 回溯逻辑:若当前是真实节点,加入路径;无论何种节点,均回溯到前驱。 #### 复杂度分析 - **时间**:$O(n \log \max(a_i))$,每个数的质因数分解 $O(\log a_i)$。 - **空间**:$O(n \log \max(a_i))$,存储图及质因数。 #### 代码实现(Python) ```python import math from collections import deque def main(): import sys input = sys.stdin.readline n = int(input()) a = [0] + list(map(int, input().split())) s, t = map(int, input().split()) if s == t: print("1\n", s) return # 质因数虚拟节点编号分配 max_id = n prime_to_id = {} graph = [[] for _ in range(4 * 10 ** 5)] # 预分配空间 # 建图:连接蜘蛛与其质因数 for i in range(1, n + 1): x = a[i] factors = [] # 质因数分解 p = 2 while p * p <= x: if x % p == 0: factors.append(p) while x % p == 0: x //= p p += 1 if x > 1: factors.append(x) for p in factors: if p not in prime_to_id: max_id += 1 prime_to_id[p] = max_id pid = prime_to_id[p] # 双向边:蜘蛛 <-> 质因数 graph[i].append(pid) graph[pid].append(i) # BFS 初始化 pre = [-1] * (max_id + 1) # 前驱数组 q = deque([s]) pre[s] = -2 # 起点标记 # BFS 遍历 while q: u = q.popleft() for v in graph[u]: if pre[v] == -1: # 未访问 pre[v] = u if v == t: q = None # 提前终止 break q.append(v) # 检查是否可达 if pre[t] == -1: print(-1) return # 重构路径(跳过虚拟节点) path = [] cur = t while cur != -2: # 回溯到起点标记 if cur <= n: # 只保留真实节点 path.append(cur) cur = pre[cur] # 输出结果 print(len(path)) print(' '.join(map(str, reversed(path)))) if __name__ == '__main__': main() ``` #### 示例说明 - **输入**:蜘蛛 $a=[2,3,4,5,6]$,$s=1, t=5$。 - **建图**: - 蜘蛛 $1$($a_1=2$)连虚拟节点 $\text{id}_2$。 - 蜘蛛 $5$($a_5=6$)连 $\text{id}_2,\text{id}_3$。 - **路径**:$1 \to \text{id}_2 \to 5$(重构后为 $[1,5]$)。 - **输出**:路径长度 $2$,路径 $1 \space 5$。 #### 相关思考 1. 若存在多条最短路径,如何输出字典序最小路径? 2. 如何进一步优化质因数分解的效率? 3. 若蜘蛛可重复访问,算法如何调整?[^1] [^1]: 解题报告(十八)数论题目泛做(Codeforces 难度:2000 ~ 3000 + ) [^2]: 如果对于每个查询q都找到不同gcd的递减个数,时间复杂度为O(n*q)会超时 [^3]: 如果看到这里,你还没有找到规律,那我们就在看一组数据
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值