827. 最大人工岛
题目：给你一个大小为 n x n 二进制矩阵 grid 。最多 只能将一格 0 变成 1 。返回执行此操作后，grid 中最大的岛屿面积是多少？
岛屿 由一组上、下、左、右四个方向相连的 1 形成。
题目链接：[827. 最大人工岛](https://leetcode.cn/problems/making-a-large-island/)
解题思路：暴力解法 把每一个0改为1计算岛屿面积 复杂度：改每一个0为1:n2计算岛屿最大面积n2 会超时
优化思路：遍历记录所有岛屿面积 将0附近（上下左右）的岛屿进行联通
1.遍历记录所有岛屿面积
如何记录：遍历过的岛屿标记岛屿编号（从2开始） 将岛屿编号和最大面积记录在set中
- 将0附近（上下左右）的岛屿进行联通
如何判断0周围的面积：遍历0周围的岛屿面积进行联通，将周围的岛屿加入set以防重复叠加
代码如下：
java
class Solution {
public int[][] mark;
public int[][] move={{0,1},{0,-1},{1,0},{-1,0}};
public HashMap<Integer, Integer> island = new HashMap<Integer, Integer>();
public int largestIsland(int[][] grid) {
//遍历岛屿并记录
int maxArea=0;
int masknum=2;
mark=new int[grid.length][grid[0].length];
for(int i=0;i<grid.length;i++){
for(int j=0;j<grid[0].length;j++){
if(mark[i][j]==0&&grid[i][j]==1){
bfs(grid,i,j,masknum);
masknum++;
}
}
}
for(int value: island.values()) {
if(value>maxArea){
maxArea=value;
}
}
//修改岛屿并记录面积
for(int i=0;i<grid.length;i++){
for(int j=0;j<grid[0].length;j++){
if(grid[i][j]==0){
HashSet<Integer> sites = new HashSet<>();
for(int p=0;p<4;p++){
int nextx=i+move[p][0];
int nexty=j+move[p][1];
if(nextx<0||nextx>=grid.length||nexty<0||nexty>=grid.length){
continue;
}
if(mark[nextx][nexty]!=0){
sites.add(mark[nextx][nexty]);
}
}
//计算面积
int area=1;
for(int p:sites){
area+=island.get(p);
}
if(area>maxArea){
maxArea=area;
}
}
}
}
return maxArea;
}
public void bfs(int[][] grid,int i,int j,int masknum){
int area=1;
Queue<int[]> queue=new LinkedList<>();
queue.offer(new int[]{i,j});
mark[i][j]=masknum;
while(!queue.isEmpty()){
int[] node=queue.poll();
for(int p=0;p<4;p++){
int nextx=node[0]+move[p][0];
int nexty=node[1]+move[p][1];
if(nextx<0||nextx>=grid.length||nexty<0||nexty>=grid.length){
continue;
}
if(mark[nextx][nexty]==0&&grid[nextx][nexty]==1){
queue.offer(new int[]{nextx,nexty});
mark[nextx][nexty]=masknum;
area++;
}
}
}
island.put(masknum,area);
}
}217 单词接龙
题目 ：字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列 beginWord -> s1 -> s2 -> ... -> sk：
每一对相邻的单词只差一个字母。
对于 1 <= i <= k 时，每个 si 都在 wordList 中。注意， beginWord 不需要在 wordList 中。
sk == endWord
给你两个单词 beginWord 和 endWord 和一个字典 wordList ，返回 从 beginWord 到 endWord 的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列，返回 0 。
题目链接 ：217 单词接龙
解题思路：
为了保证从 beginWord 到 endWord 的转换序列是最短路径，我们使用广度优先搜索（BFS）算法 。BFS 有一个重要特性：它首先访问距离源点（在这个场景中是 beginWord）最近的节点。因此，当我们首次到达 endWord 时，我们可以确信找到的路径是最短的。
我们使用队列进行广度优先搜索 每次从队列中取出一个单词，查找与其相差一个字母的所有单词，并将这些单词加入队列 为了防止重复处理相同的单词，我们需要从 wordList 中移除已经处理过的单词。具体是将其与对应路径长度加入map中
代码如下
java
class Solution {
public int ladderLength(String beginWord, String endWord, List<String> wordList) {
if (!wordList.contains(endWord)) {
return 0;
}
if (!wordList.contains(beginWord)) {
wordList.add(beginWord);
}
HashSet<String> wordSet = new HashSet<>(wordList);
Queue<String> queue = new LinkedList<>();
queue.offer(beginWord);
Map<String, Integer> visited = new HashMap<>();
visited.put(beginWord, 1);
while (!queue.isEmpty()) {
String currentWord = queue.poll();
int currentLength = visited.get(currentWord);
for (String word : wordSet) {
if (isOneLetterDiff(currentWord, word)) {
if (word.equals(endWord)) {
return currentLength + 1;
}
if (!visited.containsKey(word)) {
queue.offer(word);
visited.put(word, currentLength + 1);
}
}
}
}
return 0;
}
private boolean isOneLetterDiff(String word1, String word2) {
if (word1.length() != word2.length()) {
return false;
}
int diffCount = 0;
for (int i = 0; i < word1.length(); i++) {
if (word1.charAt(i) != word2.charAt(i)) {
diffCount++;
if (diffCount > 1) {
return false;
}
}
}
return diffCount == 1;
}
}