剑指offer java day30 分治算法

T1 17. 打印从1到最大的n位数

leetcode 返回是int[] 不考虑大数 ，原书考虑大数越界情况下

不考虑大数越界

class Solution {
    public int[] printNumbers(int n) {
        int m = (int)Math.pow(10,n)-1; //要打印的个数 10的n次(从1开始)
        int[] res = new int[m];
        for(int i=0;i<m;i++){
            res[i] = i+1;
        }

        return res;
    }
}

k神题解 考虑大数越界，不考虑本题要求返回int[]

1. 表示大数的变量类型：
   无论是 short / int / long … 任意变量类型，数字的取值范围都是有限的。因此，大数的表示应用字符串 String 类型
2. 生成数字的字符串集：
   使用 int 类型时，每轮可通过 +1+1 生成下个数字，而此方法无法应用至 String 类型。并且， String 类型的数字的进位操作效率较低，例如 “9999” 至 “10000” 需要从个位到千位循环判断，进位 4 次。

观察可知，生成的列表实际上是 nn 位 00 - 99 的 全排列 ，因此可避开进位操作，通过 递归生成数字的 String 列表 。

3. 递归生成全排列：
   基于分治算法的思想，先固定高位，向低位递归，当个位已被固定时，添加数字的字符串。例如当 n = 2n=2 时（数字范围 1 - 991−99 ），固定十位为 00 - 99 ，按顺序依次开启递归，固定个位 00 - 99 ，终止递归并添加数字字符串。

作者：jyd
链接：https://leetcode-cn.com/problems/da-yin-cong-1dao-zui-da-de-nwei-shu-lcof/solution/mian-shi-ti-17-da-yin-cong-1-dao-zui-da-de-n-wei-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

同时还要处理高位多余的0 如 “001”，“099”

判断所有位都为9 : n-start = nine

class Solution {
    StringBuilder res;
    int nine = 0, count = 0, start, n;
    char[] num, loop = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}; //位数上循环的数字
    public String printNumbers(int n) {
        this.n = n;
        res = new StringBuilder();
        num = new char[n];//n表示位数
        start = n - 1; //拿到左边界
        dfs(0);
        res.deleteCharAt(res.length() - 1); //去掉最后一个','
        return res.toString();
    }
    
    //分治打印数组
    void dfs(int x) {
        if(x == n) { // 终止条件：已固定完所有位
            String s = String.valueOf(num).substring(start); //字符数组转换为String后去掉高位0，substring表示从start开始返回
            if(!s.equals("0")) res.append(s + ",");
            if(n - start == nine) start--; //全9数字左边界左移一位
            return;
        }
        for(char i : loop) {
            if(i == '9') nine++;
            num[x] = i;
            dfs(x + 1);
        }
        nine--;
    }
}

作者：jyd
链接：https://leetcode-cn.com/problems/da-yin-cong-1dao-zui-da-de-nwei-shu-lcof/solution/mian-shi-ti-17-da-yin-cong-1-dao-zui-da-de-n-wei-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

T2 51. 数组中的逆序对

归并排序

当 左子数组当前元素 > 右子数组当前元素

则 「左子数组当前元素 至 末尾元素」 与 「右子数组当前元素」构成了若干逆序树

class Solution {
    int count; //全局变量
    public int reversePairs(int[] nums) {
        this.count = 0;
        marge(nums,0,nums.length-1); //归并排序
        return count;
    }

    //逆序数函数
    public void marge(int[] nums,int left,int right){
        int mid = left + ((right - left) >> 1); //右移比除2快

        if(left < right){
            marge(nums, left , mid);  //分
            marge(nums , mid+1 , right);
            margeSort(nums , left , mid , right); //治 对分好的数组排序
        }
    }

    //分治后排序
    public void margeSort(int[] nums,int left,int mid,int right){
        int[] tmp = new int[right - left+1]; //存放排好的数组
        int index = 0; //排序完成数组的下标
        int temp1=left , temp2=mid+1; // 左数组起始下标，右数组起始下标
        
        while(temp1<=mid && temp2<=right){ // 任一数组越界结束
            if(nums[temp1] <= nums[temp2]){ //出现逆序数
                tmp[index++] = nums[temp1++]; //先赋值后加1
            }else{
                count += (mid-temp1+1); //左子数组当前元素 至 末尾元素
                tmp[index++] = nums[temp2++]; //先赋值后加1
            }
        }

        while(temp1<=mid){
            tmp[index++] = nums[temp1++]; //先赋值后加1      剩余左数组放进tmp
        }
            
        while(temp2<=right){
            tmp[index++] = nums[temp2++]; //先赋值后加1    剩余右数组放进tmp
        }
         
        //排序好的数组覆盖原数组对应位置
        for(int i=0;i<tmp.length;i++)
            nums[i+left] = tmp[i];
    }
}