codeforces986F Oppa Funcan Style Remastered【线性筛+最短路】

本文探讨了利用质因数分解解决特定数学问题的方法,并引入了图论思想来优化解决方案。针对n的质因数分解,文章提出了一种有效算法,通过构建图模型并运用最短路径算法,判断是否能用和小于n的若干数凑出与n在p1下同余的数。此方法结合了数学和计算机科学,为复杂问题提供了一种新颖的解答思路。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

容易看出是用质因数凑n
首先01个因数的情况可以特判,2个的情况就是ap1+bp2=n,b=n/p2(mod p1),这里的b是最小的特解,求出来看bp2<=n则有解,否则无解
然后剩下的情况最小的质因数p1一定<=1e5,考虑在%p1的意义下做,考虑转成图论,点分别是%p1=x,然后对每个x连边(x+pi)%p1,边权为pi,跑最短路
如果dis[n%p1]<=n就合法,因为这表示可以用和小于n的若干数凑出和n在p1下同余的数,剩下部分用p1填即可

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
const int N=200005,M=31600000;
int t,p[M],tot,con;
long long dis[N],a[N];
bool v[M],ans[N],vis[N];
queue<int>q;
struct qwe
{
    long long n,k,id;
}b[10005];
bool cmp(const qwe &a,const qwe &b)
{
    return a.k<b.k;
}
long long read()
{
    long long r=0,f=1;
    char p=getchar();
    while(p>'9'||p<'0')
    {
        if(p=='-')
            f=-1;
        p=getchar();
    }
    while(p>='0'&&p<='9')
    {
        r=r*10+p-48;
        p=getchar();
    }
    return r*f;
}
long long ksm(long long a,long long b,long long mod)
{
    long long r=1;
    while(b)
    {
        if(b&1)
            r=r*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return r;
}
int main()
{
    t=read();
    for(int i=1;i<=t;i++)
        b[i].n=read(),b[i].k=read(),b[i].id=i;
    v[1]=1;
    for(int i=2;i<M;i++)
    {
        if(!v[i])
            p[++tot]=i;
        for(int j=1;j<=tot&&1ll*i*p[j]<M;j++)
        {
            v[i*p[j]]=1;
            if(i%p[j]==0)
                break;
        }
    }
    sort(b+1,b+1+t,cmp);
    for(int w=1;w<=t;w++)
    {
        long long n=b[w].n,k=b[w].k;
        if(w==1||b[w].k!=b[w-1].k)
        {
            long long x=k;
            con=0;
            for(int i=1;i<=tot&&x>1;i++)
            {
                if(1ll*p[i]*p[i]>x)
                {
                    a[++con]=x;
                    break;
                }
                if(x%p[i]==0)
                {
                    a[++con]=p[i];
                    while(x%p[i]==0)
                        x/=p[i];
                }
            }
        }
        // for(int i=1;i<=con;i++)
            // cerr<<a[i]<<" ";cerr<<endl;
        if(con==0)
            ans[b[w].id]=0;
        else if(con==1)
            ans[b[w].id]=(n%a[1]==0);
        else if(con==2)
            ans[b[w].id]=(1ll*n%a[1]*ksm(a[2],a[1]-2,a[1])%a[1]*a[2]<=n);
        else
        {
            if(w==1||b[w].k!=b[w-1].k)
            {
                for(int i=1;i<=a[1];i++)
                    dis[i]=1e18;
                dis[0]=0;
                vis[0]=1;
                q.push(0);
                while(!q.empty())
                {
                    int u=q.front();//cerr<<u<<endl;
                    q.pop();
                    for(int i=2;i<=con;i++)
                    {
                        int v=(u+a[i])%a[1];
                        if(dis[v]>dis[u]+a[i])
                        {
                            dis[v]=dis[u]+a[i];//cerr<<v<<endl;
                            if(!vis[v])
                            {
                                vis[v]=1;
                                q.push(v);
                            }
                        }
                    }
                    vis[u]=0;
                }
            }//cerr<<dis[n%a[1]]<<endl;
            ans[b[w].id]=dis[n%a[1]]<=n;
        }
    }
    for(int i=1;i<=t;i++)
        puts(ans[i]?"YES":"NO");
    return 0;
}

转载于:https://www.cnblogs.com/lokiii/p/11005566.html

### Codeforces 平台上的短路径算法题目 #### Dijkstra 算法的应用实例 当面对构建短路径树的需求时,可以采用Dijkstra算法来解决。该方法的核心在于优先选择当前节点能够延伸出去的多条候选边中具有小权重的一条作为扩展方向;而在仅存在唯一一条可能的拓展边的情况下,则直接选取这条边继续探索过程[^1]。 ```python import heapq def dijkstra(graph, start): n = len(graph) dist = [float('inf')] * n dist[start] = 0 heap = [(0, start)] while heap: current_dist, u = heapq.heappop(heap) if current_dist != dist[u]: continue for v, weight in graph[u].items(): alt = dist[u] + weight if alt < dist[v]: dist[v] = alt heapq.heappush(heap, (alt, v)) return dist ``` #### Floyd-Warshall 算法处理复杂情况下的优化策略 对于涉及多个源点之间的短路径计算问题,Floyd-Warshall是一个有效的解决方案。然而,在某些特定场景下(比如本题),通过预先给定的信息可以直接定位受影响的部分并加以简化,从而避免不必要的全量遍历操作,达到降低时间复杂度的效果。值得注意的是,在累加过程中应当选用`long long`类型的变量以防止溢出错误的发生[^2]。 #### 单源短路径查询案例解析 考虑到从指定起点出发前往其余各个顶点间的短距离需求,此情形适用于单源短路径类别的算法实现方式。具体而言,即是从某固定位置开始测量至其它任意可达地点的距离长度,并针对不可达的情形输出特殊标记值 `-1` 表明无法访问的状态[^3]。 ```cpp #include<bits/stdc++.h> using namespace std; const int INF=0x3f3f3f; vector<pair<int,int>> adj[100]; int dis[100]; void spfa(int src){ queue<int> q; vector<bool> vis(100,false); fill(dis,dis+100,INF); dis[src]=0;q.push(src); while(!q.empty()){ int cur=q.front();q.pop(); vis[cur]=false; for(auto& edge : adj[cur]){ int next=edge.first,cost=edge.second; if(dis[next]>dis[cur]+cost){ dis[next]=dis[cur]+cost; if(!vis[next]){ vis[next]=true; q.push(next); } } } } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值