Sicily 1444. Prime Path

1444. Prime Path

Constraints

Time Limit: 1 secs, Memory Limit: 32 MB

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

个人做法就是构图，然后BFS或者Dijkstra

第一次做是用的BFS，0.02s：

#include <stdio.h>
#include <vector>
#include <map>
#include <queue>
#include <string.h>
using namespace std;

vector<int> road[1200];
bool is_prime[10000];
int prime[10000], prime_num, prime_is_index[10000];
bool used[1200];

void make_prime() {
    prime_num = 0;
    memset(is_prime, 1, sizeof(is_prime));
    for (int i = 2; i < 10000; i++) {
        if (is_prime[i]) {
            for (int j = 2; j * i < 10000; j++) {
                is_prime[j * i] = false;
            }
            if (i >= 1000)
                prime[prime_num++] = i;
        }
    }
}

void make_prime_is_index() {
    for (int i = 0; i < prime_num; i++) {
        prime_is_index[prime[i]] = i;
    }
}

bool only_one_digit_dif(int a, int b) {
    int dif_num = 0, i;
    char aa[4], bb[4];
    
    i = 0;
    while (a) {
        aa[i++] = a % 10 + '0';
        a /= 10;
    }
    i = 0;
    while (b) {
        bb[i++] = b % 10 + '0';
        b /= 10;
    }
    
    for (i = 0; i < 4; i++) {
        if (aa[i] != bb[i])
            dif_num++;
        if (dif_num >= 2) {
            return false;
        }
    }
    if (dif_num == 1)
        return true;
    return false;
}

void make_road() {
    for (int i = 0; i < prime_num; i++) {
        for (int j = i + 1; j < prime_num; j++) {
            if (only_one_digit_dif(prime[i], prime[j])) {
                road[i].push_back(j);
                road[j].push_back(i);
            }
        }
    }
}

struct step {
    int point;
    int num;
    step(int p, int n) {
        point = p;
        num = n;
    }
};

int BFS(int sp, int ep) {
    sp = prime_is_index[sp];
    ep = prime_is_index[ep];
    memset(used, false, sizeof(used));
    queue<step> q;
    q.push(step(sp, 0));
    used[sp] = true;
    step temp(0, 0);
    int size;
    
    while (!q.empty()) {
        size = q.size();
        while (size--) {
            temp = q.front();
            q.pop();
            if (temp.point == ep)
                return temp.num;
            for (int i = 0; i < (int)road[temp.point].size(); i++) {
                if (!used[road[temp.point][i]]) {
                    q.push(step(road[temp.point][i], temp.num + 1));
                    used[road[temp.point][i]] = true;
                }
            }
        }
    }
    return -1;
}

int main() {
    int case_num, sp, ep;
    make_prime();
    make_road();
    make_prime_is_index();
    scanf("%d", &case_num);
    while (case_num--) {
        scanf("%d%d", &sp, &ep);
        printf("%d\n", BFS(sp, ep));
    }
    return 0;
}                       

后来提高效率，于是用Dijkstra，还是0.02s：

// Problem#: 1444
// Submission#: 2796944
// The source code is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
// URI: http://creativecommons.org/licenses/by-nc-sa/3.0/
// All Copyright reserved by Informatic Lab of Sun Yat-sen University
#include <stdio.h>
#include <vector>
#include <map>
#include <queue>
#include <string.h>
#define INF 0x7f7f7f
using namespace std;

vector<int> road[1200];
bool is_prime[10000];
int prime[10000], prime_num, prime_is_index[10000];
bool used[1200];

void make_prime() {
    prime_num = 0;
    memset(is_prime, 1, sizeof(is_prime));
    for (int i = 2; i < 10000; i++) {
        if (is_prime[i]) {
            for (int j = 2; j * i < 10000; j++) {
                is_prime[j * i] = false;
            }
            if (i >= 1000)
                prime[prime_num++] = i;
        }
    }
}

void make_prime_is_index() {
    for (int i = 0; i < prime_num; i++) {
        prime_is_index[prime[i]] = i;
    }
}

bool only_one_digit_dif(int a, int b) {
    int dif_num = 0, i;
    char aa[4], bb[4];
    
    i = 0;
    while (a) {
        aa[i++] = a % 10 + '0';
        a /= 10;
    }
    i = 0;
    while (b) {
        bb[i++] = b % 10 + '0';
        b /= 10;
    }
    
    for (i = 0; i < 4; i++) {
        if (aa[i] != bb[i])
            dif_num++;
        if (dif_num >= 2) {
            return false;
        }
    }
    if (dif_num == 1)
        return true;
    return false;
}

void make_road() {
    for (int i = 0; i < prime_num; i++) {
        for (int j = i + 1; j < prime_num; j++) {
            if (only_one_digit_dif(prime[i], prime[j])) {
                road[i].push_back(j);
                road[j].push_back(i);
            }
        }
    }
}

typedef pair<int, int> p;

