约瑟夫问题

目录

方法一:数组模拟

方法二:链表模拟

方法三:数学+递归


约瑟夫问题:

编号为 1 到 n 的 n 个人围成一圈。从编号为 1 的人开始报数,报到 m 的人离开。下一个人继续从 1 开始报数。

n-1 轮结束以后,只剩下一个人,问最后留下的这个人编号是多少?

方法一:数组模拟

思路:

将每个成员按照对应的编号放在数组中,然后将数组中每一个元素对应的值都初始化为一个相同的数(比如 0),然后设置一个变量记录离开的人的数量作为循环的条件。在游戏过程中,如果当前成员对应的值没有发生变化过,就继续报数,此时如果他报的数等于目标值,那么就对这个成员对应在数组中的值进行改变(比如 0 -> 1),作为其离开的标志,最后再循环遍历整个数组,输出那个始终没有发生变化的成员的编号。

约瑟夫问题_第1张图片

int ycf(int num, int target) {
    int member[10000]={0};
    int cnt=0;//记录退出的个数
    int k=-1;这里假定开始为第一个人,下标为0,编号为1,如需从编号x开始,则k=x-2
    while(cnt

方法二:链表模拟

思路:

首先要创建一个单向不带头循环链表,在创建时是先创建一个单链表,并设置头尾指针,最后单链表创建完成之后,将头尾指针连接成环。

约瑟夫问题_第2张图片

然后是删除相应的结点,我们可以使用循环的方法,循环的条件就是cur->next!=cur,即链表中只剩下一个结点。最后,返回该结点对应的值就可以了。

约瑟夫问题_第3张图片

typedef struct ListNode ListNode;

 ListNode* ListBuyNode(int x)
 {
    ListNode* node=(ListNode*)malloc(sizeof(ListNode));
    if(node==NULL)
    {
        perror("malloc");
        exit(-1);
    }
    node->val=x;
    node->next=NULL;
    return node;
 }
 //创建带环链表
 ListNode* CreateList(int n)
 {
    //创建链表
    ListNode* phead=ListBuyNode(0);
    ListNode* ptail=phead;
    for(int i=1;inext=node;
        ptail=ptail->next;
    }//创建了一个单链表
    //将尾结点和头结点连接成环
    ptail->next=phead;
    return ptail;//有尾结点就能找到头节点,返回头节点的话还需要遍历链表
 }
int iceBreakingGame(int num, int target) {
     ListNode* prev=CreateList(num);
    //进行约瑟夫游戏
    ListNode* cur=prev->next;//头结点
    int cnt=1;
    while(cur->next!=cur)
    {
        if(cnt==target)
        {
            //删除结点
            prev->next=cur->next;
            free(cur);
            cur=prev->next;
            cnt=1;//重新报数
        }
        else {
        {
            //继续报数
            prev=cur;
            cur=cur->next;
            cnt++;
        }
        }
    }
    return cur->val;

}

方法三:数学+递归

思路

题目中的要求可以表述为:给定一个长度为 num 的序列,每次向后数 target 个元素并删除,那么最终留下的是第几个元素?

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

算法

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

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

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

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

(力扣官方题解)

约瑟夫问题_第4张图片

递归:

class Solution {
    int f(int num, int target) {
        if (num == 1) {
            return 0;
        }
        int x = f(num - 1, target);
        return (target + x) % num;
    }
public:
    int iceBreakingGame(int num, int target) {
        return f(num, target);
    }
};

迭代: 

class Solution {
public:
    int iceBreakingGame(int num, int target) {
          int ans = 0;
        // 最后一轮剩下2个人,所以从2开始反推
        for (int i = 1; i <= num; i++) {
            ans = (ans + target) % i;
        }
        return ans;
    }
};

相应题目:

破冰游戏

环形链表的约瑟夫问题

你可能感兴趣的:(算法,数据结构,算法,数据结构,leetcode,链表,c++,c语言)