833. Find And Replace in String

You are given a 0-indexed string s that you must perform k replacement operations on. The replacement operations are given as three 0-indexed parallel arrays, indices, sources, and targets, all of length k.

To complete the ith replacement operation:

Check if the substring sources[i] occurs at index indices[i] in the original string s.
If it does not occur, do nothing.
Otherwise if it does occur, replace that substring with targets[i].
For example, if s = “abcd”, indices[i] = 0, sources[i] = “ab”, and targets[i] = “eee”, then the result of this replacement will be “eeecd”.

All replacement operations must occur simultaneously, meaning the replacement operations should not affect the indexing of each other. The testcases will be generated such that the replacements will not overlap.

For example, a testcase with s = “abc”, indices = [0, 1], and sources = [“ab”,”bc”] will not be generated because the “ab” and “bc” replacements overlap.
Return the resulting string after performing all replacement operations on s.

A substring is a contiguous sequence of characters in a string.

Example 1:

Input: s = "abcd", indices = [0, 2], sources = ["a", "cd"], targets = ["eee", "ffff"]
Output: "eeebffff"
Explanation:
"a" occurs at index 0 in s, so we replace it with "eee".
"cd" occurs at index 2 in s, so we replace it with "ffff".

Example 2:

Input: s = "abcd", indices = [0, 2], sources = ["ab","ec"], targets = ["eee","ffff"]
Output: "eeecd"
Explanation:
"ab" occurs at index 0 in s, so we replace it with "eee".
"ec" does not occur at index 2 in s, so we do nothing.

class Solution {
    public String findReplaceString(String s, int[] indices, String[] sources, String[] targets) {
        
        StringBuilder res = new StringBuilder(s);
        Map<Integer, String> sourcesMap = new HashMap<>();
        Map<Integer, String> targetsMap = new HashMap<>();
        
        // Build source, target map
        for(int i = 0; i< indices.length; i++ ) {
            sourcesMap.put(indices[i], sources[i]);
            targetsMap.put(indices[i], targets[i]);
        }
        System.out.println(sourcesMap); // {0=a, 2=cd}
        System.out.println(targetsMap); // {0=eee, 2=ffff}

        //So we can iterate from the back with updating the largest index first
        Arrays.sort(indices);

        for(int i = indices.length-1; i >= 0; i--) {
            
            // hashmap get O(1)
            String source = sourcesMap.get(indices[i]); // a
            String target = targetsMap.get(indices[i]); // eee
            
            int srcLength = source.length(); // O(1)
            String subStr = s.substring(indices[i], indices[i] + srcLength); // O(n)
            
             if(subStr.equals(source)) { // O(1)
                // StringBuilder replace O(n) 
                // int start, int end, String str
                res.replace(indices[i], indices[i] + srcLength, target);
            }
        }
        
        return res.toString(); // O(n)
    }
}

---

如果你覺得這篇文章很棒，請你不吝點讚 (ﾟ∀ﾟ)