剑指 Offer II 114. 外星文字典(困难 图 bfs 哈希表 拓扑排序 字符串 数组)

剑指 Offer II 114. 外星文字典

现有一种使用英语字母的外星文语言,这门语言的字母顺序与英语顺序不同。

给定一个字符串列表 words ,作为这门语言的词典,words 中的字符串已经 按这门新语言的字母顺序进行了排序 。

请你根据该词典还原出此语言中已知的字母顺序,并 按字母递增顺序 排列。若不存在合法字母顺序,返回 “” 。若存在多种可能的合法字母顺序,返回其中 任意一种 顺序即可。

字符串 s 字典顺序小于 字符串 t 有两种情况:

在第一个不同字母处,如果 s 中的字母在这门外星语言的字母顺序中位于 t 中字母之前,那么 s 的字典顺序小于 t 。
如果前面 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 <= words.length <= 100
1 <= words[i].length <= 100
words[i] 仅由小写英文字母组成

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/Jf1JuT
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

分析

跟上一道题有些类似,难点在于,如何构造出图,如何表示每个字符的度。
1、构造图。用哈希表表示图,哈希表的 key 是所有不同的字符,value 保存 key 的邻接点,为了避免重复 value 是 HashSet 类型;
向哈希表中存数据:key 可以通过遍历 words 的所有字符得来,同时创建一个哈希表来记录每个字符的度,在遍历 words 的过程中同时进行初始化 value 为 0,接下来存邻接点,邻接点应该由前后两个字符串进行比较得来,首先对前后两个字符串进行判断是否是合法的字典顺序(如果后一个字符串是前一个字符串的头部并且两个字符串不相等,说明不是合法的字典顺序,因为满足这种情况的后一个字符串应该在前一个字符串之前),判断完合法性后开始存邻接点,对于前后两个字符串每次只能填一个邻接点,即两个字符串中首个不相同的字符,如果后个字符串的不相同字符还没有被填进前一个字符串的字符的邻接点中,那么填入,并且同时后个字符串的字符的度加 1,然后直接打断遍历进入下两个字符串的邻接点填写。
2、bfs 遍历。创建队列,遍历哈希表,跟上题类似,不赘述了。

题解(Java)

class Solution {
    public String alienOrder(String[] words) {
        Map<Character, Set<Character>> graph = new HashMap<>();
        Map<Character, Integer> record = new HashMap<>();
        for (String word : words) {
            for (int j = 0; j < word.length(); j++) {
                graph.putIfAbsent(word.charAt(j), new HashSet<>());
                record.putIfAbsent(word.charAt(j), 0);
            }
        }

        for (int i = 1; i < words.length; i++) {
            String w1 = words[i - 1];
            String w2 = words[i];
            if (w1.startsWith(w2) && !w1.equals(w2)) {
                return "";
            }

            for (int j = 0; j < w1.length() && j < w2.length(); j++) {
                char ch1 = w1.charAt(j);
                char ch2 = w2.charAt(j);
                if (ch1 != ch2) {
                    if (!graph.get(ch1).contains(ch2)) {
                        graph.get(ch1).add(ch2);
                        record.put(ch2, record.get(ch2) + 1);
                    }

                    break;
                }
            }
        }

        Queue<Character> queue = new LinkedList<>();
        for (char ch : record.keySet()) {
            if (record.get(ch) == 0) {
                queue.offer(ch);
            }
        }

        StringBuilder sb = new StringBuilder();
        while (!queue.isEmpty()) {
            char ch = queue.poll();
            sb.append(ch);
            for (char next : graph.get(ch)) {
                record.put(next, record.get(next) - 1);
                if (record.get(next) == 0) {
                    queue.offer(next);
                }
            }
        }

        return sb.length() == graph.size() ? sb.toString() : "";
    }
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,你的要求已经记录下来了。让我来解答你的问题。 在 gsearch.py 中实现 DFS、BFS、基于 BFS 的最短路径和拓扑排序算法的方法如下: 1. DFS(深度优先搜索): DFS 通过深度优先的方式搜索形结构。在形结构中,DFS 沿着一个路径尽可能深入地搜索,直到找到目标节点为止,然后回溯到前一个节点,继续搜索其他路径。 以下是实现 DFS 算法的 Python 代码: ``` def dfs(graph, start, visited=None): if visited is None: visited = set() visited.add(start) for next in graph[start] - visited: dfs(graph, next, visited) return visited ``` 2. BFS(广度优先搜索): BFS 通过广度优先的方式搜索形结构。在形结构中,BFS 从起点开始,沿着所有的路径分别搜索一层,然后继续向下搜索下一层,直到找到目标节点为止。 以下是实现 BFS 算法的 Python 代码: ``` def bfs(graph, start): visited, queue = set(), [start] while queue: vertex = queue.pop(0) if vertex not in visited: visited.add(vertex) queue.extend(graph[vertex] - visited) return visited ``` 3. 基于 BFS 的最短路径算法: 基于 BFS 的最短路径算法可以用于在无权中查找最短路径。算法从起点开始,通过 BFS 搜索形结构,记录每个节点到起点的距离,并在找到目标节点时返回路径。 以下是实现基于 BFS 的最短路径算法的 Python 代码: ``` from collections import deque def shortest_path(graph, start, end): queue = deque([(start, [start])]) while queue: vertex, path = queue.popleft() for next in graph[vertex] - set(path): if next == end: return path + [next] else: queue.append((next, path + [next])) ``` 4. 拓扑排序算法拓扑排序算法用于有向无环(DAG)中的节点排序。算法从 DAG 中选择一个没有前驱节点的节点,并将其输出。然后将该节点从 DAG 中删除,并更新其余节点的前驱节点。重复此过程,直到所有节点都被输出为止。 以下是实现拓扑排序算法的 Python 代码: ``` def topological_sort(graph): in_degree = {vertex: 0 for vertex in graph} for vertex in graph: for neighbor in graph[vertex]: in_degree[neighbor] += 1 queue = deque([vertex for vertex in in_degree if in_degree[vertex] == 0]) result = [] while queue: vertex = queue.popleft() result.append(vertex) for neighbor in graph[vertex]: in_degree[neighbor] -= 1 if in_degree[neighbor] == 0: queue.append(neighbor) return result ``` 希望这些代码可以帮助你实现 gsearch.py 中的算法。如果你有任何问题,请随时问我。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值