BST permütasyon

Bir BST Verilen bu BST verim verebilecek sayının tüm diziler numaralandırmak ...: Sen geriye bu yapabileceğini

Eğer (... gerekirci olmayan makinalar kullanarak) Could

1. kök yayarlar ve yayılan kümesine ekleyin.
2. nondeterministically üstüdür yayılan takımında olmayan ağacından, ancak bir öğe seçin ve yayılan setine ekleyin ve yayarlar.
3. Bütün yayılan kadar 2 tekrarlayın.

gerekirci olmayan makinalar size tüm bu diziler verecektir. Sonra onları sayabilirsiniz.

Sorunuz verilen BST için topolojik orderings sayısını sayma sorusuna eşdeğerdir.

Örneğin, BST'deki

  10
 /  \
5   20
 \7 | \
    15 30

topolojik sıralamaların seti böyle elle sayılabilir: 10 başlar her sipariş. 20 ile başlayan alt ağacı için topolojik sıralamaların sayısının iki olması: (20, 15, 30) ve (20, 30, 15). 5 ile başlayan alt ağaç tek sipariş sahiptir: (5, 7). Bu iki sekans böylece aynı BST üretmek yirmi giriş üreten, 2 x 10 interleavings yol açan keyfi bir şekilde sokulmuş olabilir. ilk 10, muhafaza (20, 15, 30) için aşağıda verilmiştir:

 10 5 7 20 15 30
 10 5 20 7 15 30
 10 5 20 15 7 30
 10 5 20 15 30 7
 10 20 5 7 15 30
 10 20 5 15 7 30
 10 20 5 15 30 7
 10 20 15 5 7 30
 10 20 15 5 30 7
 10 20 15 30 5 7

haznenin (20, 30, 15), aşağıdaki girişlerin herhangi biri aynı BST ürettiği kontrol edebilir --- benzerdir.

Bu örnekler de sıralamaların sayısını hesaplamak için yinelemeli bir kural sağlar. bir çocuklu olmayan bir yaprak düğüm, sayı çocuk için topolojik orderings sayısına eşittir için bir yaprağın için, sayı 1'dir. L | alt ağaç boyutları ile iki çocuklu bir sigara yaprak düğüm için | ve | r |., her ikisi de sahip olan L ve R sıralamalar, solunum sayısı eşittir

  l x r x INT(|L|, |R|)

L | | Nerede INT olası interleavings sayısıdır ve | R | elementler. (| L | + | R |) Bu tarafından kolayca hesaplanabilir! / (| L |! X | R |!). Yukarıdaki örnekte, aşağıdaki özyinelemeli hesaplama olsun:

  Ord(15) = 1
  Ord(30) = 1
  Ord(20) = 1 x 1 x INT(1, 1) = 2  ; INT(1, 1) = 2! / 1 = 2
  Ord(7) = 1
  Ord(5) = 1
  Ord(10) = 1 x 2 x INT(2, 3) = 2 x 5! / (2! x 3!) = 2 x 120 / 12 = 2 x 10 = 20

Bu sorunu çözer.

Not: Bu çözüm BST tüm düğümler farklı anahtarlara sahip olduğunu varsayar.

açıklama antti.huima için teşekkürler! Bu beni anlamamıza yardımcı oldu. İşte bazı C ++ geçerli:

#include <vector>
#include <iostream>

using namespace std;

int factorial(int x) {
  return (x <= 1) ? 1 : x * factorial(x - 1);
}

int f(int a, int b) {
  return factorial(a + b) / (factorial(a) * factorial(b));
}

template <typename T>
int n(vector<T>& P) {
  if (P.size() <= 1) return 1;
  vector<T> L, R;
  for (int i = 1; i < P.size(); i++) {
    if (P[i] < P[0])
      L.push_back(P[i]);
    else
      R.push_back(P[i]);
  }
  return n(L) * n(R) * f(L.size(), R.size());
}

int main(int argc, char *argv[]) {
  vector<int> a = { 10, 5, 7, 20, 15, 30 };
  cout << n(a) << endl;
  return 0;
}

Eğer İkili Arama Ağacı (besbelli) ile tekrarlama, permütasyon ve kombinasyonlar ve aşinalık az bilgiye sahip, bu soru kolayca çözülebilir.

Öncelikle verilen dizisi ile bir ikili arama ağacı oluşturun. Ayrıca iyi bir resmini istiyorum ağaç görselleştirme ama dizideki aynı işlemi gerçekleştirebilir.

bu verilen dizideki ve sadece düzenleme dizi [2..N] getirilmesi gereken şekilde [1..n] arr verilen sekans, 1. elemanı kalmayı olacaktır.

varsayalım:

yastığı 1 = [0] arr daha az olan dizi [2..N] eleman sayısı.

ve,

bag2 = [0] arr daha büyük olan dizi [2..N] eleman sayısı.

İkili arama ağacı oluştururken sırayla yastığı 1 elemanların permütasyon bag2 mevcut numaraları ile bir çakışma poz olmayacağından, teker cevap hesaplanması başlamak başlayabilirsiniz için (n-1) elemanları dışında yastığı 1 elemanlarını toplayıp permutate ve daha sonra kalan ((n-1) - yastığı 1) bag2 elemanları şimdi sadece 1 bir şekilde yerleştirilebilir = . Yastığı 1 öğelerin Sipariş dizisinde bag2 elemanları için aynı şekilde aynı olması gerektiği ve olmalıdır.

İkili arama ağacı her alt ağaç yana bir BST olmak zorundadır. Benzer süreç her düğüm ameliyat ve son cevap düğüm için yerel cevabı çarpın olacaktır.

int ans = 1;
int size[1000000] = {0};

// calculate the size of tree and its subtrees before running function "fun" given below.
int calSize(struct node* root){
     if(root == NULL)
          return 0;

     int l = calSize(root->left);
     int r = calSize(root -> right);
     size[root->val] = l+r+1;
     return size[root->val]; 
}

void fun(struct node* root){
     if(root == NULL)
         return;

     int n = size[root->val];
     if(root->left){
         ans *= nCr(n-1, size[root->left]);
         ans *= 1; // (Just to understand that there is now only 1 way 
                   //to distribute the rest (n-1)-size of root->left)
     }

     fun(root->left);
     fun(root->right); 
}

int main(){
     struct node* root;

     //construct tree
     //and send the root to function "fun"

     fun(root);

     cout<<ans<<endl;
     return 0;
}