约瑟夫环(猴子选大王）C/C++

据说著名犹太历史学家Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。问题是，给定了和，一开始要站在什么地方才能避免被处决？Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。

问题描述： N个人围成一圈，从第K个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，K=1，M=5，被杀掉的顺序是：5，4，6，2，3。输入N, K, M，输出出环序列。

思路： 用数组a来标记是否已经出环，默认0出环标记-1。开始从第K人报数，若报M出环标记不参与下次报数。

1. 数组实现，链表实现原理相同。

#include <iostream>
using namespace std;

int main()
{
    int N, K, M;
    cin >> N >> K >> M;
    int *a = new int[N + 1];
    fill(a, a + N + 1, 0);

    //num为约瑟夫环剩余人数，count为所报数
    int p = K, count = 0, num = N;
    while (num)
    {
        //未出环的人参与报数，当count是M时出环
        if (a[p] != -1 && ++count == M)
        {
            count = 0;
            a[p] = -1; //将已出环的人标记为-1
            num--;
            cout << p << " ";
        }
        p++;                 //指针指向下一个人
        p = (p - 1) % N + 1; //p范围转成[1,N]
    }
    return 0;
}

2. 单链表实现

#include <iostream>
using namespace std;

struct Node
{
    int n;
    Node *next;
};

int main()
{
    int N, K, M;
    cin >> N >> K >> M;
    Node *head, *node, *p;
    head = new Node;
    head->next = NULL;
    p = head;
    int num = N, count = 0;
    for (size_t i = 0; i < N; i++)
    {
        node = new Node;
        node->n = K;
        p->next = node;
        p = node;
        K++;
        K = (K - 1) % N + 1;
    }
    p->next = head->next;
    delete head;
    while (num)
    {
        if (++count == M)
        {
            count = 0;
            Node *t = p->next->next;
            cout << p->next->n << " ";
            delete p->next;
            p->next = t;
            num--;
        }
        else
            p = p->next;
    }
    return 0;
}

3. 循环双链表

#include <iostream>
#include <vector>

using namespace std;

class Solution {
 public:
  vector<int> josephus(int n, int k, int m) {
    vector<int> out;
    DListNode* head = createDoubleLinkedList(n);
    while (--k > 0) {
      head = head->next;
    }
    int cnt = 0;
    while (true) {
      if (head == nullptr) {
        break;
      }
      if (++cnt == m) {
        cnt = 0;
        out.push_back(head->val);
        head = removeNode(head);
      } else {
        head = head->next;
      }
    }
    return out;
  }
 private:
  struct DListNode {
    int val;
    DListNode* prev;
    DListNode* next;
    explicit DListNode(int val = 0,
                       DListNode* prev = nullptr,
                       DListNode* next = nullptr) :
        val(val),
        prev(prev),
        next(next) {}
  };

  DListNode* createDoubleLinkedList(int n) {
    if (n == 0) {
      return nullptr;
    }
    DListNode* head = new DListNode();
    DListNode* p = head;
    for (int i = 1; i <= n; i++) {
      p->next = new DListNode(i);
      p->next->prev = p;
      p = p->next;
    }
    p->next = head->next;
    head->next->prev = p;
    delete head;
    return p->next;
  }

  DListNode* removeNode(DListNode*& node) {
    DListNode* next = node->next == node ? nullptr : node->next;
    node->next->prev = node->prev;
    node->prev->next = node->next;
    delete node;
    node = nullptr;
    return next;
  }
};

int main() {
  int n = 5, k = 1, m = 2;
  Solution solution;
  vector<int> out = solution.josephus(n, k, m);
  for (const int v : out) {
    cout << v << " ";
  }
};