Leetcode (Random)
Leetcode随意点开的题目解答
991. 坏了的计算器
class Solution {
public int brokenCalc(int X, int Y) {
// 定义结果
int res = 0;
boolean flag = true;
// 肯定有结果,所以可以用while(true)
while(flag){
if(X > Y){
while(X>Y){
res++;
X--;
}
}
// 如果Y此时已经等于X,返回res
if(X == Y) return res;
// 如果Y此时和X不相等,但是相差一位
if(X == Y+1) return res+1;
// X与Y相差大于1位,并且Y是个奇数
if(Y%2 == 1){
Y=Y+1;
res++;
}
// 此时的Y一定是偶数,然后对他模2
Y = Y/2;
res++;
}
return res;
}
}
1433. 检查一个字符串是否可以打破另一个字符串
class Solution {
public boolean checkIfCanBreak(String s1, String s2) {
char[] sc1 = s1.toCharArray();
char[] sc2 = s2.toCharArray();
sortString(sc1,0,s1.length()-1);
sortString(sc2,0,s1.length()-1);
System.out.println(sc1);
System.out.println(sc2);
int flag = 0;
for(int i = 0;i<sc1.length;i++){
if(sc1[i] == sc2[i]) continue;
if(sc1[i] > sc2[i] && flag == 0) flag = 1;
if(sc1[i] < sc2[i] && flag == 0) flag = 2;
if(sc1[i] > sc2[i] && flag == 2) return false;
if(sc1[i] < sc2[i] && flag == 1) return false;
}
return true;
}
/**
// 对字符串进行排序,使用选择排序会超时。因为选择排序的时间复杂度是O(n*n)
public String sortString(String str){
// 定义结果
char[] res = str.toCharArray();
// 采用选择排序对str进行排序
for(int i = 0;i<res.length;i++){
// 记录最小元素所在位置的下标
int index = i;
for(int j = i+1;j<res.length;j++) if(res[j] <= res[index]) index = j;
//进行交换
char temp = res[index];
res[index] = res[i];
res[i] = temp;
}
return String.valueOf(res);
}
*/
// 对字符串进行排序,使用快速排序进行排序
public void sortString(char[] str,int l,int r){
if(l<r){
int i = l;
int j = r;
char pivot = str[l];
while(i<j){
while(i<j && str[j] >= pivot) j--;
if(i<j) str[i++] = str[j];
while(i<j && str[i] <= pivot) i++;
if(i<j) str[j--] = str[i];
}
str[i] = pivot;
sortString(str,l,i-1);
sortString(str,i+1,r);
}
}
}
953. 验证外星语词典
class Solution {
public boolean isAlienSorted(String[] words, String order) {
// 利用一个额外的数据结构map
Map<Character,Integer> map = new HashMap<Character,Integer>();
int index = 0;
for(Character c:order.toCharArray()) map.put(c,index++);
for(int i =0;i<words.length-1;i++){
int j = 0;
// flag 代表如果比较两个字符串符合字典要求 就跳出第二个循环
boolean flag = true;
for(;j<Math.min(words[i].length(),words[i+1].length()) && flag ;j++){
// 第i个字符串与第i+1个字符串符合要求,直接跳出这一层循环
if(map.get(words[i].charAt(j)) < map.get(words[i+1].charAt(j))) flag = false;
// 继续遍历第i个字符串与第i+1个字符串的第j位
else if(map.get(words[i].charAt(j)) > map.get(words[i+1].charAt(j))) return false;
}
// 跳出第二个循环的原因是因为符合要求而不是两个字符串前n相等,若前n相等看前一个字符串是否还有字符
if(j == words[i+1].length() && j<words[i].length() && flag) return false;
}
return true;
}
}
131. 分割回文串
class Solution {
public List<List<String>> partition(String s) {
List<List<String>> res = new ArrayList<List<String>>();
Stack<String> path = new Stack<>();
backTracking(s,0,s.length(),path,res);
return res;
}
// 回溯家➕剪枝
// start 字符串的开始位置
// len s的长度
// path 存放路径
// res 最终的结果
public void backTracking(String s,int start,int len,Stack<String> path,List<List<String>> res){
// 到达叶子结点
if(start == len){
res.add(new ArrayList<>(path));
return ;
}
for(int i = start;i<len;i++){
// 不是回文字符串的话进行剪枝
if(!isHui(s,start,i)) continue;
path.push(s.substring(start,i+1));
backTracking(s,i+1,len,path,res);
path.pop();
}
}
// 判断是不是回文串
public boolean isHui(String s,int start,int end){
// 利用两个指针来判断
int i = start;
int j = end;
while(i<j){
if(s.charAt(i) != s.charAt(j)) return false;
i++;
j--;
}
return true;
}
}