Prime Path
Time Limit:
1000
MS
Memory Limit:
65536
KB
64bit IO Format:
%lld & %llu
Description
— 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.
1033The 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.
1733
3733
3739
3779
8779
8179
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
这道题是自己第二次打， 第一次的用的是count标记次数，那个是模仿大神写的所以有点不懂， 今天自己又用结构体打了一遍，虽然很艰难，但是收获确实很多的啊，这道题的基本题意就是让你由一个说变成下个数需要几步，每次只能改变数的一位，而且改变完的数必须是素数，所以首先要打素数表，然后一个一个列举出来所有的情况就行了，这道题的要求是找最短的方法，但是如果用队列来解这题的话就不用考虑了。因为用队列求出来的都是最短的。这道题我遇到的问题就是千位必须大于0要不然第二个测试数据的结果就变成5了所有我最后加了一个条件然后AC了。。。且行且珍惜---
#include
<stdio.h>
#include
<stdlib.h>
#include
<string.h>
#include
<iostream>
#include
<algorithm>
#include
<queue>
using
namespace
std
;
int
prime
[
10000
]; //标记素数，非素数为1；
int
v
[
10000
]; //标记这个数在之前是否压入队列里
int
ans
,
state
; //最后的步数和是否能找到那个数
int
t
[
4
]; //储存 千 百 十 个
struct
node
{
int
n
;
int
step
;
}
;
void
Prime
() //打素数表
{
int
i
,
j
;
memset
(
prime
,
0
,
sizeof
(
prime
));
for
(
i
=
2
;
i
<
10000
;
i
++)
{
if
(!
prime
[
i
])
{
for
(
j
=
i
+
i
;
j
<
10000
;
j
+=
i
)
prime
[
j
]=
1
;
}
}
}
void
bfs
(
int
a
,
int
b
)
{
queue
<
node
>
q
;
struct
node
x
;
int
i
,
j
;
x
.
n
=
a
;
x
.
step
=
0
;
q
.
push
(
x
);
if
(
x
.
n
==
b
)
{
state
=
1
;
ans
=
x
.
step
;
return
;
}
memset
(
v
,
0
,
sizeof
(
v
));
while
(!
q
.
empty
())
{
x
=
q
.
front
();
q
.
pop
();
if
(
x
.
n
==
b
)
{
ans
=
x
.
step
;
break
;
}
v
[
x
.
n
]=
1
;
t
[
0
]=
x
.
n
/
1000
;
t
[
1
]=
x
.
n
/
100
%
10
;
t
[
2
]=
x
.
n
%
100
/
10
;
t
[
3
]=
x
.
n
%
10
;
for
(
i
=
0
;
i
<
4
;
i
++)
{
int
m
=
t
[
i
],
sum
; ///一定把m存下来要不然就然后再j循环完后就达不到只改变一位的效果了
for
(
j
=
0
;
j
<
10
;
j
++)
{
t
[
i
]=
j
;
sum
=
t
[
0
]*
1000
+
t
[
1
]*
100
+
t
[
2
]*
10
+
t
[
3
];
if
(
t
[
0
]==
0
)
continue
;
if
(!
v
[
sum
]
&&
!
prime
[
sum
])
{
struct
node
e
;
e
.
n
=
sum
;
e
.
step
=
x
.
step
+1
;
if
(
e
.
n
==
b
)
{
state
=
1
;
ans
=
e
.
step
;
break
;
}
q
.
push
(
e
);
v
[
sum
]=
1
;
}
}
t
[
i
]=
m
;
if
(
state
)
break
;
}
if
(
state
)
break
;
}
}
int
main
()
{
int
t
;
scanf
(
"%d"
,&
t
);
Prime
();
prime
[
0
]=
1
;
prime
[
1
]=
1
;
while
(
t
--)
{
int
a
,
b
;
scanf
(
"%d%d"
,&
a
,&
b
);
ans
=-
1
;
state
=
0
;
bfs
(
a
,
b
);
if
(
ans
==-
1
&&
!
state
)
printf
(
"Impossible
\n
"
);
else
printf
(
"%d
\n
"
,
ans
);
}
}
扫一扫
389
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
