[刷题]剑指offer之圆圈中最后剩下的数字

题目

题目:有n个人,围成一个环，编号为 0、1、2、3、、、n-1，从第一个人开始循环报数(从1开始)，假设数到m的那个人出列，然后从下一个人继续数数，数到m出列，以此循环，最后那个人为胜利者，求胜利者的编号。

这其实就是有名的约瑟夫问题。

输入示例

• n=4, m=3 result=0
• n=50, m=20 result=33
• n=100, m=37 result=44

思路

解法一--模拟法

可以使用数组或者链表来模拟这n个人，每次删除第m个人，直到只剩下一个人为止。

使用数组删除元素的复杂度较高，链表是最优选择，C++ stl中的链表用的不太熟练，所以自己写一个。为了删除方便，选择双向链表，单向链表删除的时候还需要两个指针，很麻烦。

class Solution {
public:
    struct Node{
        int val;
        Node* next;
        Node* parent;
    }; // 链表节点
    int LastRemaining_Solution(int n, int m)
    {
        if(m == 0 || n == 0)
            return -1; // 无效情况返回-1
        // 为所有节点分配空间
        vector<Node> node(n);
        //头节点单独赋值
        node[0].val = 0;

        //构造链表
        for(int i=1;i<n;i++){
            node[i].val = i; //编号
            node[i].next = NULL; 
            node[i-1].next = &node[i]; 
            node[i].parent = &node[i-1];
        }
        node[n-1].next = &node[0];
        node[0].parent = &node[n-1];
        
        //模拟
        int num = n; //还剩下的人数
        Node *head = &node[0]; //头节点
        //在只剩下一个人的时候停止模拟
        while(num > 1){
            // 找到第m个
            int count = 0;
            while(count < m-1){
                head = head->next;
                count ++;
            }
            //找到了第m个 开始删除
            head->parent->next = head->next; 
            head->next->parent = head->parent;
            head = head->next;
            num --; // 剩余人数减1
        }
        return head->val;
    }
};

这种算法时间复杂度为O(mn)，空间复杂度为O(n)。

解法二--数学推导

感觉应该存在某种规律，但我等数学渣渣并不能够推导出来。

看完书上的解答，表示有点绕，现在用自己的话解释一遍：

f(n,m):表示 每次在n个数字0，1,...,n-1中删除第m个数字最后剩下的数字（也就是要求的结果）。（注意，要求数字标号需要是连续的，所以后面删除一个元素后标号不连续了，需要重新标号）。

在这n个数字中，第一个被删除的数字是 (m-1)%n (取余的原因是m可能比n大)，记作k，则k=(m-1)%n。删除后的序列为 0,1,...,k-1,k+1,...,n-1。由于下一次删除是从k+1开始计数的，所以相当于从标号为k+1,k+2,...,n-1,0,1,2,...,k-1的序列中继续删除第m个数字，最终剩下的数字就是结果。

剩下的n-1个数字如果重新按顺序标号得到序列0,1,...,n-2，则每次删除第m个数，最后剩下的数字就是f(n-1,m)。由于重新标号了，所以并不是f(n,m)=f(n-1,m)! 那么f(n-1,m)对应的数字在修改标号之前是什么数呢？

事实上，原先的不连续的序列A(k+1,k+2,...,n-1,0,1,2,...,k-1)变成了序列B(0,1,...,n-2)，而我们主要是想知道如何从序列B中的某个数找到序列A中对应的关系，先建立个映射表格：

B序列	序列A
0	k+1
1	k+2
n-k-2	n-1
n-k-1	0
n-k	1
n-2	k-1
f(n-1,m)	(f(n-1,m)+k+1)%n

根据表格，可以很直观的看出，在B序列中数字x，对应于A序列中的(x+k+1)%n（注意：必须取余数，因为B序列中为n-k,而n-k+k+1为n+1,必须取余数才能得到1）。所以在B序列中标号为f(n-1,m)，对于在A序列中就为(f(n-1,m)+k+1)%n。

还记得k吗，k就是在第一次删除的时候删掉的数(与n有关的变量)，k=(m-1)%n。

将其带入上面的式子，就得到:

(f(n-1,m)+k+1)%n = (f(n-1,m)+(m-1)+1)%n = (f(n-1,m)+m)%n

因此，我们就得到了这个递归公式，而当n=1的时候，也就是序列中只有标号为0的数字，显然最后剩下的数字就是0，所以整个公式就是：

根据这个公式，写代码就很简单了。

class Solution {
public:
    int LastRemaining_Solution(int n, int m)
    {
        if(m == 0 || n == 0)
            return -1; // 无效情况返回-1
        int last = 0;
        for(int i=2;i<=n;i++)
            last = (last+m) % i;
        return last;
    }
};

这种算法的时间复杂度是O(n)，空间复杂度是O(1)，远远优于第一种算法，但是推导复杂，数学渣渣表示如果没见过这个题，绝对推导不出来。。。

总结

使用链表模拟的常规解法必须掌握，数学推导，那就看状态吧。。

我的简书链接

参考

剑指offer第二版--面试题62