Перестановки BST

Вы можете сделать это в обратном направлении: Учитывая BST, перечислить все массивы целых чисел, которые могут принести этот BST ...

Не могли бы вы (с помощью недетерминизм ...)

1. испускает корень и добавить его в излучаемом наборе.
2. недетерминированно выбрать элемент из дерева, которое не находится в излучаемом наборе, но чей родитель, и добавить его в излучаемом набор и излучать.
3. повторить 2, пока все не излучается.

Недетерминизм даст вам все такие массивы. Затем их можно пересчитать.

Ваш вопрос эквивалентен вопрос о подсчете числа топологических порядков для данного BST.

Например, для BST

  10
 /  \
5   20
 \7 | \
    15 30

множество топологических порядками можно пересчитать вручную следующим образом: 10 начинается каждый заказа. Число топологических упорядочений для поддерева, начиная с 20 состоит из двух: (20, 15, 30) и (20, 30, 15). Поддерево, начиная с 5 имеет только один заказ: (5, 7). Эти две последовательности могут чередоваться в произвольном порядке, что приводит к 2-х 10 чередований, таким образом производя двадцать входов, которые производят один и тот же BST. Первые 10 перечислены ниже для случая (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

Корпус (20, 30, 15) аналогично --- вы можете проверить, что в один из следующих входов производят то же самое ЛУЧШЕЕ.

Этот пример также обеспечивает рекурсивное правило для вычисления количества упорядочений. Для листа, номер 1. Для узла не листа с одного ребенка, число которых равно числу топологических порядками для ребенка. Для узла не листа с двумя детьми с размерами поддерева | L | и | Р |., обе имеющие л и г упорядоченности, соответственно, число равно

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

Где INT этого числа возможных чередований | L | и | R | элементы. Это можно легко вычислить по формуле (| L | + | R |)! / (| L |! Х | R |!). Для приведенного выше примера, мы получим следующее рекурсивное вычисление:

  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

Это решает проблему.

Примечание: данное решение предполагает, что все узлы в BST имеют разные ключи.

Спасибо за объяснение antti.huima! Это помогло мне понять. Вот некоторые 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;
}

Этот вопрос может быть легко решена, если у вас мало знаний о рекурсии, перестановки и комбинации, а также знакомство с бинарное дерево поиска (очевидно).

Сначала вы построить бинарное дерево поиска с заданной последовательностью. Вы также можете выполнить ту же операцию в массиве, но дерева визуализации бы нарисовать хорошую картину.

Для заданной последовательности обр [1..n], первый элемент будет оставаться на месте, как в данном массиве и только расположение должно быть приведены в обр [2..n].

Предполагать:

BAG1 = число элементов в обр [2..n], которые меньше, чем обр [0].

а также,

bag2 = число элементов в обр [2..n], которые больше, чем обр [0].

Так как перестановка элементов в BAG1 в последовательности не будет представлять конфликт с числами , присутствующими в bag2 при формировании двоичного дерева поиска, можно начать начать вычисление ответа на собирание BAG1 элементов из (N-1) элементов , permutate и затем остальные ((п-1) - BAG1) = bag2 элементы могут быть размещены в 1 способом только сейчас . Упорядочение элементов в BAG1 должно должно быть одинаковым и также для bag2 элементов в последовательности.

Поскольку каждое поддерево бинарного дерева поиска должен быть BST. Аналогичный процесс будет осуществляться на каждый узел и умножать локальный ответ для узла до конечного ответа.

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