素数转换广度优先搜索-优快云博客

本文介绍了一种使用广度优先搜索解决素数转换问题的方法。通过预先筛选出所有四位素数，并采用特定的数据结构进行存储，实现从一个四位素数到另一个四位素数的最短步骤转换。

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

题目大概：

输入n组数据，每组数据两个四位素数。让第一个四位数变到第二个四位数，每步只能改一个数，改后的数也必须是素数，问最少经过几步改变可以成功。

思路:

用广度优先搜索。

先把所有的素数筛出来，方便判断，然后四位数一位一位的改变，把符合条件的数放到队列中，直到变为第二个数，输出改变次数。

感想：

数据过多，就把一类数据做成一个结构体，这样方便进队列，而且如果分多个队列，内存会不够。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>

using namespace std;
int sushu[10001];
int biao[10001];
struct q
{
    int bit[4];
    int num;
    int s;
};
queue<q>a;
void w()
{
    int i,j;
    for(i=0;i<10001;i++)
        sushu[i]=1;
    sushu[0]=0;sushu[1]=0;
    for(i=2;i<10001;i++)
    {
        if(sushu[i]==1)
        {
            for(j=i+i;j<10001;j+=i)
            {
                sushu[j]=0;
            }
        }
    }
}

int num(int a[],int b,int c)
{
    int s=0;
    for(int i=0;i<4;i++)
    {
        if(i==b)
            s=s*10+c;
        else
            s=s*10+a[i];
    }
    return s;
}

void bfs(int first,int second)
{

    int i,j,k;
    memset(biao,0,sizeof(biao));

    q f,r;

    f.num=first;
    f.bit[3]=first%10;
    f.bit[2]=(first/10)%10;
    f.bit[1]=(first/100)%10;
    f.bit[0]=(first/1000)%10;
    f.s=0;
    a.push(f);

    while(!a.empty())
    {
        r=a.front();
        a.pop();

        if(r.num==second)
        {
            cout<<r.s<<endl;
            break;
        }

for(i=0;i<4;i++)
{for(j=0;j<=9;j++)
{
        if(j==0&&i==0)continue;
    if(r.bit[i]==j)continue;
else
{
    int i1=num(r.bit,i,j);
if(sushu[i1]&&!biao[i1]){
    biao[i1]=1;
for(k=0;k<4;k++)
{
    f.bit[k]=r.bit[k];
        }
    f.bit[i]=j;
    f.num=i1;
    f.s=r.s+1;
    a.push(f);
}
}
}
}
}
}

int main()
{
    int n;

    int first,second;

   w();
   cin>>n;
    while(n--)
    {
        cin>>first>>second;
        bfs(first,second);
         while(!a.empty()){a.pop();}
    }
    return 0;
}

搜索--09