LeetCode 2976.转换字符串的最小成本 I：floyd算法(全源最短路)

【LetMeFly】2976.转换字符串的最小成本 I：floyd算法(全源最短路)

力扣题目链接：https://leetcode.cn/problems/minimum-cost-to-convert-string-i/

给你两个下标从 0 开始的字符串 source 和 target ，它们的长度均为 n 并且由小写英文字母组成。

另给你两个下标从 0 开始的字符数组 original 和 changed ，以及一个整数数组 cost ，其中 cost[i] 代表将字符 original[i] 更改为字符 changed[i] 的成本。

你从字符串 source 开始。在一次操作中，如果存在任意下标 j 满足 cost[j] == z 、original[j] == x 以及 changed[j] == y 。你就可以选择字符串中的一个字符 x 并以 z 的成本将其更改为字符 y 。

返回将字符串 source 转换为字符串 target 所需的最小成本。如果不可能完成转换，则返回 -1 。

注意，可能存在下标 i 、j 使得 original[j] == original[i] 且 changed[j] == changed[i] 。

示例 1：

复制代码

输入：source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
输出：28
解释：将字符串 "abcd" 转换为字符串 "acbe" ：
- 更改下标 1 处的值 'b' 为 'c' ，成本为 5 。
- 更改下标 2 处的值 'c' 为 'e' ，成本为 1 。
- 更改下标 2 处的值 'e' 为 'b' ，成本为 2 。
- 更改下标 3 处的值 'd' 为 'e' ，成本为 20 。
产生的总成本是 5 + 1 + 2 + 20 = 28 。
可以证明这是可能的最小成本。

示例 2：

复制代码

输入：source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
输出：12
解释：要将字符 'a' 更改为 'b'：
- 将字符 'a' 更改为 'c'，成本为 1 
- 将字符 'c' 更改为 'b'，成本为 2 
产生的总成本是 1 + 2 = 3。
将所有 'a' 更改为 'b'，产生的总成本是 3 * 4 = 12 。

示例 3：

复制代码

输入：source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
输出：-1
解释：无法将 source 字符串转换为 target 字符串，因为下标 3 处的值无法从 'd' 更改为 'e' 。

提示：

1 <= source.length == target.length <= 10⁵
source、target 均由小写英文字母组成
1 <= cost.length== original.length == changed.length <= 2000
original[i]、changed[i] 是小写英文字母
1 <= cost[i] <= 10⁶
original[i] != changed[i]

解题方法：floyd算法

如何将source字符串变为target字符串？必须一个字符一个字符地通过cost[i]的代价将original[i]变为changed[i]来实现。

不难发现source中每个字符是独立的，并且从一个字符 a a a经过数次变化最终变为字符 b b b的最小代价也是固定的，所以我们不妨先计算出 26 × 26 26\times 26 26×26种字母的转换方式分别最少需要花费多少代价：

将26个字母看成图中26个顶点，

假设通过cost[i]的代价可以将original[i]变为changed[i]，那么就看作有一个从节点original[i]指向节点changed[i]且代价为cost[i]的边。

floyd算法最适合算这个了，初始化floyd[i][i]=0，有直接a指向b的边的初始化floyd[a][b]为a指向b中代价最小的边，其他初始化为正无穷。然后：
cpp 复制代码
for (int k = 0; k < 26; k++) {
    for (int i = 0; i < 26; i++) {
        for (int j = 0; j < 26; j++) {
            floyd[i][j] = min(floyd[i][j], floyd[i][k] + floyd[k][j]);
        }
    }
}
就计算出任何一个字母转为另一个字母的最小代价了。

对original字符串中每个字母做最小代价转换，累加并返回答案或-1即可。

时间复杂度 O ( l e n ( o r i g i n a l ) + l e n ( o r i g i n a l ) + C 2 ) O(len(original)+len(original)+C^2) O(len(original)+len(original)+C2)，其中 C = 16 C=16 C=16
空间复杂度 O ( C 2 ) O(C^2) O(C2)

AC代码

C++

cpp 复制代码

/*
 * @LastEditTime: 2026-01-31 12:22:44
 */
typedef long long ll;
class Solution {
public:
    long long minimumCost(string source, string target, vector<char>& original, vector<char>& changed, vector<int>& cost) {
        ll floyd[26][26];
        memset(floyd, 0x3f, sizeof(floyd));
        for (int i = 0; i < 26; i++) {
            floyd[i][i] = 0;
        }
        for (int i = 0; i < original.size(); i++) {
            int x = original[i] - 'a';
            int y = changed[i] - 'a';
            floyd[x][y] = min(floyd[x][y], (ll)cost[i]);
        }
        for (int k = 0; k < 26; k++) {
            for (int i = 0; i < 26; i++) {
                for (int j = 0; j < 26; j++) {
                    floyd[i][j] = min(floyd[i][j], floyd[i][k] + floyd[k][j]);
                }
            }
        }
        
        ll ans = 0;
        for (int i = 0; i < source.size(); i++) {
            ll cost = floyd[source[i] - 'a'][target[i] - 'a'];
            if (cost > 1000000000000) {
                return -1;
            }
            ans += cost;
        }
        return ans;
    }
};

对了，邀请你看几个好看的hash：

还带签名的。

同步发文于CSDN和我的个人博客，原创不易，转载经作者同意后请附上原文链接哦~

千篇源码题解已开源