原创公众号：
bigsai如果不错记得点赞收藏！
关注回复 bigsai 领取Java进阶pdf资源，回复进群加入力扣打卡群。
上周打卡内容：43字符串相乘&44通配符匹配 45跳跃游戏&46全排列
昨天打卡内容：LeetCode 47全排列Ⅱ&48旋转图像
字母异位词分组
给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。
示例:
输入: ["eat", "tea", "tan", "ate", "nat", "bat"]
输出:
[
["ate","eat","tea"],
["nat","tan"],
["bat"]
]
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
说明：
所有输入均为小写字母。
不考虑答案输出的顺序。
分析
题目的意思就是给若干个字符串单词，然后将含有全部相同的字母放到一个List<String>中。我们的核心问题是将这个放到哪里？
你可以使用暴力枚举，每次遍历判断，但是那样效率太低，所以我们可以进行哈希 存储。创建一个Map<String,List<String>>类型的HashMap进行存储。
实现代码为：
public List<List<String>> groupAnagrams(String[] strs) { List<List<String>>lists=new ArrayList<>(); Map<String,List<String>>map=new HashMap<>(); for(String str: strs) { char vachar[]=str.toCharArray(); Arrays.sort(vachar); String team=String.copyValueOf(vachar); List<String>list=map.getOrDefault(team,new ArrayList<>()); list.add(str); map.put(team,list); }
// for(List<String> list:map.values())
// {
// lists.add(list);
// } lists.addAll(map.values()); return lists; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
执行结果：
Pow(x,n)
很明显的快速幂算法，强烈推荐自己写的快速幂介绍：数据结构与算法—这可能是最易懂的快速幂讲解了
但是你需要注意一些地方：
- 负数处理，并且负数可能是int最小值加个符号转换数值越界出错。所以负数转正数的时候，将负数次幂拆分一个出来就可以转正数幂进行计算了。例如5-2147483648=5-1 x 5 -2147483647 =（1/5 ) x（1/5）2147483647 。int 范围为[-2147483648,2147483647].
- 注意好停止条件，这里理论上可以稍微重写个函数优化一下，但是由于快速幂logn级别的复杂度比较低，这里就不进行优化直接写了：
public double myPow(double x, int n) { if(n<0) return (1.0/x)*myPow(1.0/x,-(n+1)); if(n==0) return 1; else if(n%2==0) return myPow(x*x,n/2); else return x*myPow(x*x,n/2);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
N皇后
n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
上图为 8 皇后问题的一种解法。
给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。
每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
示例：
输入：4
输出：[
[".Q..", // 解法 1
"...Q",
"Q...",
"..Q."],
["..Q.", // 解法 2
"Q...",
"...Q",
".Q.."]
]
解释: 4 皇后问题存在两个不同的解法。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
提示：
皇后彼此不能相互攻击，也就是说：任何两个皇后都不能处于同一条横行、纵行或斜线上。
八皇后问题我再这篇：回溯算法 | 追忆那些年曾难倒我们的八皇后问题 讲的已经很清楚了，不懂的可以详细看看。
在具体的实现上，就是需要一个map[][]的地图记录各个位置的符号，然后按照规则存储进去，但我这里用了个StringBuilder[]数组来完成。
另外，判断方向的时候因为从一行一行来，如果判断横方向就是多此一举。
附上代码：
// boolean heng[];
boolean shu[];
boolean zuoxie[];
boolean youxie[]; public List<List<String>> solveNQueens(int n) {
List<List<String>> list=new ArrayList<List<String>>();
StringBuilder stringBuilder[]=new StringBuilder[n];
for(int i=0;i<n;i++)
{
stringBuilder[i]=new StringBuilder();
for(int j=0;j<n;j++)
{ stringBuilder[i].append('.');
}
}
shu=new boolean[n];
zuoxie=new boolean[n*2];
youxie=new boolean[n*2];
dfs(0,stringBuilder,list,n);
return list;
}
private void dfs(int index, StringBuilder sBuilder[], List<List<String>> list,int n) {
// TODO Auto-generated method stub
if(index==n)//存入
{
List<String>val=new ArrayList<String>();
//StringBuilder sBuilder=new StringBuilder();
for(int i=0;i<n;i++)
{ val.add(sBuilder[i].toString()); }
list.add(val);
}
else {
for(int j=0;j<n;j++)
{ if(!shu[j]&&!zuoxie[index+j]&&!youxie[index+(n-1-j)]) { shu[j]=true; zuoxie[index+j]=true; youxie[index+(n-1-j)]=true; //map[index][j]='Q'; sBuilder[index].setCharAt(j, 'Q'); dfs(index+1,sBuilder, list, n); shu[j]=false; zuoxie[index+j]=false; youxie[index+(n-1-j)]=false; sBuilder[index].setCharAt(j, '.'); //map[index][j]='.'; }
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
总是熟悉的100%：
结语：好了今天就到这里了，欢迎关注原创技术公众号：【bigsai】，回复进群加笔者微信一起加入打卡！回复「bigsai」，领取进阶资源。
文章来源: bigsai.blog.csdn.net，作者：Big sai，版权归原作者所有，如需转载，请联系作者。
原文链接：bigsai.blog.csdn.net/article/details/109411577