阿翰 剑指offer 之 Day 30 分治法 困难

最新推荐文章于 2024-08-03 23:57:26 发布
最新推荐文章于 2024-08-03 23:57:26 发布
阅读量533 收藏
点赞数
分类专栏： leetcode 剑指offer 文章标签： leetcode 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/b_e_w/article/details/121928672
版权

目录

分治法

1 打印从1到最大的n位数

1. 循环生成 

2. k神大数打印解法

2 数组中的逆序对

1. 归并排序写法 

2. k神写法 

3. 离散化树状数组 （官方题解）

3 归并排序 

分治法

1 打印从1到最大的n位数

剑指 Offer 17. 打印从1到最大的n位数https://leetcode-cn.com/problems/da-yin-cong-1dao-zui-da-de-nwei-shu-lcof/

1. 循环生成 

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

复杂度分析：

  • 时间复杂度 O(10^n) ： 生成长度为 10^n 的列表需使用 O(10^n)时间。
  • 空间复杂度 O(1)： 建立列表需使用 O(1) 大小的额外空间（ 列表作为返回结果，不计入额外空间 ）

2. k神大数打印解法

实际上，本题的主要考点是大数越界情况下的打印。需要解决以下三个问题：

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

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

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

根据以上方法，可初步编写全排列代码：

    StringBuilder res;
    int count = 0, n;
    char[] num, loop = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
    public String printNumbersString(int n){
        this.n = n;
        res = new StringBuilder();
        num = new char[n];
        dfs(0);
        res.deleteCharAt(res.length() - 1);
        return res.toString();
    }
    void dfs(int x){
        if(x == n){
            res.append(String.valueOf(num) + ",");
            return;
        }
        for(char i : loop){
            num[x] = i;
            dfs(x+1);
        }
    }

在此方法下，各数字字符串被逗号隔开，共同组成长字符串。返回的数字集字符串如下所示：

输入：n = 1
输出："0,1,2,3,4,5,6,7,8,9"

输入：n = 2
输出："00,01,02,...,10,11,12,...,97,98,99"

输入：n = 3
输出："000,001,002,...,100,101,102,...,997,998,999"

观察可知，当前的生成方法仍有以下问题：

  • 诸如 00, 01, 02,⋯ 应显示为 0, 1, 2, ⋯ ，即应 删除高位多余的 0 ;
  • 此方法从 0 开始生成，而题目要求 列表从 1 开始 ；

以上两个问题的解决方法如下：

1. 删除高位多余的 0 ：
字符串左边界定义： 声明变量 start 规定字符串的左边界，以保证添加的数字字符串 num[start:] 中无高位多余的 0 。

例如当 n = 2 时， 1 - 9 时 start = 1 ， 10 - 99 时 start = 0。

左边界 start 变化规律： 观察可知，当输出数字的所有位都是 9 时，则下个数字需要向更高位进 1 ，此时左边界 start 需要减 1（即高位多余的 0 减少一个）。

例如当 n = 3（数字范围 1 - 999）时，左边界 start 需要减 1 的情况有： "009" 进位至 "010" ， "099" 进位至 "100" 。设数字各位中 9 的数量为 nine ，所有位都为 9 的判断条件可用以下公式表示：n - start = nine

        统计 nine 的方法： 固定第 x 位时，当 i = 9 则执行 nine = nine + 1 ，并在回溯前恢复 nine = nine - 1 。
2. 列表从 1 开始：

在以上方法的基础上，添加数字字符串前判断其是否为 "0" ，若为 "0" 则直接跳过。

    StringBuilder res;
    int nine = 0, count = 0,start, n;
    char[] num, loop = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
    public String printNumbersString(int n){
        this.n = n;
        res = new StringBuilder();
        num = new char[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);
            if(!s.equals("0"))  res.append(s+",");
            if(n - start == nine) start--;
            return;
        }
        for(char i : loop){
            if(i == '9')    nine++;
            num[x] = i;
            dfs(x+1);
        }
        nine--;
    }

 本题要求输出 int 类型数组。为 运行通过 ，可在添加数字字符串 ss 前，将其转化为 int 类型。代码如下所示：

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

但是面试肯定是考察这样的“大数”情况！！ 

