约瑟夫环问题的三种解决方法

  约瑟夫环问题是一道很经典的算法题，相信大家也都很熟悉，这里我们就一起来看看一看这道经典算法题的解法。
  >约瑟夫环问题的描述如下

编号为 1-N 的 N 个士兵围坐在一起形成一个圆圈，从编号为 1 的士兵开始依次报数（1，2，3…这样依次报），数到 m 的 士兵会被杀死出列，之后的士兵再从 1 开始报数，直到最后剩下一士兵，求这个士兵的编号。

方法一：数组
  采用数组来解决这道题。
  创建一个和题目人数相等的数组，然后给数组每个元素赋值1，2 ，3…n，数组每个元素就代表一个士兵。(这里假设n=8,m=3)。

• 下面就来演示这个报数的过程： （-1表示该士兵死亡）

• 最开始：1——2——3——4——5——6——7——8

• 第一次报数完毕：1——2——-1 ——4——5——6——7——8

• 第二次报数完毕：1——2——-1 ——4——5 ——-1——7——8

• 第三次报数完毕：-1——2——-1 ——4——5——-1 ——7——8

• 第四次报数完毕：-1——2——-1 ——4——-1——-1——7——8

• 第五次报数完毕：-1——-1——-1 ——4——-1 ——-1——7——8

• 第六次报数完毕：-1——-1——-1 ——4——-1——-1——7——-1

• 第六次报数完毕：-1——-1——-1 ——-1 ——-1——-1——7——-1

最后只剩下7，也就是活下来的士兵是7号。

 这种方法思路挺简单的，不过编码也不是那么的容易。在编程过程中，要考虑数组元素是否为-1，还要控制遍历数组的临界点，特别是到了数组末尾必须重新设置下标为0重新遍历，直到最后数组中只剩下一个不为-1的元素。

下面就给出核心的算法代码

void Solution1(short* Array , int n,int m)
{
	int count = 1;						//报数标记
	int nums = 0;						//记录死掉士兵的个数
	for (int i = 0; i < n; i++)
	{
		if (Array[i] != -1 && count == m)	//报到m的士兵被杀死
		{
			count = 1;
			Array[i] = -1;
			nums++;
		}
		if (Array[i] != -1)
			count++;
		if (i == n - 1)						//到数组末尾重新设置下标为0
			i = -1;
		if (nums == n - 1)					//只剩下最后一个士兵则退出循环
			break;
	}
}

下面是主函数

#include<iostream>
using namespace std;

const int NUM = 1000;				//最大数量的士兵
int main()
{
	short Array[NUM];
	//法一：用数组方式解决
	for (int i = 0; i < NUM; i++)
		Array[i] = i+1;
	int n, m;			//n是士兵数量，m是被杀的序号
	cin >> n >> m;
	Solution1(Array, n, m);
	for (int i = 0; i < n; i++)
	{
		if (Array[i] != -1)
			cout << "剩下的士兵编号是:"<<Array[i]<<endl;
	}
}

这种做法的时间复杂度是 O(n * m), 空间复杂度是 O(n);

方法二：环形链表
  一般我们都是在学习链表的时遇到约瑟夫环问题的，所以这道题多数人会采用链表的方式去解决的。
  链表和数组其实很类似，只不过在表示杀死士兵的时候，直接删除这个节点就可以了，直到最后链表只剩下一个节点，那么这个节点的val值就是最后存活士兵的编号。

这里就不详细演示具体过程了，直接贴代码，过程和上面的数组法类似。

节点类

class List_Node
{
public:
	using  pList_Node = List_Node* ;
	int val;				//士兵编号
	pList_Node next;

public:
	List_Node()
	{
		this->val = 0;
		this->next = nullptr;
	}
	List_Node(int val)
	{
		this->val = val;
		this->next = nullptr;
	}
};

解决方案类

class Solution
{
public:
	int Solution1(List_Node::pList_Node head, int m , int n)
	{
		int count = 1;
		List_Node::pList_Node Cur = head;
		List_Node::pList_Node pre_node = nullptr;		//前驱节点

		if (m == 1 || n < 2)
			return n;
		while (Cur->next != Cur)
		{
			// 删除节点
			if (count == m) 
			{
				count = 1;
				pre_node->next = Cur->next;
				Cur = pre_node->next;
			}
			else 
			{
				count++;
				pre_node = Cur;
				Cur = Cur->next;
			}
		}
		return Cur->val;
	}

	//创建链表
	List_Node::pList_Node Create_List(int n)
	{
		List_Node::pList_Node head = new List_Node(1);
		List_Node::pList_Node last = head;
		for (int i = 1; i < n; i++)
		{
			List_Node::pList_Node nNode = new List_Node(i+1);
			last->next = nNode;
			nNode->next = head;
			last = nNode;
		}
		return head;

	}
	
};

主函数

#include<iostream>
using namespace std;
int main()
{
	//创建链表
	int n, m;
	cin >> n >> m;
	Solution solution1;
	List_Node::pList_Node head = solution1.Create_List(n);
	cout << "剩下的士兵编号是:" << solution1.Solution1(head, m , n);
	return 0;

}

这种做法的时间复杂度是 O(n * m), 空间复杂度是 O(n);

那么有没有一种更为简洁的方案呢？答案是有的，下面就来揭晓（一行代码就可以搞定 ）

方法三：递归
  相信不少人都不会想到可以用递归的思想去解决这道题。笔者之前也不知道可以用递归的思想来处理这道题，没想到用递归一行代码就可以搞定，简直不要太过分。（哈哈）
  学过算法的道友都应该直到，递归的关键就是要找到前后的的递推关系。那么就这道题而言的话，就是要找到杀死某个士兵前后每个士兵编号映射关系。
  我们定义递归函数 fun(n，m) 的返回结果是存活士兵的编号。
  当 n = 1 时，f(n, m) = 1。
  现在就是要找到 f(n，m) 和 f(n-1，m) 之间的关系。我们假设士兵数为 n, 报数到 m 的人就被处死。则刚开始的编号为

1  2   3  4  5 …m-2   m-1   m   m+1   m+2   m+3 …n

删除一个结点之后结点编号将会发生变化，现在只剩下 n - 1 个士兵。且士兵死亡前编号为 m + 1, m + 2, m + 3 的士兵成了编号为 1， 2， 3 的节点。

假设 pre 为删除之前的节点编号， now 为删除了一个节点之后的编号，则 pre 与 now之间的关系为 pre = (now + m - 1) % n + 1。

• 这里强调下为啥要+1，因为编号是从1开始的，这里避免出现pre==0的情况，所以+1
  这样我们就得到的士兵死亡前后每个士兵的编号情况，下面就可以写这个递归函数了

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

确实这一行代码就可以搞定，而且他的性能更加的好

这种做法的时间复杂度是 O(n ), 空间复杂度是 O(n);

写在最后

  如果那你觉得这篇文章对你有所帮助的话，请给笔者点个赞 ，让更多的读者看到这篇文章。先在这里感谢各位道友啦~~~