LCR 034-验证外星语词典

某种外星语也使用英文小写字母，但可能顺序 order 不同。字母表的顺序（order）是一些小写字母的排列。

给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 true；否则，返回
false。

示例 1：

**输入：** words = ["hello","leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz"
**输出：** true
**解释：** 在该语言的字母表中，'h' 位于 'l' 之前，所以单词序列是按字典序排列的。

示例 2：

**输入：** words = ["word","world","row"], order = "worldabcefghijkmnpqstuvxyz"
**输出：** false
**解释：** 在该语言的字母表中，'d' 位于 'l' 之后，那么 words[0] > words[1]，因此单词序列不是按字典序排列的。

示例 3：

**输入：** words = ["apple","app"], order = "abcdefghijklmnopqrstuvwxyz"
**输出：** false
**解释：** 当前三个字符 "app" 匹配时，第二个字符串相对短一些，然后根据词典编纂规则 "apple" > "app"，因为 'l' > '∅'，其中 '∅' 是空白字符，定义为比任何其他字符都小（[更多信息](https://baike.baidu.com/item/%E5%AD%97%E5%85%B8%E5%BA%8F)）。

提示：

• 1 <= words.length <= 100
• 1 <= words[i].length <= 20
• order.length == 26
• 在 words[i] 和 order 中的所有字符都是英文小写字母。

注意：本题与主站 953 题相同： <https://leetcode-cn.com/problems/verifying-an-alien-
dictionary/>

方法一：直接遍历

思路与算法

题目要求按照给定的字母表 order 的顺序，检测给定的字符串数组是否按照 order 的字典升序排列，我们只需要依次检测 strs 中的字符串前一个字符串和后一个字符串在给定的字母表下小的字典序即可。具体检测如下：

• 首先将给定的 order 转化为字典序索引 index，index}[i] 表示字符 i 在字母表 order 的排序索引，index}[i] > \textit{index}[j] 即表示字符 i 在字母表中的字典序比字符 j 的字典序大，index}[i] < \textit{index}[j] 即表示字符 i 在字母表中的字典序比字符 j 的字典序小。

• 依次检测第 i 个单词 strs}[i] 与第 i-1 个单词 strs}[i-1] 的字典序大小，我们可以依次判断两个单词中从左到右每个字符的字典序大小，当第一次出现两个字符的字典序不同时，即可判断两个字符串的字典序的大小。

• 特殊情况需要处理，设 strs}[i] 的长度为 m，strs}[i] 的长度小于 strs}[i-1] 的长度且 strs}[i-1] 的前 m 个字符与 strs}[i-1] 的前 m 个字符相等，此时 strs}[i-1] 的字典序大于 strs}[i] 的字典序。

代码

[sol1-Python3]

class Solution:
    def isAlienSorted(self, words: List[str], order: str) -> bool:
        index = {c: i for i, c in enumerate(order)}
        return all(s <= t for s, t in pairwise([index[c] for c in word] for word in words))

[sol1-Java]

class Solution {
    public boolean isAlienSorted(String[] words, String order) {
        int[] index = new int[26];
        for (int i = 0; i < order.length(); ++i) {
            index[order.charAt(i) - 'a'] = i;
        }
        for (int i = 1; i < words.length; i++) {
            boolean valid = false;
            for (int j = 0; j < words[i - 1].length() && j < words[i].length(); j++) {
                int prev = index[words[i - 1].charAt(j) - 'a'];
                int curr = index[words[i].charAt(j) - 'a'];
                if (prev < curr) {
                    valid = true;
                    break;
                } else if (prev > curr) {
                    return false;
                }
            }
            if (!valid) {
                /* 比较两个字符串的长度 */
                if (words[i - 1].length() > words[i].length()) {
                    return false;
                }
            }
        }
        return true;
    }
}

[sol1-C++]

