约瑟夫问题（c++语言）

约瑟夫介绍：

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

17世纪的法国数学家加斯帕在《数目的游戏问题》中讲了这样一个故事：15个教徒和15 个非教徒在深海上遇险，必须将一半的人投入海中，其余的人才能幸免于难，于是想了一个办法：30个人围成一圆圈，从第一个人开始依次报数，每数到第九个人就将他扔入大海，如此循环进行直到仅余15个人为止。问怎样排法，才能使每次投入大海的都是非教徒。

【问题分析与算法设计】

约瑟夫问题并不难，求解的方法很多；题目的变化形式也很多。这里给出一种实现方法。

题目中30个人围成一圈，因而启发我们用一个循环的链来表示，可以使用结构数组来构成一个循环链。结构中有两个成员，其一为指向下一个人的指针，以构成环形的链；其二为该人是否被扔下海的标记，为0表示还在船上。从第一个人开始对还未扔下海的人进行计数，每数到9时，将结构中的标记改为1，表示该人已被扔下海了。这样循环计数直到有15个人被扔下海为止。

约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。
  假如最后剩下的活的人，也被杀了，那么被杀掉的顺序是：5，4，6，2，3，1。

分析：

（1）由于对于每个人只有死和活两种状态，因此可以用布尔型数组标记每个人的状态，可用true（或者1）表示死，false（或者0）表示活。

（2）开始时每个人都是活的，所以数组初值全部赋为false。

（3）模拟杀人过程，直到所有人都被杀死为止。

约瑟夫经典代码：

#include<bits/stdc++.h>

using namespace std;

int main(){

    bool a[101]={0};

    int n,m,i,f=0,t=0,s=0;

    cin>>n>>m;
     while(f!=n){  //直到所有人都被杀死为止    

        ++t;//逐个枚举圈中的所有位置

        if(t>n)

            t=1;//数组模拟环状，最后一个与第一个相连

        if(a[t]==0)

            s++;//第t个位置上有人则报数

        if(s==m)//当前报的数是m

        {

            s=0;//计数器清零

            cout<<t<<' ';//输出被杀人编号

            a[t]=1;//此处人已死，设置a[t]为1

            f++;//死亡人数+1

        }

    }

  return 0;

}

约瑟夫问题
约瑟夫问题是个著名的问题：N个人围成一圈，第一个人从1开始报数，报M的将被杀掉，下一个人接着从1开始报。如此反复，最后剩下一个，求最后的胜利者。
例如只有三个人，把他们叫做A、B、C，他们围成一圈，从A开始报数，假设报2的人被杀掉。

首先A开始报数，他报1。侥幸逃过一劫。
然后轮到B报数，他报2。非常惨，他被杀了
C接着从1开始报数
接着轮到A报数，他报2。也被杀死了。
最终胜利者是C
解决方案
普通解法
刚学数据结构的时候，我们可能用链表的方法去模拟这个过程，N个人看作是N个链表节点，节点1指向节点2，节点2指向节点3，……，节点N-1指向节点N，节点N指向节点1，这样就形成了一个环。然后从节点1开始1、2、3……往下报数，每报到M，就把那个节点从环上删除。下一个节点接着从1开始报数。最终链表仅剩一个节点。它就是最终的胜利者。

缺点：
要模拟整个游戏过程，时间复杂度高达O(nm)，当n，m非常大(例如上百万，上千万)的时候，几乎是没有办法在短时间内出结果的。

公式法
约瑟夫环是一个经典的数学问题，我们不难发现这样的依次报数，似乎有规律可循。为了方便导出递推式，我们重新定义一下题目。
问题： N个人编号为1，2，……，N，依次报数，每报到M时，杀掉那个人，求最后胜利者的编号。

这边我们先把结论抛出了。之后带领大家一步一步的理解这个公式是什么来的。
递推公式：
f ( N , M ) = ( f ( N − 1 , M ) + M ) % N

