督促自己——Java算法题四道——深度优先搜索、回溯算法
第一题:——回溯算法
给你一个字符串 s,请你将 s 分割成一些子串,使每个子串都是 回文串 。返回 s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。
示例 1:
输入:s = “aab”
输出:[[“a”,“a”,“b”],[“aa”,“b”]]
示例 2:
输入:s = “a”
输出:[[“a”]]
基本思路:
针对不同路径,对每条路径分别判断,当本条路径走完,回溯,走另一条路。总而言之,递归就完事了。
例如a a b、aa b就是不同的两条路径。不断递归缩短路径,就是这道题的做法。
class Solution {
List<List<String>>list=new ArrayList<>();
public List<List<String>> partition(String s) {
List<String>l=new ArrayList<>();
part(s,l);
return list;
}
public void part(String s,List<String>l){
if(s.length()==0){
//一条路径以便历完
if(!l.isEmpty()){
list.add(new ArrayList<>(l));
}
return;
}
for(int j=0;j<s.length();++j){
String str=s.substring(0,j+1);
if(trueOrFalse(s,0,j)){
l.add(str);//是回文子串就入顺序表
part(s.substring(j+1,s.length()),l);
if(!l.isEmpty()){
l.remove(l.size()-1);//表示当前这个回文子串已经完成使命,出顺序表,回溯
}
}
}
}
public boolean trueOrFalse(String s,int start,int end){
if(start>end||s==null){
return false;
}
while(start<end&&s.charAt(start)==s.charAt(end)){
start++;
end--;
}
if(start>=end){
return true;
}else{
return false;
}
}
}
第二题:——回溯算法
一个 「开心字符串」定义为:
仅包含小写字母 [‘a’, ‘b’, ‘c’].
对所有在 1 到 s.length - 1 之间的 i ,满足 s[i] != s[i + 1] (字符串的下标从 1 开始)。
比方说,字符串 “abc”,“ac”,“b” 和 “abcbabcbcb” 都是开心字符串,但是 “aa”,“baa” 和 “ababbc” 都不是开心字符串。
给你两个整数 n 和 k ,你需要将长度为 n 的所有开心字符串按字典序排序。
请你返回排序后的第 k 个开心字符串,如果长度为 n 的开心字符串少于 k 个,那么请你返回 空字符串 。
示例 1:
输入:n = 1, k = 3
输出:“c”
解释:列表 [“a”, “b”, “c”] 包含了所有长度为 1 的开心字符串。按照字典序排序后第三个字符串为 “c” 。
示例 2:
输入:n = 1, k = 4
输出:""
解释:长度为 1 的开心字符串只有 3 个。
示例 3:
输入:n = 3, k = 9
输出:“cab”
解释:长度为 3 的开心字符串总共有 12 个 [“aba”, “abc”, “aca”, “acb”, “bab”, “bac”, “bca”, “bcb”, “cab”, “cac”, “cba”, “cbc”] 。第 9 个字符串为 “cab”
基本思路:
分别用a、b、c做头,连接到定义的一个临时字符串变量上,当长度达到要求就用全局的一个顺序表保存,否则递归,但要注意满足( s[i] != s[i + 1] (字符串的下标从 1 开始)),以及递归结束条件:就是子串长度达到要求就结束,return返回。每一个字母做完头就要从临时字符串变量中移除,回溯,递归下一个新头。
class Solution {
List<String>list=new ArrayList<>();
public String getHappyString(int n, int k) {
getHappy(new StringBuilder(""),n);
if(k>list.size()){
return "";
}
return list.get(k-1);
}
public void getHappy(StringBuilder s,int n){
if(s.length()==n){
list.add(s.toString());
return;
}
for(char x='a';x<='c';++x){
if(s.length()==0||s.charAt(s.length()-1)!=x){
s.append(x);
getHappy(s,n);
s.deleteCharAt(s.length()-1);
}
}
}
}
第三题:——深度优先搜索
让我们一起来玩扫雷游戏!
给定一个代表游戏板的二维字符矩阵。 ‘M’ 代表一个未挖出的地雷,‘E’ 代表一个未挖出的空方块,‘B’ 代表没有相邻(上,下,左,右,和所有4个对角线)地雷的已挖出的空白方块,数字(‘1’ 到 ‘8’)表示有多少地雷与这块已挖出的方块相邻,‘X’ 则表示一个已挖出的地雷。
现在给出在所有未挖出的方块中(‘M’或者’E’)的下一个点击位置(行和列索引),根据以下规则,返回相应位置被点击后对应的面板:
如果一个地雷(‘M’)被挖出,游戏就结束了- 把它改为 ‘X’。
如果一个没有相邻地雷的空方块(‘E’)被挖出,修改它为(‘B’),并且所有和其相邻的未挖出方块都应该被递归地揭露。
如果一个至少与一个地雷相邻的空方块(‘E’)被挖出,修改它为数字(‘1’到’8’),表示相邻地雷的数量。
如果在此次点击中,若无更多方块可被揭露,则返回面板。
示例 1:
输入:
[[‘E’, ‘E’, ‘E’, ‘E’, ‘E’],
[‘E’, ‘E’, ‘M’, ‘E’, ‘E’],
[‘E’, ‘E’, ‘E’, ‘E’, ‘E’],
[‘E’, ‘E’, ‘E’, ‘E’, ‘E’]]
Click : [3,0]
输出:
[[‘B’, ‘1’, ‘E’, ‘1’, ‘B’],
[‘B’, ‘1’, ‘M’, ‘1’, ‘B’],
[‘B’, ‘1’, ‘1’, ‘1’, ‘B’],
[‘B’, ‘B’, ‘B’, ‘B’, ‘B’]]
基本思路:
判断当前点击位置的值,针对不同值有不同操作:
雷:M->X(排雷,并结束)
未翻开:E
翻开:数字1~8或者B,数字代表周围8格内雷的个数,B代表没雷。
循环判断当前位置周围是否有雷,有就计数,最终看计数是否为零,零->B,非零->数字;
之后递归,对8个方向分别做出判断,最后返回即可。
class Solution {
int[][]index=new int[][]{
{
-1,-1},{
-1,0},{
-1,1},{
0,-1},{
0,1},{
1,-1},{
1,0},{
1,1}};
public char[][] updateBoard(char[][] board, int[] click) {
int x=click[0];
int y=click[1];
if(x<0||x>=board.length||y<0||y>board[0].length){
return board;
}else if(board[x][y]=='M'){
board[x][y]='X';
return board;
}else if(board[x][y]=='E'){
int count=0;
for(int i=0;i<index.length;++i){
int nx=x+index[i][0];
int ny=y+index[i][1];
if(nx>=0&&nx<board.length&&ny>=0&&ny<board[0].length){
if(board[nx][ny]=='M'){
count++;
}
}
}
if(count==0){
board[x][y]='B';
}else{
board[x][y]=(char)(count+'0');
return board;
}
for(int i=0;i<index.length;++i){
int nx=x+index[i][0];
int ny=y+index[i][1];
if(nx>=0&&nx<board.length&&ny>=0&&ny<board[0].length){
click[0]=nx;
click[1]=ny;
if(board[nx][ny]!='M'&&board[nx][ny]=='E'){
updateBoard(board,click);
}
}
}
return board;
}else{
return board;
}
}
}
第四题:——深度优先搜索
给出二叉 搜索 树的根节点,该树的节点值各不相同,请你将其转换为累加树(Greater Sum Tree),使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。
提醒一下,二叉搜索树满足下列约束条件:
节点的左子树仅包含键 小于 节点键的节点。
节点的右子树仅包含键 大于 节点键的节点。
左右子树也必须是二叉搜索树。
输入:[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
输出:[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
基本思路:
依次遍历右树->中->左树,利用变量记录和即可.
class Solution {
int sum=0;
public TreeNode convertBST(TreeNode root) {
if(root==null){
return null;
}
convertBST(root.right);
root.val+=sum;
sum=root.val;
convertBST(root.left);
return root;
}
}
有三天左右没更新编程题了,今天有点手生,但是要坚持呀!!!!!!