LeetCode12. 整数转罗马数字 / 剑指 Offer 40. 最小的k个数 / 剑指 Offer 41. 数据流中的中位数

LeetCode12. 整数转罗马数字

2021.5.14 每日一题

题目描述

罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。

字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个整数，将其转为罗马数字。输入确保在 1 到 3999 的范围内。


示例 1:

输入: 3
输出: "III"
示例 2:

输入: 4
输出: "IV"
示例 3:

输入: 9
输出: "IX"
示例 4:

输入: 58
输出: "LVIII"
解释: L = 50, V = 5, III = 3.
示例 5:

输入: 1994
输出: "MCMXCIV"
解释: M = 1000, CM = 900, XC = 90, IV = 4.

思路

经典问题了，思路就是模拟吧，从高位到低位依次处理，我也是这样写的：

class Solution {
    public String intToRoman(int num) {
        //经典问题了，必须拿下
        //数字最大3999，因此先除以1000，等于几，添加几个M
        //再除以100，等于9 加 CM ，等于4 加CD，其余如果大于等于5，先加D，再加几个C；小于5，加C
        //下面的处理类似,
        //想想怎么循环起来
        StringBuilder sb = new StringBuilder();
        //用一个Map来存储当前位置（个十百千）对应的罗马数字
        Map<Integer, Character> map = new HashMap<>(){
            {
                put(1, 'I');
                put(5, 'V');
                put(10, 'X');
                put(50, 'L');
                put(100, 'C');
                put(500, 'D');
                put(1000, 'M');
            }
        };
        int base = 1000;
        //统计每位的个数
        while(num > 0){
            int count = num / base;
            num = num - count * base;
            char ge = map.get(base);
            char wu = ' ';
            char shi = ' ';
            if(map.containsKey(base * 5))
                wu = map.get(base * 5);
            if(map.containsKey(base * 10))
                shi = map.get(base * 10);
            
            if(count == 9){
                sb.append(ge);
                sb.append(shi);
                count = 0;
            }
            else if(count == 4){
                sb.append(ge);
                sb.append(wu);
                count = 0;
            }
            else if(count >= 5){
                sb.append(wu);
                count = count - 5;
            }

            for(int i = 0; i < count; i++){
                sb.append(ge);
            }

            base /= 10;
        }
        return sb.toString();
    }
}

没啥问题，看了题解吧，发现也是模拟，只不过把数分的更加详细了，贴一个weiwei哥的代码：

public class Solution {

    public String intToRoman(int num) {
        // 把阿拉伯数字与罗马数字可能出现的所有情况和对应关系，放在两个数组中，并且按照阿拉伯数字的大小降序排列
        int[] nums = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        String[] romans = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};

        StringBuilder stringBuilder = new StringBuilder();
        int index = 0;
        while (index < 13) {
            // 特别注意：这里是等号
            while (num >= nums[index]) {
                stringBuilder.append(romans[index]);
                num -= nums[index];
            }
            index++;
        }
        return stringBuilder.toString();
    }
}

剑指 Offer 40. 最小的k个数

题目描述

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

 

示例 1：

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]
示例 2：

输入：arr = [0,1,2,1], k = 1
输出：[0]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

第一种：堆排序，用最大堆存储数组中最小的k个数，如果堆顶大于新来的数，就弹出，加入当前数，最后堆中就是k个最小的数

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        //最小的数可以求，最小的两个数可以求，那么最小的四个数其实也可以写，只不过有点复杂，判断条件多了
        //或者排序
        //用最大堆，堆中存储4个最小的数字，如果新的数字小于堆顶，进行替换
        if(k == 0)
            return new int[]{};
        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
            public int compare(Integer a, Integer b){
                return b - a;
            }
        });

        for(int i = 0; i < arr.length; i++){
            if(pq.size() < k){
                pq.offer(arr[i]);
            }else{
                if(pq.peek() > arr[i]){
                    pq.poll();
                    pq.offer(arr[i]);
                }
            }
        }
        int[] res = new int[k];
        for(int i = 0; i < k; i++){
            res[i] = pq.poll();
        }
        return res;
    }   
}

第二种：快排思想

