[] Structure de données en utilisant python pour résoudre le problème sous trois angles josephus

EDITORIAL 0

josephus problème est un exemple courant d'une structure de données des matériaux, le problème peut être décrite comme suit:

installer $n$ individus assis autour exige maintenant de $k$ Countin personnel, le premier rapport $m$ nombre de personnes quitter. Puis commencez à la prochaine personne de continuer à suivre les mêmes règles que le nombre de journaux et quitter jusqu'àsortie de toutmonde. ordre de sortie requis chaque numérosérie.

Un concept de solution basée sur la baie

Considérons d'abord le concept d'un tableau de taille fixe et la liste python basée sur la liste à venir vu comme un nombre fixe d'éléments dans un objet, pour modifier la valeur sans supprimer les éléments, mettre l'équivalent d'un cercle $n$ chaises, maisgensarrêtermais encore, nous pouvons donnerchacun de $1$ à $n$ Non, la position de personne avec $0$ idées exprimées sont les suivantes:

• Le premier
  établissement inclut $n$ personnel (nombre) de la liste
  pour trouver la première $k$ individus commencent
• exécuter à
  partir $k$ est le nombre de la positiondépart $m$ , rencontre l'intermédiaire $0$ puis sauter
  count $m$ puis, sa valeur à $0$
  puis continuer le cycle,circulation totale $n$ fois (parce que chaque boucle quitte une personne)

Code est la suivante:

def josephus_A(n, k, m):
    people = list(range(1, (n+1)))
    i = k-1
    for num in range(n):
        count = 0
        while count < m: 
            if people[i] > 0:
                count += 1
            if count == m:
                print(people[i], end=" ")
                people[i] = 0
            i = (i+1) % n # count只是flag，真正记的数是i
        if num < n-1:
            print(end=",", )
        else:
            print(" ")

Méthode 2 est basée sur la table de séquence

table de séquence est une table linéaire, à savoir les éléments de table sur une assez grande zone de mémoire contiguë, la position de départ du premier élément stocké dans la zone de stockage, les éléments restants sont stockées séquentiellement. table de séquence en python est Liste, avec la première solution est différente lorsque la première $m$ sortie individuelle doit fonctionner pour supprimeréléments, estl'ordre de la table. Et le tableauvous souhaitez supprimer la première solution est pas si facile, car il n'y a passupport intégré pourtableau de python, donclieu d'une liste,référence spécifique peut être faite dans le c tableau ++, si vous voulez supprimer un élément au milieu de celuici, vous devez numéroter les éléments derrière. Code est misœuvre comme suit:

def josephus_L(n, k, m):
    people = list(range(1, (n+1)))
    i=k-1
    for num in range(n,0,-1):
        i=(i+m-1)%num
        print(people.pop(i),end=", " if num>1 else "\n")

3 sur la base de la liste unique cyclique Solution

À savoir, une table de liste de liens à sens unique, typiquement c ++ est une liste liée, une seule boucle de chaîne est une chaîne extrémité reliée à l'extrémité, la table aussi linéaire, circulaire en utilisant une seule liste chaînée Cette question a enregistré $n$ individus assis autourla plusforme. Nous avons juste besoin de compter sur $m$ noeuds sont supprimés, l'opérationsuppression est relativement facile pour la liste, et ne nécessite pas i = (i + 1)%divisible partelle opération. Mais le problème est non pas comme c ++ et python qui ontsupport intégré pour la liste, il est nécessaire d'établir une liste des classes, l'établissement est tropproblèmes, mais l'opération est relativement simple, comme suit:

class LNode: # 建立链表结点
    def __init__(self,elem,next_=None):
        self.elem=elem
        self.next=next_
class LCList: # 建立循环链接表
    def __init__(self):
        self._rear=None
    def is_empty(self):
        return self._rear is None
    def prepend(self,elem): # 前端插入
        p=LNode(elem)
        if self._rear is None:
            p.next=p # 建立一个结点的环
            self._rear=p
        else:
            p.next=self._rear.next
            self._rear.next=p
    def append(self,elem): # 尾端插入
        self.prepend(elem)
        self._rear = self._rear.next
    def pop(self): # 前端弹出
        if self._rear is None:
            raise LinkedListUnderflow("in pop of CLList")
        p = self._rear.next
        if self._rear is p:
            self._rear =None
        else:
            self._rear.next=p.next
        return p.elem
    def printall(self): # 输出表元素
        if self.is_empty():
            return
        p = self._rear.next
        while True:
            print(p.elem)
            if p is self._rear:
                break
            p=p.next
class LinkedListUnderflow(ValueError): # 自定义异常
    pass
class Josephus(LCList):
    def __init__(self,n,k,m):
        LCList.__init__(self)
        for i in range(n):
            self.append(i+1)
        self.turn(k-1)
        while not self.is_empty():
            self.turn(m-1)
            print(self.pop(),end=("\n" if self.is_empty() else ", "))
    def turn(self,m):
        for i in range(m):
            self._rear = self._rear.next