f ( N , M ) f(N,M)f(N,M)表示，N个人报数，每报到M时杀掉那个人，最终胜利者的编号
f ( N − 1 , M ) f(N-1,M)f(N−1,M)表示，N-1个人报数，每报到M时杀掉那个人，最终胜利者的编号
下面我们不用字母表示每一个人，而用数字。
1 、 2 、 3 、 4 、 5 、 6 、 7 、 8 、 9 、 10 、 11 1、 2 、 3、 4、5 、6、 7 、 8、 9、 10、 11
1、2、3、4、5、6、7、8、9、10、11

表示11个人，他们先排成一排，假设每报到3的人被杀掉。

刚开始时，头一个人编号是1，从他开始报数，第一轮被杀掉的是编号3的人。
编号4的人从1开始重新报数，这时候我们可以认为编号4这个人是队伍的头。第二轮被杀掉的是编号6的人。
编号7的人开始重新报数，这时候我们可以认为编号7这个人是队伍的头。第三轮被杀掉的是编号9的人。
……
第九轮时，编号2的人开始重新报数，这时候我们可以认为编号2这个人是队伍的头。这轮被杀掉的是编号8的人。
下一个人还是编号为2的人，他从1开始报数，不幸的是他在这轮被杀掉了。
最后的胜利者是编号为7的人。
下图表示这一过程（先忽视绿色的一行）

现在再来看我们递推公式是怎么得到的！
将上面表格的每一行看成数组，这个公式描述的是：幸存者在这一轮的下标位置

f ( 1 , 3 ) f(1,3)f(1,3)：只有1个人了，那个人就是获胜者，他的下标位置是0
f ( 2 , 3 ) = ( f ( 1 , 3 ) + 3 ) % 2 = 3 % 2 = 1 f(2,3)=(f(1,3)+3)%2=3%2=1f(2,3)=(f(1,3)+3)%2=3%2=1：在有2个人的时候，胜利者的下标位置为1
f ( 3 , 3 ) = ( f ( 2 , 3 ) + 3 ) % 3 = 4 % 3 = 1 f(3,3)=(f(2,3)+3)%3=4%3=1f(3,3)=(f(2,3)+3)%3=4%3=1：在有3个人的时候，胜利者的下标位置为1
f ( 4 , 3 ) = ( f ( 3 , 3 ) + 3 ) % 4 = 4 % 4 = 0 f(4,3)=(f(3,3)+3)%4=4%4=0f(4,3)=(f(3,3)+3)%4=4%4=0：在有4个人的时候，胜利者的下标位置为0
……
f ( 11 , 3 ) = 6 f(11,3)=6f(11,3)=6
很神奇吧！现在你还怀疑这个公式的正确性吗？上面这个例子验证了这个递推公式的确可以计算出胜利者的下标，下面将讲解怎么推导这个公式。
问题1： 假设我们已经知道11个人时，胜利者的下标位置为6。那下一轮10个人时，胜利者的下标位置为多少？
答： 其实吧，第一轮删掉编号为3的人后，之后的人都往前面移动了3位，胜利这也往前移动了3位，所以他的下标位置由6变成3。

问题2： 假设我们已经知道10个人时，胜利者的下标位置为3。那下一轮11个人时，胜利者的下标位置为多少？
答： 这可以看错是上一个问题的逆过程，大家都往后移动3位，所以f ( 11 , 3 ) = f ( 10 , 3 ) + 3 f(11,3)=f(10,3)+3f(11,3)=f(10,3)+3。不过有可能数组会越界，所以最后模上当前人数的个数，f ( 11 , 3 ) = （ f ( 10 , 3 ) + 3 ） % 11 f(11,3)=（f(10,3)+3）%11f(11,3)=（f(10,3)+3）%11

问题3： 现在改为人数改为N，报到M时，把那个人杀掉，那么数组是怎么移动的？
答： 每杀掉一个人，下一个人成为头，相当于把数组向前移动M位。若已知N-1个人时，胜利者的下标位置位f ( N − 1 , M ) f(N-1,M)f(N−1,M)，则N个人的时候，就是往后移动M为，(因为有可能数组越界，超过的部分会被接到头上，所以还要模N)，既f ( N , M ) = ( f ( N − 1 , M ) + M ) % n f(N,M)=(f(N-1,M)+M)%nf(N,M)=(f(N−1,M)+M)%n

