摸爬滚打刷题--回文质数

一、背景介绍

1.质数

        质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。

2.回文数

        也是在做算法题的时候接触到的新词，所谓回文数，就是指一个整数，正看反看都一样，例如151, 2552, 35566553等等。

3.回文质数

        顾名思义，即是质数、又是回文数的自然数。

二、题目描述

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

        输入格式

        第一行输入两个正整数a和b。

        输出格式

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

        

三、解决问题思路及代码

        先去观察规律，这点很重要，尤其是复杂的算法题！

        看到题目给的数据范围是5到100000000，首先一亿肯定不是质数，将其排除。为什么要排除呢？因为一亿这个数太大了，如果所有数字遍历一次，那时间消耗也是非常恐怖的。但是我们只舍弃一亿这一个数字肯定掀不起波浪，所以我们就需要找到规律，争取删掉更多的数字。

        首先我们肯定要做的是写一个函数，去判断一个数是否为质数或回文数。

        判断一个数是否为质数：

int isPrime(int a) //判断a是否为质数
{
    if (a == 1)
    {
        return 0;
    }
    for (int i = 2; i <= sqrt(a); i++) //这里有一个sqrt，在a较小时可以不开方，
    {                                  //但是a较大时，开方可以省去一大部分时间
        if (a % i == 0)
        {
            return 0;
        }
    }

    return 1;
}

         判断一个数是否为回文数：

int isPalindrome(int a) //判断a是否为回文数
{
    int s = 0; //s用来保存a倒置的数
    int k = a;

    while (k != 0)
    {
        s *= 10;
        s += k % 10;
        k /= 10;
    }

    if (s == a) //判断a倒置后是否与原来相等
    {
        return 1;
    }
    return 0;
}

        接下来，我们的想法就很容易了，依次列举a到b之间的整数，判断是否为回文质数，如果是则输出，但刚才提到了，这么多数字，耗时是硬伤，所以需要删去数字，删去什么呢？答：删去所有偶数位数的数字，因为偶数位数的回文数一定不是质数。

        可是为什么呢？

        我们不妨先列举几个回文质数看看：55、1551、2882、465564、19733791。通过计算器计算，发现这几个数字都可以被11整除。那么这是巧合吗？答案肯定不是，不然这题说到这儿白说了……

        简单证明如下：

        好了，那可以省去的数字就是所有的八位数，当b大于9999999时，都可以把b当作9999999来看。

        再者小学就知道的常识，除2以外的偶数都不是质数，而题目范围从5开始，故不需考虑2，遇到偶数跳过即可。

        完整代码如下：

#include <iostream>
#include <cmath>

int isPrime(int a) //检查a是否为质数
{
    if (a == 1)
    {
        return 0;
    }
    for (int i = 2; i <= sqrt(a); i++)
    {
        if (a % i == 0)
        {
            return 0;
        }
    }

    return 1;
}

int isPalindrome(int a) //检查a是否为回文数
{
    int s = 0;
    int k = a;

    while (k != 0)
    {
        s *= 10;
        s += k % 10;
        k /= 10;
    }

    if (s == a)
    {
        return 1;
    }
    return 0;
}

int main()
{
    int a, b;
    std::cin >> a >> b;

    if (a % 2 == 0) //当a是偶数直接检查下一个数字
    {
        a++;
    }
    if (b >= 9999999) //当b是八位数或一亿时，直接舍弃掉
    {
        b = 9999999;
    }
    for (int i = a; i <= b; i += 2) //从奇数遍历，每次+2，也可省去大概一半的时间
    {
        if (isPrime(i) && isPalindrome(i))
        {
            std::cout << i << std::endl;
        }
    }

    return 0;
}

        实际上这样的代码提交后最后三个数据会超时，我在做这个题的时候也看了别人的做法，那个时候这样提交代码就没问题了，但是我提交后三个还是过不去，不知道是不是数据优化了。有懂的大佬欢迎指正！

        ……

        下面我就要用自己的方法了（每次到这个时候都觉得自己好菜，写的就是傻瓜代码，长而简单，没有技巧可言，唯一的好处就是易懂了吧……）

        其实这个题如果大家没有读完，肯定会像我上面一样考虑，对于普通人来说，这样的思维是正常的。题下面还有一段提示：

         这样思路又明确了，根据上面分析可以舍弃的数字，我们直接产生3位数、5位数、7位数的回文数，再判断他是不是质数即可。这样下来可以说省去了很大一部分的数字了，所以后面才会过。产生回文数的函数如下：

int createPalindrom(int d1, int d2) //产生3位数的回文数
{
    int p = d1 * 100 + d2 * 10 + d1;
    return p;
}

int createPalindrom(int d1, int d2, int d3) //产生5位数的回文数
{
    int p = d1 * 10000 + d2 * 1000 + d3 * 100 + d2 * 10 + d1;
    return p;
}

int createPalindrom(int d1, int d2, int d3, int d4) //产生7位数的回文数
{
    int p = d1 * 1000000 + d2 * 100000 + d3 * 10000 + d4 * 1000 + d3 * 100 + d2 * 10 + d1;
    return p;
}

        除了这个函数，我们还需一个函数来确定产生几位回文数：