2 数组中的逆序对

剑指 Offer 51. 数组中的逆序对https://leetcode-cn.com/problems/shu-zu-zhong-de-ni-xu-dui-lcof/

class Solution {
    public int reversePairs(int[] nums) {
        int n = nums.length;
        int count= 0;
        for (int i = 0; i < n; i++) {
            for (int j = i+1; j < n; j++) {
                if(nums[i] > nums[j])
                    count++;
            }
        }
        return count;
    }
}

超过时间限制

1. 归并排序写法 

class Solution {
    private int ans;
    public int reversePairs(int[] nums) {
        if (nums.length == 0 || nums.length == 1) {
            return 0;
        }
        mergeSort(nums, 0, nums.length - 1);
        return ans;
    }

    public void mergeSort(int[] nums, int l, int r) {
        if (l >= r) {
            return;
        }
        int mid = ((r - l) >> 1) + l;
        mergeSort(nums, l, mid);
        mergeSort(nums, mid + 1, r);
        merge(nums, l, mid, r);
    }
    /**
     合并排序，从小到大
     */
    public void merge(int[] nums, int l, int mid, int r) {
        // 第一组左边界
        int l1 = l;
        // 第二组左边界
        int l2 = mid + 1;
        // 临时数组保存排序结果
        int[] tmp = new int[r - l + 1];
        int count = 0;
        // 归并排序
        while (l1 <= mid && l2 <= r) {
            if (nums[l1] <= nums[l2]) {
                tmp[count++] = nums[l1++];
                // 这里前面的数字大于后面的数字，所以前面的这个数字后面都大于后面的这个数字
            } else {
                ans += (mid - l1 + 1);
                tmp[count++] = nums[l2++];
            }
        }
        // 把左边剩余的数移入数组
        while (l1 <= mid) {
            tmp[count++] = nums[l1++];
        }
        // 把右边边剩余的数移入数组
        while (l2 <= r) {
            tmp[count++] = nums[l2++];
        }
        // 把临时数组中的数覆盖nums数组 
        for (int i = l; i <= r; i++) {
            nums[i] = tmp[i - l];
        }
    }
}

2. k神写法 

感觉就是在归并排序（分治），过程中去累加计算逆序对。

直观来看，使用暴力统计法即可，即遍历数组的所有数字对并统计逆序对数量。此方法时间复杂度为 O(N^2) ，观察题目给定的数组长度范围 0≤N≤50000 ，可知此复杂度是不能接受的。

归并排序」与「逆序对」是息息相关的。归并排序体现了 “分而治之” 的算法思想，具体为：

  • 分： 不断将数组从中点位置划分开（即二分法），将整个数组的排序问题转化为子数组的排序问题；
  • 治： 划分到子数组长度为 1 时，开始向上合并，不断将 较短排序数组 合并为 较长排序数组，直至合并至原数组时完成排序；

 如下图所示，为数组 [7, 3, 2, 6, 0, 1, 5, 4] 的归并排序过程。

合并阶段 本质上是 合并两个排序数组 的过程，而每当遇到 左子数组当前元素 > 右子数组当前元素 时，意味着 「左子数组当前元素 至 末尾元素」 与 「右子数组当前元素」 构成了若干 「逆序对」 。 

因此，考虑在归并排序的合并阶段统计「逆序对」数量，完成归并排序时，也随之完成所有逆序对的统计。 

为简化代码，「当 j = r + 1 时」 与 「当 tmp[i] ≤ tmp[j] 时」 两判断项可合并。

package jzof.Day30;

import java.util.Arrays;

/**
 * @author ahan
 * @create_time 2021-12-14-3:50 下午
 */
public class _51 {
    public static void main(String[] args) { 
        System.out.println(new _51().reversePairs(new int[]{5,4,3,2,1}));
    }
    int[] nums, tmp;
    public int reversePairs(int[] nums) {
        this.nums = nums;
        int n = nums.length;
        tmp = new int[n];
        int res = mergeSort(0, n-1);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
        return res;
    }
    private int mergeSort(int l, int r) {
        // 终止条件
        if (l >= r) return 0;
        // 递归划分
        int m = (l + r) / 2;
        int res = mergeSort(l, m) + mergeSort(m + 1, r);
        // 合并阶段
        int i = l, j = m + 1;
        for (int k = l; k <= r; k++)
            tmp[k] = nums[k];
        for (int k = l; k <= r; k++) {
            if (i == m + 1)
                nums[k] = tmp[j++];
            else if (j == r + 1 || tmp[i] <= tmp[j])
                nums[k] = tmp[i++];
            else {
                nums[k] = tmp[j++];
                res += m - i + 1; // 统计逆序对
            }
        }
        return res;
    }
}

