DS实验题 击鼓传花

题目：

代码1(数组实现)：

//
//  main.cpp
//  DS-击鼓传花
//
//  Created by wasdns on 16/11/9.
//  Copyright © 2016年 wasdns. All rights reserved.
//

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string.h>
#include <string>
using namespace std;

int killman[1000];  //killer and alive man

int main()
{
    int n, m;
    
    cin >> n >> m;
    
    memset(killman, 0, sizeof(killman));
    
    int killt = 1;                  //死亡情况，如果killt=总人数，结束游戏
    killman[1] = -1;                //第一位发言差，根据题目要求首杀
    
    int rcd = 1, turn = 1;          //rcd记录存活者，turn为指针
    int cnt = 0;                    //cnt计数器，一旦为m，杀掉此时指针指向者
    
    while (1)
    {
        if (turn > n) {             //指针越界
            turn %= n;
        }
        
        if (killman[turn] == -1) {  //此时指向的人已经死亡
            turn++;
            
            continue;
        }
        
        cnt++;                      //指向的人还活着，更新计数器
        
        if (cnt == m) {             //计数器计数为m，同时指针指向的人还活着
            killman[turn] = -1;     //杀死
            
            killt++;                //总死亡人数加一
            
            rcd = turn;             //rcd记录截止目前最后一位阵亡的同学
            
            cnt = 0;                //计数器置0
            
            if (killt == n) break;  //游戏结束
        }
        
        turn++;                     //游戏还没有结束，指针后移
    }
    
    cout << rcd << endl;            //最后一位同学假死，存活
    
    return 0;
}

结果：

代码2(指针实现)：

//
//  main2.cpp
//  DS-击鼓传花
//
//  Created by wasdns on 16/11/9.
//  Copyright © 2016年 wasdns. All rights reserved.
//

#include <cstdio>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;

struct killman {
    int num;
    killman *next;
};

/*
 建立循环链表：
 */

killman* CreatCircle(int n) {
    
    killman *k;
    
    k = new killman;
    k -> next = NULL;
    k -> num = 1;
    
    killman *p1, *p2;
    
    p1 = p2 = k;
    
    for (int i = 2; i <= n; i++)
    {
        p1 = new killman;
        
        p1 -> next = NULL;
        p1 -> num = i;
        
        p2 -> next = p1;
        p2 = p1;
    }
    
    p1 -> next = k;
    
    return k;
}

/*
 根据题目要求，找到开始节点的前一个节点。
 目的是为了删除第一个节点。
 */

killman* FindKpre(killman *k)
{
    killman *p;
    p = k;
    
    while (p -> next != k) {
        p = p -> next;
    }
    
    return p;
}

/*
 杀人游戏主体：
 */

int killgame(killman *k, int m)
{
    int cnt = m;                        //计数器cnt，根据题目要求，初始置m
    
    killman *p1, *p2;                   //p1 为指向当前节点的指针；
                                        //p2 为指向前一个节点的指针。
    p1 = k;
    p2 = FindKpre(k);                   //找到开始节点的前一个节点，进行删除操作
    
    while (1)
    {
        if (cnt == m) {                 //计数器达到阈值时，删除当前节点
            
            p1 = p1 -> next;
            p2 -> next = p1;
            
            cnt = 1;                    //注意：删除之后，本质上进行了前移；
                                        //计数器置1.
            continue;
        }
        
        if (p2 -> next == p2) break;    //当出现回环(loop)的时候：
                                        //说明只剩下当前节点，游戏结束。
        
        cnt++;                          //计数器尚未溢出，指针前移，更新计数器。
        
        p2 -> next = p1;
        p2 = p1;
        
        p1 = p1 -> next;
    }
    
    return p1 -> num;                   //返回游戏的赢家
}

/*
 Debug，输出环形链表：
 */

void KPrint(killman *k) {
    
    killman *p;
    p = k -> next;
    
    while (p != k) {
        cout << "p " << p -> num << endl;
        p = p -> next;
    }
    
}

int main()
{
    int n, m;
    
    cin >> n >> m;
    
    killman *k;
    
    k = CreatCircle(n);
    
    //KPrint(k);
    
    int rcd = 1;
    
    rcd = killgame(k, m);
    
    cout << rcd << endl;
    
    return 0;
}

结果：

小结：

此题是经典的约瑟夫问题，采用ADT表，有两种实现方法：(1)指针实现 (2)数组实现。
需要注意的点是：

• 题目把第一个人直接出局
• 计数器和指针更新时的位置(更新指针之后马上更新计数器！)
• 循环结束条件

可以看到，使用环形链表的性能更优，但是实现相比数组而言更加复杂。

2016/11/9