P1217 [USACO1.5]回文质数 Prime Palindromes

最新推荐文章于 2024-08-02 00:05:49 发布
原创 最新推荐文章于 2024-08-02 00:05:49 发布 · 306 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种算法，用于在指定范围内找出所有既是质数又是回文数的整数（回文质数）。通过逐步生成不同长度的回文数并检查它们是否为质数来实现。文中提供了完整的C++代码实现，并针对效率进行了优化。

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

题目描述

因为151既是一个质数又是一个回文数(从左到右和从右到左是看一样的)，所以 151 是回文质数。

写一个程序来找出范围[a,b](5 <= a < b <= 100,000,000)( 一亿)间的所有回文质数;

输入输出格式

输入格式：
第 1 行: 二个整数 a 和 b .

输出格式：
输出一个回文质数的列表，一行一个。

输入输出样例

输入样例#1： 复制
5 500
输出样例#1： 复制
5
7
11
101
131
151
181
191
313
353
373
383
说明

Hint 1: Generate the palindromes and see if they are prime.

提示 1: 找出所有的回文数再判断它们是不是质数（素数）.

Hint 2: Generate palindromes by combining digits properly. You might need more than one of the loops like below.

提示 2: 要产生正确的回文数，你可能需要几个像下面这样的循环。

题目翻译来自NOCOW。

USACO Training Section 1.5

产生长度为5的回文数:

for (d1 = 1; d1 <= 9; d1+=2) { // 只有奇数才会是素数

 for (d2 = 0; d2 <= 9; d2++) {
     for (d3 = 0; d3 <= 9; d3++) {
       palindrome = 10000*d1 + 1000*d2 +100*d3 + 10*d2 + d1;//(处理回文数...)
     }
 }

}

超时代码

#include <bits/stdc++.h>
using namespace std;
int fun1(int a)
{
    if(a<=1)
        return 0;
    for(int i=2;i<=sqrt(a);i++)
    {
        if(a%i==0)
            return 0;
    }
    return 1;

}
int main()
{
    int a[100000],l=0;//用一个数组把所有符合条件的数存起来；超时
    for(int i=2;i<=9;i++)
    {
        if(fun1(i))
        {
            a[l]=i;
            l++;
        }

    }
    //if(a==11)//除11外，偶数位回文数肯定不为素数
    a[l]=11;
    l++;
    //if(a>=100&&a<=999)//三位数
    //{
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                int f=100*d1 + 10*d2 + d1;//(处理回文数...)
                if(fun1(f))
                {
                    a[l]=f;
                    l++;
                }
            }
        }
    //}
    //if(a<=99999&&a>=10000)//五位数
    //{
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    int f=10000*d1 + 1000*d2 +100*d3 + 10*d2 + d1;//(处理回文数...)
                    if(fun1(f))
                    {
                        a[l]=f;
                        l++;
                    }
                }
            }
        }
    //}
    //if(a<=9999999&&a>=1000000)//七位数
    //{
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    for (int d4 = 0; d4 <= 9; d4++)
                    {
                        int f=1000000*d1 + 100000*d2 +10000*d3 + 1000*d4+100*d3+10*d2 + d1;//(处理回文数...)
                        if(fun1(f))
                        {
                            a[l]=f;
                            l++;
                        }
                    }
                }
            }
        }
    //}
    //if(a<=999999999&&a>=100000000)//九位数
    //{
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    for (int d4 = 0; d4 <= 9; d4++)
                    {
                        for (int d5 = 0; d5 <= 9; d5++)
                        {
                            int f=100000000*d1 + 10000000*d2 +1000000*d3 + 100000*d4+10000*d5+1000*d4+100*d3+10*d2 + d1;//(处理回文数...)
                            if(fun1(f))
                            {
                                a[l]=f;
                                l++;
                            }
                        }
                    }
                }
            }
        }
    //}
    //偶数位全为非素数
    int m,n;
    cin>>m>>n;
    for(int s=0; ;s++)
    {
        if(a[s]<=n&&a[s]>=m)
            cout<<a[s]<<endl;
        if(a[s]>n)
            break;
    }

    return 0;
}

依旧超时

