SWJTU-有价值的题目1028 全素羊羔 DFS

全素羊羔

一道简单的DFS题目，先看看题目
1028:全素羊羔
总时间限制: 1000ms 内存限制: 65536kB
描述
在羊的世界里，每一只羊被分配了唯一整数标号作为名字，如我的名字叫2015。

我们称一只羊为全素羊，当且仅当这只羊被分配的数字X满足：

1、X是素数（X称为素数，当且仅当X只能被1和它本身整除，特殊地，整数1不是素数）；

2、依次去除X的个位数（除非只剩下个位），每次操作后所得到的整数Y仍然是素数。

比如标号为233的羊就是全素羊，因为：

1、233是素数；

2、去除个位的3后，值为23，且为素数；然后，再去除个位的3，得到2，显然2也是素数。

因此，标号为233的羊就是全素羊。

虽然，我不是全素羊，但是我想知道标号在区间[L, R]的羊群当中有多少全素羊，你能帮帮我吗？

输入
第一组包含一个整数T，表示测试数据的个数；
对于每一组测试数据，仅包含2个整数L和R，表示需要查询的区间[L, R]。
数据范围：
50%：1 <= T <= 100，1 <= L <= R <= 10^12；
100%：1 <= T <= 100，1 <= L <= R <= 10^18。
输出
对于每一组测试数据，输出测试序号（从1开始），以及对应的答案。
样例输入
2
1 3
2 10
样例输出
Case #1: 2
Case #2: 4
提示
共2个测试点，各25分，共50分。

数字的范围都是上百亿的，而且时间限制为1000ms，显然O(n)的时间复杂度都会超时。

可以从全素数的定义中找到解题思路，因为一个数如果是全素数，那么去掉它的个位数也是全素数，也就是说，如果一个数不是全素数，那么他后面跟任何数字都不会是全素数。

我们可以利用DFS的思想，从个位开始，找到所有的全素数，然后给他们后面依次加上一个数，判断是否仍是全素数，这么一直深搜下去，（此处可以自行脑补一棵10叉树）

边界条件是当前的搜索数字不可以大于区间的大值R。
剪枝条件就是当前的搜索数字不是素数。

然后很快就得到了答案。
AC代码如下：

#include <bits/stdc++.h>
#define fur(i,a,b) for(int i=(a);i<(b);i++)
#define furr(i,a,b) for(int i=(a);i>(b);i--)
#define max(a,b) ( ((a)>(b)) ? (a):(b) )
#define min(a,b) ( ((a)>(b)) ? (b):(a) )
#define cl(a, b) memset((a),1,sizeof(a))
#define Point int
#define null NULL
#define OFFSET 500000
typedef long long ll;
typedef unsigned long long ull;
const int inf=0x3f3f3f3f;
const double eps=1e-8;
const ll mod=10000;
const double pi=acos(-1.0);
const int N=1010;

using namespace std;

ll L,R;
int res;

bool isprime(ll x){
    if(x == 0 || x == 1)
        return false;
    int i;
    for(i=2 ;i<=(ll)sqrt(x) ;i++){
        if(x %i == 0)
            return false;
    }
    return true;
}

void dfs(ll x){
    ll i,num;
    for(i=0 ;i<=9 ;i++){
        num = x + i;
        if(isprime(num)){
            if(num > R)
                return;
            if(num>=L)
                res++;
            dfs(num*10);
        }
    }
}

int main(){
    int T;
    scanf("%d",&T);
    fur(i,0,T)
    {
        res = 0;
        scanf("%lld%lld",&L,&R);
        dfs(0);
        printf("Case #%d: %d\n",i+1,res);
    }
    return 0;
}

这个算法是否还可以优化呢？
答案当然是肯定的，因为我们不难发现，可以充当第一位的数字只能是2，3，5，7（因为0，1，4，6，9都不是素数），充当其他位的数字只能为1,3,7,9（因为以其他数字结尾的数都可以很容易找到因子证明它不是素数，如以5结尾肯定可以被5整除）

发现这个规律后，就没必要从0-9这么跑循环了（10叉树变身4叉树），改进后的AC代码如下：

#include <bits/stdc++.h>
#define fur(i,a,b) for(int i=(a);i<(b);i++)
#define furr(i,a,b) for(int i=(a);i>(b);i--)
#define max(a,b) ( ((a)>(b)) ? (a):(b) )
#define min(a,b) ( ((a)>(b)) ? (b):(a) )
#define cl(a, b) memset((a),1,sizeof(a))
#define Point int
#define null NULL
#define OFFSET 500000
typedef long long ll;
typedef unsigned long long ull;
const int inf=0x3f3f3f3f;
const double eps=1e-8;
const ll mod=10000;
const double pi=acos(-1.0);
const int N=1010;


int start[4] = {2,3,5,7};
int ends[4] = {1,3,7,9};
ll L,R;
int res;

bool isprime(ll x)
{
    if(x==0||x==1)
        return false;
    fur(i,2,(ll)sqrt(x)+1)
        if(x%i==0)
            return false;
    return true;
}

void dfs(long num)
{
    long tmp;
    fur(i,0,4){
        tmp = num + ends[i];
        if(isprime(tmp)){
            if(tmp > R)
                return;
            if(tmp>=L)
                res++;
            dfs(tmp*10);
        }
    }
}
using namespace std;

int main()
{

    int T;
    scanf("%d",&T);
    fur(i,0,T)
    {
        res = 0;
        scanf("%I64d%I64d",&L,&R);
        fur(j,0,4)
        {
            if(start[j]>R)
                break;
            if(start[j]>=L)
                res++;
            dfs(start[j]*10);
        }

        printf("Case #%d: %d\n",i+1,res);
    }
    return 0;
}