督促自己——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;
}
}
有三天左右没更新编程题了，今天有点手生，但是要坚持呀！！！！！！