约瑟夫环

约瑟夫问题：

N个人围成一圈，第一个人从1开始报数，报M的将被杀掉，下一个人接着从1开始报。如此反复，最后剩下一个，求最后的胜利者。

思路一：

数组模拟

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <string>
#include <math.h>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <sstream>
const int INF=0x3f3f3f3f;
typedef long long LL;
const int mod=1e9+7;
//const double PI=acos(-1);
#define Bug cout<<"---------------------"<<endl
const int maxn=1e5+10;
using namespace std;

int A[maxn];

int main()
{
    int n,m;
    while(~scanf("%d %d",&n,&m))
    {
        memset(A,0,sizeof(A));
        int num=n;
        int Index=0;
        int cnt=0;
        while(num>=1)
        {
            if(A[Index]==0)
            {
                cnt++;
                if(num==1)
                {
                    printf("%d
",Index);
                    break;
                }
            }
            if(cnt==m)
            {
                num--;
                cnt=0;
                A[Index]=1;
            }
            Index++;
            if(Index==n)
                Index=0;
        }
    }
    return 0;
}

思路二：

循环链表

下方程序问题：出队时节点并没真正使出队节点释放 

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <string>
#include <math.h>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <math.h>
const int INF=0x3f3f3f3f;
typedef long long LL;
const int mod=1e9+7;
const int maxn=1e6+10;
const int maxm=1e4+10;
using namespace std;

typedef struct node
{
    int pos;//位置 
    int val;//密码 
    int flag;//是否出列的标志 
    node* next;
}people,*PN;

int main()
{
    int n,m;
    printf("请输入n和m的值：");
    scanf("%d %d",&n,&m);
    PN first,p;
    printf("请依次输入各密码：");
    for(int i=1;i<=n;i++)
    {
        PN q=(PN)malloc(sizeof(node));
        scanf("%d",&q->val);
        q->pos=i;
        q->flag=0;
        q->next=NULL;
        if(i==1)
            first=q;
        else
            p->next=q;
        p=q;
    }
    p->next=first;
    printf("出列顺序为：
");
    p=first;
    int cot=0;//计数器 
    int num=n;//人数 
    while(num)
    {
        if(p->flag==0)
            cot++;
        if(cot==m)
        {
            printf("%d ",p->pos);
            m=p->val;//重新对m赋值 
            p->flag=1;
            cot=0;
            num--;
        }
        p=p->next;    
    }
    return 0;
}

思路三：

用队列实现

#include<bits/stdc++.h>
using namespace std;

int main(){
    int n,m;
    cin>>n>>m;
    queue<int> q;
    for(int i=1;i<=n;i++){
        q.push(i);
    }
    int cnt=0;
    while(q.size()>1){
        cnt++;
        if(cnt!=m){
            q.push(q.front());
        }
        else{
            cnt=0;
        }
        q.pop();
    }
    cout<<q.front()<<endl;
}

思路四：

公式法

参考：https://blog.csdn.net/u011500062/article/details/72855826

递推公式：
f(N,M)=(f(N−1,M)+M)%N

f(N,M)表示，N个人报数，每报到M时杀掉那个人，最终胜利者的编号
f(N−1,M)表示，N-1个人报数，每报到M时杀掉那个人，最终胜利者的编号

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

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

下图表示这一过程（先忽视绿色的一行）

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

f(1,3) ：只有1个人了，那个人就是获胜者，他的下标位置是0
f(2,3)=(f(1,3)+3)%2=3%2=1：在有2个人的时候，胜利者的下标位置为1
f(3,3)=(f(2,3)+3)%3=4%3=1：在有3个人的时候，胜利者的下标位置为1
f(4,3)=(f(3,3)+3)%4=4%4=0：在有4个人的时候，胜利者的下标位置为0
……
f(11,3)=6 

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

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

注意：该方法求出的结果是数组中的下标，最终的编号还要加1

代码如下：

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <string>
#include <math.h>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <sstream>
const int INF=0x3f3f3f3f;
typedef long long LL;
const int mod=1e9+7;
//const double PI=acos(-1);
#define Bug cout<<"---------------------"<<endl
const int maxn=1e5+10;
using namespace std;

int Solve(int n,int m)
{
    int t=0;//i=1时，胜利者的下标位置为0
    for(int i=2;i<=n;i++)//递推
        t=(t+m)%i;
    return t;
}

int main()
{
    int n,m;
    while(~scanf("%d %d",&n,&m))
    {
        printf("%d
",Solve(n,m));
    }
    return 0;
}

下文摘自：https://blog.csdn.net/qq_23502651/article/details/89919817

typedef long long ll;
ll calc(int n, ll m) {
    ll p = 0;
    for (int i = 2; i <= n; i++) {
        p = (p + m) % i;
    }
    return p + 1;//
}

ll cal1(ll n, ll m, ll k) { // (k == n)equal(calc)
    ll p = m % (n - k + 1);
    if (p == 0) p = n - k + 1;
    for (ll i = 2; i <= k; i++) {
        p = (p + m - 1) % (n - k + i) + 1;
    }
    return p;
}

递归：

int ysfh(int n,int m,int k)//n个人报m，第k个出列的编号,追忆编号要+1 
{
    if(k==1) return (m-1+n)%n;
    else return (ysfh(n-1,m,k-1)+m)%n; 
}

ll cal2(ll n, ll m, ll k) {
    if (m == 1) return k;
    else {
        ll a = n - k + 1, b = 1;
        ll c = m % a, x = 0;
        if (c == 0) c = a;
        while (b + x <= k) {
            a += x, b += x, c += m * x;
            c %= a;
            if (c == 0) c = a;
            x = (a - c) / (m - 1) + 1;
        }
        c += (k - b) * m;
        c %= n;
        if (c == 0) c = n;
        return c;
    }
}

-