先来复习一下快排，快排思路就是将数组划分为小于基准数和大于基准数两部分，最重要的是细节
刚开始写了下面的代码：

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        //来写一下快排
        quickSort(arr, 0, arr.length - 1);
        return Arrays.copyOf(arr, k);
    }   

    public void quickSort(int[] arr, int l, int r){
        if(l >= r)
            return;
        //基准值取最左边的值
        int base = arr[l];
        int i = l; 
        int j = r;
        while(i < j){
            while(i < j && arr[i] <= base)
                i++;
            while(i < j && arr[j] >= base)
                j--;
            swap(arr, i, j);
        }
        swap(arr, i, l);
        quickSort(arr, l, i - 1);
        quickSort(arr, i + 1, r);

    }

    public void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
}

这个报错了，[0,1,2,1] 1 这个例子倒下了，我输出的是1，答案应该是0
然后我把下面两个循环的顺序颠倒了，就过了

			while(i < j && arr[j] >= base)
                j--;
			while(i < j && arr[i] <= base)
                i++;

这说明第一种写法，排序结果不对，为什么呢，看一下错误的例子，
第一轮排序，基准是0，第一轮两个循环结束，i == 1，j == 1，交换不变，最后交换基准，把0和1的位置交换了，所以发生错误
第二种写法，先移动j，第一轮两个循环结束，j = 0，i = 0，交换不变，最后交换基准，也不变，即0排在最前面，正确
因此，第一种快排模板，很简洁明了，背过

第二种模板，也还行吧，也顺带记一下

 	private int partition(int[] nums, int lo, int hi) {
        int v = nums[lo];
        int i = lo, j = hi + 1;
        while (true) {
            while (++i <= hi && nums[i] < v);
            while (--j >= lo && nums[j] > v);
            if (i >= j) {
                break;
            }
            int t = nums[j];
            nums[j] = nums[i];
            nums[i] = t;
        }
        nums[lo] = nums[j];
        nums[j] = v;
        return j;
    }

然后针对这个问题，对快排进行改进，因为要返回的是最小的k个数，因此不需要对数组进行排序，只需要将数组划分为长度为k和剩余部分两个部分就可以了。
因此只需要找到基准位置的下标为k就可以了，此时，左边的数正好是k个

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        //来写一下快排——> 快排思想
        //如果k比数组长度还大，就直接返回数组
        if(k >= arr.length)
            return arr;
        return quickSort(arr, 0, arr.length - 1, k);
    }   

    public int[] quickSort(int[] arr, int l, int r, int k){
        //基准值取最左边的值
        int base = arr[l];
        int i = l; 
        int j = r;
        while(i < j){
            while(i < j && arr[j] >= base)
                j--;
            while(i < j && arr[i] <= base)
                i++;
            swap(arr, i, j);
        }
        swap(arr, i, l);
        //如果当前基准数的位置大于k，说明在左边
        if(i > k) return quickSort(arr, l, i - 1, k);
        if(i < k) return quickSort(arr, i + 1, r, k);
        return Arrays.copyOf(arr, k);

    }

    public void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

剑指 Offer 41. 数据流中的中位数

题目描述

如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。

例如，

[2,3,4] 的中位数是 3

[2,3] 的中位数是 (2 + 3) / 2 = 2.5

设计一个支持以下两种操作的数据结构：

void addNum(int num) - 从数据流中添加一个整数到数据结构中。
double findMedian() - 返回目前所有元素的中位数。
示例 1：

输入：
["MedianFinder","addNum","addNum","findMedian","addNum","findMedian"]
[[],[1],[2],[],[3],[]]
输出：[null,null,null,1.50000,null,2.00000]
示例 2：

输入：
["MedianFinder","addNum","findMedian","addNum","findMedian"]
[[],[2],[],[3],[]]
输出：[null,null,2.00000,null,2.50000]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shu-ju-liu-zhong-de-zhong-wei-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

还是想办法优化时间复杂度，因为如果用数组每次插入找到位置，然后移动的话，时间复杂度为O(n)
然后就想起之前做过的用两个对顶堆求中位数的方法；中位数把一组数分成了大数部分和小数部分，用一个小顶堆存放大数部分，堆顶就是大数部分最小数；大顶堆存放小数部分，堆顶就是小数部分最大数
主要是怎么维护这两个堆，首先插入元素，如果大于小顶堆堆顶，放入小顶堆；小于大顶堆堆顶，放在大顶堆；介于中间，也放在小顶堆
然后调整两个堆的大小，使得大小之差小于等于1
仔细想了一下后，写了下面代码：

