力扣——833. 字符串中的查找与替换（Java、C代码实现百分百击败用户用时）

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 开始，所以它没有被替换。

C代码：

#define MAX_RET_LEN 5001

typedef struct {
    int index;
    char *source;
    char *target;
} Change; 

int Cmp(const void *a, const void *b) {
    Change *x = (Change *)a;
    Change *y = (Change *)b;
    
    return x->index - y->index;
}

char * findReplaceString(char * S, int* indexes, int indexesSize, char ** sources, int sourcesSize, char ** targets, int targetsSize){
    char *ret = NULL;
    int i, j, k, num, start;
    int lenS = strlen(S);
    Change *change = NULL;

    ret = (char *)malloc(sizeof(char) * MAX_RET_LEN);
    memset(ret, 0, sizeof(char) * MAX_RET_LEN);

    if (lenS == 0) {
        return ret;
    }

    change = (Change *)malloc(sizeof(Change) * indexesSize);
    memset(change, 0, sizeof(Change) * indexesSize);
    for (i = 0; i < indexesSize; i++) {
        change[i].index = indexes[i];
        change[i].source = sources[i];
        change[i].target = targets[i];
    }

    qsort(change, indexesSize, sizeof(Change), Cmp);
    for (i = 0, j = 0, k = 0; i < lenS;) {
        //printf("i=%d, j=%d, k=%d ", i, j ,k);        
        if (j == indexesSize || i != change[j].index) {
            ret[k] = S[i];
            k++;
            i++;
            continue;
        }
        
        //比较source和S对应index处的子串是否相等
        num = 0;
        start = i;
        while (i < lenS && num < strlen(change[j].source) && S[i] == change[j].source[num]) {
            num++;
            i++;
        }
        
        if (num == strlen(change[j].source)) {
            memcpy(ret + k, change[j].target, strlen(change[j].target));
            k += strlen(change[j].target);
        } else {
            i = start;
            ret[k] = S[i];
            k++;
            i++;
        }
        j++;        
    }
    return ret;
}

Java代码：

class Solution {
     public String findReplaceString(String S, int[] indexes, String[] sources, String[] targets) {
        int[] array = new int[S.length()];
        int[] temp = new int[S.length()];
        for (int i = 0; i < indexes.length; i++) {
            if (S.startsWith(sources[i], indexes[i])) {
                array[indexes[i]] = sources[i].length();
                temp[indexes[i]] = i;
            }
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0, j = 0; j <= array.length; j++) {
            if (j == array.length) {
                sb.append(S.substring(i));
                break;
            }
            if (array[j] > 0) {
                sb.append(S.substring(i, j)).append(targets[temp[j]]);
                i = j + array[j];
            }
        }
        return sb.toString();
    }
}

作者：KJ.JK
本文仅用于交流学习，未经作者允许，禁止转载，更勿做其他用途，违者必究。
文章对你有所帮助的话，欢迎给个赞或者 star，你的支持是对作者最大的鼓励，不足之处可以在评论区多多指正，交流学习