permutációk BST

Ehhez valójában visszafelé: Adott egy BST, felsorolni az összes tömbök egészek, amelyek így ez BST ...

Nem tudná (a nondeterminism ...)

1. bocsátanak ki, gyökér, és add meg a kibocsátott készlet.
2. nondeterministically válasszon egy elemet a fa, amely nem a kibocsátott meg, de akinek a szülő, és add meg a kibocsátott szettet, és bocsátanak ki azt.
3. ismételjük, amíg az összes 2 kibocsátásra.

A nondeterminism kapsz minden ilyen tömböket. Akkor számíthat rájuk.

A kérdés az, hogy egyenértékű a kérdést, hogy megszámoljuk a topológiai rendezéséhez az adott BST.

Például, a BST

  10
 /  \
5   20
 \7 | \
    15 30

A beállított topológiai megrendeléseknek lehet számítani kézzel, mint ez: 10 kezdődik minden rendelés. A száma topológiai rendezéséhez az részfájának kezdődő 20 két: (20, 15, 30) és (20, 30, 15). A részfa kezdve 5 csak egy rendelési: (5, 7). Ez a két szekvencia interlivelhetjük önkényesen, ami a 2 x 10 alváltozatok, ezáltal húsz bemenetek ugyanazt BST. Az első 10 az alábbiakban kerülnek részletezésre a tok (20, 15, 30):

 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

Az ügy (20, 30, 15) analóg --- akkor ellenőrizze, hogy azok az alábbi bemenetek ugyanazt az BST.

Ezek a példák is biztosít rekurzív szabály kiszámítja a száma a megrendeléseknek. Egy levél, ez a szám 1 nem levél csomópont, egy gyermek, a szám megegyezik a számát topológiai megrendeléseknek a gyermek számára. Egy nem levél csomópont kétgyermekes részfa méretben | L | és | R |, mindkettő L és R rendezésekkel, ill., a szám egyenlő a

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

Amennyiben INT a számos lehetséges alváltozatok az | L | és | R | elemekkel. Ez lehet számítani könnyen (| L | + | R |)! / (| L |! X | R |!). A fenti példa alapján, megkapjuk a következő rekurzív számítási:

  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

Ez megoldja a problémát.

Megjegyzés: ez a megoldás feltételezi, hogy minden csomópont a BST különböző kulcsokat.

Köszönöm a magyarázatot antti.huima! Ez segített megérteni. Itt van néhány C ++:

#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;
}

Ez a kérdés könnyen megoldható, ha kevés ismerete rekurzió, permutáció és kombináció, és ismerete bináris keresési fa (természetesen).

Először is építeni egy bináris keresési fa az adott szekvencia. Azt is ugyanazt a műveletet a tömbben, hanem fa-vizualizációs festeni egy jó kép.

Mert adott szekvencia arr [1..n], 1. elem lenne maradsz, ahogy azt az adott tömb, és csak az elrendezés kell hozni a tomb [2..n].

Feltételezni:

BAG1 = elemek száma arr [2..n], amelyek kevesebb, mint arr [0].

és,

bag2 = elemek száma arr [2..n], amelyek nagyobbak, mint arr [0].

Mivel a permutáció elemek BAG1 a sorozat nem jelent konfliktust a számok jelen a bag2 közben egy bináris keresési fa, el lehet kezdeni kezdődik kiszámításakor válaszoljon szedés BAG1 elemei közül (n-1) elemek permutate és ezután pihenni ((n-1) - BAG1) = bag2 elemeket lehet elhelyezni 1 módon csak most . Elemek rendezését a BAG1 kell azonosnak kell lennie, és hasonlóképpen az bag2 elemek a sorrendben.

Mivel minden részfáját bináris kereső fába kell lennie BST. Hasonló folyamat lenne működtetni minden csomópont, és szaporodnak a helyi válasz a csomópont a végső választ.

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;
}