C++约瑟夫问题的10种解法【学不会私信我】

最新推荐文章于 2025-03-13 17:34:31 发布
原创 最新推荐文章于 2025-03-13 17:34:31 发布
· 4.1k 阅读 · 50 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #数据结构 #c++ #开发语言 #java

目录

简介

解法一：循环链表法

解法二：数组模拟法

解法三：递归法 

解法四：数学公式法 

解法五：动态规划法

解法六：二进制法 

解法七：约瑟夫环公式法 

解法八：迭代法 

解法九：动态数组模拟法 

解法十：队列法

简介

有n个人（编号从1到n），围成一圈坐在一起。从第一个人开始报数，每报到m的人出列，然后从下一个人开始重新报数，直到最后剩下一个人为止。要求根据给定的n和m，确定最后剩下的人的编号。

约瑟夫问题有多种解法，包括使用循环链表、数组模拟、递归求解、数学公式等。其中使用队列实现的方法是比较常见的一个解法。这种方法利用队列的先进先出特性，不断将报数小于m的人重新入队，直到只剩下最后一个人。

解法一：循环链表法

#include <iostream>
using namespace std;

struct Node {
    int value;
    Node* next;
    Node(int val) : value(val), next(nullptr) {}
};

int josephus(int n, int m) {
    Node* head = new Node(1);
    Node* prev = head;
    for (int i = 2; i <= n; ++i) {
        Node* newNode = new Node(i);
        prev->next = newNode;
        prev = newNode;
    }
    prev->next = head;  // 循环链表

    Node* curr = head;
    while (curr->next != curr) {
        int count = 1;
        while (count != m-1) {
            curr = curr->next;
            ++count;
        }
        Node* temp = curr->next;
        curr->next = temp->next;
        delete temp;
        curr = curr->next;
    }

    int lastPerson = curr->value;
    delete curr;
    return lastPerson;
}

int main() {
    int n = 10;  // 人数
    int m = 3;   // 报到m的人出列
    int lastPerson = josephus(n, m);
    cout << "The last person remaining is: " << lastPerson << endl;

    return 0;
}

解法二：数组模拟法

#include <iostream>
using namespace std;

int josephus(int n, int m) {
    bool* eliminated = new bool[n];
    for (int i = 0; i < n; ++i) {
        eliminated[i] = false;
    }

    int remaining = n;  // 剩余的人数
    int index = 0;     // 当前报数的人的索引

    while (remaining > 1) {
        int count = 0;  // 报数的次数
        while (count < m) {
            if (!eliminated[index]) {
                ++count;
                if (count == m) {
                    eliminated[index] = true;
                    --remaining;
                }
            }
            index = (index + 1) % n;
        }
    }

    int lastPerson = 0;
    for (int i = 0; i < n; ++i) {
        if (!eliminated[i]) {
            lastPerson = i + 1;
            break;
        }
    }

    delete[] eliminated;
    return lastPerson;
}

int main() {
    int n = 10;  // 人数
    int m = 3;   // 报到m的人出列
    int lastPerson = josephus(n, m);
    cout << "The last person remaining is: " << lastPerson << endl;

    return 0;
}

解法三：递归法 

#include <iostream>
using namespace std;

int josephus(int n, int m) {
    if (n == 1) {
        return 1;
    } else {
        return (josephus(n - 1, m) + m - 1) % n + 1;
    }
}

int main() {
    int n = 10;  // 人数
    int m = 3;   // 报到m的人出列
    int lastPerson = josephus(n, m);
    cout << "The last person remaining is: " << lastPerson << endl;

    return 0;
}

解法四：数学公式法 

#include <iostream>
using namespace std;

int josephus(int n, int m) {
    int lastPerson = 0;
    for (int i = 2; i <= n; ++i) {
        lastPerson = (lastPerson + m) % i;
    }
    return lastPerson + 1;
}

int main() {
    int n = 10;  // 人数
    int m = 3;   // 报到m的人出列
    int lastPerson = josephus(n, m);
    cout << "The last person remaining is: " << lastPerson << endl;

    return 0;
}

解法五：动态规划法

#include <iostream>
using namespace std;

int josephus(int n, int m) {
    int dp = 0;
    for (int i = 2; i <= n; ++i) {
        dp = (dp + m) % i;
    }
    return dp + 1;
}

int main() {
    int n = 10;  // 人数
    int m = 3;   // 报到m的人出列
    int lastPerson = josephus(n, m);
    cout << "The last person remaining is: " << lastPerson << endl;

    return 0;
}

解法六：二进制法 

#include <iostream>
using namespace std;

