2022-3-2 剑指offer day20

题1：

JZ11 旋转数组的最小数字

描述

有一个长度为 n 的非降序数组，比如[1,2,3,4,5]，将它进行旋转，即把一个数组最开始的若干个元素搬到数组的末尾，变成一个旋转数组，比如变成了[3,4,5,1,2]，或者[4,5,1,2,3]这样的。请问，给定这样一个旋转数组，求数组中的最小值。

 

数据范围：1 \le n \le 100001≤n≤10000，数组中任意元素的值: 0 \le val \le 100000≤val≤10000

要求：空间复杂度：O(1)O(1) ，时间复杂度：O(logn)O(logn)

 

import java.util.ArrayList;
public class Solution {
//     public int minNumberInRotateArray(int [] array) {
//         int ans=array[0];
//         int i=1;
//         while (i<array.length&&array[i]>=array[i-1]) i++;
//         return i>=array.length?ans:array[i];
//     }
    
    
    public int minNumberInRotateArray(int [] array) {
       int l=0,r=array.length-1;
        while (l<=r) {
           int mid=(l+r)/2;
           if (array[mid]>array[r]){
               l=mid+1;
           }else if (array[mid]<array[r]){
               r=mid;
           }else r--;
        }
        return array[l];
    }
    

}

思路：二分或者直接遍历。

 

题2：

JZ38 字符串的排列

 

描述

输入一个长度为 n 字符串，打印出该字符串中字符的所有排列，你可以以任意顺序返回这个字符串数组。

例如输入字符串ABC,则输出由字符A,B,C所能排列出来的所有字符串ABC,ACB,BAC,BCA,CBA和CAB。

数据范围：n < 10n<10
要求：空间复杂度 O(n!)O(n!)，时间复杂度 O(n!)O(n!)

 

输入描述：

输入一个字符串,长度不超过10,字符只包括大小写字母。

 

import java.util.*;
public class Solution {
    ArrayList<String> ans;
    Set<String> set;
    public ArrayList<String> Permutation(String str) {
        char[] arr=str.toCharArray();
        boolean[] visited=new boolean[arr.length];
        ans=new ArrayList<>();
        set=new HashSet<>();
        StringBuilder sb=new StringBuilder();
        dfs(0,arr,sb,visited);
        return ans;
    }
    
    public void dfs(int n,char[] arr,StringBuilder sb,boolean[] v){
        if (n==arr.length) {
            if (!set.contains(sb.toString())){
                ans.add(sb.toString());
                set.add(sb.toString());
            }
            return;
        }
        for (int i=0;i<arr.length;i++) {
            if (!v[i]) {
                sb.append(arr[i]);
                v[i]=true;
                dfs(n+1,arr,sb,v);
                sb.deleteCharAt(sb.length()-1);
                v[i]=false;
            }
        }
    }
    
}

思路：递归全排列，可能有重复字母，所以用set去重。