1.
/*首先为了方便表示,我们先给每一个单词标号,即给每个单词分配一个 id。创建一个由单词 word 到 id 对应的映射 wordId,并将 beginWord 与 wordList 中所有的单词都加入这个映射中。之后我们检查 endWord 是否在该映射内,若不存在,则输入无解。我们可以使用哈希表实现上面的映射关系。
然后我们需要建图,依据朴素的思路,我们可以枚举每一对单词的组合,判断它们是否恰好相差一个字符,以判断这两个单词对应的节点是否能够相连。但是这样效率太低,我们可以优化建图。
具体地,我们可以创建虚拟节点。对于单词 hit,我们创建三个虚拟节点 *it、h*t、hi*,并让 hit 向这三个虚拟节点分别连一条边即可。如果一个单词能够转化为 hit,那么该单词必然会连接到这三个虚拟节点之一。对于每一个单词,我们枚举它连接到的虚拟节点,把该单词对应的 id 与这些虚拟节点对应的 id 相连即可。
最后我们将起点加入队列开始广度优先搜索,当搜索到终点时,我们就找到了最短路径的长度。注意因为添加了虚拟节点,所以我们得到的距离为实际最短路径长度的两倍。同时我们并未计算起点对答案的贡献,所以我们应当返回距离的一半再加一的结果。
*/
Map<String, Integer> wordId = new HashMap<>();
List<List<Integer>> edge = new ArrayList<>();
int nodeNum = 0;
public int ladderLength(String beginWord, String endWord, List<String> wordList) {
if (!wordList.contains(endWord)) {
return 0;
}
for (String s : wordList) {
addEdge(s);
}
addEdge(beginWord);
int[] dis = new int[nodeNum];
Arrays.fill(dis, Integer.MAX_VALUE);
int beginId = wordId.get(beginWord), endId = wordId.get(endWord);
dis[beginId] = 0;
Queue<Integer> queue = new LinkedList<>();
queue.offer(beginId);
while (!queue.isEmpty()) {
int id = queue.poll();
if (id == endId) {
return dis[endId] / 2 + 1;
}
for (int nextId : edge.get(id)) {
if (dis[nextId] == Integer.MAX_VALUE) {
dis[nextId] = dis[id] + 1;
queue.offer(nextId);
}
}
}
return 0;
}
public void addEdge(String s) {
addWord(s);
int id1 = wordId.get(s);
char[] array = s.toCharArray();
for (int i = 0; i < array.length; i++) {
char temp = array[i];
array[i] = '*';
String newWord = new String(array);
addWord(newWord);
int id2 = wordId.get(newWord);
edge.get(id1).add(id2);
edge.get(id2).add(id1);
array[i] = temp;
}
}
public void addWord(String s) {
if (!wordId.containsKey(s)) {
wordId.put(s, nodeNum++);
edge.add(new ArrayList<Integer>());
}
}
2.
//如果节点为1开始dfs直到无法继续,将经过的点设为0,岛屿数等于进行的dfs次数
public int numIslands(char[][] grid) {
if (grid == null || grid.length == 0) {
return 0;
}
int rl = grid.length;
int cl = grid[0].length;
int numOfIsland = 0;
for (int i = 0; i < rl; i++) {
for (int j = 0; j < cl; j++) {
if (grid[i][j] == '1') {
numOfIsland += 1;
islandDfs(grid, i, j);
}
}
}
return numOfIsland;
}
public void islandDfs(char[][] grid, int row, int col) {
int rl = grid.length;
int cl = grid[0].length;
if (row < 0 || row >= rl || col < 0 || col >= cl || grid[row][col] == '0') {
return;
}
grid[row][col] = '0';
islandDfs(grid, row - 1, col);
islandDfs(grid, row, col - 1);
islandDfs(grid, row + 1, col);
islandDfs(grid, row, col + 1);
}
3.
//思路:该问题等价于寻找有无环的存在
//括扑排序法
List<List<Integer>> edges;
int[] inCount;
public boolean canFinish(int numCourses, int[][] prerequisites) {
edges = new ArrayList<>();
inCount = new int[numCourses];
for (int i = 0; i < numCourses; i++) {
edges.add(new ArrayList<Integer>());
}
for (int[] prerequisite : prerequisites) {
edges.get(prerequisite[1]).add(prerequisite[0]);
inCount[prerequisite[0]]++;
}
Queue<Integer> queue = new LinkedList<>();
for (int i = 0; i < numCourses; i++) {
if (inCount[i] == 0){
queue.offer(i);
}
}
int visited = 0;
while (!queue.isEmpty()){
visited++;
int u = queue.poll();
for (int v : edges.get(u)) {
inCount[v] -= 1;
if (inCount[v] == 0){
queue.offer(v);
}
}
}
return numCourses == visited;
}
//dfs法
List<List<Integer>> edges;
int[] visited;
boolean valid = true;
public boolean canFinish(int numCourses, int[][] prerequisites) {
edges = new ArrayList<>();
visited = new int[numCourses];
for (int i = 0; i < numCourses; i++) {
edges.add(new ArrayList<Integer>());
}
for (int[] prerequisite : prerequisites) {
edges.get(prerequisite[1]).add(prerequisite[0]);
}
for (int i = 0; i < numCourses && valid; i++) {
if (visited[i] == 0) {
dfs(i);
}
}
return valid;
}
public void dfs(int u) {
visited[u] = 1;
for (int v : edges.get(u)) {
if (visited[v] == 0) {
dfs(v);
if (!valid) {
return;
}
} else if (visited[v] == 1) {
valid = false;
return;
}
}
visited[u] = 2;
}
4.
//该题与第三题本质一样,只需要在第三题的基础上把寻找环的每步记录下来即可
public int[] findOrder(int numCourses, int[][] prerequisites) {
edges = new ArrayList<>();
inCount = new int[numCourses];
for (int i = 0; i < numCourses; i++) {
edges.add(new ArrayList<Integer>());
}
for (int[] prerequisite : prerequisites) {
edges.get(prerequisite[1]).add(prerequisite[0]);
inCount[prerequisite[0]]++;
}
Queue<Integer> queue = new LinkedList<>();
for (int i = 0; i < numCourses; i++) {
if (inCount[i] == 0){
queue.offer(i);
}
}
int visited = 0;
int[] order = new int[numCourses];
while (!queue.isEmpty()){
int u = queue.poll();
order[visited] = u;
visited++;
for (int v : edges.get(u)) {
inCount[v] -= 1;
if (inCount[v] == 0){
queue.offer(v);
}
}
}
if (numCourses == visited){
return order;
}else {
return new int[0];
}
}