Prime Path素數篩與BFS動態規劃

埃拉託斯特尼篩法（sieve of Eratosthenes ） 是古希臘數學家埃拉託斯特尼發明的計算素數的方法。對於求解不大於n的全部素數，咱們先找出sqrt(n)內的全部素數p1到pk，其中k = sqrt(n)，依次剔除Pi的倍數，剩下的全部數都是素數。

具體操做如上述 圖片所示。

C++實現

#include<iostream>
#include<vector>
using namespace std;
int main() {
    int n;
    cin >> n;
    vector<bool> isprime(n + 5, true);
    vector<int> ans;
    for (int i = 2; i <= n; i++) {
        if (isprime[i]) {
            ans.push_back(i);
            for (int j = i * i; j <= n; j += i)isprime[j] = false;
        }
    }
    for (auto i : ans)cout << i << " ";
    cout << endl;
    return 0;
}

整除問題

給定n，a求最大的k，使n！能夠被a^{k整除但不能被a}(k+1)整除。

輸入描述

兩個整數n(2<=n<=1000)，a(2<=a<=1000)

輸出描述

示例1

輸入

555 12

輸出

274

#include<iostream>
#include<vector>
#include<map>
using namespace std;
int main() {
    int n, a, temp;
    int ans = 0x7fffffff;
    cin >> n >> a;
    vector<bool> isprime(1010, true);
    vector<int> prime;  //素數列表
    map<int, int> primecntnp;  //存儲n!的質因子的指數
    map<int, int> primecnta;  //存儲a的質因子的指數
    for (int i = 2; i <= 1010; i++) {  //採用素數篩選出前1010個數中的素數，並將map初始化
        if (isprime[i]) {
            prime.push_back(i);
            primecntnp[i] = primecnta[i] = 0;
            for (int j = i * i; j <= 1010; j += i)isprime[j] = false;
        }
    }
    //4! = 24 = 1*2*3*4 = 2*2*2*3
    for (int i = 0; i < prime.size(); i++) { //對n!進行因式分解
        temp = n;
        while (temp) { //按照p、p*p、p*p*p來進行因式分解
            primecntnp[prime[i]] += temp / prime[i];
            temp /= prime[i];
        }
    }
    for (int i = 0; i < prime.size(); i++) { //對a進行因式分解
        temp = a;
        while (temp % prime[i] == 0) {
            primecnta[prime[i]]++;
            temp /= prime[i];
        }
        if (primecnta[prime[i]] == 0)continue; //a裏面不存在的則沒法提供
        if (primecntnp[prime[i]] / primecnta[prime[i]] < ans)ans = primecntnp[prime[i]] / primecnta[prime[i]];
    }//找到最小的指數，即是最大的k值
    cout << ans << endl;
    return 0;
}
/*
555 12
274
*/

拓展

Prime Path素數篩與BFS動態規劃的綜合應用

問題 POJ

Description

The ministers of the cabinet were quite upset by the message from the Chief of Security stating that they would all have to change the four-digit room numbers on their offices.

— It is a matter of security to change such things every now and then, to keep the enemy in the dark.

— But look, I have chosen my number 1033 for good reasons. I am the Prime minister, you know!

— I know, so therefore your new number 8179 is also a prime. You will just have to paste four new digits over the four old ones on your office door.

— No, it’s not that simple. Suppose that I change the first digit to an 8, then the number will read 8033 which is not a prime!

— I see, being the prime minister you cannot stand having a non-prime number on your door even for a few seconds.

— Correct! So I must invent a scheme for going from 1033 to 8179 by a path of prime numbers where only one digit is changed from one prime to the next prime.Now, the minister of finance, who had been eavesdropping, intervened.

— No unnecessary expenditure, please! I happen to know that the price of a digit is one pound.

— Hmm, in that case I need a computer program to minimize the cost. You don’t know some very cheap software gurus, do you?

— In fact, I do. You see, there is this programming contest going on… Help the prime minister to find the cheapest prime path between any two given four-digit primes! The first digit must be nonzero, of course. Here is a solution in the case above.

1033
1733
3733
3739
3779
8779
8179

The cost of this solution is 6 pounds. Note that the digit 1 which got pasted over in step 2 can not be reused in the last step – a new 1 must be purchased.

Input

One line with a positive number: the number of test cases (at most 100). Then for each test case, one line with two numbers separated by a blank. Both numbers are four-digit primes (without leading zeros).

Output

One line for each case, either with a number stating the minimal cost or containing the word Impossible.

Sample Input

3
1033 8179
1373 8017
1033 1033

Sample Output

6
7
0

問題大意

從一個素數換到另外一個素數，每次只能換一個數字（一位）且換後的每次都是素數。求最小次數？

C++代碼

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
const int maxn = 10000;
 
bool isprime[maxn + 1];
int dp[maxn + 1];
 
int getNext(int num, int t, int change){
    //num : 當前的數，t當前的位置，change是改變位的值
    if(t == 0) return num / 10 * 10 + change; //最低位
    else if(t == 1) return num /100 * 100 + change * 10 + num % 10;
    else if(t == 2) return num /1000 * 1000 + change * 100 + num % 100;
    else return change * 1000 + num % 1000;
}
 
int main(){
    fill(isprime+2, isprime + maxn, true);
    for(int i = 2; i <= maxn; i++){
        if(isprime[i]){
            for(int j = i * i; j <= maxn; j += i){
                isprime[j] = false;
            }
        }
    }//打表
    int T;
    cin>>T;
    while(T--){
        int a, b;
        cin>>a>>b;
        fill(dp, dp + maxn, 0x3f);
        dp[a] = 0; //記錄從一個prime跳躍到另外一個prime所需的最少次數
 
        queue<int> q;
        q.push(a);
        while(!q.empty()){
            int cur = q.front(); //取出隊列的第一個
            q.pop();
            for(int i = 0; i < 4; i++){
                for(int j = 0; j < 10; j++){
                    if(i == 3 && j == 0) continue; //
                    int next = getNext(cur, i, j); //替換
                    if(isprime[next] == false || dp[next] <= dp[cur]) continue;
                    // 不是素數不行，若是到next已經有更小的那也不用這個變換路徑了
                    dp[next] = dp[cur] + 1;
                    q.push(next);
                }
            }
        }
        cout<<dp[b]<<endl;
    }
    return 0;
}
 
/* 
3
1033 8179
1373 8017
1033 1033
 */