**注：**理解这个递推式的核心在于关注胜利者的下标位置是怎么变的。每杀掉一个人，其实就是把这个数组向前移动了M位。然后逆过来，就可以得到这个递推式。

因为求出的结果是数组中的下标，最终的编号还要加1

下面给出代码实现：

int cir(int n,int m)
{
	int p=0;
	for(int i=2;i<=n;i++)
	{
		p=(p+m)%i;
	}
	return p+1;
}

问题来源
约瑟夫问题是以弗拉维奥·约瑟夫命名的，他是1世纪的一名犹太历史学家，他在自己的日记中写道，他和他的40个战友被罗马军队包围在洞中。他们讨论是自杀还是被俘，最终决定自杀，并以抽签的方式决定杀掉谁，约瑟夫和另外一个人是最后留下的两个人。约瑟夫说服了那个人，他们将向罗马军队投降，不再自杀。约瑟夫把他的存活归因于运气或天意，他不知道是究竟是哪一个。

约瑟夫问题是一个出现在计算机科学和数学中的问题。在计算机编程的算法中，类似问题又称为约瑟夫环。

人们站在一个等待被处决的圈子里。 计数从圆圈中的指定点开始，并沿指定方向围绕圆圈进行。 在跳过指定数量的人之后，处刑下一个人。 对剩下的人重复该过程，从下一个人开始，朝同一方向跳过相同数量的人，直到只剩下一个人，并被释放。

问题即，给定人数、起点、方向和要跳过的数字，选择初始圆圈中的位置以避免被处决。

问题描述
编号为1～N 的N个士兵站成一个圆圈（编号分别为1，2，3…N），从编号为k的士兵开始依次报数（1，2…m），数到m的士兵会出列，之后的士兵再从1开始报数。直到剩下最后一个士兵，求这个是士兵编号。

解法
比较简单的做法是用循环单链表模拟整个过程。如下图所示，由5个结点组成一圈，编号分别为1，2，3，4，5。

比如，从2号开始数3个数，即1，2，3，则4号出圈；

继续从5号开始数3个数，即1，2，3，则2号出圈；依次类推，最后一个结点为5号。

代码实现
定义一个头指针head和尾指针tail分别指向1号结点和5号结点，定义一个当前结点指向tail结点，首先找到开始报数的编号为k结点的前一个结点。继续向后遍历m次，找到出圈结点的前一个结点，这样就可以删除出圈结点，依次类推…

第1题     约瑟夫问题2  查看测评数据信息

n个人排成一圈。从某个人开始，按顺时针方向依次编号。从编号为1的人开始顺时针"一二……"报数，报到2的人退出圈子。这样不断循环下去，圈子里的人将不断减少。由于人的个数是有限的，因此最终会剩下一个人。试问最后剩下的人最开始的编号。

输入格式

一个正整数n，表示人的个数。输入数据保证数字n<=1000。

输出格式

一个正整数。它表示经过“一二……”报数后最后剩下的人的编号。

输入/输出例子1

输入：

9

输出：

3

样例解释

当n=9时，退出圈子的人的编号依次为：

2 4 6 8 1 5 9 7

最后剩下的人编号为3

#include<bits/stdc++.h>
using namespace std;
int main(){
    bool a[101]={0};
    int n,m=2,i,f=0,t=0,s=0,x=0;
    cin>>n;
    while(f!=n){ 
		++t;
		if(t>n)
			t=1;
		if(a[t]==0)
			s++;
		if(s==m){
			s=0;
			x=t;
			a[t]=1;
			f++;
		}
    }
	cout<<x;
    return 0;
}

第2题     约瑟夫"密码问题" 查看测评数据信息

编号为1、2、3、...、N的N个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。从指定编号为1的人开始，按顺时针方向自1开始顺序报数，报到指定数M时停止报数，报M的人出列，并将他的密码作为新的M值，从他在顺时针方向的下一个人开始，重新从1报数，依此类推，直至所有的人全部出列为止。第一个指定的数M，为第一个人所持有的密码。

