USACO SuperPrime Rib

  题目连接如下：http://ace.delos.com/usacoprob2?a=OhfCIAcGGcZ&S=sprime

  这道题目是一道水题，本身不难，没什么算法思想，关键在于如何优化。如果说把输入的N位数字全部遍历来判断

是会超时的。我的想法如下：

•   第一个数字必须是质数，因为最后判断的时候就要求第一个数字是质数，这是题目要求
•   除第一个数字以外的其它数必须是奇数，因为如果是偶数的话，在cut的时候，以它为尾数的整数肯定能被

           2整除就已经不是质数了

  

  这里面在写代码的时候，我必须根据运行时的变量N来决定循环次数，因为我要手动去合成需要check的整数，

合成过程就是第一个数字外加N-1个奇数合成的整数，后来发现用递归来实现这个是最合适的，当时卡了一下。

  如果这样优化是很接近pass的，但是还不够，我的最后一个优化就是在循环判断各个位组成的整数是否是质数的

时候反过来，先判断位数少的，如果是质数再判断位数多的，这个其实不是技巧，但至少也是一种优化，而且没想

到竟然pass了，这个挺神奇，

   代码如下：

 

#include <iostream>
#include <cmath>
#include <fstream>
#include <vector>
#include <stack>

using namespace std;

vector<int> vec;

//to show the function parameter
#define OUT
#define IN

bool IsPrime(IN int nTest)
{
    if(1 == nTest) //1 is not prime
        return false;

    int nDivideTillNum = static_cast<int>(sqrt(static_cast<double>(nTest)));

    for(int i=2; i <= nDivideTillNum; i++)
    {
        if(nTest % i == 0)
        {
            return false;
        }
    }

    return true;
}

bool IsSpecialPrime(IN int nTest, IN int nBitNum)
{
    int nDivide=1;
    stack<int> s;

    //to reversely check to speed the program
    for(int i=0; i < nBitNum; i++)
    {
        s.push(nTest);
        nTest = nTest / 10;
    }
    while( ! s.empty())
    {
        int nTemp = s.top();
        s.pop();
        if(! IsPrime(nTemp))
        {
            return false;
        }
    }

    return true;
}

//
void GenerateNum(IN int n,IN  int num)
{
    if(0==n)
    {
        vec.push_back(num);
        return;
    }
    int original_num = num;
    for(int i=1; i <=9; i+=2)
    {
        num = num *10 + i;
        GenerateNum(n-1,num);
        num = original_num;
    }
}

int main(void)
{
    ifstream ifs;
    ifs.open("sprime.in");

    ofstream ofs;
    ofs.open("sprime.out");

    int N=0;
    ifs>>N;

    int nFirstNum[4] = {2,3,5,7};
    int nTest=0;
    GenerateNum(N-1,0);
    for(int i=0; i < 4; i++)
    {
        nTest = nFirstNum[i] * pow(10.0,(double)(N-1));
        for(vector<int>::iterator it=vec.begin(); it!=vec.end(); it++)
        {
            nTest += *it;
            if(IsSpecialPrime(nTest,N))
            {
                ofs<<nTest<<endl;
            }
            nTest -= *it;
        }
    }

    ifs.close();
    ofs.close();
    return 0;
}