复杂度分析：

  • 时间复杂度 O(NlogN) ： 其中 N 为数组长度；归并排序使用 O(NlogN) 时间；
  • 空间复杂度 O(N) ： 辅助数组 tmp 占用 O(N) 大小的额外空间； 

3. 离散化树状数组 （官方题解）

 解法二：离散化树状数组

预备知识

「树状数组」是一种可以动态维护序列前缀和的数据结构，它的功能是：

  • 单点更新 update(i, v)： 把序列 i 位置的数加上一个值 v，这题 v = 1
  • 区间查询 query(i)： 查询序列 [1⋯i] 区间的区间和，即 i 位置的前缀和

修改和查询的时间代价都是O(logn)，其中 n 为需要维护前缀和的序列的长度。

思路

从后往前遍历，i位置+1 并且 加上该数的前i-1的前缀和。还有一个问题，如果数字很大，内存是存不下这么大的数据，所以离散化。

离散化一个序列的前提是我们只关心这个序列里面元素的相对大小，而不关心绝对大小（即只关心元素在序列中的排名）；离散化的目的是让原来分布零散的值聚集到一起，减少空间浪费。那么如何获得元素排名呢，我们可以对原序列排序后去重，对于每一个 a_i 通过二分查找的方式计算排名作为离散化之后的值。当然这里也可以不去重，不影响排名。

复制一个数组tmp，排序，nums[i] = tmp中对应元素序号+1 知道排名即可。

class Solution {
    public int reversePairs(int[] nums) {
        int n = nums.length;
        int[] tmp = new int[n];
        System.arraycopy(nums, 0, tmp, 0, n);
        // 离散化
        Arrays.sort(tmp);
        for (int i = 0; i < n; ++i) {
            nums[i] = Arrays.binarySearch(tmp, nums[i]) + 1;
        }
        // 树状数组统计逆序对
        BIT bit = new BIT(n);
        int ans = 0;
        for (int i = n - 1; i >= 0; --i) {
            ans += bit.query(nums[i] - 1);
            bit.update(nums[i]);
        }
        return ans;
    }
}

class BIT {
    private int[] tree;
    private int n;

    public BIT(int n) {
        this.n = n;
        this.tree = new int[n + 1];
    }

    public static int lowbit(int x) {
        return x & (-x);
    }

    public int query(int x) {
        int ret = 0;
        while (x != 0) {
            ret += tree[x];
            x -= lowbit(x);
        }
        return ret;
    }

    public void update(int x) {
        while (x <= n) {
            ++tree[x];
            x += lowbit(x);
        }
    }
}

 

 

3 归并排序 

package jzof.Day30;

/**
 * @author ahan
 * @create_time 2021-12-14-5:19 下午
 */
public class guibing {
    public static void main(String[] args) {
        int[] sort = sort(new int[]{1, 3, 4, 5, 6, 1}, 0, 5);

        for (int i = 0; i < sort.length; i++) {
            System.out.print(sort[i] + " ");
        }
        System.out.println("");
        new guibing().sort2(new int[]{1, 3, 4, 5, 6, 1});

    }
    public static int[] sort(int[] a,int low,int high){
        int mid = (low+high)/2;
        if(low<high){
            sort(a,low,mid);
            sort(a,mid+1,high);
            //左右归并
            merge(a,low,mid,high);
        }
        return a;
    }

