permutări de BST

Ai putea face acest lucru în sens invers: Având în vedere un BST, enumera toate matricele de numere întregi care ar putea oferi acest BST ...

Nu s-a putut tine (folosind nedeterminismul ...)

1. emit rădăcină și adăugați-l la setul emis.
2. alege nedeterminist un articol din copac, care nu se află în setul emis, dar al cărui părinte este, și adăugați-l la setul emis și emit-l.
3. 2 se repetă până când toate emise.

Nedeterminismul vă va da toate aceste tablouri. Apoi, le puteți conta.

Întrebarea dvs. este echivalentă cu problema de numărare a numărului de ordonări topologice pentru BST dat.

De exemplu, pentru BST

  10
 /  \
5   20
 \7 | \
    15 30

setul de ordonări topologice pot fi numărate manual, astfel: 10 începe în fiecare ordonare. Numărul orderings topologice pentru subarborele începând cu 20 este de două: (20, 15, 30) și (20, 30, 15). Subarborele începând cu 5 are doar o singură ordonare: (5, 7). Aceste două secvențe pot fi intercalate într-un mod arbitrar, conducând la 2 x 10 interleavings, producând astfel douăzeci intrări care produc aceeași BST. Primele 10 sunt enumerate mai jos pentru cazul (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

Cazul (20, 30, 15) este analog --- puteți verifica dacă oricare dintre următoarele intrări produce aceeași BST.

Acest exemplu prevede, de asemenea, o regulă recursiv pentru a calcula numărul de ordonările. Pentru o frunză, numărul este 1. Pentru un nod fără frunze cu un copil, numărul este egal cu numărul de ordonări topologice pentru copil. Pentru un nod non-frunze, cu doi copii cu dimensiuni de subramificație | L | și | R |., ambele având l și r ordonări, respectiv, numărul este egal cu

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

În cazul în care INT este numărul de posibile interleavings ale | L | și | R | elemente. Acest lucru poate fi calculată cu ușurință prin (| L | + | R |)! / (| L |! X | R |!). Pentru exemplul de mai sus, vom obține următorul calcul recursiv:

  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

Aceasta rezolvă problema.

Notă: această soluție presupune că toate nodurile din BST au chei diferite.

Vă mulțumim pentru antti.huima explicația! Acest lucru ma ajutat să înțeleg. Iată câteva 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;
}

Această întrebare poate fi rezolvată cu ușurință dacă aveți puține cunoștințe de recursie, permutare și combinații, și familiaritatea cu binar de căutare arbore (evident).

În primul rând construi un arbore binar de căutare cu secvența dată. Puteți efectua, de asemenea, aceeași operațiune în matrice, dar copac-vizualizare ar picta o imagine bună.

Pentru secvența dată arr [1..n], primul element de ar rămâne pune așa cum este în matrice dat și numai aranjament trebuie să fie adus în arr [2..N].

Să presupunem:

femeie1 = numărul de elemente în arr [2..N] care sunt mai puțin de arr [0].

și,

bag2 = numărul de elemente în arr [2..N] care sunt mai mari decât arr [0].

Deoarece permutarea elementelor în femeie1 în secvența nu va reprezenta un conflict cu numerele prezente în bag2 în timp ce formează un arbore binar de căutare, se poate începe începe calcularea unui răspuns prin alegerea elementelor femeie1 din elemente (n-1) permutate și apoi restul ((n-1) - femeie1) = elemente bag2 pot fi plasate în mod 1 numai acum . Comandarea elementelor în femeie1 ar trebui să fie aceeași și de asemenea pentru elementele bag2 în secvență.

Din moment ce fiecare subarbore dintr-un arbore binar de căutare trebuie să fie un BST. Un proces similar ar fi operat pe fiecare nod și se multiplică răspunsul local pentru nodul la răspuns final.

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