《剑指offer》面试题45 圆圈中最后剩下的数字(Java版本）

引言

这道题网上的讲解都是直接抄书，没意思，所以想自己写一写，补充一下，便于自己理解。另外，大家都忽略了经典解法，虽然这种解法效率不及第二种，但是我觉得在项目当中阅读性其实很重要，牺牲一点点效率保证代码的可维护性和阅读性是值得的。与此同时，第二种方法其实需要比较好的数学功底，我不认为一般的程序员在毕业多年之后还能保证自己的数学功底，而且在面试的时候你能在短时间和高压下准确的推导吗？我相信有人能做到，但是我不知道我能不能做到，所以经典解法可以作为一种稳妥的替代方案。

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

测试样例：

输入： 0，1 , 2, 3, 4

输出： 3

经典解法，用环形链表模拟圆圈

源码：

     public static int lastRemaining_1(int n,int m){
         if(n<1||m<1) return -1;
         List<Integer> list = new ArrayList<Integer>();
         for(int i=0;i<n;i++){
             list.add(i);
         }

         int current = 0;//从1到m计数
         int currentSize = n;//用以记录链表中元素的个数

         Iterator<Integer> iterator = list.iterator();
         while(currentSize>1){
             for(current=1;current<=m;current++){
                 if(iterator.hasNext()) iterator.next();
                 else {
                     //------到链表末尾--------
                     iterator = list.iterator();
                     iterator.next();
                 }
             }//end for
             iterator.remove();
             currentSize--;
         }//end while
         iterator = list.iterator();
         return iterator.next();
     }

这个思路大部分人都能立马想到，在从1到m个元素遍历时要注意有没有到达链表的末尾，若到达链表末尾，就要回到表头重新开始遍历。另外，由于java中的迭代器没有求size()的方法，所以需要自己定义一个变量currentSize记录链表中元素的个数。这种方法每删除一个数字需要m步操作，总共n个数字，因此时间复杂度是O（mn），另外还需要维持一个拥有n个元素的链表，即空间复杂度是O（n）.

创新的解法

源码：

public static int lastRemaining_2(int n,int m){
        if(n<1||m<1) return -1;
        int last = 0;
        for(int i=2;i<=n;i++){
            last = (last+m)%i;
        }
        return last;
    }

这段代码简直精简的爆，这就是数学的魅力啊！但是阅读性？要是在项目中出现这玩意，并且没有专门的注释或者讲解，你认为后期接手项目的人看到这段是什么感觉？估计砸键盘，原地爆炸了。。。

讲解：

定义函数f(n,m)，表示每次在n个数字0,1,...,n-1中每次删除第m个数字最后剩下的数字。

在n个数字中，第一个被删除的数字是（m%n）-1，(这里插一句，原书上说是(m-1)%n，我觉得不对，但是这两种答案最后带到递推公式里都能得到一样的结果)，我们把这个数字记为K. 在删除掉第一个元素K后，剩下的n-1个数字就是0,1,2,...,k-1,k+1,...,n-1，并且下一次删除从K+1开始计数。那么，在下一次计数的时候其实就相当于在这样一个序列中遍历：K+1，...，n-1，0, 1，... ,  K-1 。这个序列和前一个序列其实是一样的，不一样的是我们把它的顺序修改了一下而已，但是删除元素时遍历顺序是一样的。故经过若干次删除后剩下的数字和前一个序列也应该是一样的。我们把后一个序列每次删除第m个数字最后剩下的数字记为f'(n-1,m)，至于为什么记为f'(n-1,m)你看到后面就懂了。那么现在我们最起码可以确定的是f(n,m)=f'(n-1,m)。

我们再来看分析这个序列：k+1，...，n-1，0，1，...，k-1 。我们将这个序列做一个映射，映射结果是形成一个从0到n-2的序列：

k+1     ->    0

k+2     ->    1

......

n-1     ->     n-k-2

0        ->     n-k-1

1        ->     n-k

......

k-1      ->     n-2

  f'(n-1,m)     f(n-1,m)

我们定义映射为p，那么p(x) = (x-k-1)%n 。 它表示如果映射前的数字是x，那么映射后的数字是(x-k-1)%n。该映射的逆映射是p^-1(x)=(x+k+1)%n。既然要掌握这个方法，就要彻底搞懂，下面跟着我一起证明一遍：

证明：

令y = p(x)，即 y = (x-k-1)%n

则有  y = (x-k-1) +t₁n，t₁属于整数，且0<= y <n

< --->   x =  y - t₁n + k + 1

<---->   x =  (y+k+1) + t₂n ，即 y = (x+k+1) + tn，故p^-1(x) =  (x+k+1) %n

证明完毕。

现在，我们发现经过映射之后的n-1个数字是不是和原先的n个数字形式上是一样的？只不过少看一个数字n-1而已。那么，对0，1，...，n-2这n-1个数字，排成一个圆圈，从数字0开始每次删除第m个数，剩下的数字是不是可以表示成f(n-1,m)?! 现在有没有发现我们之前为什么要定义那么序列为 f'(n-1,m)? 这是要建立两次删除之间的联系！就是说原始的n个元素，在删除第一个元素k之后，按理说初始序列已经被打乱了，没有规则了；但是我们通过一个映射关系，让序列重新排列成初始序列的形式。这样只要我们找到这样的映射关系，求出两次操作之间的函数关系（迭代规律）就将问题转化成了递归问题。而递归问题的出口很好确定，当n=1时，序列只有一个元素：0，f(1,m)就是这个0！

既然有了映射关系，下面我们求两次迭代操作之间的关系，即如何由f(n-1,m)求得f(n,m)。

求解：

因为f(n,m) = f'(n-1,m)，且f'(n-1,m) = (f(n-1,m)+k+1)%n，故f(n,m) = (f(n-1,m)+k+1)%n。 又因为 k = (m%n)-1，带入f(n,m) = (f(n-1,m)+k+1)%n，得：f(n,m) = (f(n-1,m)+m)%n。

因此，当n=1时，f(n,m) = 0

当n>1时，f(n,m) = [f(n-1,m)+m]%n

有了这个递推关系，是不是可以写代码了？可以由上而下的用递归，也可以由下而上的用迭代。递归在这里显然不存在子问题重复求解的问题，但是会有大量的堆栈操作，不如直接用迭代的方式。至于迭代方式的源码，上面已经给出了。 int last = 0; 是当n=1时,f(1,m)的值；后面的for循环就是自下而上的求解f(n,m）的值了。

这种思路非常复杂，但是代码尤其简洁，主要的时间都花在了分析和推导公式上了。该方法时间复杂度为O（n），空间复杂度是O（1），无论是时间复杂度和空间复杂度都要好于第一种方法。