int josephus(int n, int m) {
    int lastPerson = 0;
    for (int i = 1; i <= n; ++i) {
        lastPerson = (lastPerson + m) % i;
    }
    return lastPerson + 1;
}

int main() {
    int n = 10;  // 人数
    int m = 3;   // 报到m的人出列
    int lastPerson = josephus(n, m);
    cout << "The last person remaining is: " << lastPerson << endl;

    return 0;
}

解法七：约瑟夫环公式法 

#include <iostream>
#include <cmath>
using namespace std;

int josephus(int n, int m) {
    if (n == 1) {
        return 1;
    } else {
        return ((josephus(n - 1, m) + m - 1) % n) + 1;
    }
}

int main() {
    int n = 10;  // 人数
    int m = 3;   // 报到m的人出列
    int lastPerson = josephus(n, m);
    cout << "The last person remaining is: " << lastPerson << endl;

    return 0;
}

解法八：迭代法 

#include <iostream>
using namespace std;

int josephus(int n, int m) {
    int lastPerson = 0;
    for (int i = 2; i <= n; ++i) {
        lastPerson = (lastPerson + m) % i;
    }
    return lastPerson + 1;
}

int main() {
    int n = 10;  // 人数
    int m = 3;   // 报到m的人出列
    int lastPerson = josephus(n, m);
    cout << "The last person remaining is: " << lastPerson << endl;

    return 0;
}

解法九：动态数组模拟法 

#include <iostream>
#include <vector>
using namespace std;

int josephus(int n, int m) {
    vector<bool> eliminated(n, false);

    int remaining = n;  // 剩余的人数
    int index = 0;     // 当前报数的人的索引

    while (remaining > 1) {
        int count = 0;  // 报数的次数
        while (count < m) {
            if (!eliminated[index]) {
                ++count;
                if (count == m) {
                    eliminated[index] = true;
                    --remaining;
                }
            }
            index = (index + 1) % n;
        }
    }

    int lastPerson = 0;
    for (int i = 0; i < n; ++i) {
        if (!eliminated[i]) {
            lastPerson = i + 1;
            break;
        }
    }

    return lastPerson;
}

int main() {
    int n = 10;  // 人数
    int m = 3;   // 报到m的人出列
    int lastPerson = josephus(n, m);
    cout << "The last person remaining is: " << lastPerson << endl;

    return 0;
}

解法十：队列法

#include <iostream>
#include <queue>
using namespace std;

int josephus(int n, int m) {
    queue<int> q;
    for (int i = 1; i <= n; ++i) {
        q.push(i);
    }

    while (q.size() > 1) {
        for (int i = 1; i < m; ++i) {
            q.push(q.front());  // 报数小于 m 的人重新入队
            q.pop();
        }
        q.pop();  // 报数为 m 的人出队
    }

    return q.front();
}

int main() {
    int n = 10;  // 总人数
    int m = 3;   // 报数到 m 的人出列
    int lastPerson = josephus(n, m);
    cout << "The last person remaining is: " << lastPerson << endl;

    return 0;
}
《C/C++实战专栏》介绍
dvlinker的技术专栏
07-31 15万+
本文详细介绍《C/C++实战专栏》的主体内容构成。
C/C++程序员为什么要学习汇编？学习汇编有哪些好处？
热门推荐
dvlinker的技术专栏
05-29 4万+
本文详细讲述一个从汇编代码的角度去理解多线程编程问题实例，并详细介绍熟悉汇编代码都有哪些用处。
c++ 约瑟夫问题
a___rt___a的博客
12-20 640
什么是？约瑟夫问题：n个人围成一圈，初始编号从1~n排列，从约定编号为x的人开始报数，数到第m个人出圈，接着又从1开始报数，报到第m个数的人又退出圈，以此类推，最后圈内只剩下一个人，这个人就是赢家，求出赢家的编号。是不是有点点复杂，其实该问题归结为模拟类型的算法题，根据题目要求模拟即可。我说，一行代码解决约瑟夫问题！？？？我去别着急，我们一步一步学习。
C++ 约瑟夫（Josephus）问题
ChanJose的博客
12-31 6253
一、题目：约瑟夫问题：n个人围成一桌，数到m的人出列   二、实现方法1: 每出列一个，就往前移动数组，用求余解决到尾问题 // 每出列一个，就往前移动数组 // 用求余解决到尾问题 #include &lt;iostream&gt; void JosePhus(int n, int m, int start) {     int i, *arr = new int[n]; // 动态分...
C/C++:约瑟夫环问题的C++实现与解析
最新发布
qq_63117516的博客
03-13 305
约瑟夫环问题是一个经典的数学问题，描述了一群人围成一圈，从某个位置开始报数，数到特定数的人出列，然后从下一个人重新开始报数，直到所有人都出列。这个问题不仅在数学上有趣，也在计算机科学中有着广泛的应用，比如算法设计、数据结构等。我将通过一个C++程序来模拟约瑟夫环问题，并详细解析代码的实现逻辑。题目：n个猴子围坐一圈并按照顺时针方向从1到n编号，从第s个猴子开始进行1到m的报数，报数到第m的猴子退出报数，从紧挨它的下一个猴子重新开始1到m的报数，如此进行下去知道所有的猴子都退出为止。
约瑟夫问题求解(C++)
kenby的专栏
02-26 3761
 设有n个人站成一圈，每个人持有一个密码（正整数)。现从第t个人开始，按顺时针方向“1,2,3,4,…”循环报数，数到m1（第t个人所持密码）的人出列，然后从出列者的下一个人重新开始报数，数到m2（刚出列者所持密码）的人又出列，如此重复进行，直到n个人都出列为止。问题是：对于任意给定的n个人的原始排列顺序，求出n个人的出列顺序。输入数据从文本文件中读取。该文件有两行：第1行只有一个
