算法与数据结构 --- 约瑟夫环变种（双向）

题目简述

假设现在有n个人，围成一个从1到n的环。
先顺时针的方向数$R$个人，数到$R$的人出局，将自己手里的牌子给下一个人。然后逆时针数$L$个人，第$L$个人出局，将自己手里的牌子给下一个人（逆时针），然后再顺时针，再逆时针，直到最后剩下$max(L,R)-1$个人为止，输入为n R L，输出为最后手里令牌最多的人的序号以及令牌数量。

思考

• 注意顺序是有序的，先顺时针然后再逆时针，方向可以用一个bool变量来控制。
• 本文直接利用数组来做的，因此要注意环，当越界的时候，要将下标置于边界处。
• 出局的时候，需要将自己的令牌转移，此时注意，只是做了转移的操作，并没有将指向自己的指针进行移动，因此findFirstR或者findFirstL函数的时候，注意传递的参数哪些是引用，哪些是值传递。

代码

需要调试的时候，将DEBUG打开即可。

#include <iostream>
#include <vector>
#define DEBUG 0
using namespace std;

// 用于调试时输出res数组
void printRes(vector<int>& res)
{
    cout<<"当前的res是：";
    for(int i=0; i<res.size();++i)
    {
        cout<<res[i]<<" ";
    }
    cout<<endl;
}

void findFirstR(vector<int>& res, int s,int tmp_value_R)
{
    bool finded=false;
    for(int i=s;i<res.size();++i)
    {   
        if(res[i]!=-1)
        {
            res[i]+=tmp_value_R;
            finded=true;
            break;
        }
    }

// 没找到时，从头再开始找
    if(finded==false)
    {
        for(int i=1;i<s;++i)
        {   
            if(res[i]!=-1)
            {
                res[i]+=tmp_value_R;
                finded=true;
                break;
            }
        }
    }
}

void findFirstL(vector<int>& res, int s,int tmp_value_L)
{
    bool finded =false;
    for(int i=s;i>0;--i)
    {
        if(res[i]!=-1 && i!=s)
        {
            res[i]+=tmp_value_L;
            finded=true;
            break;
        }
    }

    if(finded==false)
    {
        for(int i=res.size()-1;i>s;--i)
        {
            if(res[i]!=-1)
            {
                res[i]+=tmp_value_L;
                finded=true;
                break;
            }   
        }
    }
}

int main()
{
    int n,R,L;
    cin>>n>>R>>L;
    // cnt 计数：当前出局的人数
    // p1,p2： 双指针，用于顺逆时针搜索出局的人
    // k_p1,k_p2: 对应于双指针的计数器，用于有效人数的计数，一到R或者L，则将对应的人踢出，并重新将计数器归0
    int cnt=0,p1=0,p2=n+1,k_p1=0,k_p2=0; 
   
   // 初始的时候的牌子数量，简单起见，下标是多少，牌子数量就是多少
    vector<int> res;
    for(int i=0;i<=n;++i)
    {
        res.emplace_back(i);
    }

	// 终止条件：最多出局的人数为maxCnt
    int maxCnt=n-max(L,R)+1;

    // tmp_R_val,tmp_L_val: 顺逆时针需要传递的令牌数量，由于当前人出局了，所以相当于有一个裁判留着他的牌子，进而给到下一个人，这个工作不由出局的人来做，相当于由一个中间人存着牌子，再由中间人去找下一个选手，把牌子转交给他
    int tmp_R_val=0;
    int tmp_L_val=0;
    bool Direction=1; // 顺逆时针
    while(cnt!=maxCnt)
    {
        // 向右传递
        if(Direction==1)
        {
            p1++;
            if(p1>n) p1=1; //如果越界了，就重新置到1
            if(res[p1]!=-1) // 没有出局
            {
                k_p1++; // 裁判开始计数，这是一个有效的人
                if(k_p1==R) // 计数到R的时候，这个人该出局了
                {
                    tmp_R_val=res[p1]; // 裁判拿着这个人的令牌
                    res[p1]=-1; // 将这个人踢出局
                    cnt++; // 踢出局的人数+1
                    findFirstR(res,p1,tmp_R_val); // 裁判来找下一个人，并转交令牌
                    if(DEBUG)
                    {
                        cout<<p1<<" ";    
                        printRes(res);
                    }
                    k_p1=0; // 裁判的计数器重新归0
                    Direction=0; // 并且指明裁判开始要逆时针工作
                }
            }
        }

        // 向左
        if (Direction==0)
        {
            p2--; // 逆时针的裁判，按逆时针去走
            if(p2<=0) p2=n; //如果走到1的位置了，就回到右边界重新走
            if(res[p2]!=-1) // 如果是有效的人
            {
                k_p2++; // 计数器+1
                if(k_p2==L) // 数到了，该出局了
                {
                    tmp_L_val=res[p2]; //没收令牌
                    res[p2]=-1; // 踢出局
                    cnt++;
                    findFirstL(res,p2,tmp_L_val); //转交令牌
                    if(DEBUG)
                    {
                        cout<<p2<<" ";
                        printRes(res);
                    }
                    k_p2=0; //计数器归零
                    Direction=1; //方向变换，告诉裁判该顺时针工作了
                }
            }
        }
    }
    
	// 输出最后令牌最多的人（下标）以及令牌数量
    int maxVal=-1;
    int index=-1;
    for(int i=0;i<res.size();++i)
    {
        if(res[i]>maxVal)
        {
            index=i;
            maxVal=res[i];
        }
    }
    cout<<index<<" "<<maxVal;
    system("pause");
    return 0;
}