请设计一个程序求出出列的顺序，其中N,M<=30。

输入格式

第一行1个整数 N，表示人数。

第二行N个整数，表示每人手上的密码值

输出格式

N个数，两个相邻的数字用空格隔开

输入/输出例子1

输入：

3 

2 2 2

输出：

2 1 3

输入/输出例子2

输入：

4 

3 5 2 3

输出：

3 1 2 4

#include<bits/stdc++.h>
using namespace std;
int main(){

    bool a[35]={0};
    int b[35],n,m,i, f=0, t=0, s=0;
    cin>>n;
    for(int i=1;i <= n;i++)
    cin>>b[i];
    m=b[1];
    while(f != n){ 
    ++t;
    if(t>n)
    t=1;
    if(a[t] == 0)
    s++;
    if(s == m){
    s=0;
    cout << t <<" ";
    a[t]=1;
    f++;
    m=b[t];
}

}
    return 0;
}

第3题     猴子选大王 查看测评数据信息

n只猴子要选大王，选举方法如下：所有猴子按1，2，…，n编号并按照顺序围成一圈，从第k个猴子起，由1开始报数，报到m时，该猴子就跳出圈外，下一只猴子再次由1开始报数，如此循环，直到圈内只剩下一只猴子时，这只猴子就是大王。

输入格式

三个整数，猴子总数n(n<1000)，起始报数的猴子编号为k，出局数字为m（m<100）

输出格式

猴子大王的编号

输入/输出例子1

输入：

10 5 3

输出：

8

#include<bits/stdc++.h>
using namespace std;
int main(){
    bool a[1005]={0};
    int n,m,i,f=0,t=0,s=0;
    cin>>n>>t>>m;
    t--;
    while(f!=n)
    {  //直到所有人都被杀死为止    
        t++;//逐个枚举圈中的所有位置
        if(t>n) t=1;//数组模拟环状，最后一个与第一个相连
        if(a[t]==0) s++;//第t个位置上有人则报数
        if(s==m)//当前报的数是m
        {
            s=0;//计数器清零
            a[t]=1;//此处人已死，设置a[t]为1
            f++;//死亡人数+1
        }
    }
    cout<<t;
    return 0;
}

第4题     慈善的约瑟夫  查看测评数据信息

你一定听说过约瑟夫问题吧？即从N个人中找出唯一的幸存者。现在老约瑟夫将组织一个皆大欢喜的新游戏，假设N个人站成一圈，从第1人开始交替的去掉游戏者，但只是暂时去掉（例如一开始的暂时去掉2），直到最后剩下唯一的幸存者为止。幸存者选出后，所有比幸存者号码高的人每人得到1个金币，永久性离开。其余剩下的将重复以上的游戏过程，比幸存者号码高的人每人得到1个金币后离开。经过这样的过程后，一旦人数不再减少，则最后剩下的那些人将得到2个金币。请你计算一下老约瑟夫一共要付出多少个金币？

输入格式

一行一个正整数N表示人数。

输出格式

一行一个正整数表示共需支付的金币个数。

输入/输出例子1

输入：

10

输出：

13

样例解释

1<=N<=100000

#include<bits/stdc++.h>
using namespace std;
#define N 100005
int a[N];
int main(){
	int i;
	a[1]=1;
	for(i=2;i<N;i++){
		a[i]=a[i-1]+2;
		if(a[i]>i){
			a[i]=1;
		}
	}
	for(i=1;i<N;i++){
		if(a[i]!=i){
			a[i]=a[a[i]];
		}
	}
	while(scanf("%d",&i)==1){
		printf("%d\n",a[i]+i);
		break;
	}
}

什么是约瑟夫问题？ 

约瑟夫问题：n个人围成一圈，初始编号从1~n排列，从约定编号为x的人开始报数，数到第m个人出圈，接着又从1开始报数，报到第m个数的人又退出圈，以此类推，最后圈内只剩下一个人，这个人就是赢家，求出赢家的编号。

是不是有点点复杂，其实该问题归结为模拟类型的算法题，根据题目要求模拟即可。

