3约瑟夫斯问题
3约瑟夫斯问题
后顺时针每隔1枚拿走2枚棋子，连续 转了10周，9次越过A.当将要第10次越 过A处棋子取走其它棋子时，小洪发 现圆周上余下20多枚棋子. 若N是14的 倍数，则圆周上还有多少枚棋子？
作业：
在一个圆周上放一枚黑色 的和1990枚白色棋子.一个 同学进行这样的操作：从 黑色开始，按顺时针方向， 每隔1枚，取走1枚.当他取 到黑子时，圆周上还剩下 多少枚棋子？
• 例2：有1000个学生坐成一圈，依次编号为1,2， 3,…，1000. 现在进行1，2，1，2，…这样报数. 1号学生报1后立即离开，2号学生报2并留下； 三号学生报1后立即离开，4号学生报2并留下； …；如此进行下去，报1的同学离开，报2的同 学留下，直到最后还剩下1个人. 问这个人的编 号是多少？
约瑟夫斯问题
• 在古代，有一个野蛮部落，将抓起来的俘 虏围成一圈，并从某人开始按顺时针方向 以自然数1，2，3， 编号，然后杀掉1号、 3号、5号如此进行下去，隔一个人杀一个 人，直至最后余下一个人为止，这个幸存 者就是约瑟夫斯.
• 例1：有1000人排成一排，依次编号为1，2，3， …，1000. 现在进行1，2，1，2，…这样报数. 1 号学生报1后立即离开，2号学生报2并留下；3号 学生报1后立即离开，4号学生报2并留下；…； 999号学生报1后立即离开，1000号学生报2并留 下；然后从2号开始重新报数，2号学生报1后立 即离开，4号学生报2并留下；…；如此进行下去 ，报1的同学离开，报2的同学留下，直到最后还 剩下1个人. 问这个人的编号是多少？
• 例3：有100张的一摞卡片，玲玲拿着它们，从 最上面的一张开始按如下的顺序进行操作：把 最上面的第一张卡片舍去，把下一张卡片放在 这一摞卡片的最下面。再把原来的第三张卡片 舍去，把下一张卡片放在最下面. 反复这样做直 到手中只剩下一张卡片，那么剩下的这张卡片 是原来那一摞卡片的第几张？
约瑟夫问题及变种
“约瑟夫”问题及若干变种例1、约瑟夫问题(Josephus)[问题描述]M只猴子要选大王，选举办法如下：所有猴子按1…M编号围坐一圈，从第1号开始按顺序1，2，…，N 报数，凡报到N的猴子退出到圈外，再从下一个猴子开始继续1~ N报数，如此循环，直到圈内只剩下一只猴子时，这只猴子就是大王。
M和N由键盘输入，1≤N,M≤10000，打印出最后剩下的那只猴子的编号。
例如，输入8 3，输出：7。
[问题分析1]这个例题是由古罗马著名史学家Josephus提出的问题演变而来的，所以通常称为Josephus(约瑟夫)问题。
在确定程序设计方法之前首先来考虑如何组织数据，由于要记录m只猴子的状态，可利用含m个元素的数组monkey来实现。
利用元素下标代表猴子的编号，元素的值表示猴子的状态，用monkey[k]=1表示第k只猴子仍在圈中，monkey[k]=0则表示第k只猴子已经出圈。
程序采用模拟选举过程的方法，设变量count表示计数器，开始报数前将count置为0，设变量current 表示当前报数的猴子编号，初始时也置为0，设变量out记录出圈猴子数，初始时也置为0。
每次报数都把monkey[current]的值加到count上，这样做的好处是直接避开了已出圈的猴子（因为它们对应的monkey[current]值为0），当count=n时，就对当前报数的猴子作出圈处理，即：monkey[current]：=0，count：=0，out：=out+1。
然后继续往下报数，直到圈中只剩一只猴子为止（即out=m-1）。
参考程序如下：program josephus1a {模拟法，用数组下标表示猴子的编号}const maxm=10000;var m,n,count,current,out,i:integer;monkey:array [1..maxm] of integer;beginwrite('Input m,n:');readln(m,n);for i:=1 to m do monkey[i]:=1;out:=0; count:=0; current:=0;while out<m-1 dobeginwhile count<n dobeginif current<m then current:=current+1 else current:=1;count:=count+monkey[current];end;monkey[current]:=0; out:=out+1; count:=0end;for i:=1 to m doif monkey[i]=1 then writeln('The monkey king is no.',i);readlnend.[运行结果]下划线表示输入Input m，n:8 3The monkey king is no.7 {时间：0秒}Input m，n:10000 1987The monkey king is no.8544 {时间：3秒}[反思]时间复杂度很大O(M*N)，对于极限数据会超时。
抽杀问题-约瑟夫问题教学内容
抽杀问题-约瑟夫问题[阅读材料]世界名题与小升初之：抽杀问题（約瑟夫问题）--马到成功老师在各类竞赛中，各类小升初考试中相关的世界名题出现的概率极高，这是由小升初与数学竞赛的特点决定，这特点便是：知识性，趣味性，思想性相结合。
先给大家介绍这一问题的由来。
据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特後，39 個犹太人与Josephus及他的朋友躲到一個洞中，39個犹太人決定宁愿死也不要被人抓到，于是決定了一个自杀方式，41個人排成一个圆圈，由第1個人开始报数，每报数到第3人该人就必須自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。
然而Josephus 和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他將朋友与自己安排在第16個与第31個位置，于是逃过了这场死亡游戏。
解法約瑟夫问题可用代数分析來求解，将这个问题扩大好了，假设现在您与m 个朋友不幸参与了这个游戏，您要如何保护您的朋友？只要画两个圆圈就可以让自己与朋友免于死亡游戏，这两个圆内圈是排列顺序，而外圈是自杀顺序，如下图所示：使用程式来求解的话，只要将阵列当作环状来处理就可以了，在陈列中由计数1开始，每找到三个无资料区就填入一个计数，直接计数來求解的話，只要將阵列当作环状来处理就可以了，在阵列中由計数1开始，每找到三个无资料区就填入一个計数，直而計数达41为止，然后將阵列由索引1开始列出，就可以得知每个位置的自杀順序，这就是約瑟夫排列，41個人报数3的約瑟夫排列如下所示：14 36 1 38 15 2 24 30 3 16 34 4 25 17 5 40 31 6 18 26 7 37 19 8 35 27 9 20 32 10 41 21 11 28 39 12 22 33 13 29 23由上可知，最后一個自杀的是在第31个位置，而倒数第二个自杀的要排在第16个位置，之前的人都死光了，所以他们也就不知道約瑟夫与他的朋友并没有遵守游戏规则了。
约瑟夫问题pascal
约瑟夫问题（有时也称为约瑟夫斯置换，是一个出现在计算机科学和数学中的问题。
在计算机编程的算法中，类似问题又称为约瑟夫环。
又称“丢手绢问题”）据说著名犹太历史学家Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。
然而Josephus 和他的朋友并不想遵从。
首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。
接着，再越过k-1个人，并杀掉第k个人。
这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。
问题是，给定了和，一开始要站在什么地方才能避免被处决？Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。
//详情请见百度百科。
[题目描述]Josephus问题是建立在历史学家Josephus的一个报告的基础之上，该报告讲述了他和40个士兵在公元67年被罗马军队包围期间签定的一个自杀协定，Josephus建议每个人杀死他的邻居，他很聪明的使自己成为这些人中的最后一个，因此获得生还。
21世纪的今天，我们将Josephus问题稍作扩展：设N个人围成一圈，依次从1到N编号，从第S号开始报数，报到K的人出列，求第T个出列的人的编号。
显然，Josephus面对的是N = 40, K = 2, S= 1, T = 40的退化情况。
[数据范围]30%的数据，K = 2100%的数据，1 <= N <= 1000000, 1<= K <= 2147483647, 1 <= S <= N, 1 <= T <= N最简单的推导方法应该是模拟。
约瑟夫问题大全
“约瑟夫”问题及若干变种林厚从例1、约瑟夫问题(Josephus)[问题描述]M只猴子要选大王，选举办法如下：所有猴子按1…M编号围坐一圈，从第1号开始按顺序1，2，…，N报数，凡报到N的猴子退出到圈外，再从下一个猴子开始继续1~ N报数，如此循环，直到圈内只剩下一只猴子时，这只猴子就是大王。
M和N由键盘输入，1≤N,M≤10000，打印出最后剩下的那只猴子的编号。
例如，输入8 3，输出：7。
[问题分析1]这个例题是由古罗马著名史学家Josephus提出的问题演变而来的，所以通常称为Josephus(约瑟夫)问题。
在确定程序设计方法之前首先来考虑如何组织数据，由于要记录m只猴子的状态，可利用含m 个元素的数组monkey来实现。
利用元素下标代表猴子的编号，元素的值表示猴子的状态，用monkey[k]=1表示第k只猴子仍在圈中，monkey[k]=0则表示第k只猴子已经出圈。
程序采用模拟选举过程的方法，设变量count表示计数器，开始报数前将count置为0，设变量current表示当前报数的猴子编号，初始时也置为0，设变量out记录出圈猴子数，初始时也置为0。
每次报数都把monkey[current]的值加到count上，这样做的好处是直接避开了已出圈的猴子（因为它们对应的monkey[current]值为0），当count=n时，就对当前报数的猴子作出圈处理，即：monkey[current]：=0，count：=0，out：=out+1。
然后继续往下报数，直到圈中只剩一只猴子为止（即out=m-1）。
参考程序如下：program josephus1a {模拟法，用数组下标表示猴子的编号}const maxm=10000;var m,n,count,current,out,i:integer;monkey:array [1..maxm] of integer;beginwrite('Input m,n:');readln(m,n);for i:=1 to m do monkey[i]:=1;out:=0; count:=0; current:=0;while out<m-1 dobeginwhile count<n dobeginif current<m then current:=current+1 else current:=1;count:=count+monkey[current];end;monkey[current]:=0; out:=out+1; count:=0end;for i:=1 to m doif monkey[i]=1 then writeln('The monkey king is no.',i);readlnend.[运行结果]下划线表示输入Input m，n:8 3The monkey king is no.7 {时间：0秒}Input m，n:10000 1987The monkey king is no.8544 {时间：3秒}[反思]时间复杂度很大O(M*N)，对于极限数据会超时。
约瑟夫问题实验报告
一、实验目的1. 理解并掌握约瑟夫问题的基本原理和解决方法。
2. 学习使用循环链表解决线性问题。
3. 提高编程能力和算法设计能力。
二、实验原理约瑟夫问题（Josephus Problem）是一个著名的数学问题，也称为约瑟夫环问题。
问题描述为：N个人围成一圈，从第一个人开始按顺时针方向报数，每数到M的人出列，然后从下一个人开始继续报数，直到所有人都出列。
我们需要找到一种方法，计算出每个人出列的顺序。
三、实验内容1. 创建一个循环链表，模拟N个人围成一圈。
2. 编写一个函数，实现报数和出列操作。
3. 输出每个人出列的顺序。
四、实验步骤1. 定义一个循环链表节点结构体，包含编号和指向下一个节点的指针。
2. 创建一个循环链表，包含N个节点，节点的编号依次为1到N。
3. 编写一个函数`kill(int m, int n)`，实现报数和出列操作：- 初始化一个指针指向第一个节点。
- 从第一个节点开始，按照报数上限M进行报数，每数到M的人出列。
- 更新指针，指向下一个节点，继续报数。
- 重复上述步骤，直到所有节点都被删除。
4. 输出每个人出列的顺序。
五、实验代码```c#include <stdio.h>#include <stdlib.h>// 定义循环链表节点结构体typedef struct Node {int number; // 节点编号struct Node next; // 指向下一个节点的指针} Node;// 创建循环链表Node create(int n) {Node head = NULL, tail = NULL, temp = NULL; for (int i = 1; i <= n; i++) {temp = (Node)malloc(sizeof(Node));temp->number = i;temp->next = NULL;if (head == NULL) {head = temp;tail = temp;} else {tail->next = temp;tail = temp;}}tail->next = head; // 形成循环链表return head;}// 输出循环链表void printList(Node head) {Node temp = head;do {printf("%d ", temp->number);temp = temp->next;} while (temp != head);printf("\n");}// 解决约瑟夫问题void josephus(int m, int n) {Node head = create(n);Node temp = head, pre = NULL;for (int i = 1; i <= n; i++) {for (int j = 1; j < m; j++) {pre = temp;temp = temp->next;}printf("%d ", temp->number);pre->next = temp->next; // 删除节点 free(temp);temp = pre->next;}printf("\n");}int main() {int m, n;printf("请输入报数上限M: ");scanf("%d", &m);printf("请输入人数N: ");scanf("%d", &n);printf("初始站队为: ");josephus(m, n);return 0;}```六、实验结果与分析通过运行实验代码，可以得到每个人出列的顺序。
小学趣味数学故事之约瑟夫问题
小学趣味数学故事之约瑟夫问题
数学中的一些美丽定理具有这样的特性: 它们极易从
事实中归纳出来, 但证明却隐藏的极深.下面是为大家收集的趣味数学故事之约瑟夫问题，供大家参考。
有一个古老的传说，有64名战士被敌人俘虏了，敌人命令它们排成一个圈，编上号码1，2，3，……64。
敌人把1号杀了，又把3号杀了，他们是隔一个杀一个这样转着圈杀。
最后剩下一个人，这个人就是约瑟夫，请问约瑟夫是多少号?
这就是数学上有名的“约瑟夫问题”。
给大家一个提示，敌人从l号开始，隔一个杀一个，第一圈把奇数号码的战士全杀死了。
剩下的32名战士需要重新编号，而敌人在第二圈杀死的是重新编排的奇数号码。
按照这个思路，看看你能不能解决这个问题?
答案解析：
由于第一圈剩下的全部是偶数号2，4，6，8，……64。
把它们全部用2除，得1，2，3，4，……32.这是第二圈重新编的号码。
第二圈杀过之后，又把奇数号码都杀掉了，还剩下16个人。
如此下去，可以想到最后剩下的必然是64号。
64=2×2×2×2×2×2，它可以连续被2整除6次，是从1
到64中质因数里2最多的数，因此，最后必然把64号剩下。
从64=2×2×2×2×2×2还可以看到，是转过6圈之后，把约瑟夫斯剩下来的。
约瑟夫环问题(Josephus)-文档资料
问题描述
• 已知n（<2^15）个人（以编号1,2，…，n 分别表示）围坐在一圆桌上，从编号为k （1≤ k≤ n）的人开始报数，数到m的那个 人出列，他的下一个人又从1开始报数，数 到m的那个人又出列，依此重复，直到圆桌 周围的人全部出列，依次输出最后三个出 列的序号。
输入格式：
第一行为一个整数T（<2^15）表示测 试次数，接着第二到T+1行分别为n，m和k 的值。 例：2 10 2 3
算法设计
Josephus jp=new Josephus(); int a[]=new int[n]; for(int i=0;i<n;i++){ a[i]=i+1; } jp.SortArray(a,n,m,k,g); } public void show(int[]b,int g){ for(int i=b.length-g;i<b.length;i++){ System.out.print(b[i]+" "); } }
输出格式：
T行最后min（n，3）个出列的编号。 结果：6 1 5
问题背景
• 这个问题是以弗拉维奥•约瑟夫斯命名的， 它是1世纪的一名犹太历史学家。他在自己 的日记中写道，他和他的40个战友被罗马 军队包围在洞中。他们讨论是自杀还是被 俘，最终决定自杀，并以抽签的方式决定 谁杀掉谁。约瑟夫斯和另外一个人是最后 两个留下的人。约瑟夫斯说服了那个人， 他们将向罗马军队投降，不再自杀。
约瑟夫斯问题
约瑟夫斯问题约瑟夫问题维基百科，⾃由的百科全书跳到导航跳到搜索约瑟夫问题（有时也称为约瑟夫斯置换），是⼀个出现在计算机科学和数学中的问题。
在计算机编程的算法中，类似问题⼜称为约瑟夫环。
⼈们站在⼀个等待被处决的圈⼦⾥。
计数从圆圈中的指定点开始，并沿指定⽅向围绕圆圈进⾏。
在跳过指定数量的⼈之后，处刑下⼀个⼈。
对剩下的⼈重复该过程，从下⼀个⼈开始，朝同⼀⽅向跳过相同数量的⼈，直到只剩下⼀个⼈，并被释放。
问题即，给定⼈数、起点、⽅向和要跳过的数字，选择初始圆圈中的位置以避免被处决。
历史这个问题是以弗拉维奥·约瑟夫命名的，他是1世纪的⼀名犹太历史学家。
他在⾃⼰的⽇记中写道，他和他的40个战友被罗马军队包围在洞中。
他们讨论是⾃杀还是被俘，最终决定⾃杀，并以抽签的⽅式决定谁杀掉谁。
约瑟夫斯和另外⼀个⼈是最后两个留下的⼈。
约瑟夫斯说服了那个⼈，他们将向罗马军队投降，不再⾃杀。
约瑟夫斯把他的存活归因于运⽓或天意，他不知道是哪⼀个。
[1]解法⽐较简单的做法是⽤循环单链表模拟整个过程，时间复杂度是O(n*m)。
如果只是想求得最后剩下的⼈，则可以⽤数学推导的⽅式得出公式。
且先看看模拟过程的解法。
Python版本-- coding: utf-8 --class Node(object):def init(self, value):self.value = valueself.next = Nonedef create_linkList(n):head = Node(1)pre = headfor i in range(2, n+1):newNode = Node(i)pre.next= newNodepre = newNodepre.next = headreturn headn = 5 #总的个数m = 2 #数的数⽬if m == 1: #如果是1的话，特殊处理，直接输出print (n)else:head = create_linkList(n)pre = Nonecur = headwhile cur.next != cur: #终⽌条件是节点的下⼀个节点指向本⾝for i in range(m-1):pre = curcur = cur.nextprint (cur.value)pre.next = cur.nextcur.next = Nonecur = pre.nextprint (cur.value)using namespace std;typedef struct _LinkNode {int value;struct _LinkNode* next;} LinkNode, *LinkNodePtr;LinkNodePtr createCycle(int total) {int index = 1;LinkNodePtr head = NULL, curr = NULL, prev = NULL;head = (LinkNodePtr) malloc(sizeof(LinkNode));head->value = index;prev = head;while (--total > 0) {curr = (LinkNodePtr) malloc(sizeof(LinkNode));curr->value = ++index;prev->next = curr;prev = curr;}curr->next = head;return head;}void run(int total, int tag) {LinkNodePtr node = createCycle(total);LinkNodePtr prev = NULL;int start = 1;int index = start;while (node && node->next) {if (index == tag) {printf("%d\n", node->value);prev = node->next;node->next = NULL;node = prev;} else {prev->next = node->next;node->next = NULL;node = prev->next;}index = start;} else {prev = node;node = node->next;index++;}}}int main() {if (argc < 3) return -1;run(atoi(argv[1]), atoi(argv[2]));return 0;}数学推导解法我们将明确解出{\displaystyle k=2}k=2时的问题。
约瑟夫问题多种解决方法
著名约瑟夫问题一
• 17世纪的法国数学家加斯帕在《数目的游戏问题》中讲了 这样一个故事：15个教徒和15 个非教徒在深海上遇险， 必须将一半的人投入海中，其余的人才能幸免于难，于是 想了一个办法：30个人围成一圆圈，从第一个人开始依次 报数，每数到第九个人就将他扔入大海，如此循环进行直 到仅余15个人为止。问怎样排法，才能使每次投入大海的 都是非教徒。题目中30个人围成一圈，因而启发我们用一 个循环的链来表示。可以使用结构数组来构成一个循环链。 结构中有两个成员，其一为指向下一个人的指针，以构成 环形的链；其二为该人是否被扔下海的标记，为1表示还 在船上。从第一个人开始对还未扔下海的人进行计数，每 数到9时，将结构中的标记改为0，表示该人已被扔下海了。 这样循环计数直到有15个人被扔下海为止
约瑟夫问题的另外一个有名的例子
• 一堆猴子都有编号，编号是1，2，3 ...m , 这群猴子（m个）按照1-m的顺序围坐一圈， 从第1开始数，每数到第N个，该猴子就要 离开此圈，这样依次下来，直到圈中只剩 下最后一只猴子，则该猴子为大王。
• 二． 基本要求： (1) 输入数据：输入 m,n m,n 为整数，n<m （2）中文提示 按照m个猴子，数n 个数的方法，输出为大 王的猴子是几号 ，建立一个函数来实现此 功能
12
• p2->next=p1; • p2=p1; •} • p2->next=head; • return head; •} • struct monkey *findout(struct monkey *start,int
n) •{ • int i; • struct monkey *p; • i=n; • p=start;
• cout<<"----------------------------------------
约瑟夫斯问题实验报告
约瑟夫斯问题实验报告学号150820127 姓名王碧辉一、问题描述1、实验题目约瑟夫斯（Josephus）问题的一种描述是：编号为1，2，…，n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。
一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始报数，报到m时停止报数。
报m 的人出列，将他的密码作为新的m值，从他在顺时针方向下一个人开始重新从1报数，如此下去，直至所有的人全部出列为止。
试设计一个程序，按出列顺序印出各人编号。
2、基本要求利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。
3、测试数据m的初值为20；n=7，7个人的密码依次为：3，1，7，2，4，8，4。
m初值为6（正确的出列顺序应为6，1，4，7，2，3，5）。
4、简述每一部分的对象、目的和要求：(1)主函数部分：对象：链表；目的：创建新链表；要求：将该链表初始化。
（2）被调函数部分：对象：结构体；目的：创建循环链表并且模拟约瑟夫斯问题；要求：让链表首尾相接，并且释放原来单链表的头结点空间。
通过该函数的调用，依次输出各结点的编号，并且符合规则。
二、需求分析1.程序所能达到的基本可能：该程序用循环链表来模拟n个人顺时针围坐一圈，用链表中的每一个结点代表一个人，结点结构体中设置两个变量，分别存放其编号以及密码。
在输入初始密码后，对该链表进行遍历，直到遍历到第m个结点，释放其空间，使其出列。
然后用被释放空间结点的密码值作为新的密码值，重复上述过程，直至所有结点被释放空间出列，链表成为空链表。
2.输入输出形式及输入值范围：程序运行后显示提示信息："Please input a data:"，提示用户输入密码信息，在输入达预定次数后自动跳出该循环，同时循环链表创建成功，在主函数中有相应的输出给予检验。
然后程序显示提示信息："Please input the number m:"，提示用户输入初始密码，程序执行结束后会输出相应的出列结点的顺序，亦即其编号。
约瑟夫问题
约瑟夫问题约瑟夫问题约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。
例如N=6，M=5，被杀掉的人的序号为5，4，6，2，3。
最后剩下1号。
假定在圈子里前K个为好人，后K个为坏人，你的任务是确定这样的最少M，使得所有的坏人在第一个好人之前被杀掉。
举个例子：有64名战士被敌人俘虏了。
敌人命令他们拍成一圆圈，编上号码1，2，3…，64。
敌人把1号杀了，又把3号杀了，他们隔着一个杀一个这样转着圈杀。
最后只剩下一个人，这个人就是约瑟夫斯。
请问约瑟夫斯是多少号？（这就是“约瑟夫斯”问题。
）这个问题解答起来比较简单：敌人从1号开始，隔一个杀一个，第一圈把所有的奇数号码的战士圈杀光了。
剩下的32名战士需要重新编号，而敌人在第二圈杀死的是重新编号的奇数号码。
由于第一圈剩下的全部是偶数号2，4，6，…，64。
把它们全部用2去除，得1，2，3，…，32。
这是第二圈编的号码。
第二圈杀过以后，又把奇数号码都杀掉了，还剩16个人。
如此下去，可以想到最后剩下的必然是64号。
$64=2^6$，它可以连续被2整除6次，是从1到64中能被2整除次数最多的数，因此，最后必然把64 号留下。
如果有65名战士被俘，敌人还是按上述的方法残杀战士，最后还会剩下约瑟夫斯吗？经过计算，很容易得到结论，不是。
因为第一个人被杀后，也就是1号被杀后，第二个被杀的是必然3号。
如果把1号排除在外，那么还剩下的仍是64人，新1号就是3号。
这样原来的2号就变成了新的64 号，所以剩下的必然是2号。
进一步的归类，不难发现如果原来有$2^k$个人，最后剩下的必然$2^k$号；如果原来有$2^k+1$个人，最后剩下2号；如果原来有$2^k+2$个人，最后剩下4号……如果原来有$2^k+m$个人，最后剩下2m号.比如：原来有100人，由于$100=64+36=2^6+36$，所以最后剩下的就是36×2=72号；又如：原来有11 1人，由于$100=64+47=2^6+47$，所以最后剩下的就是47×2=94号传说古代有一批人被蛮族俘虏了，敌人命令他们排成圆圈，编上号码1，2，3，…然后把1号杀了，把3号杀了，总之每隔一个人杀一个人，最后剩下一个人，这个人就是约瑟夫斯。
约瑟夫问题
倒推问题！
例：n=5, m=3
(0+3) mod 5 = 3 5：0(a),1(b),2(c),3(d),4(e) 2 号 c 是5个人中第一个出列 剩下4个人从3(d)开始报数，环为：3(d),4(e),0(a),1(b) 4：0(d),1(e),2(a),3(b) (1+3) mod 4 = 0 2 号 a 是4个人中第一个出列 剩下3个人从3(b)开始报数，环为：3(b),0(d),1(e) 3：0(b),1(d),2(e) (1+3) mod 3 = 1 2 号 e 是3个人中第一个出列 剩下2个人从0(b)开始报数，环为：0(b),1(d) 2：0(b),1(d) (0+3) mod 2 = 1 0 号 b 是2个人中第一个出列 剩下1个人从1(d)开始报数，环为：1(d) 0 1：0(d) 0 号 d 是1个人中第一个出列，也是最后一个出列。
n 个人构成一个环， 0, 1, 2, …, n-2, n-1 称为 n元约瑟夫环。 从 0 开始报数，假设 x 是最后一个出列的人的编号。
假设 k = m mod n 第一个出列的人编号为 k-1(当元素出现在边界时特殊处理) 0, 1, 2,…, k-2, k-1, k, k+1,…, n-2, n-1 他出列之后，剩下的 n-1 个人也构成了一个(n-1)元环: k, k+1,…, n-2, n-1, 0, 1, 2,…, k-2 从 k 开始报 0。 这 n-1 个人最后一个出列的人也是 x
// 出列n-1个人
/* 初始化状态数组 */ for i <- 1 to n step 1 do person[i] <- 1 /* n-1 个人出列 */ i <- 0 for p <- 1 to n-1 step 1 do begin j <- 0 while ( j < m ) do begin i <- (i mod n) + 1 if ( person[i] <> 0 ) then j <- j + 1 end person[i] <- 0 end /* 查找没有出列的人 */ i <- 1 while ( person[i] = 0 ) do i <- i+1 write( i )
NOIP算法：约瑟夫问题(C++)
约瑟夫问题也称为约瑟夫斯置换,在计算机编程的算法中，类似问题又称为约瑟夫环，又称“丢手绢问题”。
一、一般形式1.N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。
例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3，1。
2.有ｎ只猴子，按顺时针方向围成一圈选大王（编号从１到ｎ），从第１号开始报数，一直数到ｍ，数到ｍ的猴子退出圈外，剩下的猴子再接着从1开始报数。
就这样，直到圈内只剩下一只猴子时，这个猴子就是猴王，编程求输入ｎ，ｍ后，输出最后猴王的编号。
算法思路：模拟（1）由于对于每个人只有在与不在环中两种状态（2）开始时每个人都在环中（3）模拟过程，直到环中只剩下一人。
方法一：设立标记，每个元素标记为出队或在队中/ch0302/1748/#include<iostream>#include<algorithm>#include<cstring>#include<cstdio>using namespace std;const int maxn=310;int a[maxn];int main(){int p,num,cnt,n,m,tmp;while(scanf("%d%d",&n,&m)!=EOF&&(n!=0||m!=0)){memset(a,0,sizeof(a));p=1;for(num=1;num<=n;num++){//一共要数n轮for(cnt=1;cnt<=m;cnt++){//每一轮数到mwhile(a[p]==1)p=p%n+1;//如果指针所指已有标记指针后移tmp=p;//此时p指向环中的第cnt只猴子p=p%n+1;//指针后移}a[tmp]=1; //将第m只猴子标记}printf("%d\n",tmp);//第n轮的第m只猴子就是解}return 0;}方法二：使用数组模拟链表codevs1282 约瑟夫问题/problem/1282/#include<iostream>#include<algorithm>#include<cstring>#include<cstdio>#include<vector>using namespace std;const int maxn=30050;int a[maxn];int main(){int n,m,i,j,p;scanf("%d%d",&n,&m);for(i=1;i<n;i++)a[i]=i+1;a[n]=1;p=n;for(i=1;i<=n;i++){for(j=1;j<m;j++)p=a[p];printf("%d ",a[p]);a[p]=a[a[p]];}return 0;}二、深入探讨对于约瑟夫问题，若需要依次记录退出编号的情况：优化方法是使用线段树维护区间和，并进行单点更新。
约瑟夫斯问题求解与停车场停车问题.
实验一：约瑟夫斯问题求解一、问题描述1、实验题目约瑟夫斯（Josephus）问题的一种描述是：编号为1，2，…，n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。
一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始报数，报到m时停止报数。
报m的人出列，将他的密码作为新的m值，从他在顺时针方向下一个人开始重新从1报数，如此下去，直至所有的人全部出列为止。
试设计一个程序，按出列顺序印出各人编号。
2、基本要求利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。
3、测试数据n=7，7个人的密码依次为：3，1，7，2，4，8，4。
m初值为6（正确的出列顺序应为6，1，4，7，2，3，5）。
二、需求分析1、本程序利用循环链表结构模拟出约瑟夫斯问题中在任意人数每人任意编号情况下，各编号的出列顺序2、程序运行后显示提示信息，建立输入处理，输入n输入以及每个人的密码；m的初值。
控制输入的n、m及个人密码必为正整数。
3、建立一个输出函数，程序自动输出正确的序列。
三、概要设计为实现上述功能，用单向循环链表存储结构模拟此过程，因此需要有单向循环链表这一数据结构。
1、定义一个结点类型来储存每个人编号及密码：typedef int ElemType;typedef struct node{ElemType mima;int bianhao;struct node *next; }SLNODE;2、单向循环链表抽象数据类型定义：ADT {数据对象：SLNODE 类型数据关系：线性关系基本操作：SLNODE *initlist();//创建空链表void createfromRear( SLNODE *head,int n);//尾插法输入循环链表；利用n 来控制输入次数void DelLinkList(SLNODE *p); /* 删除p 指针指向结点的后一个结点 */void xunhuan(SLNODE *head);//循环链表｝3、主程序流程及其模块调用关系1）主函数流程2）模块调用关系主程序模块单向循环链表单元模块：实现单向循环链表的抽象数据类型四、详细设计1、单向循环链表结点类型typedef int ElemType;typedef struct node{ElemType mima;int bianhao; struct node *next;输入编号总数n 输入n 个编号密码 输入起始m 调用输出函数，输出出列顺序编号主函数模块单向循环链表单元模块}SLNODE;2、实现每个基本操作的伪码//创建空链表SLNODE *initlist(){SLNODE *head;head =(SLNODE *) malloc( sizeof(SLNODE) );head->next = NULL;return head;}//尾插法输入循环链表；void createfromRear( SLNODE *head,int n)//注意控制n>0; {SLNODE *r, *s;ElemType x;int i=1;//利用i来控制输入次数r = head;cout<<"输入第"<<i<< "个密码";cin>>x;while (x>0&&i<=n){s =(SLNODE*) malloc( sizeof(SLNODE) );s->mima =x;s->bianhao=i;r->next =s;r=s; /*r永远指向链表的最后一个结点*/r->next =NULL;i++;if(i<=n)//控制输入提示语句出现个数{cout<<"输入第"<<i<< "个密码";cin>>x;}}}//循环链表void xunhuan(SLNODE *head){SLNODE *r;r=head;while(r->next!=NULL){r=r->next;}r->next=head;}//删除函数；void DelLinkList(SLNODE *p) /* 删除p指针指向结点的后一个结点*/ { SLNODE *q;if(p->next !=NULL){ q=p->next ; /* q指向p的后继结点*/p->next=q->next; /* 修改p结点的指针域*/free(q); } /* 删除并释放结点*/}3、主函数伪码int main(){cout<<"实验名称：实验一.约瑟夫斯求解问题"<<endl;cout<<"学号：031120206"<<endl;cout<<"姓名：李希文"<<endl;cout<<"程序运行开始，";time_t rawtime;struct tm * timeinfo;time (&rawtime);timeinfo = localtime (&rawtime);printf ("Current local time and date: %s", asctime(timeinfo));SLNODE *head=NULL;head=initlist();int n,m;do//控制n>0;{cout<<"输入编号总数n";cin>>n;}while(n<=0);cout<<"输入编号密码"<<endl;createfromRear(head,n);xunhuan(head);do//控制m>0;{cout<<"输入起始m";cin>>m;}while(m<=0);cout<<"输出出列顺序编号";shuchu(head,m);cout<<endl;cout<<"程序运行结束，";printf ("Current local time and date: %s", asctime(timeinfo));system("PAUSE");return 0;}4、输出模块的伪码//输出出列顺序编号函数；void shuchu(SLNODE *head,int m){SLNODE *r=head;int j=m,i;while(j>0 && head->next!=head)//控制不再空链表时操作{i=1;//重新计数while(i<j){if(r->next==head)//循环时略过头结点r=r->next;r=r->next;i++;}if(r->next==head)//循环时略过头结点r=r->next;j=r->next->mima;cout<<r->next->bianhao<<" ";DelLinkList(r);//删除第m 个结点} }4、函数调用关系图五、调试分析实验遇到的问题以及解决的办法1）调试无问题，运行时出现了如图的问题 主函数 SLNODE *initlist();//创建空链表函数 void createfromRear( SLNODE *head,int n);//尾插法输入循环链表；利用n 来控制输入次数 void DelLinkList(SLNODE *p); /* 删除p 指针指向结点的后一个结点 */ void xunhuan(SLNODE *head);//循环链表 void shuchu(SLNODE *head,int m)//输出出列顺序编号函数；经检查：在链表插入函数中插入了新结点后少了r->next=NULL;这一步，致使存储空间无法使用。
约 瑟 夫 环 问 题 的 三 种 解 法
约瑟夫问题(数学解法及数组模拟)约瑟夫问题（有时也称为约瑟夫斯置换，是一个出现在计算机科学和数学中的问题。
在计算机编程的算法中，类似问题又称为约瑟夫环。
又称“丢手绢问题”.）据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。
然而Josephus 和他的朋友并不想遵从。
首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。
接着，再越过k-1个人，并杀掉第k个人。
这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。
问题是，给定了和，一开始要站在什么地方才能避免被处决？Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。
? 以上来自百度百科约瑟夫问题是个很有名的问题：N个人围成一个圈，从第一个人开始报数，第M个人会被杀掉，最后一个人则为幸存者，其余人都将被杀掉。
例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3，1。
约瑟夫问题其实并不难，但求解的方法多种多样；题目的变化形式也很多。
接下来我们来对约瑟夫问题进行讨论。
1.模拟解法优点 : 思维简单。
?缺点：时间复杂度高达O(m*n)当n和m的值较大时，无法短时间内得到答案。
为了叙述的方便我们将n个人编号为：1- n ，用一个数组vis 来标记是否存活：1表示死亡 0表示存活 s代表当前死亡的人数? cnt 代表当前报了数的人数用t来枚举每一个位置(当tn时 t=1将人首尾相连)? 那么我们不难得出核心代码如下：bool vis[1000]; --标记当前位置的人的存活状态int t = 0; --模拟位置int s = 0; --死亡人数int cnt = 0; --计数器if(t n) t = 1;if(!vis[t]) cnt++; --如果这里有人,计数器+1if(cnt == m) --如果此时已经等于m,这这个人死去cnt = 0; --计数器清零s++; --死亡人数+1vis[t] = 1 --标记这个位置的人已经死去coutt" "; --输出这个位置的编号}while(s != n);接下来我们来看另一种更为高效快速的解法数学解法我们将这n个人按顺时针编号为0~n-1，则每次报数到m-1的人死去，剩下的人又继续从0开始报数，不断重复，求最后幸存的人最初的编号是多少？我们只需要将最后求得的解加1就能得到原来的编号。
经典数学故事之约瑟夫问题
有⼀个古⽼的传说，有64名战⼠被敌⼈俘虏了，敌⼈命令它们排成⼀个圈，编上号码1，2，3，……64。
敌⼈把1号杀了，⼜把3号杀了，他们是隔⼀个杀⼀个这样转着圈杀。
最后剩下⼀个⼈，这个⼈就是约瑟夫，请问约瑟夫是多少号?
这就是数学上有名的“约瑟夫问题”。
给⼤家⼀个提⽰，敌⼈从l号开始，隔⼀个杀⼀个，第⼀圈把奇数号码的战⼠全杀死了。
剩下的32名战⼠需要重新编号，⽽敌⼈在第⼆圈杀死的是重新编排的奇数号码。
按照这个思路，看看你能不能解决这个问题?
答案解析：
由于第⼀圈剩下的全部是偶数号2，4，6，8，……64。
把它们全部⽤2除，得1，2，3，4，……32.这是第⼆圈重新编的号码。
第⼆圈杀过之后，⼜把奇数号码都杀掉了，还剩下16个⼈。
如此下去，可以想到最后剩下的必然是64号。
64=2×2×2×2×2×2，它可以连续被2整除6次，是从1到64中质因数⾥2最多的数，因此，最后必然把64号剩下。
从
64=2×2×2×2×2×2还可以看到，是转过6圈之后，把约瑟夫斯剩下来的。
小学生数学故事约瑟夫问题与因式分解-教育文档
小学生数学故事约瑟夫问题与因式分解
17:51:50小学生数学故事：约瑟夫问题与因式分解
有一个古老的传说，有64名战士被敌人俘虏了，敌人命令它们排成一个圈，编上号码1，2，3，……64。
敌人把1号杀了，又把3号杀了，他们是隔一个杀一个这样转着圈杀。
最后剩下一个人，这个人就是约瑟夫，请问约瑟夫是多少号？
这就是数学上有名的“约瑟夫问题”。
给大家一个提示，敌人从l号开始，隔一个杀一个，第一圈把奇数号码的战士全杀死了。
剩下的32名战士需要重新编号，而敌人在第二圈杀死的是重新编排的奇数号码。
按照这个思路，看看你能不能解决这个问题？
答案解析：
由于第一圈剩下的全部是偶数号2，4，6，8，……64。
把它们全部用2除，得1，2，3，4，……32．这是第二圈重新编的号码。
第二圈杀过之后，又把奇数号码都杀掉了，还剩下16个人。
如此下去，可以想到最后剩下的必然是64号。
64＝2×2×2×2×2×2，它可以连续被2整除6次，是从1到64中质因数里2最多的数，因此，最后必然把64号剩下。
从64＝2×2×2×2×2×2还可以看到，是转过6圈之后，把约瑟夫斯剩下来的。
2019年7月19日星期五。
抽杀问题约瑟夫问题
阅读材料世界名题与小升初之：抽杀问题约瑟夫问题--马到成功老师在各类竞赛中,各类小升初考试中相关的世界名题出现的概率极高,这是由小升初与数学竞赛的特点决定,这特点便是：知识性,趣味性,思想性相结合;先给大家介绍这一问题的由来;据说着名犹太历史学家Josephus有过以下的故事：在罗马人占领乔塔帕特後,39 个犹太人与Josephus及他的朋友躲到一个洞中,39个犹太人决定宁愿死也不要被人抓到,于是决定了一个自杀方式,41个人排成一个圆圈,由第1个人开始报数,每报数到第3人该人就必须自杀,然后再由下一个重新报数,直到所有人都自杀身亡为止;然而Josephus 和他的朋友并不想遵从,Josephus要他的朋友先假装遵从,他将朋友与自己安排在第16个与第31个位置,于是逃过了这场死亡游戏;解法约瑟夫问题可用代数分析来求解,将这个问题扩大好了,假设现在您与m个朋友不幸参与了这个游戏,您要如何保护您的朋友只要画两个圆圈就可以让自己与朋友免于死亡游戏,这两个圆内圈是排列顺序,而外圈是自杀顺序,如下图所示：使用程式来求解的话,只要将阵列当作环状来处理就可以了,在陈列中由计数1开始,每找到三个无资料区就填入一个计数,直接计数来求解的话,只要将阵列当作环状来处理就可以了,在阵列中由计数1开始,每找到三个无资料区就填入一个计数,直而计数达41为止,然后将阵列由索引1开始列出,就可以得知每个位置的自杀顺序,这就是约瑟夫排列,41个人报数3的约瑟夫排列如下所示：14 36 1 38 15 2 24 30 3 16 34 4 25 17 5 40 31 6 18 26 7 37 19 8 35 27 9 20 32 10 41 21 11 28 39 12 22 33 13 29 23由上可知,最后一个自杀的是在第31个位置,而倒数第二个自杀的要排在第16个位置,之前的人都死光了,所以他们也就不知道约瑟夫与他的朋友并没有遵守游戏规则了;小升初常见抽杀考题例举：例1：把1～999这999个自然数按顺时针的方向依次排列在一个圆圈上如下图;从1开始按顺时针的方向,保留1,擦去2；保留3,擦去4……这样每隔一个数擦去一个数,转圈擦下去;问：最后剩下一个数时,剩下的是哪个数马到成功解析：可通过找规律得出,如果有2n个数,那么转一圈擦去一半,剩下2n-1个数,起始数还是1；再转一圈擦去剩下的一半,又剩下2n-2个数,起始数还是1……转了n圈后,就剩下一个数是1;如果有2n+dd＜2n个数,那么当擦去d个数时,剩下2n个数,此时的第一个数是最后将剩下的数;因为擦去的第d个数是2d,所以2d+1就是最后剩下的整数;999=29+487,最后剩下的一个数是487×2+1=975;例2：1000个学生坐成一圈,依次编号为1,2,3,…,1000;现在进行1,2报数：1号学生报1后立即离开,2号学生报2并留下,3号学生报1后立即离开,4号学生报2并留下……学生们依次交替报1或2,凡报1的学生立即离开,报2的学生留下,如此进行下去,直到最后还剩下一个人;问：这个学生的编号是几号分析：这个问题与上面这题非常相似,只不过本例是报1的离开报2的留下,而上题相当于报1的留下报2的离开,由上题的结果可以推出本例的答案;本例中编号为1的学生离开后还剩999人,此时,如果原来报2的全部改报1并留下,原来报1的全部改报2并离开,那么,问题就与上面这题完全一样了;因为剩下999人时,第1人是2号,所以最后剩下的人的号码应比上题大1,是975＋1=976号;为了加深理解,我们重新解这道题;解：如果有2n个人,那么报完第1圈后,剩下的是2的倍数号；报完第2圈后,剩下的是22的倍数号……报完第n圈后,剩下的是2n的倍数号,此时,只剩下一人,是2n号;如果有2n＋d1≤d＜2n人,那么当有d人退出圈子后还剩下2n人;因为下一个该退出去的是2d＋1号,所以此时的第2d＋1号相当于2n人时的第1号,而2d号相当于2n人时的第2n 号,所以最后剩下的是第2d号;由1000=29＋488知,最后剩下的学生的编号是488×2=976号;例3：有100张的一摞卡片,玲玲拿着它们,从最上面的一张开始按如下的顺序进行操作：把最上面的第一张卡片舍去,把下一张卡片放在这一摞卡片的最下面;再把原来的第三张卡片舍去,把下一张卡片放在最下面;反复这样做,直到手中只剩下一张卡片,那么剩下的这张卡片是原来那一摞卡片的第几张分析与解：这100张卡片如果用线串起来,其实还是一个围成一圈的约瑟夫问题;如果上面几题的解法看不太懂,可学学这题,从最简单的情况开始找规律;下面从简单的不失题目性质的问题入手,寻找规律;列表如下：设这一摞卡片的张数为N,观察上表可知：1当N=2aa=0,1,2,3,…时,剩下的这张卡片是原来那一摞卡片的最后一张,即第2a张；2当N=2a+mm＜2a时,剩下的这张卡片是原来那一摞卡片的第2m张;取N=100,因为100=26+36,2×36=72,所以剩下这张卡片是原来那一摞卡片的第72张;总结上题及例1例2：可归纳为两种情况：1、留1,杀2类：剩下号＝总数－小于总数最大的2的次方数×2＋12、杀1,留2类：剩下号＝总数－小于总数最大的2的次方数×2记住留1要加1,杀1不用加1,总发现有学生在这点上分辨不清;因此可对照：例1：为“留1”类,可用：999－512×2＋1＝975例2：为“杀1”类,可用1000－512×2＝976例3：为“杀1”类,可用100－64×2＝72上面的512,64都是小于总数的最大的2的次方数;再看一道经变化的逆推题：例4：如下左图,七枚棋子围成一个圆圈,从①开始,每隔一个取一个,依次取走①、③、⑤、⑦、④、②,最后剩下⑥.二十枚棋子围成一个圆圈如右图,从开始,每隔一个取一个,最后将只剩下一枚棋子是⑥.实际上例就是抽杀问题的“杀1留2类”,右图可假设先从1开始取起,那根据规律留下的为：20－16×2＝8号,想留下6号得逆时针倒推2枚棋子;则最后结果为19号开始; 试试我们玩的扑克牌：例5：有两副扑克牌,每副牌的排列顺序均按头两张是大王、小王,然后是黑桃、红桃、方块、梅花四种花色排列;每种花色的牌又按1,2,3,…,J,Q,K 顺序排列;某人把按上述排列的两副扑克牌上下叠放在一起,然后把第一张丢掉,把第二张放在最底层,再把第三张丢掉,把第四张放在最底层,…….如此进行下去,直至最后只剩下一张牌;试问所剩的这张牌是哪一张解：注意到：如果手中只有64张牌,按这样规则丢牌,那么后剩下的应该是第64张牌;现在手中有108张牌,多出108－64＝44张,我们只需按此规定丢掉44张后,把88张牌放在手中牌的最底层时,这时手中牌恰为64张;这样,再丢下去,最后留下的就是原牌顺序的第88张,接下来的难点就涉及周期问题了,是哪张牌呢先去掉一副,再去掉黑桃、红桃各十三张,即为88-54-2×26＝6;按照花色排列应为方块6;来个再难点的三个数一组的题：例6：连续自然数1,2,3,…,8899排成一列;从1开始,留1划掉2和3,留4划掉5和6……这么转圈划下去,最后留下的是哪个数可仿例1与例2;这道题留1划2和3,每次留下三分之一,显然与3的N 次方有关了;当有3n 个数时,留下的数是1号;小于8899的形如3n 的数是38=6561,故从1号开始按规则划数,划了8899-6561=2338个数后,还剩下6561个数;这划去的数中的最后一个2338÷2×3=3507,故最后留下6561个数中的第一个就是3508;这道题也可归纳出一个规律：“留1,杀2,3”型留下的这个数为＝总数－小于总数的最大的3的次方数÷2×3＋1考一考：连续自然数1,2,3,…,8899排成一列;从1开始,划掉1和2,留下3,划掉4和5留下6……这么转圈划下去,最后留下的是哪个数这道题可定为“杀1,2留3”型,其中的规律与答案就留给你自己去研究了;另外在最前面约瑟夫的介绍中的类型可说成为“留1、2杀3型”你探索一下这道题有什么规律; 最后见识一下隐形抽杀问题：例7：在纸上写着一列自然数1,2,……,99,100;一次操作是指将这列数中最前面的两个数划去,然后把这两个数的和写在数列的最后面,例如一次操作后得到3,4,…,99,100,3；而两次操作后得到5,6,…,99,100,3,7;这样不断进行下去,最后将只剩下一个数;问：最后剩下的数是多少最初的100个数连同后面写下的数,纸上出现的所有数的总和是多少① ③ ② ④ ⑤ ⑥ ⑦ ① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ ⑾ ⑿ ⒀ ⒁ ⒂ ⒃ ⒄ ⒅ ⒆ ⒇马到成功解析：在每次操作过程中,数列中添加的数等于划去的两个数之和,因此数列中所有数的和保持不变,于是当最后只剩下一个数时,它就是原来的100个数之和,为1+2+…+99+100=5050;当数列中有2n个数时,经过n次操作后将被全部划去,同时出现n个新数,并且这n 个新数之和等于原来2n个数的和;这提示我们去考虑数列包含2,2 ×2,2 ×2 ×2,…项的时刻;6个2连乘是64,当经过100-64=36次操作后,原来的数1,2,…,71,36×2=72被划去,划去的数的和是1+2+…+71+72=2628;此时数列中共有64个数,并且这64个数的和与原来100个数的和相等,是5050;从该时刻起,依次再经过32,16,8,4,2,1次操作后,纸上出现的新数的个数依次为32,16,8,4,2,1;根据前面的分析,每一轮出现的所有新数的和都是5050;从数列中有64个数变为只有1个数,操作共进行了6轮;综上所述,纸上写出的所有数之和为2628+5050+5050×6=37978;学会了抽杀问题的思路再来理解这题的设计就比较容易了;。