【每日一题】833. 字符串中的查找与替换

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", 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] 仅由小写英文字母组成

解题思路

思路：创建一个长度为n的替换列表，用于存储被替换后的字符串和被替换的长度。收集完该替换列表信息后，再遍历字符串s，如果被替换后的字符串不为空则后移被替换的长度，反之则后移长度1。s.compare(pos,len,substr)用于比较s中从pos位置开始长度为len的字符串与substr字符串。

class Solution {
public:
    string findReplaceString(string s, vector<int>& indices, vector<string>& sources, vector<string>& targets) {
        int n=s.length();
        // 开启一个长度为n的替换列表 存储被替换后的字符串和被替换的长度
        vector<pair<string,int>> replace(n,{"",1});
        for(int i=0;i<indices.size();i++)
        {
            if(s.compare(indices[i],sources[i].size(),sources[i])==0)
                // 替换后的字符串 被替换的字符串长度
                replace[indices[i]]={targets[i],sources[i].length()};
        }
        string res;
        // 无需替换时i+=1
        for(int i=0;i<n;i+=replace[i].second)
        {
            if(replace[i].first=="")
                res+=s[i];
            else
                res+=replace[i].first;
        }
        return res;
    }
};

思路：第一种思路是直接模拟，但是由于indices下标无序，故不可行。

class Solution {
public:
    string findReplaceString(string s, vector<int>& indices, vector<string>& sources, vector<string>& targets) {
        // 如果indices下标有序则该思路可行！
        string res="";
        int n=s.size();
        int start=0;
        for(int k=0;k<sources.size();k++)
        {
            bool flag=true;
            for(int i=0,j=indices[k];i<sources[k].size()&&j<n;i++,j++)
            {
                if(sources[k][i]!=s[j])
                    flag=false;
            }
            // 收集前面未替换部分
            if(indices[k]-start>0)
            {
                res+=s.substr(start,indices[k]-start);
                start=indices[k];
            }
            // 收集可替换部分
            if(flag)
            {
                res+=targets[k];
                start=indices[k]+sources[k].size();
            }
        }
        // 收集后面未替换部分
        if(start!=n)
            res+=s.substr(start);
        return res;
    }
};