【LeetCode】题解- 866. 回文素数

质数、回文、回文质数等问题。

重读基础概念

素数

自然数（natural number）：用以计量事物件数和或表示事物次序的数。从 0 开始，由全体非负整数组成的集合。
素数（prime number），又称质数，满足条件：仅有 1 和自身两个正因数的自然数（N≥2）称之为素数。0、1 既不是合数，也不是质数。数论的重要概念。

// 判断质数
int isPrime(int x) {
	if (x<2) return 0;
  	for (int i=2; i*i<=x; i++) {
      	if (x%i==0) return 0;
    }
  	return 1;
}

回文数

回文数（palindrome number），N 是一任意自然数，将 N 的各位数字反向排列所得自然数与 N 相等，正读和倒读都一样的自然数。按数位分析如下：

• 0~9，个位数全是回文数；
• 10~99，两位数中，个位数和十位数相同的自然数，也就是 11 的倍数全是回文数；
• 100~999，三位数中，个位数和百位数相同的自然数全是回文数，d1*100 + d2*10 + d1（1<=d1<=9，0<=d2<=9）；
• 10000~9999，四位数中，个位数和千位数相同，十位数和百位数相同的自然数全是回文数，d1*1000 + d2*100 + d2*10 + d1（1<=d1<=9，0<=d2<=9）；
• etc.

// 数组方法：LeetCode 运行时间，0ms，超过100%的其它方案
int isPalindrome(int x) {
    if (x<0) return 0;
    if (0<=x&&x<=9) return 1;
    if (x%10==0) return 0;

    int num[10]; // INT_MAX 是 9 位数
    int i = 0;
    while (x) {
        num[i++] = x%10;
        x /= 10;
    }
	/** 个人更加习惯的写法是：for，遇到不等就结束 */
    for(int lo=0, hi=i-1; lo<hi; lo++, hi--) {
        if(num[lo]!=num[hi]) return 0;
    }
    return 1;
	/** while 实现方式
	int lo=0, hi=i-1; // 双指针解法
 	while (num[lo] == num[hi]) {
    	if (lo==hi || lo==hi-1) return 1; // 奇数数位 || 偶数数位，到中间结束
      	lo++; hi--;
    }
  	return 0;
    */
}

int reverse(int x) { 
  	int ans = 0; 
  	while (x) { 
      	ans = 10*ans + x%10; x /= 10; 
    } 
  	return ans; 
} 
// 数学方法 
int isPalindrome(int x) { 
  	if (x==reverse(x)} return 1; else return 0; 
}

经典案例重现

P1217 [USACO1.5]回文质数

1- 读题
回文质数，既回文数，又质数，找出 [a, b] 范围内的所有质数，使用换行符分隔（5≤a<b≤100000000）。

• 输入，一行两个数字 a，b
• 输出，一个回文质数的列表，一行一个

2- 列举

• 一位数，0~9 全是回文数，其中，5、7 同时是素数
• 两位数，回文数全是 11 的倍数，除 11 之外，必然都不是素数
• 三位数，若个位数和百位数相等，全是回文数，当个位数是偶数，一定能被 2 整除，非素数。个位数和百位数相等，且是奇数时，才有可能是回文质数
• 四位数，若个位数和千位数相等、十位数和百位数相等，则是回文数，1000*d1 + 100*d2 + 10*d2 + d1 = 1001*d1 + 110*d2 = 11 * ( 91*d1 + 10*d2)，四位数的回文数一定能被 11 整除，肯定不是素数。其它，偶数位数的回文数，也一定能被 11 整除，同样不是素数
• 五位数、七位数等位数为奇数的数字，有可能是回文质数

3- 编程实现
（1）暴力破解：回文和素数分开单独做判断。最后一个测试点，出现 TLE：Time Limit Exceeded. 超时。

#include <iostream>
using namespace std;

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