int Dijkstra(int sp, int ep) {
    if (sp == ep)
        return 0;
    if (!is_prime[sp] || !is_prime[ep])
        return -1;
    sp = prime_is_index[sp];
    ep = prime_is_index[ep];
    int d[1200];
    memset(d, INF, sizeof(d));
    memset(used, false, sizeof(used));
    d[sp] = 0;
    priority_queue<p, vector<p>, greater<p> > q;
    q.push(p(0, sp));
    p top;
    while (!q.empty()) {
        top = q.top();
        q.pop();
        if (top.second == ep)
            return d[ep];
        if (used[top.second] || d[top.second] < top.first)
            continue;
        used[top.second] = true;
        for (int i = 0; i < (int)road[top.second].size(); i++) {
            if (d[road[top.second][i]] > d[top.second] + 1) {
                d[road[top.second][i]] = d[top.second] + 1;
                q.push(p(d[road[top.second][i]], road[top.second][i]));
            }
        }
    }
    return -1;
}

int main() {
    int case_num, sp, ep;
    make_prime();
    make_road();
    make_prime_is_index();
    scanf("%d", &case_num);
    while (case_num--) {
        scanf("%d%d", &sp, &ep);
        int temp = Dijkstra(sp, ep);
        if (temp == -1) {
            printf("Impossible\n");
        } else {
            printf("%d\n", temp);
        }
    }
    return 0;
}      

最后上网看了别人的，终于知道原来提高效率的关键在于改进我的make_road的算法，由此前的简单二重循环改为对每个素数主动地去构建新的只有一位不同的数，然后判断是否是素数即可，这样效率就是1000 * 40，提高了许多，于是终于0s了：

// Problem#: 1444
// Submission#: 2796971
// The source code is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
// URI: http://creativecommons.org/licenses/by-nc-sa/3.0/
// All Copyright reserved by Informatic Lab of Sun Yat-sen University
#include <stdio.h>
#include <vector>
#include <map>
#include <queue>
#include <string.h>
#define INF 0x7f7f7f
using namespace std;

vector<int> road[1200];
bool is_prime[10000];
int prime[10000], prime_num, prime_is_index[10000];
bool used[1200];

void make_prime() {
    prime_num = 0;
    memset(is_prime, 1, sizeof(is_prime));
    for (int i = 2; i < 10000; i++) {
        if (is_prime[i]) {
            for (int j = 2; j * i < 10000; j++) {
                is_prime[j * i] = false;
            }
            if (i >= 1000)
                prime[prime_num++] = i;
        }
    }
}

void make_prime_is_index() {
    for (int i = 0; i < prime_num; i++) {
        prime_is_index[prime[i]] = i;
    }
}

bool only_one_digit_dif(int a, int b) {
    int dif_num = 0, i;
    char aa[4], bb[4];
    
    i = 0;
    while (a) {
        aa[i++] = a % 10 + '0';
        a /= 10;
    }
    i = 0;
    while (b) {
        bb[i++] = b % 10 + '0';
        b /= 10;
    }
    
    for (i = 0; i < 4; i++) {
        if (aa[i] != bb[i])
            dif_num++;
        if (dif_num >= 2) {
            return false;
        }
    }
    if (dif_num == 1)
        return true;
    return false;
}

void make_road() {
    for (int i = 0; i < prime_num; i++) {
        int temp[4];
        int temp_prime = prime[i], j = 3;
        while (temp_prime) {
            temp[j--] = temp_prime % 10;
            temp_prime /= 10;
        }
        for (j = 0; j < 4; j++) {
            int save = temp[j];
            int new_temp;
            for (int k = 0; k <= 9; k++) {
                if (save != k) {
                    temp[j] = k;
                    if (j == 0 && k == 0) {
                        continue;
                    }
                    new_temp = temp[0] * 1000 + temp[1] * 100 + temp[2] * 10 + temp[3];
                    if (is_prime[new_temp]) {
                        road[i].push_back(prime_is_index[new_temp]);
                        road[prime_is_index[new_temp]].push_back(i);
                    }
                }
            }
            temp[j] = save;
        }
    }
}

typedef pair<int, int> p;

int Dijkstra(int sp, int ep) {
    if (sp == ep)
        return 0;
    if (!is_prime[sp] || !is_prime[ep])
        return -1;
    sp = prime_is_index[sp];
    ep = prime_is_index[ep];
    int d[1200];
    memset(d, INF, sizeof(d));
    memset(used, false, sizeof(used));
    d[sp] = 0;
    priority_queue<p, vector<p>, greater<p> > q;
    q.push(p(0, sp));
    p top;
    while (!q.empty()) {
        top = q.top();
        q.pop();
        if (top.second == ep)
            return d[ep];
        if (used[top.second] || d[top.second] < top.first)
            continue;
        used[top.second] = true;
        for (int i = 0; i < (int)road[top.second].size(); i++) {
            if (d[road[top.second][i]] > d[top.second] + 1) {
                d[road[top.second][i]] = d[top.second] + 1;
                q.push(p(d[road[top.second][i]], road[top.second][i]));
            }
        }
    }
    return -1;
}

int main() {
    int case_num, sp, ep;
    make_prime();
    make_prime_is_index();
    make_road();
    scanf("%d", &case_num);
    while (case_num--) {
        scanf("%d%d", &sp, &ep);
        int temp = Dijkstra(sp, ep);
        if (temp == -1) {
            printf("Impossible\n");
        } else {
            printf("%d\n", temp);
        }
    }
    return 0;
}