Dato un array di interi arr = [5,6,1].
Quando costruire un BST con questo ingresso nello stesso ordine, avremo 5 come root, 6 come figlio destro e 1 come figlio partita.
Ora, se il nostro ingresso è cambiato in [5,1,6], ancora la nostra struttura BST sarà identico.
Quindi, dato un array di interi, come trovare il numero di differenti permutazioni della matrice di input che provoca la BST identico come il BST formata sull'ordine matrice originale?
Si potrebbe fare questo a ritroso: Dato un BST, enumerare tutti gli array di interi che potrebbe produrre questa BST ...
Impossibile voi (usando nondeterminismo ...)
Il determinismo vi darà tutte queste matrici. Poi si può contare.
La tua domanda è equivalente alla domanda di contare il numero di ordinamenti topologici per il dato BST.
Ad esempio, per il BST
10
/ \
5 20
\7 | \
15 30
l'insieme di ordinamenti topologici può essere contato manualmente simili: 10 inizia ogni ordinazione. Il numero di ordinamenti topologici sottostruttura iniziano con 20 è due: (20, 15, 30) e (20, 30, 15). La sottostruttura iniziando con 5 ha un solo ordine: (5, 7). Questi due sequenza può essere interleaved in modo arbitrario, portando a 2 x 10 interleavings, producendo così venti input che producono lo stesso BST. Il primo 10 sono elencati di seguito per il caso (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
Il caso (20, 30, 15) è analogo --- è possibile verificare che uno qualsiasi dei seguenti ingressi produce lo stesso BST.
Questo esempio fornisce anche una regola ricorsiva per calcolare il numero degli ordinamenti. Per una foglia, il numero è 1. Per un nodo non foglia con un bambino, il numero è uguale al numero di ordinamenti topologici per il bambino. Per un nodo non foglia con due figli con dimensioni di sottostruttura | L | e | R |., entrambi con L e R ordinamenti, risp, il numero è uguale a
l x r x INT(|L|, |R|)
Dove INT è il numero di possibili interleavings di | L | e | R | elementi. Questo può essere calcolato facilmente (| L | + | R |)! / (| L |! X | R |!). Per l'esempio di cui sopra, otteniamo la seguente calcolo ricorsiva:
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
Questo risolve il problema.
Nota: questa soluzione presuppone che tutti i nodi del BST hanno chiavi diverse.
Grazie per la spiegazione antti.huima! Questo mi ha aiutato a capire. Ecco qualche 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;
}
Questa domanda può essere risolto facilmente se si ha poca conoscenza di ricorsione, permutazione e le combinazioni, e la familiarità con Binary Search Albero (ovviamente).
In primo luogo si costruisce un albero binario di ricerca con la sequenza data. È inoltre possibile eseguire la stessa operazione nella matrice, ma albero-visualizzazione potrebbe dipingere una buona immagine.
Per data sequenza arr [1..n], 1 ° elemento rimarrebbe messo come è nell'array specificato e solo accordo deve essere portato in arr [2..n].
Assumere:
bag1 = numero di elementi in arr [2..n] che sono meno di arr [0].
e,
bag2 = numero di elementi in arr [2..n] che sono superiori arr [0].
Poiché la permutazione di elementi bag1 nella sequenza non porrà un conflitto con i numeri presenti nella bag2 formando un albero di ricerca binaria, si può iniziare iniziare il calcolo della risposta di raccolta elementi bag1 su (n-1) elementi di permutate e poi riposare ((n-1) - bag1) = elementi bag2 possono essere posizionati in modo 1 solo ora . Ordinamento degli elementi in bag1 dovrebbe dovrebbe essere lo stesso e anche per gli elementi bag2 nella sequenza.
Dal momento che ogni sottostruttura di un albero binario di ricerca deve essere un BST. processo simile potrebbe essere utilizzato su ciascun nodo e moltiplicare la risposta locale per il nodo di risposta finale.
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;
}