    public static void merge(int[] a, int low, int mid, int high) {
        int[] temp = new int[high-low+1];
        int i= low;
        int j = mid+1;
        int k=0;
        // 把较小的数先移到新数组中
        while(i<=mid && j<=high){
            if(a[i]<a[j]){
                temp[k++] = a[i++];
            }else{
                temp[k++] = a[j++];
            }
        }
        // 把左边剩余的数移入数组
        while(i<=mid){
            temp[k++] = a[i++];
        }
        // 把右边边剩余的数移入数组
        while(j<=high){
            temp[k++] = a[j++];
        }
        // 把新数组中的数覆盖nums数组
        for(int x=0;x<temp.length;x++){
            a[x+low] = temp[x];
        }
    }
//下面是第二种方法
    int[] nums, tmp;
    public void sort2(int[] nums) {
        this.nums = nums;
        int n = nums.length;
        tmp = new int[n];
        mergeSort(0, n-1);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
    }
    private void mergeSort(int l, int r) {
        // 终止条件
        if (l >= r) return ;
        // 递归划分
        int m = (l + r) / 2;
        mergeSort(l, m);
        mergeSort(m + 1, r);
        // 合并阶段
        int i = l, j = m + 1;
        for (int k = l; k <= r; k++)
            tmp[k] = nums[k];
        for (int k = l; k <= r; k++) {
            if (i == m + 1)
                nums[k] = tmp[j++];
            else if (j == r + 1 || tmp[i] <= tmp[j])
                nums[k] = tmp[i++];
            else {
                nums[k] = tmp[j++];
            }
        }
    }
}

