Java&C++题解与拓展——leetcode890.查找和替换模式【么的新知识】

最新推荐文章于 2024-05-11 10:24:57 发布

AnjaVon

最新推荐文章于 2024-05-11 10:24:57 发布

阅读量117

点赞数 1

本文链接：https://blog.csdn.net/sinat_41135487/article/details/125247338

版权

leetcode 专栏收录该内容

96 篇文章 1 订阅

订阅专栏

每日一题做题记录，参考官方和三叶的题解

题目要求

在这里插入图片描述

思路：哈希表模拟

用哈希表 $m a p$ 存放当前单词与模板之间的映射关系，为了避免重复映射，维护一个 $v i s$ 表示已遍历过；
- 字符集数量小（26个），所以用数组替代了。

Java

class Solution {
    public List<String> findAndReplacePattern(String[] words, String pattern) {
        List<String> res = new ArrayList<>();
        int[] map = new int[26], vis = new int[26];
        for(String w : words) {
            Arrays.fill(map, -1);
            Arrays.fill(vis, 0);
            boolean match = true;
            for(int i = 0; i < pattern.length() && match; i++) {
                int cw = w.charAt(i) - 'a', cp = pattern.charAt(i) - 'a';
                if(map[cw] == -1 && vis[cp] == 0) {
                    map[cw] = cp; // cp映射为cw
                    vis[cp] = 1;
                }
                else if(map[cw] != cp)
                    match = false;
            }
            if(match)
                res.add(w);
        }
        return res;
    }
}

时间复杂度： $O(\sum^n_{i=0}len(ws[i])+n\times C)$ ，其中 $C$ 为字符集大小，即26.
空间复杂度： $O (C)$

C++

class Solution {
public:
    vector<string> findAndReplacePattern(vector<string>& words, string pattern) {
        vector<string> res;
        int map[26], vis[26];
        for(string w : words) {
            memset(map, -1, sizeof(map));
            memset(vis, 0, sizeof(vis));
            bool match = true;
            for(int i = 0; i < pattern.length() && match; i++) {
                int cw = w[i] - 'a', cp = pattern[i] - 'a';
                if(map[cw] == -1 && vis[cp] == 0) {
                    map[cw] = cp; // cp映射为cw
                    vis[cp] = 1;
                }
                else if(map[cw] != cp)
                    match = false;
            }
            if(match)
                res.push_back(w);
        }
        return res;
    }
};

时间复杂度： $O(\sum^n_{i=0}len(ws[i])+n\times C)$ ，其中 $C$ 为字符集大小，即26.
空间复杂度： $O (C)$

Rust

usize类型里似乎不能识别负号，所以就搞了个99替代。

impl Solution {
    pub fn find_and_replace_pattern(words: Vec<String>, pattern: String) -> Vec<String> {
        let mut res = Vec::new();
        for w in words {
            let(mut map, mut vis, mut MATCH) = (vec![0; 26], vec![0; 26], true);
            for i in 0..26 {
                map[i] = 99 as usize;
                vis[i] = 0 as usize;
            }
            for i in 0..w.len() {
                let cw = (w.as_bytes()[i] - 'a' as u8) as usize;
                let cp = (pattern.as_bytes()[i] - 'a' as u8) as usize;
                if map[cw] == 99 && vis[cp] == 0 {
                    map[cw] = cp; // cp 映射为cw
                    vis[cp] = 1;
                }
                else if map[cw] != cp {
                    MATCH = false;
                }
            }
            if MATCH {
                res.push(w);
            }
        }
        res
    }
}