class MedianFinder {
    //怎么快速计算中位数，
    //如果之前是偶数个数，中位数是m，m = （l + r）/ 2 
    //现在添加了一个t，如果t大于r，中位数变成r；小于l，中位数变成l；l和r之间，中位数为t
    //现在是奇数，中位数是m，记录左边的数l和右边的数r，添加一个数，如果大于r，更新mid = (r + mid) / 2，l = mid，r = r；
    //同理处理小于r和在l和r之间的情况，不行。。。。。。。。。。。

    //那么怎么办呢，突然想起来之前做过的一道题，两个堆找中位数，就是一个大根堆，一个小跟堆，两个顶部的数就是中位数
    //想想逻辑怎么实现，小根堆里存大数，大根堆里存小数
    //先把第一个数放进任意一个堆中，例如小根堆中，
    //然后放第二个数，如果第二个数大于第一个数，那么就把第一个数弹出，放入大根堆中，再把第二个数放在小根堆中
    //放第三个数，和两个堆顶的数进行比较，如果大于小根堆堆顶，放在小根堆中；小于大根堆堆顶，放在大根堆里；介于之间，放在小根堆
    //放入以后，调整两个堆的数个数，使得两个堆个数之差不大于1
    //这样，如果奇数，就取小根堆堆顶的数；如果偶数，就两个堆堆顶的数平均
    //放一个数的时间复杂度为O(logn),计算中位数的时间复杂度为O(1)


    /** initialize your data structure here. */
    PriorityQueue<Integer> small;
    PriorityQueue<Integer> big;

    public MedianFinder() {
        small = new PriorityQueue<>();       //小根堆，放大数
        big = new PriorityQueue<>(new Comparator<Integer>(){     //大根堆，放小数
            public int compare(Integer a, Integer b){
                return b - a;
            }   
        });
    }
    
    public void addNum(int num) {
        //刚开始放在小根堆里
        if(small.isEmpty() && big.isEmpty()){
            small.add(num);
            return; 
        }
        //如果大于小根堆堆顶，说明是大数部分的，放在小根堆里面
        if(!small.isEmpty() && num > small.peek())
            small.offer(num);
        //如果小于大根堆堆顶，说明是小数部分的，放在大根堆里面
        else if(!big.isEmpty() && num < big.peek())
            big.offer(num);
        //介于中间的，也放在小根堆堆顶
        else
            small.offer(num);

        //调整两个堆元素的数量
        while(small.size() - big.size() > 1){
            big.offer(small.poll());
        }
        while(big.size() - small.size() > 1){
            small.offer(big.poll());
        }
    }
    
    public double findMedian() {
        if(small.size() > big.size())
            return small.peek();
        else if(small.size() < big.size())
            return big.peek();
        else
            return (double)((small.peek() + big.peek()) / 2.0);
    }
}

这样写代码有点复杂，不过感觉思路还是很清晰的。
然后去看了题解，其实直接根据两个堆的大小，直接进行两个堆的更新就可以了
首先规定，如果是奇数，那么小顶堆的个数要比大顶堆多1个
那么如果此时两个堆大小相同，就可以先将要加入的数num放在大顶堆中，然后把大顶堆堆顶的数弹出，放在小顶堆中
如果大小不同，由于小顶堆个数多一个，那么就放在小顶堆里，然后弹出一个放进大顶堆中

class MedianFinder {
    /** initialize your data structure here. */
    PriorityQueue<Integer> small;
    PriorityQueue<Integer> big;

    public MedianFinder() {
        small = new PriorityQueue<>();       //小根堆，放大数
        big = new PriorityQueue<>(new Comparator<Integer>(){     //大根堆，放小数
            public int compare(Integer a, Integer b){
                return b - a;
            }   
        });
    }
    
    public void addNum(int num) {
        if(small.size() == big.size()){
            big.offer(num);
            small.offer(big.poll());
        }else{
            small.offer(num);
            big.offer(small.poll());
        }
    }
    
    public double findMedian() {
        if(small.size() > big.size())
            return small.peek();
        else
            return (small.peek() + big.peek()) / 2.0;
    }
}