Leetcode - 面试题62-- 圆圈中最后剩下的数字

圆圈中最后剩下的数字

题目描述

0,1,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字。求出这个圆圈里剩下的最后一个数字。

例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。

• 题目限制
  • 1 <= n <= 10^5
  • 1 <= m <= 10^6

示例

1. 示例1

输入: n = 5, m = 3
输出: 3

2. 示例2

输入: n = 10, m = 17
输出: 2

解题思路

队列模拟

看到这个题，我第一眼想到的是使用队列去模拟题目所说的情况，先将0-n-1个数字加入到队列中，开始数数，从0开始到m-1，取出队列重新加入到队列尾部，删除第m个，不断重复这个过程，直到队列中只剩1个元素，直接返回这个剩余的元素即可。

很不幸，这种方法超时了。。。。

var lastRemaining = function(n, m) {
    let queue = new Queue()
    let index = 0
    for (let i=0; i<n; i++) {
        queue.enqueue(i)
    }
    while (queue.size() > 1) {
    /**
     * 开始数数字
     * 不是m的时候，重新加入到队列的末尾
     * 是m的时候，将其从队列删除
    */
    for (let i=0; i<m-1; i++) {
      queue.enqueue(queue.dequeue())
    }
    // 是m的时候直接删除
    queue.dequeue()
  }
  let end = queue.front()
  return end
};

这种方法不成功是显而易见的，首先，事件复杂度O(nm),再看一下数据范围，不超时才怪！！！！

链表模拟

与队列模拟相同，只不过是换一下数据结构而已！！

使用数组求解

首先，对于本题，假设删除的位置是index位置的元素，那么下一个要删除的是index + m位置的元素，但是由于当前位置的数字删除了，后面的数字会前移一位，所以实际的下一次删除的位置是index + m - 1,由于是一个环，所以可以取模：

(index + m - 1) mod n来从头开始

// 通过
var lastRemaining = function(n, m) {
    let arr = []
   for (let i=0; i<n; i++) {
       arr.push(i)
   }
   let id = 0
   while(n > 1){
       id = (id + m - 1) % n
       arr.splice(id,1)
       n-- 
   }
   return arr[0]
};

这种方法过是侥幸过了，但耗时有点大

数学+递归 – 官方答案

1. 思路

   题目中的要求可以表述为：给定一个长度为 n 的序列，每次向后数 m 个元素并删除，那么最终留下的是第几个元素？

   这个问题很难快速给出答案。但是同时也要看到，这个问题似乎有拆分为较小子问题的潜质：如果我们知道对于一个长度 n - 1 的序列，留下的是第几个元素，那么我们就可以由此计算出长度为 n 的序列的答案。

2. 算法

   我们将上述问题建模为函数 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, m) = (m % n + x) % n = (m + x) % n

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

   /**
   class Solution {
       int f(int n, int m) {
           if (n == 1)
               return 0;
           int x = f(n - 1, m);
           return (m + x) % n;
       }
   public:
       int lastRemaining(int n, int m) {
           return f(n, m);
       }
   //时间复杂度：O(n)O(n)，需要求解的函数值有 nn 个。
   //空间复杂度：O(n)O(n)，函数的递归深度为 nn，需要使用 O(n)O(n) 的栈空间
   */
   //官方C++代码毫无问题，使用JS后 RangeError: Maximum call stack size exceeded报错！！！
   function f (n, m) {
      if (n === 1) {
          return 0
      } 
      let x = f(n-1, m)
      return (m+x) % n
   }
   function lastRemaining(n, m) {
       return f(n,m)
   }
   

   意思是递归次数太多导致内存消耗过大！！！！好尴尬！！！！

数学+迭代 – 官方答案

1. 避免递归使用栈空间。

   // 完美通过
   function lastRemaining(n, m) {
       let f = 0;
       for (let i = 2; i != n + 1; ++i)
           f = (m + f) % i;
       return f;
   }
   //时间复杂度：O(n)O(n)，需要求解的函数值有 nn 个。
   //空间复杂度：O(1)O(1)，只使用常数个变量。反推法
   

反推法

1. 思路

   n个人编号0,1,2,…,n-1，每数m次删掉一个人

   假设有函数f(n)表示n个人最终剩下人的编号

   n个人删掉1个人后可以看做n-1的状态，不过有自己的编号。

   n个人删掉的第一个人的编号是(m-1)%n，那么n个人时删掉第一个人的后面那 个人(m-1+1)%n一定是n-1个人时候编号为0的那个人，即n个人时的编号m%n（这个编号是对于n个人来考虑的），n-1个人时编号为i的人就是n个人时(m+i)%n

   所以f(n)=(m+f(n-1))%n
   f(1)=0，因为1个人时只有一个编号0

   因此可以将人数从2反推到n：

       var lastRemaining = function (n, m) {
         let ans = 0;
         for (let i = 2; i <= n; i++) {
           ans = (ans + m) % i;
         }
         return ans;
   	 }
   

​