解析AcWing 190. 字串变换，巧妙运用贪心算法优化题解

闲谈

2023-11-05 17:43:12

题意解读

给定两个字串 A, B 及一组字串变换的规则（至多 6 个规则）:
A1→B1
A2→B2
...

需要判断是否可以通过有限次规则变换，将字串 A 转变为字串 B。如果可以，则输出最少的变换次数，否则输出 -1。

解题思路

这道题的核心在于如何优化题解，以减少不必要的计算量。这里我们将介绍一种基于贪心算法的优化策略，该策略能够有效地缩短求解时间。

首先，将给定的变换规则存储在一个哈希表中，以提高查找效率。

其次，利用贪心算法选择当前最优的变换规则。具体做法是，在每次变换时，从哈希表中找到所有可以匹配当前字串 A 的变换规则，然后选择匹配长度最长的规则进行变换。

通过这种贪心策略，我们可以确保在每次变换时都获得最大的收益，从而减少总的变换次数。

代码实现

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

// 哈希表存储变换规则
unordered_map<string, string> rules;

// 贪心算法选择最优的变换规则
string choose_best_rule(const string& A) {
  string best_rule;
  int max_len = 0;
  for (const auto& rule : rules) {
    if (A.find(rule.first) != string::npos && rule.first.length() > max_len) {
      best_rule = rule.first;
      max_len = rule.first.length();
    }
  }
  return best_rule;
}

// 判断是否可以通过有限次规则变换，将字串 A 转变为字串 B
bool is_transformable(const string& A, const string& B) {
  // 如果 A 和 B 相等，则可以直接变换
  if (A == B) {
    return true;
  }

  // 选择最优的变换规则
  string best_rule = choose_best_rule(A);

  // 如果没有匹配的规则，则无法变换
  if (best_rule.empty()) {
    return false;
  }

  // 应用变换规则
  string new_A = A;
  size_t pos = new_A.find(best_rule);
  while (pos != string::npos) {
    new_A.replace(pos, best_rule.length(), rules[best_rule]);
    pos = new_A.find(best_rule, pos + rules[best_rule].length());
  }

  // 递归判断是否可以通过有限次规则变换，将新字串 new_A 转变为字串 B
  return is_transformable(new_A, B);
}

// 计算最少的变换次数
int min_transformations(const string& A, const string& B) {
  if (!is_transformable(A, B)) {
    return -1;
  }

  int count = 0;
  string cur_A = A;
  while (cur_A != B) {
    // 选择最优的变换规则
    string best_rule = choose_best_rule(cur_A);

    // 应用变换规则
    cur_A.replace(cur_A.find(best_rule), best_rule.length(), rules[best_rule]);

    // 统计变换次数
    count++;
  }

  return count;
}

int main() {
  // 读取输入
  int n;
  cin >> n;
  for (int i = 0; i < n; i++) {
    string A1, B1;
    cin >> A1 >> B1;
    rules[A1] = B1;
  }
  string A, B;
  cin >> A >> B;

  // 判断是否可以通过有限次规则变换，将字串 A 转变为字串 B
  if (is_transformable(A, B)) {
    // 计算最少的变换次数
    int count = min_transformations(A, B);
    cout << count << endl;
  } else {
    cout << -1 << endl;
  }

  return 0;
}