我说，一行代码解决约瑟夫问题！

？？？我去

别着急，我们一步一步学习

方法一：数组

在第一次遇到这个题的时候，我是用数组做的，我猜绝大多数人也都知道怎么做。方法是这样的：

用一个数组来存放 1，2，3 ... n 这 n 个编号，如图（这里我们假设n = 6, m = 3）

 然后不停着遍历数组，对于被选中的编号，我们就做一个标记，例如编号 arr[2] = 3 被选中了，那么我们可以做一个标记，例如让 arr[2] = -1，来表示 arr[2] 存放的编号已经出局的了。

然后就按照这种方法，不停着遍历数组，不停着做标记，直到数组中只有一个元素是非 -1 的，这样，剩下的那个元素就是我们要找的元素了。我演示一下吧：

这种方法简单吗？思路简单，但是编码却没那么简单，临界条件特别多，每次遍历到数组最后一个元素的时候，还得重新设置下标为 0，并且遍历的时候还得判断该元素时候是否是 -1。用这种数组的方式做，千万不要觉得很简单，编码这个过程还是挺考验人的。

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

方法二：环形链表

学过链表的人，估计都会用链表来处理约瑟夫环问题，用链表来处理其实和上面处理的思路差不多，只是用链表来处理的时候，对于被选中的编号，不再是做标记，而是直接移除，因为从链表移除一个元素的时间复杂度很低，为 O(1)。当然，上面数组的方法你也可以采用移除的方式，不过数组移除的时间复杂度为 O(n)。所以采用链表的解决方法如下：

1、先创建一个环形链表来存放元素：

2、然后一边遍历链表一遍删除，直到链表只剩下一个节点，我这里就不全部演示了 

感兴趣的友友可以自己实现以下代码，这里就不放了

下面我们来看看，是如何一行代码实现约瑟夫问题！

方法三：递归

其实这道题还可以用递归来解决，递归是思路是每次我们删除了某一个人之后，我们就对这些人重新编号，然后我们的难点就是找出删除前和删除后编号的映射关系。

我们定义递归函数 f(n，m) 的返回结果是存活士兵的编号，显然当 n = 1 时，f(n, m) = 1。假如我们能够找出 f(n，m) 和 f(n-1，m) 之间的关系的话，我们就可以用递归的方式来解决了。我们假设人员数为 n, 报数到 m 的人就自杀。则刚开始的编号为

… 1 ... m - 2

m - 1

m

m + 1

m + 2 ... n …

进行了一次删除之后，删除了编号为 m 的节点。删除之后，就只剩下 n - 1 个节点了，删除前和删除之后的编号转换关系为：

删除前 --- 删除后

… --- …

m - 2 --- n - 2

m - 1 --- n - 1

m ---- 无(因为编号被删除了)

m + 1 --- 1(因为下次就从这里报数了)

m + 2 ---- 2

… ---- …

新的环中只有 n - 1 个节点。且删除前编号为 m + 1, m + 2, m + 3 的节点成了删除后编号为 1， 2， 3 的节点。

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

 注：有些人可能会疑惑为什么不是 old = (new + m ) % n 呢？主要是因为编号是从 1 开始的，而不是从 0 开始的。如果 new + m == n的话，会导致最后的计算结果为 old = 0。所以 old = (new + m - 1) % n + 1. 这样，我们就得出 f(n, m) 与 f(n - 1, m)之间的关系了，而 f(1, m) = 1.所以我们可以采用递归的方式来做。

有n个囚犯站成一个圆圈，准备处决。首先从一个人开始报数,报到k的人被处死,剩下n-1个人继续这个过程,直到最终只剩下一个人留下.

问题是，给定了n和k，一开始要站在什么地方才能避免被处决？

 模拟实现

我们利用计算机来模拟这个过程,可以得到最后的结果.

具体的编码中,考虑到每次要随机删除一个人,用链表实现比较方便.然后又是一个圈,可以考虑用循环链表.

指针从头到尾遍历到k,删去节点,直到只剩下一个节点为止.

简单的编码如下:

#include<iostream>
using namespace std;
int *A;
int f(int n,int k)
{
    int p=1;int q=n;
    int count=n;
    while(count--)
    {
        for(int i=0;i<k-1;i++)
        {
            q=p;
            p=A[p];
        }
        A[q]=A[p];
        p=A[p];
    }
    return p;
}
int main()
{
    int n,k;
    cin>>n>>k;
    A=new int[n+1];
    for(int i=1;i<n;i++)
    {
        A[i]=i+1;
    }A[n]=1;
    cout<<f(n,k)<<endl;
    return 0;
}

 数学解法

因为k==2的时候有较多的研究,也有较直观和简单,简单到位级别的算法,我们先来考虑k==2的情况.

当k==2时,所有的偶数哥死掉了.剩下基数们,重新排列后,原来位置是x的哥,排到了(x+1)/2的位置(有兴趣的可以自己画画图).

用函数f(n)表示,当序列还有n个人的时候幸存者的位置.如下图：
 

根据上面的说法,可以得出下面公式:

N为偶数:f(N)=2*f(N/2)+1;

N为基数:f(N)=2*f((N-1)/2)+1;                                                                                       (1)

幸存者一直活到N=1的时候,即

f(1)=1;                                                                                                                           (2)

根据上面(1)(2),我们可以写出简单的递推方法,

F (1) = 1;

f (2n) = 2f (n) - 1; 当 n>1;

f (2n + 1) = 2f (n) + 1; 当 n>1;

从1->N递推,时间复杂度为O(N);

A[1]=1;
int f(int n)
{
    for(int i=2;i<=n;i++)
        A[i]=i&1?((A[i>>1]<<1)+1):(((A[i>>1])<<1)-1);
    return A[n];
}

或者用递归函数,从N->1,时间复杂度为O(logN).

int f(int n)
{
    if(!(n^1))
        return 1;
    if(n&1)
        return 2*f((n-1)/2)+1;
    else
        return 2*f(n/2)-1;
}

接着我们要推出更简洁的方法.

列出的f(N)与N如下:

N     1,    2     3     4,    5     6     7     8,    9     10    11    12    13    14    15    16,

F(N)1     1     3     1     3     5     7     1     3     5     7     9     11    13    15    1

通过观察我们能够发现,f(N)是一个基数的循环,以2^m为开头,即:

如果N=2^m+L,(0<=L<2^m),那么f(N)=2*L+1;

当然,看到2^m,我们很自然地想到要用位操作解决.

2^m,即m+1位为1;如2^3=8的二进制数就是1000.

N 的二进制表示为:N=b0b1b2b3….,其中b0表示非0的最高位.

那么2^m<N的最大2^m为b0,000000,(N-2^m)*2+1=b1b2…..b0.

也就是f(b0b1b2..)=b1b2..b0;

OK,开始编码:

int f(int n)
{
    int pos=1;int temp=1;
    for(int i=0;i<31;i++)
    {
        if(n&pos)
            temp=pos;
        pos=(pos<<1);
    }
    return ((n-temp)<<1)+1;
}

K的一般解法

之所以k==2单独拉出来讨论,是由于其简单好理解.再加上二进制的妙用简化了计算.

下面是k的一般解法.

我们考虑如下过程

1     2     3     4     5     6     …..  k-1  k     k+1  …    n-1  n

第一次编号为k的哥挂掉,然后剩下n-1个人,从k+1号继续.

k+1  k+1  ….n-1 n  1     2     3     4     5     6     ,序号全部-k,得到如下序列:

1     2     3     4     5     6…..       n-1也就是n-1个人的情况.

图示如下：

假设最后剩下的人,在第(n-1)人的序列中的编号是f(n-1),那么他在n个人的序列中,编号为(k+f(n-1))%n,也就得到了我们的递推公式:

f(n)=(k+f(n-1))%n;

f(1)=1;

递推算法的时间复杂度为O(N),编码如下:

int *A;
int f(int n,int k)
{
    A[1]=0;
    for(int i=2;i<=n;i++)
    {
        A[i]=(A[i-1]+k)%i;
    }
    return A[n]+1;
}