约瑟夫问题(简略版)

 在学习STL容器和模板知识点时，看到了这样一个经典的题目:

10-5 约瑟夫问题：n个骑士编号1、2、…、n，围坐在圆桌旁，编号为1的骑士从1开始报
数，报到m 的骑士出列，然后下一个位置再从1开始报数，找出最后留在圆桌的骑
土编号。
(1）编写一个函数模板，以一种顺序容器的类型作为模板参数，在模板中使用指定类
型的顺序容器求解约瑟夫问题，m、n是该函数模板的形参。
(2）分别以vector<int>、deque<int>、list<int>作为类型参数调用该函数模板，
调用时将n设为较大的数，将m设为较小的数（例如令m=100000，n=5)，观察
3种情况下调用该函数模板所需花费的时间。

话不多说，上代码(注释在代码上)

#include <iostream>
#include <vector>
#include <deque>
#include <list>
#include <ctime>
#include<algorithm>
using namespace std;

// 函数模板，参数为报数上限 m 和骑士数量 n，容器类型为模板参数
template<typename Container>
int josephusProblem(int m, int n) 
{
    Container knights;  // 创建指定类型的容器来存储骑士编号

    // 初始化容器，将骑士编号 1 到 n 放入容器中
    for (int i = 1; i <= n; ++i) 
    {
        knights.push_back(i);
    }

    int count = 0;  // 用于记录当前报数的数值
    auto it = knights.begin();  // 获取容器的起始迭代器

    // 当容器中骑士数量大于 1 时，进行循环操作
    while (knights.size() > 1) 
    {
        count++;  // 报数数值加 1

        // 如果报数达到上限 m
        if (count == m) 
        {
            it = knights.erase(it);  // 移除当前位置的骑士
            count = 0;  // 报数数值重置为 0
        }
        else 
        {
            ++it;  // 迭代器指向下一个位置
        }

        // 如果迭代器到达容器末尾，将其重置为起始位置
        if (it == knights.end()) 
        {
            it = knights.begin();
        }
    }
    // 返回最后留在容器中的骑士编号
    return knights.front();
}

int main() {
    int m = 100000;  // 报数上限
    int n = 5;  // 骑士数量

    clock_t start1 = clock();  // 记录使用 vector 容器开始的时间
    int result1 = josephusProblem<vector<int>>(m, n);  // 使用 vector 容器解决问题
    clock_t end1 = clock();  // 记录使用 vector 容器结束的时间
    
    //CLOCKS_PER_SEC 用来定义当前环境下一秒钟有多少个时钟计时单元
    double elapsed1 = double(end1 - start1) / CLOCKS_PER_SEC;  // 计算使用 vector 容器花费的时间

    // 输出使用 vector 容器的结果和花费的时间
    cout << "Using vector<int>: Result = " << result1 << ", Time elapsed: " << elapsed1 << " seconds" << endl;

    clock_t start2 = clock();  // 记录使用 deque 容器开始的时间
    int result2 = josephusProblem<deque<int>>(m, n);  // 使用 deque 容器解决问题
    clock_t end2 = clock();  // 记录使用 deque 容器结束的时间
    double elapsed2 = double(end2 - start2) / CLOCKS_PER_SEC;  // 计算使用 deque 容器花费的时间

    // 输出使用 deque 容器的结果和花费的时间
    cout << "Using deque<int>: Result = " << result2 << ", Time elapsed: " << elapsed2 << " seconds" << endl;

    clock_t start3 = clock();  // 记录使用 list 容器开始的时间
    int result3 = josephusProblem<list<int>>(m, n);  // 使用 list 容器解决问题
    clock_t end3 = clock();  // 记录使用 list 容器结束的时间
    double elapsed3 = double(end3 - start3) / CLOCKS_PER_SEC;  // 计算使用 list 容器花费的时间

    // 输出使用 list 容器的结果和花费的时间
    cout << "Using list<int>: Result = " << result3 << ", Time elapsed: " << elapsed3 << " seconds" << endl;

    return 0;
}

 

 在实际运行中，由于数据规模较小（m = 100000，n = 5），可能难以明显观察到三种容器在时间上的显著差异。但一般来说，对于频繁的插入和删除操作，list 可能会表现得更优；而随机访问时，vector 效率较高。deque 则在两端的插入和删除操作上有较好性能。具体的性能差异还会受到硬件和编译器等因素的影响。