题目描述：

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

要完成第 i 个替换操作:

1. 检查 子字符串  sources[i] 是否出现在 原字符串 s 的索引 indices[i] 处。
2. 如果没有出现， 什么也不做 。
3. 如果出现，则用 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", indices = [0,2], sources = ["a","cd"], targets = ["eee","ffff"]
输出："eeebffff"
解释：
"a" 从 s 中的索引 0 开始，所以它被替换为 "eee"。
"cd" 从 s 中的索引 2 开始，所以它被替换为 "ffff"。

示例 2：

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

提示：

• 1 <= s.length <= 1000
• k == indices.length == sources.length == targets.length
• 1 <= k <= 100
• 0 <= indices[i] < s.length
• 1 <= sources[i].length, targets[i].length <= 50
• s 仅由小写英文字母组成
• sources[i] 和 targets[i] 仅由小写英文字母组成

解题思路：

方法一：按照下标排序 + 模拟
思路与算法

我们直接按照题目的要求进行模拟即可。

首先我们根据数组 indices\textit{indices}indices，将所有的替换操作进行升序排序。在这一步中，同时对 indices\textit{indices}indices，sources\textit{sources}sources，targets\textit{targets}targets 这三个数组进行排序较为困难，我们可以使用一个长度（记为 mmm）与它们相同的数组 ops\textit{ops}ops，存储 000 到 m−1m-1m−1 这 mmm 个下标，随后对 ops\textit{ops}ops 本身按照 indices\textit{indices}indices 作为第一关键字进行排序即可。

在排序完成后，我们就可以遍历给定的字符串 sss 进行操作了。我们使用另一个指针 pt\textit{pt}pt 指向 ops\textit{ops}ops 的首个元素，表示当前需要进行的操作。当我们遍历到第 iii 个字符时，我们首先不断往右移动 pt\textit{pt}pt，直到其移出边界，或者第 ops[pt]\textit{ops}[\textit{pt}]ops[pt] 个操作的下标不小于 iii。此时，会有如下的两种情况：

如果这个下标大于 iii，说明不存在下标为 iii 的操作。我们可以直接将第 iii 个字符放入答案中；

如果这个下标等于 iii，说明存在下标为 iii 的操作。我们将 sss 从位置 iii 开始的长度与 sources[ops[i]]\textit{sources}[\textit{ops}[i]]sources[ops[i]] 的子串与 sources[ops[i]]\textit{sources}[\textit{ops}[i]]sources[ops[i]] 进行比较：

如果相等，那么替换操作成功，我们将 targets[ops[i]]\textit{targets}[\textit{ops}[i]]targets[ops[i]] 放入答案中。由于替换操作不可能重叠，因此我们可以直接跳过 sources[ops[i]]\textit{sources}[\textit{ops}[i]]sources[ops[i]] 长度那么多数量的字符；

否则，替换操作失败，我们可以直接将第 iii 个字符放入答案中。

需要注意的是，题目中只保证了成功的替换操作不会重叠，而不保证失败的替换操作不会重叠。因此当这个下标等于 iii 时，可能会有多个替换操作需要进行尝试，即我们需要不断往右移动 ptptpt，直到其移出边界，或者第 ops[pt]\textit{ops}[\textit{pt}]ops[pt] 个操作的下标严格大于 iii。遍历到的替换操作需要依次进行尝试，如果其中一个成功，那么剩余的不必尝试，可以直接退出。

代码

class Solution {
    public String findReplaceString(String s, int[] indices, String[] sources, String[] targets) {
        //定义n,m分别代表s字符串的长度和索引数组的长度
        int n = s.length(), m = indices.length;
        //用ArrayList ops来保存indices，作为对应s字符串下标值
        //利用ArrayList以便于排序等操作
        List<Integer> ops = new ArrayList<>();
        for (int i = 0; i < m; i++) {
            ops.add(i);
        }
        //？？
        ops.sort((i, j) -> indices[i] - indices[j]);
        
        //利用StringBuilder保存结果
        StringBuilder ans = new StringBuilder();
        //？？
        //>>>>>>>>>>>>>这是在准备下标值
        int pt = 0;
        for (int i = 0; i < n;) {
            while (pt < m && indices[ops.get(pt)] < i) {
                pt++;
            }
        //>>>>>>>>>>>>>>
            //初始化查找结果标记
            boolean succeed = false;
            //遍历条件1：下标的限制条件
            while (pt < m && indices[ops.get(pt)] == i) {
                //遍历条件2：字符串比较的条件
                if (s.substring(i, Math.min(i + sources[ops.get(pt)].length(), n)).equals(sources[ops.get(pt)])) {
                    //查找结果标记改变
                    succeed = true;
                    //相等则退出本次循环
                    break;
                }
                //循环下一个下标值
                pt++;
            }
            //本次查找完成后对应的操作
            if (succeed) {
                //有匹配的：需要进行使用目标字符串替换被查找的字符串的对应的字符
                ans.append(targets[ops.get(pt)]);
                i += sources[ops.get(pt)].length();
            } else {
                //没有匹配的：直接追加到结果尾部
                ans.append(s.charAt(i));
                i++;
            }
        }
        //返回结果字符串
        return ans.toString();

    }
}