833. 字符串中的查找与替换

题目描述：

你会得到一个字符串 s (索引从 0 开始)，你必须对它执行 k 个替换操作。替换操作以三个长度均为 k 的并行数组给出：indices, sources, targets。

要完成第 i 个替换操作:

检查 子字符串 sources[i] 是否出现在 原字符串 s 的索引 indices[i] 处。
如果没有出现， 什么也不做 。
如果出现，则用 targets[i] 替换该子字符串。

例如，如果 s = "abcd" ， indices[i] = 0 , sources[i] = "ab"， targets[i] = "eee" ，那么替换的结果将是 "eeecd" 。

所有替换操作必须同时发生，这意味着替换操作不应该影响彼此的索引。测试用例保证元素间不会重叠 。

例如，一个 s = "abc" ， indices = [0,1] ， sources = ["ab"，"bc"] 的测试用例将不会生成，因为 "ab" 和 "bc" 替换重叠。

在对 s 执行所有替换操作后返回 结果字符串 。

子字符串 是字符串中连续的字符序列。

示例 1：

输入：s = "abcd", indexes = [0,2], sources = ["a","cd"], targets = ["eee","ffff"]
输出："eeebffff"
解释：
"a" 从 s 中的索引 0 开始，所以它被替换为 "eee"。
"cd" 从 s 中的索引 2 开始，所以它被替换为 "ffff"。

示例 2：

输入：s = "abcd", indexes = [0,2], sources = ["ab","ec"], targets = ["eee","ffff"]
输出："eeecd"
解释：
"ab" 从 s 中的索引 0 开始，所以它被替换为 "eee"。
"ec" 没有从原始的 S 中的索引 2 开始，所以它没有被替换。

实现代码与思路：

哈希表 + 模拟

若一个位置有多个匹配

class Solution {
public:
    string findReplaceString(string s, vector<int>& indices, vector<string>& sources, vector<string>& targets) {

        unordered_map<int, vector<int>> m;
        string res = "";

        for (int i = 0; i < indices.size(); i++)
            m[indices[i]].push_back(i);
        
        // 遍历
        for (int i = 0; i < s.size();)
        {
            int flag = 0;
            if (m.count(i)) // 存在从这里开始的替换
            {
                for (auto t: m[i]) // 一个位置可能有多个替换
                {
                    // 相同
                    if (s.substr(i, sources[t].size()) == sources[t])
                    {
                        flag = 1;
                        res += targets[t];
                        i += sources[t].size(); // 移动
                        break;
                    }
                }
            }
            if (flag == 0)
            {
                res += s[i];
                i++;
            }
        }
        return res;
    }
};

不过此题说了不重复，可以直接这样写：

class Solution {
public:
    string findReplaceString(string s, vector<int>& indices, vector<string>& sources, vector<string>& targets) {

        unordered_map<int, int> m;
        string res = "";

        for (int i = 0; i < indices.size(); i++)
            m[indices[i]] = i;

        // 遍历 
        for (int i = 0; i < s.size();)
        {
            if (m.count(i)) // 存在从这里开始的替换
            {
                int t = m[i];
                if (s.substr(i, sources[t].size()) == sources[t])
                {
                    res += targets[t]; // 替换
                    i += sources[t].size(); // 移动
                    continue;
                }
            }
            res += s[i];
            i++;

        }
        return res;
    }
};