Disjoints-set et optimisation

Disjoints-set

contour

propriété

• Une structure d'arbre
• algorithme disjoint-ensemble ne prend pas en charge un ensemble de fendage

élément

• Les représentants de yuans
  • Les éléments de la collection, utilisés pour représenter l'ensemble des
  • Tous les éléments d'un ensemble pour représenter organisés en une structure en arbre est l'élément racine
• parent [x]
  • Pour chaque élément, parent [x] x point de noeud parent dans la structure arborescente. Si x est un nœud racine, de sorte que le parent [x] = x

d'exploitation

• MakeSet
  • Initialisation disjoints-set
  • Définition d'un représentant de

  •   function MakeSet(x) // 参数 => 选定的代表元
      x.parent := x
    

• Trouver
  • Déterminer quel sous-ensemble d'éléments appartenant à renvoyer un ensemble de métadonnées représentant de l'élément appartient
  • Méthode => peut continuer à se déplacer vers le haut dans la structure d'arbre le long d'un parent [x], jusqu'à atteindre le noeud de racine
  • Déterminer si les deux appartiennent au même ensemble d'éléments, se regardent la même chose à leurs représentants de yuans

  •   function Find(x) // 参数 => 带查找的元素
      	if x.parent == x // 到达根节点
      		return x
      	else
      		return Find(x.parent)
    

• syndicat
  • Dans les deux sous-ensembles et la même collection

  •   function Union(x, y)
      	xRoot := Find(x)
      	yRoot := Find(y)
      	xRoot.parent := yRoot
    

Disjoints-set optimisation Uuion

• Et cet ensemble la méthode la plus base pour vérifier la représentation du tableau
• Performance inférieure à la méthode de la liste, parce que l'arbre pourrait créer un grave déséquilibre, certaines branches profondeur trop élevée
  • Optimisation de l'équilibre
    • Par fusion de rang

      • Ce sera toujours un petit arbre relié à un arbre plus grand

      • Rang: Profondeur

      • Affecter le temps d'exécution est la profondeur des arbres, ajouter des arbres plus petits ne seront pas augmenter au même rang sur le classement sauf si elles ont des racines plus profondes de l'arbre

      • Définie comme un seul rang de l'élément 0, lorsqu'il est combiné avec deux arbres rang est r, leur rang r + 1

      • Le pire complexité temporelle de cas de O (logN)

      •   function MakeSet(x) // 初始化
              x.parent := x
              x.rank := 0 // 并查集树结构每个节点包含秩信息
        

      •   function Union(x, y) // 合并
        	  xRoot := Find(x)
        	  yRoot := Find(y)
        	  if xRoot == yRoot
              return
        	  // x和y不在同一个集合，合并他们。
        	  if xRoot.rank < yRoot.rank
              xRoot.parent := yRoot
        	  else if xRoot.rank > yRoot.rank
        	      yRoot.parent := xRoot
        	  else
        	      yRoot.parent := xRoot
        	      xRoot.rank := xRoot.rank + 1
        

    • compression Path
      • Procédé de réalisation d'une structure d'arbre lorsque le plat « recherche »
      • Chaque noeud sur le chemin d'accès peut être connecté directement à la racine
      • Trouver récursivement dans l'arborescence, chaque noeud de la référence modifiée à la racine de l'arbre pour donner un plus plat, après l'accélération du noeud d'opération directement ou indirectement des références

      •   function Find(x)
          	if x.parent != x
          		x.parent := Find(x.parent) // 将每个节点引用到根节点
          	return x.parent
        

      • algorithme optimal progressive: Fredman et Saks explique le O temps moyen (N) en 1989 peut obtenir une disjoints-set

L'opération principale

• Les opérations ci-dessus sont supposés éléments indépendants respectivement appartenant à un ensemble distinct
• Fusionner deux ensembles disjoints
  • Définition d'un tableau de parent, x représente le nombre de parents
  • Fusionner deux ensembles disjoints qui moyen est de trouver une collection de l'ancêtre, l'ancêtre d'un autre ensemble d'un père qui lui

  •   void Union(int x, int y) {
      	xRoot = Find(x); // 找到始祖
      	yRoot = Find(y); // 找到始祖
      	if (xRoot != yRoot)
      		parent[xRoot] = yRoot; // x -> y
      }
    

• L'analyse de deux éléments appartiennent au même ensemble
  • Recherche ancêtre, l'ancêtre de la comparaison sont les mêmes

  •   bool same(int x, int y) {
      	return Find(x) == Find(y); // 比较始祖是否相同
      }
    

Et l'optimisation de recherche ensemble

• compression Path

  •   int getfather(int v) {
      	if (parent[v] == v) // 根节点
      		return v; // 返回始祖
      	else {
      		parent[v] = getfather(parent[v]); // 路径压缩【递归】
      		return parent[v]; // 返回并查集根节点
      	}
      }
    

• fusion rang
  • La profondeur minimale de la plus profonde collection d'éléments où la collection sera fusionné dans l'élément au cours de laquelle

  •   void judge(int x, int y) {
      	// 寻找始祖
      	xRoot = Find(x);
      	yRoot = Find(y);
      	if (rank[xRoot] > rank[yRoot])
      		parent[yRoot] = xRoot;
      	else {
      		parent[xRoot] = yRoot; // 以yRoot为始祖
      		if (rank[xRoot] == rank[yRoot])
      			++rank[yRoot]; // 重要的是始祖的rank，只修改始祖的，其他的不用管
      	}
      }
    

  • initialisation

    memset(rank, 0, sizeof(int)*rank_size);
    

Le temps et la complexité de l'espace

• complexité du temps
  • compression Path simultanément, par rang (rang) complexité temporelle moyenne combinée de procédure d'optimisation de chaque opération est O (N)
• complexité espace
  • O (N) N est le nombre d'éléments