约瑟夫环总结

约瑟夫环

N个人围成一圈，从第一个人开始报数，报到m的人出圈，剩下的人继续从1开始报数，报到m的人出圈，如此往复。

• 问题一：所有人都出圈，求出圈的人的编号顺序

模拟法

解法1：用一维数组模拟(时间复杂度较高)

• 既然是模拟，那么就设立一个数组，然后数到哪里，就删除哪个位置的元素
• 写法有很多，这里记录一种最简洁的vector写法，看着简洁，但是复杂度挺高的
• 代码如下

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

vector<int> a;
int n, m;

void solve() {
    int i = 0, ptr = 0;
    //这里是连续读入多组输入数据
    while (~scanf("%d%d", &n, &m)) {
        a.clear();//所以每一次都要清空
        for (i = 1; i <= n; i++) a.push_back(i);
        ptr = 0;
        while (n) {
            ptr = (ptr + m - 1) % n;//确定要删除元素的位置
            printf("%d ", a[ptr]);//先打印出来，如果删除了就打印不了了
            a.erase(a.begin() + ptr);//删除
            n--;//删除之后数组长度减一，切不可把这个写在上面变成while(n--),因为之前还要对n取模
        }
        printf("\n");
    }
}

int main(void) {
    solve();
    return 0;
}

解法2：用链表模拟

• 链表模拟也有很多写法，这里记录一种时间最快但是空间消耗较大的双向循环链表法
• 代码如下

#include <iostream>
using namespace std;

//定义结点类
class Node {
   public:
    int data;
    Node* prev;
    Node* next;
    Node(int a = 0, Node* p = nullptr, Node* n = nullptr)
        : data(a), prev(p), next(n) {}
};

//定义双向循环链表类，不用头结点，因为删除的时候很麻烦
class CList {
   public:
    CList() { head = nullptr; }
    ~CList() {}
    //定义尾插函数
    void insert_back(int val) {
        if (head == nullptr) {
            head = new Node(val);
            head->next = head;
            head->prev = head;
            return;
        }
        Node* t = head->prev;
        head->prev = new Node(val);
        head->prev->prev = t;
        head->prev->next = head;
        t->next = head->prev;
    }
    //定义删除函数，删除之后返回下一个结点的指针，删完了就返回空指针
    Node* del_node(Node* p) {
        if (p->next == p) {
            delete p;
            head = nullptr;
            return nullptr;
        }
        p->prev->next = p->next;
        p->next->prev = p->prev;
        Node* t = p->next;
        delete p;
        return t;
    }
    Node* Begin() { return head; }

   private:
    Node* head;
};

int n, m;
CList a;
void solve() {
    int i = 0, cnt = 0;
    scanf("%d%d", &n, &m);
    for (i = 1; i <= n; i++) a.insert_back(i);
    Node* ptr = a.Begin();
    while (ptr) {
        cnt++;//一直无脑的数下去就行了，不用算删除的位置
        if (cnt % m == 0) {
            printf("%d ", ptr->data);
            ptr = a.del_node(ptr);
            continue;
        }
        ptr = ptr->next;
    }
    printf("\n");
}

int main(void) {
    solve();
    return 0;
}

• 问题二：求最后一个出圈的人的编号
• 这里记录一种个人认为最快最简洁的递推法

思路

• 由于只求最后一个出圈人的编号，所以不必去模拟每一步

• 如果把每一次出圈之后的人重新排列一次，可知，最后一次出圈前，就只有一个人了，那么这个时候这个人的编号为0

• 由于这个人是最后出圈的，所以在这之前的所有状态里面，这个人都有一个编号

• 那么这些编号之间是否有什么关系呢？

• 如果我能知道这之间的关系，那么我就能从最后一个编号0向前递推，最后推到最初状态的编号，得到答案

• 下面先列出整个过程的所有状态，假设最初有8个人，数到4的时候出圈
  

• 由模拟可知，最后一个出圈的人是6，其在每一种状态下的下标在最右列给出

• 从头到尾推：可以知道，编号为 $i$ 的人出圈了，那么最后出圈的人的编号会向前移动 $m$，$m$ 是数到 $m$ 的人出圈。

• 如果减成负数了怎么办？比如最后一个出圈的人的编号为1时，那下一个编号是多少呢？

• 循环即可，怎么循环呢？如果减成负数了，那么就一直加当前数组的长度，直到变成正数（由此得到的第一个正数肯定是合法的）

• 为了统一格式，我们可以在无论当前编号是多少，都减去 $m\%长度$，再加一个长度，最后再对长度取一个模

• 比如当前编号是 $k$，当前数组长度是 $n$，那么下一个编号为：$$p=(k-m\%n+n)\%n$$

• 验证可知，这个式子是对的

• 如果要化简一下的话，

• 那这个是从前往后推，最后一个人的编号是已知的，但是事先我们并不知道，那好办，倒过来就可以了

• 从后往前推：当前编号为 $k$，当前数组长度为 $n$，那么$$p=(k+m)\%(n+1)$$

• 当然还有其他形式，因为可以化过来化过去的嘛，其中的 $n$ 的最大值是 初始长度-1

• 如果你想让 $n$ 的最大值为 初始长度的话，那么就有以下式子$$p=(k+m)\%n$$

• 我们找到一种就够用了，不过后者更简洁

• 代码如下：

#include <iostream>
using namespace std;

void solve() {
    int n, m;
    int i = 0, ans = 0;
    scanf("%d%d", &n, &m);
    for (i = 1; i <= n; i++) {
        ans = (ans + m) % i;
    }
    printf("%d\n", ans + 1);
}

int main(void) {
    solve();
    return 0;
}

• 当然你还可以把它弄成递归，核心代码就一行

#include <iostream>
using namespace std;

int f(int n, int m) { return n == 0 ? 0 : ((f(n - 1, m) + m) % n); }

void solve() {
    int n, m;
    printf("%d\n", f(n, m) + 1);
}

int main(void) {
    solve();
    return 0;
}

暂时就这些吧