b_e_w
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python《剑指offer》算法实现-分治法解决最近对问题
12-25
# Python实现《剑指offer》 部分代码自己添加了一些测试用例, 或者自己添加了一些功能 1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,...
剑指Offer(题目和答案)
01-31
"剑指Offer"是一本针对面试准备的书籍，包含了许多常见的编程面试题。通过解决这些题目，可以提升编程能力，理解和熟练掌握各种算法和数据结构，为面试做好充分准备。 总结，以上内容涵盖了二维数组查找、字符串...
LeetCode–打印从1到最大的n位数
归子莫的博客
09-10 318
LeetCode–打印从1到最大的n位数 博客说明 文章所涉及的资料来自互联网整理和个人总结，意在于个人学习和经验汇总，如有什么地方侵权，请联系本人删除，谢谢！ 介绍 剑指 Offer 17. 打印从1到最大的n位数 题目 输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。 示例 1: 输入: n = 1 输出: [1,2,3,4,5,6,7,8,9]说明： 用返回一个整数列表来代替打印 n 为正整数代码 class So
String类的常用知识点及功能方法总结
weixin_38445123的博客
02-09 733
一、 String类的理解： Java中的String类是字符串操作类，提供了多种方法对字符串进行操作。 通过查阅JDK提供的API，可以查看String类的相关说明。 注意：① 字符串可以将其看成字面值"abcd"，也同样可以看成一个字符串对象。    ② 字符串是常量，一旦创建不能被改变。 二、String类的构造方法： 1. public String(): 空构造 创建空字符串 St...
Java之学习笔记（12）-----------数据类型转换valueOf、subString、indexOf用法
huohu1007的博客
01-18 727
之前，在http://blog.csdn.net/u011225629/article/details/45271019博客中，发现了valueOf的用法有几分困惑，又不好记忆，非常的混乱，特整理了一下，方便学习！ String.valueOf() 方法的使用 1. 由 基本数据型态转换成 String String 类别中已经提供了将基本数据型态转换成 String 的 sta
疯狂Java之学习笔记（12）-----------数据类型转换valueOf、subString、indexOf用法
chunbo1110的博客
04-14 154
之前，在http://blog.csdn.net/u011225629/article/details/45271019博客中，发现了valueOf的用法有几分困惑，又不好记忆，非常的混乱，特整理了一下，方便学习！ String.valueOf() 方法的使用 1. 由 基本数据型态...
Android 关于字符串的使用String.valueOf(y).substring(0, 5)
zhangjikuan的专栏
03-05 2341
在使用字符串的时候很多情况下要筛选字符串的位数 例如当把一个float类型转换成字符串类型并且显示的时候很多情况下要限制显示位数也就是设定小数点后几位小数 可用函数String.valueOf(y).substring(0, 5) 次函数作用是把y转换成string的类型，然后从string的第0个数开始选取，共选取五位 注意5中包含正负号和小数点
阿翰 剑指offer 之 Day 20 分治算法 中等
b_e_w的博客
11-30 417
分治算法 1 重建二叉树 2 数值的整数次方 3 二叉搜索树的后序遍历
剑指offer全部代码
03-07
《剑指Offer》是面试官在招聘过程中常常参考的一本书，它涵盖了大量经典的编程面试题，旨在帮助求职者提升算法和编程能力。该压缩包包含了《剑指Offer》中的所有代码，适合用Visual Studio（VS）开发环境打开，并且...
剑指Offer-V1.pdf
12-12
《剑指Offer》是一本专注于算法和数据结构的书籍，特别针对面试和编程竞赛中的常见问题进行了深入解析。V1版本仅提供了Java语言的解决方案。书中涵盖了大量编程面试中经常遇到的问题，旨在提升读者在算法设计、实现...
剑指offerc++代码
10-21
《剑指Offer——C++代码实现》是一系列针对面试中常见数据结构与算法问题的解决方案，旨在帮助程序员提升在面试中的竞争力。这个压缩包包含了针对《剑指Offer》书中问题的C++编程实践，涵盖了从基础到进阶的各类算法...
剑指offer 打印从1到最大的n位数
Infor_learning的博客
01-05 149
输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。 1、法一：递归生成全排列，通过n和9的个数之间的关系截取。 比如说生成 ...097 098 099 ... 9的个数分别为 1 1 2 。n-count 分别为2 2 1 当前的start为1，满足n - start == count 时 start向前一位，代表截取起始坐标前进一位。 class Solution { StringBuilder res;...
【leetcode详解】直角三角形：用空间换时间(O(m*n*(m+n))＞O(m*n))(思路详解)
H13420972436的博客
08-02 226
用空间换时间：现在的问题就变成了，如何比较高效地知道该点所在 行、列 的“1”的个数 2.1 当然，我们可以对每个值为“1”的点都去重新搜索其所在行、列这样,时间复杂度就是O(m*n*(m+n)) 2.2 我们就思考，有没有什么地方可以优化嘞？是有滴，不难发现，如果按上面的思路，那么就存在大量重复操作：对同行的点去进行 对该行的查找 明显是重复的，同列的原理一样
「数组」Knuth洗牌算法|C++random库简单介绍 / LeetCode 384（C++）
dakingffo的博客
08-03 184
Knuth算法可以公平地对数组进行随机排序。
二叉树的中序遍历 - 力扣（LeetCode）C语言
SikJ_2020_0_24的博客
08-03 71
注：本题中returnSize，指的是二叉树的结点数，返回的必须是malloc开辟的。递归算法很简单，你可以通过迭代算法完成吗？注意要点与前序遍历相同，请参考。（点击前面链接即可查看题目）给定一个二叉树的根节点。
Leetcode 第 135 场双周赛题解
最新发布
ProgramNovice的博客
08-03 613
Leetcode 第 135 场双周赛题解
Java中等题-无重叠区间（力扣）
t1750982356的博客
08-02 254
排序， 设第一个区间为满足不重叠条件的最后一个区间，然后从第一个区间开始往后移动，如果后面的区间不与这个区间重叠，就把后一个区间作为满足不重叠条件的最后一个区间。排序，用一个数组f[i]表示以第i个区间为最后一个区间的最多的不重叠区间个数。你需要移除两个 [1,2] 来使剩下的区间没有重叠。你不需要移除任何区间，因为它们已经是无重叠的了。需要移除区间的最小数量，使剩余区间互不重叠。移除 [1,3] 后，剩下的区间没有重叠。方法一：（可能会导致。方法二：使用贪心算法。
Java中等题-多数元素2（力扣）【摩尔投票升级版】
t1750982356的博客
07-30 257
方法二：使用摩尔投票：一个数组中出现次数要大于总数的三分之一，满足条件的最多也只有两个数。方法一：使用HashMap,key记录值，value记录出现次数。的整数数组，找出其中所有出现超过。
分治法深入解析：排序算法与搜索算法
"分治法是一种重要的算法设计策略，它将大问题分解为小问题来解决。本资源涵盖了分治法的基本思想、主要流程，并详细介绍了折半搜索算法以及几种常见的排序算法，包括插入排序、归并排序和快速排序。此外，还探讨了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值