leetcode剑指offer II 114. 外星文字典 (构建有向图+有向图的拓扑排序)

题目描述:
现有一种使用英语字母的外星文语言,这门语言的字母顺序与英语顺序不同。
给定一个字符串列表 words ,作为这门语言的词典,words 中的字符串已经 按这门新语言的字母顺序进行了排序 。
请你根据该词典还原出此语言中已知的字母顺序,并 按字母递增顺序 排列。若不存在合法字母顺序,返回 “” 。若存在多种可能的合法字母顺序,返回其中 任意一种 顺序即可。
字符串 s 字典顺序小于 字符串 t 有两种情况:
1)在第一个不同字母处,如果 s 中的字母在这门外星语言的字母顺序中位于 t 中字母之前,那么 s 的字典顺序小于 t 。
2)如果前面 min(s.length, t.length) 字母都相同,那么 s.length < t.length 时,s 的字典顺序也小于 t 。
示例1:
输入:words = [“wrt”,“wrf”,“er”,“ett”,“rftt”]
输出:“wertf”
示例 2:
输入:words = [“z”,“x”]
输出:“zx”
示例 3:
输入:words = [“z”,“x”,“z”]
输出:“”
解释:不存在合法字母顺序,因此返回 “” 。
思路:
主要参照了官方题解
解本题的关键点:
1)分析怎样可以得到一个合法的顺序:对数组的单词每相邻的两个进行比较,第一个不一样的字母可以得到一个有效的顺序。
2)无法得到有效的顺序的两种情况:
a. 在输出所形成的有向图的时候有环,证明有关系是相互指的,无法得到一个整体的有效顺序。
b. 相邻两个单词满足后面的单词是前面的单词的前缀,且后面的单词的长度小于前面的单词的长度,例如words=[“ab",“a"]。
综上,本题的代码块大概可以分成两个部分,一个是利用数组中的单词生成有向图,一个是对有向图进行拓扑排序。
拓扑排序有深度优先和广度优先两种方式;
深度优先就是先遍历一条路径,为路径中的每一个结点标注一个状态,如果在路径中出现了重复的元素,则证明是有环的;
广度优先则是利用队列的方式,根据入度来进行排序输出,入度为0才可以输出,证明他之前的都已经输出,最终看得到的顺序长度是否与总长度相等,如果相等则得到一个有效的顺序。
下面是题解的截图:
leetcode剑指offer II 114. 外星文字典 (构建有向图+有向图的拓扑排序)_第1张图片
leetcode剑指offer II 114. 外星文字典 (构建有向图+有向图的拓扑排序)_第2张图片

leetcode剑指offer II 114. 外星文字典 (构建有向图+有向图的拓扑排序)_第3张图片

class Solution:
    def alienOrder(self, words: List[str]) -> str:
    	# 利用<字母,[]列表>来生成有向图
        g = {}
        for c in words[0]:
            g[c] = []
        for i in range(1, len(words)):
            s = words[i - 1]
            t = words[i]
            for c in t:
                g.setdefault(c, [])
            flag = False
            for u, v in zip(s, t):
                if u != v:
                    g[u].append(v)
                    flag = True
                    break
            if not flag:  # 一种无法得到合法的情况
                if len(s) > len(t):
                    return ""

        visiting, visited = 1, 2  # 用来标志状态
        states = {}
        stack = []
        def dfs(u: str)-> bool:
            states[u] = visiting
            for v in g[u]:
                if v not in states:
                    if not dfs(v):
                        return False
                elif states[v] == visiting:
                    return False
            states[u] = visited
            stack.append(u)
            return True
        res = []
        for q in g:
            if q not in states:  # 已经判断过的不能再执行了,否则会在stack中append两次
                res.append(dfs(q))
        return "".join(reversed(stack)) if all(res) else ""  # 这里reverse是因为在深度或者说递归的时候,后面的先加入进去了,是反的,所以输出的时候倒序输出

leetcode剑指offer II 114. 外星文字典 (构建有向图+有向图的拓扑排序)_第4张图片
leetcode剑指offer II 114. 外星文字典 (构建有向图+有向图的拓扑排序)_第5张图片

在这里插入代码片class Solution:
    def alienOrder(self, words: List[str]) -> str:
        g = {}
        number = {}  # 用来统计入度的数量
        for c in words[0]:
            g[c] = []
            number[c] = 0
        for i in range(1, len(words)):
            s = words[i-1]
            t = words[i]
            for c in t:
                g.setdefault(c, [])
                number.setdefault(c, 0)
            flag = False
            for u, v in zip(s, t):
                if u != v:
                    g[u].append(v)
                    number[v] += 1
                    flag = True
                    break
            if not flag:
                if len(s) > len(t):
                    return ""

        # 从入度的角度
        queue = []
        res = []
        for k in number:
            if number[k] == 0:
                queue.append(k)
        while queue:
            cur = queue.pop(0)
            res.append(cur)
            for q in g[cur]:
                number[q] -= 1
                if number[q] == 0:  # 只有入度为0才能加入到队列中,表明他之前的都已经输出了,如果有环的话是输出不来的
                    queue.append(q)
        if len(res) == len(g):
            return "".join(res)
        else:
            return ""

你可能感兴趣的:(LeetCode练习,编程练习,leetcode,深度优先,算法)