class Solution {
public:
    bool isAlienSorted(vector<string>& words, string order) {
        vector<int> index(26);
        for (int i = 0; i < order.size(); i++) {
            index[order[i] - 'a'] = i;
        }
        for (int i = 1; i < words.size(); i++) {
            bool valid = false;
            for (int j = 0; j < words[i - 1].size() && j < words[i].size(); j++) {
                int prev = index[words[i - 1][j] - 'a'];
                int curr = index[words[i][j] - 'a'];
                if (prev < curr) {
                    valid = true;
                    break;
                } else if (prev > curr) {
                    return false;
                }
            }
            if (!valid) {
                /* 比较两个字符串的长度 */
                if (words[i - 1].size() > words[i].size()) {
                    return false;
                }
            }
        }
        return true;
    }
};

[sol1-C#]

public class Solution {
    public bool IsAlienSorted(string[] words, string order) {
        int[] index = new int[26];
        for (int i = 0; i < order.Length; ++i) {
            index[order[i] - 'a'] = i;
        }
        for (int i = 1; i < words.Length; i++) {
            bool valid = false;
            for (int j = 0; j < words[i - 1].Length && j < words[i].Length; j++) {
                int prev = index[words[i - 1][j] - 'a'];
                int curr = index[words[i][j] - 'a'];
                if (prev < curr) {
                    valid = true;
                    break;
                } else if (prev > curr) {
                    return false;
                }
            }
            if (!valid) {
                /* 比较两个字符串的长度 */
                if (words[i - 1].Length > words[i].Length) {
                    return false;
                }
            }
        }
        return true;
    }
}

[sol1-C]

bool isAlienSorted(char ** words, int wordsSize, char * order){
    int index[26];
    int len = strlen(order);
    for (int i = 0; i < len; i++) {
        index[order[i] - 'a'] = i;
    }
    for (int i = 1; i < wordsSize; i++) {
        bool valid = false;
        int l1 = strlen(words[i - 1]);
        int l2 = strlen(words[i]);
        int n = l1 < l2 ? l1 : l2;
        for (int j = 0; j < n; j++) {
            int prev = index[words[i - 1][j] - 'a'];
            int curr = index[words[i][j] - 'a'];
            if (prev < curr) {
                valid = true;
                break;
            } else if (prev > curr) {
                return false;
            }
        }
        if (!valid) {
            /* 比较两个字符串的长度 */
            if (l1 > l2) {
                return false;
            }
        }
    }
    return true;
}

[sol1-JavaScript]

var isAlienSorted = function(words, order) {
    const index = new Array(26).fill(0);
    for (let i = 0; i < order.length; ++i) {
        index[order[i].charCodeAt() - 'a'.charCodeAt()] = i;
    }
    for (let i = 1; i < words.length; i++) {
        let valid = false;
        for (let j = 0; j < words[i - 1].length && j < words[i].length; j++) {
            let prev = index[words[i - 1][j].charCodeAt() - 'a'.charCodeAt()];
            let curr = index[words[i][j].charCodeAt() - 'a'.charCodeAt()];
            if (prev < curr) {
                valid = true;
                break;
            } else if (prev > curr) {
                return false;
            }
        }
        if (!valid) {
            /* 比较两个字符串的长度 */
            if (words[i - 1].length > words[i].length) {
                return false;
            }
        }
    }
    return true;
};

[sol1-Golang]

func isAlienSorted(words []string, order string) bool {
    index := [26]int{}
    for i, c := range order {
        index[c-'a'] = i
    }
next:
    for i := 1; i < len(words); i++ {
        for j := 0; j < len(words[i-1]) && j < len(words[i]); j++ {
            pre, cur := index[words[i-1][j]-'a'], index[words[i][j]-'a']
            if pre > cur {
                return false
            }
            if pre < cur {
                continue next
            }
        }
        if len(words[i-1]) > len(words[i]) {
            return false
        }
    }
    return true
}

复杂度分析

• 时间复杂度：O(m \times n)，其中 m 为字符串数组的长度，n 为数组中字符串的平均长度，每个字符串需要前一个字符串进行比较，因此时间复杂度为 O(m \times n)。

• 空间复杂度：O(C)。其中 C 表示字母表的长度，需要存储字母表 order 每个字符的字典序索引，题目中给定的字母表的长度为 C = 26。