int count(int s) //实际上就是通过上界b来确定产生回文数的位数
{                //至于a后面会限定
    int n = 0;
    while (s != 0)
    {
        s /= 10;
        n++;
    }
    return n;
}

        那么细枝末节搞完了，完整代码如下：

#include <iostream>
#include <cmath>

int isPrime(int a)
{
    if (a == 1)
    {
        return 0;
    }
    for (int i = 2; i <= sqrt(a); i++)
    {
        if (a % i == 0)
        {
            return 0;
        }
    }

    return 1;
}

int createPalindrom(int d1, int d2)
{
    int p = d1 * 100 + d2 * 10 + d1;
    return p;
}

int createPalindrom(int d1, int d2, int d3)
{
    int p = d1 * 10000 + d2 * 1000 + d3 * 100 + d2 * 10 + d1;
    return p;
}

int createPalindrom(int d1, int d2, int d3, int d4)
{
    int p = d1 * 1000000 + d2 * 100000 + d3 * 10000 + d4 * 1000 + d3 * 100 + d2 * 10 + d1;
    return p;
}

int count(int s)
{
    int n = 0;
    while (s != 0)
    {
        s /= 10;
        n++;
    }
    return n;
}

int main()
{
    int a, b;
    std::cin >> a >> b;

    if (a % 2 == 0)
    {
        a++;
    }
    if (b >= 9999999)
    {
        b = 9999999;
    }

    int countb = count(b);

    if (a <= 5)
    {
        std::cout << 5 << std::endl;
        std::cout << 7 << std::endl;
        std::cout << 11 << std::endl;
    }
    if (a > 5 && a <= 7)
    {
        std::cout << 7 << std::endl;
        std::cout << 11 << std::endl;
    }
    if (a > 7 && a <= 11)
    {
        std::cout << 11 << std::endl;
    }
    if (countb == 3)
    {
        for (int d1 = 1; d1 <= b / 100; d1 += 2)
        {
            for (int d2 = 0; d2 <= 9; d2++)
            {
                int palindrom = createPalindrom(d1, d2);
                if (isPrime(palindrom) && palindrom <= b && palindrom >= a)
                {
                    std::cout << palindrom << std::endl;
                }
            }
        }
    }
    if (countb == 5)
    {
        for (int d1 = 1; d1 <= 9; d1 += 2)
        {
            for (int d2 = 0; d2 <= 9; d2++)
            {
                int palindrom = createPalindrom(d1, d2);
                if (isPrime(palindrom) && palindrom <= b && palindrom >= a)
                {
                    std::cout << palindrom << std::endl;
                }
            }
        }
        for (int d1 = 1; d1 <= b / 10000; d1 += 2)
        {
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    int palindrom = createPalindrom(d1, d2, d3);
                    if (isPrime(palindrom) && palindrom <= b && palindrom >= a)
                    {
                        std::cout << palindrom << std::endl;
                    }
                }
            }
        }
    }
    if (countb == 7)
    {
        for (int d1 = 1; d1 <= 9; d1 += 2)
        {
            for (int d2 = 0; d2 <= 9; d2++)
            {
                int palindrom = createPalindrom(d1, d2);
                if (isPrime(palindrom) && palindrom <= b && palindrom >= a)
                {
                    std::cout << palindrom << std::endl;
                }
            }
        }
        for (int d1 = 1; d1 <= 9; d1 += 2)
        {
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    int palindrom = createPalindrom(d1, d2, d3);
                    if (isPrime(palindrom) && palindrom <= b && palindrom >= a)
                    {
                        std::cout << palindrom << std::endl;
                    }
                }
            }
        }
        for (int d1 = 1; d1 <= b / 1000000; d1 += 2)
        {
            for (int d2 = 0; d2 <= 9; d2++)
            {
                for (int d3 = 0; d3 <= 9; d3++)
                {
                    for (int d4 = 0; d4 <= 9; d4++)
                    {
                        int palindrom = createPalindrom(d1, d2, d3, d4);
                        if (isPrime(palindrom) && palindrom <= b && palindrom >= a)
                        {
                            std::cout << palindrom << std::endl;
                        }
                    }
                }
            }
        }
    }

    return 0;
}

        上面代码长就长在if分支中，我们对于a只考虑5、7、11这三个数字，看a在哪里，确定这三个数字输出哪个，如果b的长度为3，那么产生3位数的回文数很正常，但是b的位数如果是5，我们仍需产生所有3位的回文数，因为a我们不确定在哪里，同理，b如果是7位数，也要产生5位回文数和3位回文数，那么久可以在输出的时候只输出大于a的回文质数，这样就保证了a的下界作用。代码看起来很长，实际上做的都是重复而简单的工作，循环看似很多层，实际产生数据规模小了很大一部分。

        这道题目就这样解决了，我也是刚AC就来写这篇文章了，所以代码可能会不完善，比如哪里可以优化让代码看起来不这么复杂……这些都是后话了，反正上面代码足够AC了。。。

四、总结

        通过分析舍去了所有的两位数（除了11）、四位数、六位数、八位数和一亿，并且前面只保留了5、7、11这三个数字，先产生3、5、7位回文数，再判断是否为质数，输出时需要满足大于等于a而小于等于b，这样就解决了。

        大佬如果有好的建议欢迎讨论！