C++之约瑟夫环

问题原型:

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

数学模型:

约瑟夫环（约瑟夫问题）：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。

(一)数组解决

#include "stdio.h"
int main()
{
	const int N_man =41;      //人数
	int arr[N_man] = {0};     //初始化每一个都为0
	int num = 0;
	int k = 1;
	int i = 0;
	for (i = 0; i<N_man; i++)
	{
		printf("%d\t", arr[i]);
	}
	printf("\n");
	while (num<N_man-2)
	{
		if (arr[i] == 0)
		{
			k+=1;
			if (k == 3)
			{
				num += 1;
				k = 0;
				arr[i] = num;
				
			}

		}
		i = (i + 1) % N_man;
	}
	for ( i=0;i<N_man;i++)
	{
		printf("%d\t ",arr[i]);
	}
	    return 0;
}

(二)链表解决

* 结构体和函数声明 */  
typedef struct _node_t  
{  
    int             n_num;  
    int             passwd;  
    struct _node_t *next;  
} node_t;  
  
/* 功能函数实现 */  
  
/* 
*  name: node_t_create 
*  params: 
*    n         [in]        输入要构造的链表的个数 
*  return: 
*    返回构造成功的环形单向链表指针 
*  notes: 
*    构造节点数量为 n 的环形单向链表 
* 
*/  
node_t * node_t_create(int n,int key[])  
{  
    node_t *p_ret   = NULL;  
      
    if (0 != n)  
    {  
        int     n_idx   = 1;  
        node_t *p_node  = NULL;  
          
        /* 构造 n 个 node_t */  
        p_node = (node_t *) malloc(n * sizeof(node_t));  
        if (NULL == p_node)  
            return NULL;  
        else  
            memset(p_node, 0, n * sizeof(node_t));  
          
        /* 内存空间申请成功 */  
        p_ret = p_node;  
        for (; n_idx < n; n_idx++)  
        {  
            p_node->n_num = n_idx;  
            p_node->passwd = key[n_idx];  
            p_node->next = p_node + 1;  
            p_node = p_node->next;  
        }  
        p_node->n_num = n;  
        p_node->passwd = key[n];  
        p_node->next = p_ret;  
    }  
      
    return p_ret;  
}  
  
/* 
*  name: main 
*  params: 
*    none 
*  return: 
*    int 
*  notes: 
*    main function 
*/  
int main()  
{  
    int     n, m;  
    node_t *p_list, *p_iter;  
    int *key;  
      
    printf("input two integers:");  
    scanf("%d %d",&n,&m);  
      
    key =(int *) malloc(n * sizeof(int));  
    int j = 1;  
    for(;j <= n; ++j)  
        scanf("%d",key+j);  
      
    /* 构造环形单向链表 */  
    p_list = node_t_create(n,key);  
      
    /* Josephus 循环取数 */  
    p_iter = p_list;  
    int k = 1;  
    int l = 1;  
      
    /* 取到第 m-1 个节点 */  
    for (; l < m - 1; l++)  
    {  
        p_iter = p_iter->next;  
    }  
      
    /* 输出第 m 个节点的值 */  
    printf("%d/n", p_iter->next->n_num);  
      
    m = p_iter->next->passwd;//保存将要删除的节点key值，作为下一次的密码用  
  
    /* 从链表中删除第 m 个节点 */  
    p_iter->next = p_iter->next->next;  
    p_iter = p_iter->next;  
  
    while (p_iter != p_iter->next)  
    {  
        int i   = 1;  
          
        /* 取到第 m-1 个节点 */  
        for (; i < m - 1; i++)  
        {  
            p_iter = p_iter->next;  
        }  
          
        /* 输出第 m 个节点的值 */  
        printf("%d/n", p_iter->next->n_num);  
        m = p_iter->next->passwd;  
        /* 从链表中删除第 m 个节点 */  
        p_iter->next = p_iter->next->next;  
        p_iter = p_iter->next;  
    }  
    printf("%d/n", p_iter->n_num);  
      
    /* 释放申请的空间 */  
    free(p_list);  
    return 0;  
}

猜你喜欢