833. Find And Replace in String

To some string S, we will perform some replacement operations that replace groups of letters with new ones (not necessarily the same size).

Each replacement operation has 3 parameters: a starting index i, a source word x and a target word y.  The rule is that if x starts at position i in the original string S, then we will replace that occurrence of x with y.  If not, we do nothing.

For example, if we have S = "abcd" and we have some replacement operation i = 2, x = "cd", y = "ffff", then because "cd" starts at position 2 in the original string S, we will replace it with "ffff".

Using another example on S = "abcd", if we have both the replacement operation i = 0, x = "ab", y = "eee", as well as another replacement operation i = 2, x = "ec", y = "ffff", this second operation does nothing because in the original string S[2] = 'c', which doesn't match x[0] = 'e'.

All these operations occur simultaneously.  It's guaranteed that there won't be any overlap in replacement: for example, S = "abc", indexes = [0, 1], sources = ["ab","bc"] is not a valid test case.

Example 1:

Input: S = "abcd", indexes = [0,2], sources = ["a","cd"], targets = ["eee","ffff"]
Output: "eeebffff"
Explanation: "a" starts at index 0 in S, so it's replaced by "eee".
"cd" starts at index 2 in S, so it's replaced by "ffff".

Example 2:

Input: S = "abcd", indexes = [0,2], sources = ["ab","ec"], targets = ["eee","ffff"]
Output: "eeecd"
Explanation: "ab" starts at index 0 in S, so it's replaced by "eee". 
"ec" doesn't starts at index 2 in the original S, so we do nothing.

Notes:

1. 0 <= indexes.length = sources.length = targets.length <= 100
2. 0 < indexes[i] < S.length <= 1000
3. All characters in given inputs are lowercase letters.

没人写答案，自己写下QAQ

比较简单的操作array，本来还想优化答案的，被骗了钱烦的1B，就懒得优化了。

注意的就是从头开始改，建立一个数据结构用于储存需要被换掉的string块，然后通过index从头到位sort，从头到尾改。

class Solution {
public:
    string findReplaceString(string S, vector<int>& indexes, vector<string>& sources, vector<string>& targets) {
        vector<replacement>buffer;
        for(int i=0; i<indexes.size(); ++i)buffer.push_back(replacement(indexes[i], sources[i], targets[i]));
        sort(buffer.begin(), buffer.end(), m_comp);
        int cur_i=0;
        string ret;
        
        for(int i=0; i<S.size();){
            if(cur_i<buffer.size()&&i==buffer[cur_i].index){
                const replacement &temp=buffer[cur_i];
                if(temp.index+temp.source.size()<=S.size()&&S.substr(temp.index, temp.source.size())==temp.source){
                    ret+=temp.target;
                    i+=temp.source.size();
                }
                else{
                    ret+=S.substr(temp.index, temp.source.size());
                    i+=temp.source.size();
                }
                ++cur_i;
            }
            else{
                ret+=S[i];
                ++i;
            }
        }
        return ret;
    }
private:
    struct replacement{
        int index;
        string source;
        string target;
        replacement(int index, string source, string target):index(index), source(source), target(target){}
    };
    static bool m_comp(const replacement& R1, const replacement& R2){
        return R1.index<R2.index;
    }
};