#include <bits/stdc++.h>
using namespace std;
int fun1(int a)
{
    if(a<=1)
        return 0;
    for(int i=2;i<=sqrt(a);i++)
    {
        if(a%i==0)
            return 0;
    }
    return 1;

}
int main()
{//用数组存超时，改成直接输出
    int m,n;
    cin>>m>>n;
    for(int i=2;i<=9;i++)
    {
        if(fun1(i))
        {
            if(i>=m&&i<=n)
                cout<<i<<endl;
        }

    }
    //if(a==11)//除11外，偶数位回文数肯定不为素数
    if(11>=m&&11<=n)
        cout<<11<<endl;
    //if(a>=100&&a<=999)//三位数
    //{
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                int f=100*d1 + 10*d2 + d1;//(处理回文数...)
                if(fun1(f))
                {
                    if(f>=m&&f<=n)
                        cout<<f<<endl;
                }
            }
        }
    //}
    //if(a<=99999&&a>=10000)//五位数
    //{
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    int f=10000*d1 + 1000*d2 +100*d3 + 10*d2 + d1;//(处理回文数...)
                    if(fun1(f))
                    {
                        if(f>=m&&f<=n)
                        cout<<f<<endl;
                    }
                }
            }
        }
    //}
    //if(a<=9999999&&a>=1000000)//七位数
    //{
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    for (int d4 = 0; d4 <= 9; d4++)
                    {
                        int f=1000000*d1 + 100000*d2 +10000*d3 + 1000*d4+100*d3+10*d2 + d1;//(处理回文数...)
                        if(fun1(f))
                        {
                            if(f>=m&&f<=n)
                            cout<<f<<endl;
                        }
                    }
                }
            }
        }
    //}
    //if(a<=999999999&&a>=100000000)//九位数
    //{
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    for (int d4 = 0; d4 <= 9; d4++)
                    {
                        for (int d5 = 0; d5 <= 9; d5++)
                        {
                            int f=100000000*d1 + 10000000*d2 +1000000*d3 + 100000*d4+10000*d5+1000*d4+100*d3+10*d2 + d1;//(处理回文数...)
                            if(fun1(f))
                            {
                                if(f>=m&&f<=n)
                                cout<<f<<endl;
                            }
                        }
                    }
                }
            }
        }
    //}
    //偶数位全为非素数


    return 0;
}

88分的超时代码

#include <bits/stdc++.h>
using namespace std;
int fun1(int a)
{
    if(a<=1)
        return 0;
    for(int i=2;i<=sqrt(a);i++)
    {
        if(a%i==0)
            return 0;
    }
    return 1;

}
int main()
{//用数组存超时，改成直接输出
    int m,n;
    cin>>m>>n;
    for(int i=2;i<=9;i++)
    {
        if(fun1(i))
        {
            if(i>=m&&i<=n)
                cout<<i<<endl;
        }

    }
    //if(a==11)//除11外，偶数位回文数肯定不为素数
    if(11>=m&&11<=n)
        cout<<11<<endl;
    //if(a>=100&&a<=999)//三位数
    //{
    if(m<=999&&n>=100)
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                int f=100*d1 + 10*d2 + d1;//(处理回文数...)
                if(fun1(f))
                {
                    if(f>=m&&f<=n)
                        cout<<f<<endl;
                }
            }
        }
    //}
    //if(a<=99999&&a>=10000)//五位数
    //{
    if(m<=99999&&n>=10000)
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    int f=10000*d1 + 1000*d2 +100*d3 + 10*d2 + d1;//(处理回文数...)
                    if(fun1(f))
                    {
                        if(f>=m&&f<=n)
                        cout<<f<<endl;
                    }
                }
            }
        }
    //}
    //if(a<=9999999&&a>=1000000)//七位数
    //{
    if(m<=9999999&&n>=1000000)
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    for (int d4 = 0; d4 <= 9; d4++)
                    {
                        int f=1000000*d1 + 100000*d2 +10000*d3 + 1000*d4+100*d3+10*d2 + d1;//(处理回文数...)
                        if(fun1(f))
                        {
                            if(f>=m&&f<=n)
                            cout<<f<<endl;
                        }
                    }
                }
            }
        }
    //}
    //if(a<=999999999&&a>=100000000)//九位数
    //{
    if(m<=999999999&&n>=100000000)
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    for (int d4 = 0; d4 <= 9; d4++)
                    {
                        for (int d5 = 0; d5 <= 9; d5++)
                        {
                            int f=100000000*d1 + 10000000*d2 +1000000*d3 + 100000*d4+10000*d5+1000*d4+100*d3+10*d2 + d1;//(处理回文数...)
                            if(fun1(f))
                            {
                                if(f>=m&&f<=n)
                                cout<<f<<endl;
                            }
                        }
                    }
                }
            }
        }
    //}
    //偶数位全为非素数


    return 0;
}

终于过了

