剑指offer——第三十天( 分治算法“困难”）

# 第一题：剑指 Offer 17. 打印从1到最大的n位数

问题描述

思路（小数）

只考虑小数的话比较简单，思路直接用for循环然后得到答案。

代码

class Solution {
    public int[] printNumbers(int n) {
        int m = (int)(Math.pow(10,n) - 1);
        int array[] =new int[m];
        for(int i=0,j=1;i<m;i++,j++){
            array[i] = j;
        }
        return array;
    }
}

时间空间复杂度

思路（大数）

大数不管是用long 还是 long long 都有越界的地方。
因此用到0 - 9 这个数字的全排列来组合。
具体实现看代码！！！

代码

class Solution {
    int[] res;
    int nine = 0, count = 0, start, n;
    char[] num, loop = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
    public int[] printNumbers(int n) {
        this.n = n;
        res = new int[(int)Math.pow(10, n) - 1];
        num = new char[n];
        start = n - 1;
        dfs(0);
        return res;
    }
    void dfs(int x) {
        if(x == n) {
            String s = String.valueOf(num).substring(start);
            if(!s.equals("0")) res[count++] = Integer.parseInt(s);
            if(n - start == nine) start--;
            return;
        }
        for(char i : loop) {
            if(i == '9') nine++;
            num[x] = i;
            dfs(x + 1);
        }
        nine--;
    }
}

时间空间复杂度

第二题：剑指 Offer 51. 数组中的逆序对

问题描述

思路

代码

class Solution {
    int cnt = 0;
    int[] temp;

    public int reversePairs(int[] nums) {
        int n = nums.length;
        temp = new int[n];
        mergeSort(nums, 0, n - 1);
        return cnt;
    }

    private void mergeSort(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        // 像不像二叉树的后序遍历？
        int mid = (right - left) / 2 + left;
        // 递 => 将数组分割成不可再分的小块
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        // 归 => 逐步合并已完成排序的左右小块
        merge(arr, left, mid, right);
    }

    private void merge(int[] arr, int left, int mid, int right) {
        // 复制一下，准备归并
        for (int i = left; i <= right; i++) {
            temp[i] = arr[i];
        }

        // 修改原数组，归并 temp
        int i = left, j = mid + 1, k = left;
        while (i <= mid && j <= right) {
            if (temp[i] > temp[j]) {
                arr[k] = temp[j++];
                // mid 前有多少个 temp[j] 比当前 temp[i] 小 
                cnt += mid - i + 1;
            } else {
                arr[k] = temp[i++];
            }
            k++;
        }

        while (i <= mid) {
            arr[k++] = temp[i++];
        }

        while (j <= right) {
            arr[k++] = temp[j++];
        }
    }
}

时间空间复杂度