int isPalindrome(int x) {
	if (x < 0) return 0;
	if (1 <= x && x <= 9) return 1;
	if (x % 10 == 0) return 0;
	
	int num[10]; // INT_MAX 是 9 位数
	int i = 0;
	while (x) {
		num[i++] = x % 10;
		x /= 10;
	}
	
	for(int lo = 0, hi = i - 1; lo < hi; lo++, hi--) {
		if (num[lo] != num[hi]) {
			return 0;
		}
	}
	return 1;
}

int main() {
	int a, b;
	cin >> a >> b;
	// 小优化：素数一定是奇数
	a = a % 2 ? a : a + 1;
	while (a <= b) {
		// 小优化：回文数的判断更省时， && 短路效果
		if(isPalindrome(a) && isPrime(a)) {
			cout << a << '\n';
		}
		a += 2;
	}
	return 0;
}

（2）优化算法：统一回文素数特点，构造回文，且极可能是素数的数字降低循环次数。

#include <cstdio>
using namespace std;

// 根据题况，调整 isPrime
int isPrime(int x) {
	for(int i=3; i*i<=x; i++) if(x%i==0) return 0;
	return 1;
}

int main() {
	int a, b;
	scanf("%d%d", &a, &b);
	// 1- <100 5、7、11
	if (a<=5 && b>=5) printf("%d\n", 5);
	if (a<=7 && b>=7) printf("%d\n", 7);
	if (a<=11 && b>=11) printf("%d\n", 11);
	
	int num = 0;
	// 2- 100~999
	for(int d1=1; d1<=9; d1+=2) {
		for(int d2=0; d2<=9; d2++) {
			num = 101*d1 + 10*d2;
			if(num < a) continue; // 从 a 开始
			if(num > b) return 0; // 到 b 结束
			if(isPrime(num)) printf("%d\n", num);
		}
	}
	
	// 3- 10000~99999
	for(int d1=1; d1<=9; d1+=2) {
		for(int d2=0; d2<=9; d2++) {
			for(int d3=0; d3<=9; d3++) {
				num = 10001*d1 + 1010*d2 + 100*d3;
				if(num < a) continue; // 从 a 开始
				if(num > b) return 0; // 到 b 结束
				if(isPrime(num)) printf("%d\n", num);
			}
		}
	}
	
	// 4- 1000000~9999999
	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++) {
					num = 1000001*d1 + 100010*d2 + 10100*d3 + 1000*d4;
					if(num < a) continue; // 从 a 开始
					if(num > b) return 0; // 到 b 结束
					if(isPrime(num)) printf("%d\n", num);
				}
			}
		}
	}
	return 0;
}

866. 回文素数

1- 读题
求出大于或等于 N 的最小回文素数（1 <= N <= 10^8^）。答案肯定存在，且小于 2 * 10⁸。

2- 列举

3- 编程实现
暴力破解超时，统一考虑回文素数特点，避免数字为偶数数位时的循环。

class Solution {
public:
    int isPrime(int x) {
        for(int i=2; i*i <= x; i++) if(x%i==0) return 0;
        return 1;
    }

    int reverse(int x) {
        int ans = 0;
        while (x) {
            ans = ans*10 + x%10;
            x /= 10;
        }
        return ans;
    }

    int isPalindrome(int x) {
        if(x%10==0) return 0;

        int num[10]; // INT_MAX 最大是 9 位数
        int i=0;
        while(x) {
            num[i++] = x%10;
            x /= 10;
        }
        for(int lo=0, hi=i-1; lo<hi; lo++, hi--) {
            if(num[lo] != num[hi]) return 0;
        }
        return 1;
    }

    int primePalindrome(int x) {
        if(x<=2) return 2;
        if(x<=3) return 3;
        if(x<=5) return 5;
        if(x<=7) return 7;
        if(x<=11) return 11;
        if(x<=101) return 101;

        while(true) {
            // if(x == reverse(x) && isPrime(x)) {
            if(isPalindrome(x) && isPrime(x)) {
                return x;
            }
            x ++;
            if (1000 < x && x < 10000) x = 10001;
            else if (100000 < x && x < 1000000 ) x = 1000001;
            else if (10000000 < x && x < 100000000) x = 100000001;
        }
    }
};