zoukankan      html  css  js  c++  java
  • 【LeetCode】面试题62. 圆圈中最后剩下的数字

    题目:面试题62. 圆圈中最后剩下的数字

    这题很有意思,也很巧妙,故记录下来。

    官方题解思路,是约瑟夫环的数学解法:


    我们将上述问题建模为函数 f(n, m),该函数的返回值为最终留下的元素的序号。

    首先,长度为n的序列会先删除第m % n个元素,然后剩下一个长度为n - 1的序列。那么,我们可以递归地求解f(n - 1, m),就可以知道对于剩下的n - 1个元素,最终会留下第几个元素,我们设答案为x = f(n - 1, m)

    由于我们删除了第m % n个元素,将序列的长度变为n - 1。当我们知道了f(n - 1, m)对应的答案x之后,我们也就可以知道,长度为n的序列最后一个删除的元素,应当是从 m % n开始数的第x个元素。因此有f(n - 1, m) = (m % n + x) % n = (m + x) % n

    我们递归计算f(n, m),f(n - 1, m),f(n - 2, m), ... 直到递归的终点f(1, m)。当序列长度为1时,一定会留下唯一的那个元素,它的编号为0

    作者:LeetCode-Solution
    链接:https://leetcode-cn.com/problems/yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof/solution/yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-by-lee/
    来源:力扣(LeetCode)
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。


    需要注意的是下标的细节(老生常谈了):这里的数组 index = number,但 m 是从1开始计数。f() 的返回值 x 应该是从0开始计数的number。上文中“应当是从m % n开始数的第x个元素。”这句话里的m % n是被删除的元素的下一个元素的index,从它开始的index为x的元素正是下一步要删除的元素在原数组里的index。

    Java递归代码如下:

    class Solution {
        public int lastRemaining(int n, int m) {
            return f(n, m);
        }
    
        private int f(int n, int m) {
            if (n == 1) return 0;
            int x = f(n - 1, m);
            return (x + m) % n;
        }
    }
    // 13 ms / 41.8 MB   37.71% / -%
    
    • 时间复杂度:O(n),需要求解的函数值有n个。
    • 空间复杂度:O(n),函数的递归深度为n,需要使用O(n)的栈空间。

    写成迭代,代码如下:

    class Solution {
        public int lastRemaining(int n, int m) {
            int index = 0;
            for (int i = 2; i <= n; i++) {
                index = (index + m) % i;
            }
            return index;
        }
    }
    // 7 ms / 36.6 MB   99.88% / -%
    
    • 时间复杂度:O(n),需要求解的函数值有n个。
    • 空间复杂度:O(1),只使用常数个变量。

    总的来说迭代的时间和空间都更少。而且迭代的写法其实有点像动态规划了。


    以下是踩坑过程:

    我首先想的是,建一个首尾相连的链表,然后暴力跑,可想而知的超时,只通过了26/36个测试用例。

    然后想了下优化策略,每次访问所需的步数可以通过模运算减少,然后调整了一下每次访问的过程,虽然多通过了一个测试用例,但还是超时。

    class Solution {
        public int lastRemaining(int n, int m) {
            Node head = new Node(-1);
            Node p = head;
            Node q = head;
            for (int i = 0; i < n; i++) {
                p.next = new Node(i);
                p = p.next;
            }
            int step = 0;
            while (n > 1) {
                step = (step + m - 1) % n + 1;
    
                q = head;
                p = head;
                for (int i = 0; i < step; i++) {
                    q = p;
                    p = p.next;
                }
                //System.out.println(p.value);
                q.next = p.next;
    
                step--;
                n--;
            }
            return head.next.value;
        }
    }
    
    class Node {
        int value;
        Node next;
    
        Node(int value) {
            this.value = value;
        }
    }
    

    然后把数据存到 LinkedList 中去试试,发现效果差不多,还是超时。结果没想到换成 ArrayList 之后居然能通过,看来在数据访问和数据移动的性能取舍之间有一个微妙的平衡,本题是倾向于需要更快的访问速度。

    class Solution {
        public int lastRemaining(int n, int m) {
            // List<Integer> list = new LinkedList<>();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                list.add(i);
            }
            int index = 0;
            while (list.size() != 1) {
                index = (index + m - 1) % list.size();
                // System.out.println(list.get(index));
                list.remove(index);
            }
            // System.out.println(Arrays.toString(list.toArray()));
            return list.get(0);
        }
    }
    // 1122 ms / 43.1 MB    16.61% / -%
    
  • 相关阅读:
    Volatile关键字的解读
    JVM内存模型
    Redis为何是单线程的
    乐观锁&CAS问题
    String为什么要设置成Final类型
    后端开发之光!Django应用的容器化部署实践~
    一小时完成后台开发:DjangoRestFramework开发实践
    Django快速开发实践:Drf框架和xadmin配置指北
    Django应用部署:nginx+uwsgi方式
    Python踩坑:类与类对象类型参数传递与使用
  • 原文地址:https://www.cnblogs.com/caophoenix/p/12598046.html
Copyright © 2011-2022 走看看