Leetcode (Random-1)

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;
    }
}