#include <bits/stdc++.h>
using namespace std;
int fun1(int a)
{
    if(a<=1)
        return 0;
    for(int i=2;i<=sqrt(a);i++)
    {
        if(a%i==0)
            return 0;
    }
    return 1;

}
int main()
{//用数组存超时，改成直接输出
    int m,n;
    cin>>m>>n;
    for(int i=2;i<=9;i++)
    {
        if(fun1(i))
        {
            if(i>=m&&i<=n)
                cout<<i<<endl;
        }

    }
    //if(a==11)//除11外，偶数位回文数肯定不为素数
    if(11>=m&&11<=n)
        cout<<11<<endl;
    //if(a>=100&&a<=999)//三位数
    //{
    if(m<=999&&n>=100)
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                int f=100*d1 + 10*d2 + d1;//(处理回文数...)
                if(fun1(f))
                {
                    if(f>=m&&f<=n)
                        cout<<f<<endl;
                }
            }
        }
    //}
    //if(a<=99999&&a>=10000)//五位数
    //{
    if(m<=99999&&n>=10000)
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    int f=10000*d1 + 1000*d2 +100*d3 + 10*d2 + d1;//(处理回文数...)
                    if(fun1(f))
                    {
                        if(f>=m&&f<=n)
                        cout<<f<<endl;
                    }
                }
            }
        }
    //}
    //if(a<=9999999&&a>=1000000)//七位数
    //{
    if(m<=9999999&&n>=1000000)
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    for (int d4 = 0; d4 <= 9; d4++)
                    {
                        int f=1000000*d1 + 100000*d2 +10000*d3 + 1000*d4+100*d3+10*d2 + d1;//(处理回文数...)
                        if(fun1(f))
                        {
                            if(f>=m&&f<=n)
                            cout<<f<<endl;
                        }
                    }
                }
            }
        }
    //}
    //if(a<=999999999&&a>=100000000)//九位数  九位数不存在回文质数
    //{
    /*if(m<=999999999&&n>=100000000)
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   // 只有奇数才会是素数
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    for (int d4 = 0; d4 <= 9; d4++)
                    {
                        for (int d5 = 0; d5 <= 9; d5++)
                        {
                            int f=100000000*d1 + 10000000*d2 +1000000*d3 + 100000*d4+10000*d5+1000*d4+100*d3+10*d2 + d1;//(处理回文数...)
                            if(fun1(f))
                            {
                                if(f>=m&&f<=n)
                                cout<<f<<endl;
                            }
                        }
                    }
                }
            }
        }*/
    //}
    //偶数位全为非素数


    return 0;
}

正解

