约瑟夫环
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 i i 的人出圈了,那么最后出圈的人的编号会向前移动 m m m, m m m 是数到 m m m 的人出圈。
-
如果减成负数了怎么办?比如最后一个出圈的人的编号为1时,那下一个编号是多少呢?
-
循环即可,怎么循环呢?如果减成负数了,那么就一直加当前数组的长度,直到变成正数(由此得到的第一个正数肯定是合法的)
-
为了统一格式,我们可以在无论当前编号是多少,都减去 m % 长 度 m \% 长度 m%长度,再加一个长度,最后再对长度取一个模
-
比如当前编号是 k k k,当前数组长度是 n n n,那么下一个编号为: p = ( k − m % n + n ) % n p=(k-m\%n+n)\%n p=(k−m%n+n)%n
-
验证可知,这个式子是对的
-
如果要化简一下的话,
-
那这个是从前往后推,最后一个人的编号是已知的,但是事先我们并不知道,那好办,倒过来就可以了
-
从后往前推:当前编号为 k k k,当前数组长度为 n n n,那么 p = ( k + m ) % ( n + 1 ) p=(k+m)\%(n+1) p=(k+m)%(n+1)
-
当然还有其他形式,因为可以化过来化过去的嘛,其中的 n n n 的最大值是 初始长度-1
-
如果你想让 n n n 的最大值为 初始长度的话,那么就有以下式子 p = ( k + m ) % n p=(k+m)\%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;
}
暂时就这些吧