约瑟夫问题（C++）
m0_59850318的博客
07-15 3244
约瑟夫问题（C++）循环算法
约瑟夫问题（c++语言）
你猜我是谁？
01-25 3832
据说著名犹太历史学家Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。
约瑟夫问题(C++)
12-16
报数分为杀1留2，即1，2，1，2报数，报1的人死，报2的人留下。 　　杀2留1，即1，2，1，2报数，报1的人留下，报2的人死。 　　约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的人的序号为5，4，6，2，3。最后剩下1号。 　　假定在圈子里前K个为好人，后K个为坏人，你的任务是确定这样的最少M，使得所有的坏人在第一个好人之前被杀掉。
C++约瑟夫环队列实现
qq_41979469的博客
07-23 3461
遵循队列的先进先出原则，通过引入队列的头文件<queue>，实现对该容器的，压入和抛出，代码量少，且容易理解。 empty();如果队列空则返回真 push( （这个里面加入你需要加入的元素或者结构体） );在末尾加入一个元素 front();返回第一个元素 back();返回最后一个元素 pop();删除第一个元素 size();...
C++实现约瑟夫环问题与指针应用解析
约瑟夫环问题是一个著名的理论问题，也被称为约瑟夫斯问题、约瑟夫循环或杀人游戏。它源自于一个传说：古罗马军队包围了犹太人的城市，即将围城期间，有一群孩子躲进一个洞中。当孩子们发现身陷困境时，他们约定围成...
约瑟夫问题c++
01-18
约瑟夫问题的详细且明了的c++的约瑟夫环的程序实现，分为四个部分。
约瑟夫问题的C++代码
07-21
约瑟夫问题的C++解决方案，挺好用的.约瑟夫问题的C++解决方案，挺好用的.
约瑟夫问题（c++）
01-11
约瑟夫问题是描述一桌人吃饭，哪个能拿到筷子的问题 隐身到可解决电梯算法，猫吃老鼠游戏等实际应用中
c++多种方法解决约瑟夫环问题
11-19
多种方法解决约瑟夫环问题，1.顺序表2.循环链表3.循环队列4.普通一位数组
内存不足引发C++程序闪退崩溃问题的分析与总结
dvlinker的技术专栏
11-25 1万+
本文在多年项目实践的基础上，详细总结一下内存不足的相关问题场景以及内存不足引发程序异常的具体原因，供大家借鉴或参考。
C++约瑟夫问题
JH_duangduang的博客
02-14 674
模拟，简单！ #include <iostream> using namespace std; int main(){ int n,m; bool a[10000]; cin>>n>>m; for(int i=1;i<=n;i++) a[i]=false; int f=0,s=0,t=0; while(f!=n){ t++; if(t==n+1) t=1; if(a[t]==false) s++; if(s==m){
Joseph约瑟夫问题（C++）
weixin_58346595的博客
03-09 1471
题目描述 The Joseph's problem is notoriously known. For those who are not familiar with the original problem: from among n people, numbered 1, 2, . . ., n, standing in circle every mth is going to be executed and only the life of the last remaining person wil
约瑟夫问题——C++
qq_42898149的博客
04-26 994
n个人围成一圈，从第一个人开始报数,数到m的人出列，再由下一个人重新从1开始报数，数到m的人再出圈，依次类推，直到所有的人都出圈，请输出依次出圈人的编号。n−1。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

浪子小院

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值