#include <bits/stdc++.h>
using namespace std;
int fun1(int a)
{
    if(a<=1)
        return 0;
    for(int i=2;i<=sqrt(a);i++)
    {
        if(a%i==0)
            return 0;
    }
    return 1;

}
int main()
{
    int m,n;
    cin>>m>>n;
    for(int i=2;i<=9;i++)
    {
        if(fun1(i))
        {
            if(i>=m&&i<=n)
                cout<<i<<endl;
        }

    }

    if(11>=m&&11<=n)
        cout<<11<<endl;

    if(m<=999&&n>=100)
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   
            for (int d2 = 0; d2 <= 9; d2++)
            {
                int f=100*d1 + 10*d2 + d1;
                if(fun1(f))
                {
                    if(f>=m&&f<=n)
                        cout<<f<<endl;
                }
            }
        }

    if(m<=99999&&n>=10000)
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    int f=10000*d1 + 1000*d2 +100*d3 + 10*d2 + d1;
                    if(fun1(f))
                    {
                        if(f>=m&&f<=n)
                        cout<<f<<endl;
                    }
                }
            }
        }

    if(m<=9999999&&n>=1000000)
        for (int d1 = 1; d1 <= 9; d1+=2)
        {   
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    for (int d4 = 0; d4 <= 9; d4++)
                    {
                        int f=1000000*d1 + 100000*d2 +10000*d3 + 1000*d4+100*d3+10*d2 + d1;
                        if(fun1(f))
                        {
                            if(f>=m&&f<=n)
                            cout<<f<<endl;
                        }
                    }
                }
            }
        }
    return 0;
}
洛谷 P1217 [USACO1.5]回文质数 Prime Palindromes
AnUnverse
04-29 1734
点击打开链接题目描述：因为151既是一个质数又是一个回文数(从左到右和从右到左是看一样的)，所以 151 是回文质数。写一个程序来找出范围[a,b](5 &lt;= a &lt; b &lt;= 100,000,000)( 一亿)间的所有回文质数;题解：如果先筛出区间范围内的素数，再对该素数进行判别是否为回文数，或者先筛出回文数，再进行质数判别，可能会超时。所以有必要换种思路。由筛选改为创建回文质...
每日一题洛谷P1217 [USACO1.5] 回文质数 Prime Palindromes c++
2401_88089822的博客
01-30 469
作者实测先一后二AC6个，先二后一AC9个。想要最后一个AC的话要用到一种筛选质数的算法，欧拉筛（线性筛）和埃氏筛都可以。其实作者两个都知道，但是都不会写。于是写了一个简略版的欧拉筛（就是for中的第一个if语句）。大意是在判断回文数时先把一些明显不符合题意的数字直接跳过，作者跳过了2、3、5的倍数。整个代码的思路是：1、初步筛选出符合条件的数；此题可以分为两个步骤，一、判断质数，二、判断回文数。显然，先判断回文数会快很多。
回文质数 Prime Palindromes
wzw-yali的博客
07-12 654
题目描述 因为151既是一个质数又是一个回文数(从左到右和从右到左是看一样的)，所以 151 是回文质数。 写一个程序来找出范围[a,b](5 输入输出格式 输入格式： 第 1 行: 二个整数 a 和 b . 输出格式： 输出一个回文质数的列表，一行一个。 输入输出样例 输入样例#1： 5 500 输出样例#1： 5 7 11 101 131 151 181 1
洛谷 P1217.[USACO1.5]回文质数 Prime Palindromes
TWF
02-17 429
洛谷 P1217.[USACO1.5]回文质数 Prime Palindromes 题目描述 因为 151 既是一个质数又是一个回文数（从左到右和从右到左是看一样的），所以 151 是回文质数。 写一个程序来找出范围 [ a,b ] (5≤a<b≤100,000,000)( 一亿)间的所有回文质数。 输入格式 第 1 行: 二个整数 a 和 b . 输出格式 输出一个回文质数的列表...
回文质数
sundujing的博客
07-17 833
151既是一个质数又是一个回文数(从左到右和从右到左是看一样的)，
P1217 USACO1.5 回文质数 Prime Palindromes
06-10
P1217 [USACO1.5] 回文质数 Prime Palindromes
洛谷 P1217 [USACO1.5] 回文质数 Prime Palindromes
万瓦罗的博客
08-02 708
本题AC的很不容易，断断续续写了一天，遇到很多问题。
筛素数-线性筛法（P1217 [USACO1.5] 回文质数 Prime Palindromes）
m0_64267361的博客
01-31 780
平常我们使用筛素数的时候，只需要使用欧拉筛法（线性筛法）就行了，因为复杂度是为。O（n）的，而且比较好写。
P1217 [USACO1.5]回文质数 Prime Palindromes (暴力枚举)
m0_73935863的博客
02-28 166
P1217 [USACO1.5]回文质数 Prime Palindromes (暴力枚举)
【洛谷】P1217 [USACO1.5]回文质数 Prime Palindromes
karshey的博客
01-26 759
做这道题十分曲折。 此题有多种做法： 1、从a到b判断是否是质数且是回文数：我的做法。 2、创造回文数（正如Hint里的代码）：太牛了的创造做法 3、打表：惊呆我的打表做法 我的过程： 1、先判断是否回文（回文好判断，耗时少）——判断是否质数。 2、做到最后发现最后一个测试点过不去，于是在别人的博客里得知了最后一个测试数据，直接特判（从打表得来的思路） 要注意： 1、此题非常容易TLE，故想要减少时间，就要将容易判断的、判断时间短的放前面。（如先判断回文） 2、关于质数：偶数位数的都不是质数（11除外...
洛谷-P1217 [USACO1.5]回文质数 Prime Palindromes
weixin_43098069的博客
07-22 231
题目描述 因为 151 既是一个质数又是一个回文数（从左到右和从右到左是看一样的），所以 151 是回文质数。 写一个程序来找出范围[a,b] (5 \le a < b \le 100,000,000)[a,b](5≤a<b≤100,000,000)( 一亿)间的所有回文质数。 输入格式 第 1 行: 二个整数 a 和 b . 输出格式 输出一个回文质数的列表，一行一个。 输入输出样例 输入 #1复制 5 500 输出 #1复制 5 7 11 101 131 151.
P1217 [USACO1.5]回文质数 Prime Palindromes-C++编程解析-函数
xingzhe_666的博客
10-12 574
解题思路： 题目是让我们去求一个闭区间内的回文质数，我们要求的数满足两个条件：第一个条件，是回文。即从左往右读和从右往左读是一样的。第二个条件是质数。因此，在闭区间范围内，偶数全部不满足条件。因此，我们需要处理的数据缩小为原闭区间数据个数的一半。偶数位数不存在回文质数。比如，四位的回文数xyyx=1000x+100y+10y+x=1001x+110y，通过分析，该数一定能被11整除，其他同理...
洛谷 P1217 [USACO1.5]回文质数 Prime Palindromes（埃氏筛法）
Yuhan的博客
12-30 402
题目链接： P1217 [USACO1.5]回文质数 Prime Palindromes 思路： 1.首先我们需要知道偶数长度的回文不会是素数，因为它必定能被11整除，这样我们就能将范围缩到一千万以内； 2.然后用埃氏筛法，得到一千万以内的所有素数，再挨个判断他们是否为回文即可； 代码： #include<bits/stdc++.h> using namespace std; ...
洛谷P1217-[USACO1.5]回文质数 Prime Palindromes
霞之丘诗羽的博客
03-26 344
https://www.luogu.org/problemnew/show/P1217 题目描述 因为151既是一个质数又是一个回文数(从左到右和从右到左是看一样的)，所以 151 是回文质数。 写一个程序来找出范围[a,b](5 <= a < b <= 100,000,000)( 一亿)间的所有回文质数; 输入输出格式 输入格式： 第 1 行: 二个整数 a ...
P1217 [USACO1.5] 回文质数 Prime Palindromes java
最新发布
03-19
### USACO P1217 Prime Palindromes 的 Java 实现 以下是基于枚举方法并结合回文数构造的方式实现的一个高效解决方案。此方案利用了回文数的特性以及质数判断算法，从而避免了大量的冗余计算。 #### 方法概述 为了提高效率，可以先生成给定范围内所有的回文数，再逐一验证这些回文数是否为质数。这种方法显著减少了需要测试的数量，因为大多数非回文数可以直接排除[^4]。 #### AC代码 (Java) ```java import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int a = scanner.nextInt(); int b = scanner.nextInt(); List<Integer> result = findPalindromePrimes(a, b); for (int num : result) { System.out.println(num); } } private static boolean isPrime(int n) { if (n < 2) return false; if (n == 2 || n == 3) return true; // 特殊情况处理 if (n % 2 == 0 || n % 3 == 0) return false; for (int i = 5; i * i <= n; i += 6) { // 跳过偶数和能被3整除的数 if (n % i == 0 || n % (i + 2) == 0) return false; } return true; } private static List<Integer> generatePalindromes(int length) { List<Integer> palindromes = new ArrayList<>(); if (length == 1) { for (int i = 0; i <= 9; i++) { palindromes.add(i); } return palindromes; } int halfLength = (length + 1) / 2; int start = (int) Math.pow(10, halfLength - 1); int end = (int) Math.pow(10, halfLength); for (int prefix = start; prefix < end; prefix++) { String s = Integer.toString(prefix); StringBuilder sb = new StringBuilder(s); if (length % 2 == 0) { sb.append(new StringBuilder(s).reverse()); } else { sb.append(new StringBuilder(s.substring(0, s.length() - 1)).reverse()); } palindromes.add(Integer.parseInt(sb.toString())); } return palindromes; } private static List<Integer> findPalindromePrimes(int a, int b) { List<Integer> primes = new ArrayList<>(); for (int len = 1; len <= 8 && Math.pow(10, len - 1) <= b; len++) { List<Integer> candidates = generatePalindromes(len); // 构造长度为len的所有回文数 for (int candidate : candidates) { if (candidate >= a && candidate <= b && isPrime(candidate)) { primes.add(candidate); } } } return primes; } } ``` --- #### 关键点解释 1. **回文数生成逻辑**: 使用 `generatePalindromes` 函数动态生成指定长度的回文数。对于奇数长度的回文数，中间字符不重复；而对于偶数长度，则完全对称。 2. **质数检测优化**: 利用了跳过偶数和能被3整除的数的方法，并进一步缩小循环范围至平方根级别 \( \sqrt{n} \)。 3. **边界条件处理**: 需要特别注意上下界 `[a, b]` 和最大可能值 \(10^8\) 的约束条件[^2]。 --- #### 时间复杂度分析 由于只针对回文数进行质数检验，而且回文数数量远少于总自然数数量，因此该算法的时间复杂度相较于暴力解法大幅降低。具体时间复杂度取决于区间大小和回文数分布密度。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值