POJ 3126 *** Prime Path

最新推荐文章于 2023-08-12 18:22:10 发布

原创最新推荐文章于 2023-08-12 18:22:10 发布 · 292 阅读

0 ·

CC 4.0 BY-SA版权

[acm]搜索专栏收录该内容

7 篇文章

订阅专栏

本文探讨了在1000-9999区间内，通过改变素数A的一个位上的数字，使得最终得到的数字成为另一个指定素数B的最小步骤数问题。通过广度优先搜索（BFS）策略遍历所有可能状态，判断每一步是否依然保持素数特性，最终找到从A到B的最短路径。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意:给两个1000-9999内的素数A,B，每次改变A的一个位上的数字，得到后的数字必须为素数。问最少需要多少步才能得到B。

想法:对于A而言每次改变一个数字，那么用bfs遍历对A而言所有可能的状态同时判断是否为素数就可以了。

代码如下：

#pragma warning(disable:4996)
#include<iostream>
#include<cstdio>
#include<cmath>
#include<stack>
#include<queue>
#include<cstring>
#include<sstream>
#include<set>
#include<string>
#include<iterator>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;
typedef long long ll;

int prime[10000];
int flag[10000];
int base[4] = { 1,10,100,1000 };

int main(void) {
	//获得素数
	memset(prime, 1, sizeof(prime));
	for (int i = 2; i < 10000; ++i) {
		if (prime[i])
			for (int k = 2; k < 10010 / i; ++k)
				prime[i * k] = 0;
	}

	int n, ori, tar;
	cin >> n;
	while (n--) {
		cin >> ori >> tar;

		//如果ori==tar，直接输出结果
		if (ori == tar) {
			cout << 0 << endl;
			continue;
		}
		
		//如果ori!=tar，按以下方式处理
		memset(flag, 0, sizeof(flag));
		flag[ori] = 1;
		queue<int> path;
		path.push(ori);
		int now, temp, sign = 1;
		while (!path.empty()&&sign) {
			now = path.front();
			path.pop();

			int o[4];
			o[0] = now % 10, o[1] = now % 100 / 10;
			o[2] = now % 1000 / 100, o[3] = now / 1000;

			for (int i = 0; i < 4&&sign; ++i)
				for (int j = 0; j < 10&&sign; ++j) {
					temp = now - o[i] * base[i] + j*base[i];
					if (temp == tar) {
						flag[tar] = flag[now];
						sign = 0;
						break;
					}
					if (!flag[temp] && prime[temp] && temp>1000) {
						flag[temp] = flag[now] + 1;
						path.push(temp);
					}
			}
		}
		if (flag[tar])cout << flag[tar] << endl;
		else cout << "Impossible" << endl;
	}
	return 0;
}