MYOJ_4576:(洛谷P1032)[NOIP 2002 提高组]字串变换(BFS提高)

第一次写NOIP-S的题解，有bug请多多指教~

题目描述

已知有两个字串 A,B 及一组字串变换的规则（至多 6 个规则），形如：

• A1​→B1​。
• A2​→B2​。

规则的含义为：在 A 中的子串 A1​ 可以变换为 B1​，A2​ 可以变换为 B2​⋯。

例如：A=abcd，B＝xyz，

变换规则为：

• abc→xu，ud→y，y→yz。

则此时，A 可以经过一系列的变换变为 B，其变换的过程为：

• abcd→xud→xy→xyz。

共进行了 3 次变换，使得 A 变换为 B。

对于 100% 数据，保证所有字符串长度的上限为 20。

输入

第一行有两个字符串 A,B。 

接下来若干行，每行有两个字符串 Ai​,Bi​，表示一条变换规则。

输出

若在 10 步（包含 10 步）以内能将 A 变换为 B，则输出最少的变换步数；否则输出 NO ANSWER!。

样例输入输出

输入：

abcd xyz
abc xu
ud y
y yz
输出：3

思路：

BFS(老朋友)主场，理解了题目就好做了，看实现↓↓↓

STEP 1:还是一样的，定义结构体，方便BFS的queue用，包括字符串状态与当前步数

STEP 2:定义，注意vis不再是之前的BFS的数组，因为需要存储当前被访问的那个字符串作为键值，所以建议使用map。

替代：哈希表(其实根本不需要，本题时间复杂度是完全可以使用map的，而且哈希要处理哈希冲突)，set(太麻烦且不直观)

STEP 3:BFS，步骤如下：

1. 初始化队列和访问标记：

   • 创建一个队列 q，用于存储待处理的字符串状态。

   • 将初始字符串 s1 标记为已访问，并将其加入队列，步数为 0。

2. 处理队列中的状态：

   • 从队列中取出一个状态 s 和其对应的步数 d。

   • 如果 s 等于目标字符串 s2，则返回当前步数 d。

   • 如果步数 d 超过 10，则终止搜。

3. 应用所有可能的变换规则：

   • 对于每一个变换规则 a[k] → b[k]，在当前字符串 s 中查找所有可以应用该规则的位置。

   • 使用 substr 检查从位置 i 开始的子串是否等于 a[k]。

   • 如果匹配，则进行替换，生成新的字符串 t。

   • 如果新字符串 t 未被访问过，则标记为已访问，并将其加入队列，步数为 d + 1。

4. 搜索失败：

   • 如果队列为空且未找到目标字符串，返回 -1。

STEP 4:输入，使用ans保存bfs结果，若为-1输出"NO ANSWER!"否则输出ans

代码

#include<bits/stdc++.h>
using namespace std;
struct Node
{
	string s;
	int d;
};
string s1,s2,a1,b1,a[1005],b[1005];
map<string,bool>vis;
int n;
int bfs()
{
	queue<Node>q;
	vis[s1]=true;
	q.push(Node{s1,0});
	while(!q.empty())
	{
		string s=q.front().s;
		int d=q.front().d;
		q.pop();
		if(s==s2)
		{
			return d;
		}
		if(d>10)
		{
			break;
		}
		for(int k=0;k<n;k++)
		{
			for(int i=0;i<=int(s.length()-a[k].length());i++)
			{
				if(s.substr(i,a[k].length())==a[k])
				{
					string t=s;
					t.replace(i,a[k].length(),b[k]);
					if(!vis[t])
					{
						vis[t]=true;
						q.push(Node{t,d+1});
					}
				}
			}
		}
	}
	return -1;
}
int main()
{
	cin>>s1>>s2;
	while(cin>>a[n]>>b[n])
	{
		n++;
	}
	int ans=bfs();
	if(ans==-1)
	{
		cout<<"NO ANSWER!";
	}
	else
	{
		cout<<ans;
	}
    return 0;
}

运行结果