BST के क्रमपरिवर्तन

आप पीछे की ओर ऐसा कर सकता है: एक BST को देखते हुए, पूर्णांकों जो इस BST उत्पन्न हो सकते हैं के सभी सरणियों की गणना ...

नहीं आप (nondeterminism का उपयोग कर ...) किया जा सका

1. जड़ फेंकना और उत्सर्जित सेट में जोड़ें।
2. nondeterministically पेड़ जो उत्सर्जित सेट में नहीं है, लेकिन जिसकी मूल है से एक आइटम चुनते हैं, और उत्सर्जित सेट करने के लिए जोड़ कर उसे फेंकना।
3. दोहराने 2 जब तक सभी उत्सर्जित।

nondeterminism आप ऐसे सभी सरणियों दे देंगे। उसके बाद आप उन्हें भरोसा कर सकते हैं।

आपका प्रश्न दिए गए BST के लिए संस्थानिक orderings की संख्या की गणना के सवाल के बराबर है।

उदाहरण के लिए, BST के लिए

  10
 /  \
5   20
 \7 | \
    15 30

संस्थानिक orderings का समूह इस तरह हाथ से गिना जा सकता है: 10 शुरू होता है हर आदेश। सबट्री 20 के साथ शुरू करने के लिए संस्थानिक orderings की संख्या दो है: (20, 15, 30) और (20, 30, 15)। सबट्री 5 के साथ शुरू में केवल एक ही आदेश है: (5, 7)। इन दोनों अनुक्रम एक मनमाना तरीके से interleaved जा सकता है, 2 एक्स 10 interleavings के लिए अग्रणी है, इस प्रकार बीस आदानों जो एक ही BST उत्पादन का निर्माण किया। पहले 10 मामले (20, 15, 30) के लिए नीचे enumerated हैं:

 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) के अनुरूप है --- आप देख सकते हैं कि निम्नलिखित आदानों में से किसी एक ही BST पैदा करता है।

यह उदाहरण भी orderings की संख्या की गणना करने के लिए एक पुनरावर्ती नियम प्रदान करता है। एक पत्ता के लिए, संख्या 1. एक बच्चे के साथ एक गैर-पत्ती नोड, नंबर बच्चे के लिए संस्थानिक orderings की संख्या के बराबर है के लिए है। एल | साथ सबट्री आकार दो बच्चों के साथ एक गैर पत्ती नोड के लिए | और | R |।, दोनों होने एल और आर orderings, resp, संख्या के बराबर होती है

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

एल | कहाँ INT के संभावित interleavings की संख्या है | और | R | तत्वों। यह द्वारा आसानी से गणना की जा सकती (| एल | + | R |)! / (| एल |! X | 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 के लिए धन्यवाद! यह मुझे समझने में मदद की। यहाँ कुछ सी ++ है:

#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] आगमन दिया अनुक्रम के लिए, 1 तत्व डाल रहने के रूप में यह दिया सरणी में है और केवल व्यवस्था में आगमन [2..n] लाया जाना चाहिए।

मान लीजिये:

bag1 = में आगमन [2..n] तत्व है जो [0] आगमन की तुलना में कम कर रहे हैं की संख्या।

तथा,

bag2 = में आगमन [2..n] तत्व है जो [0] आगमन से अधिक हैं की संख्या।

के बाद से अनुक्रम में bag1 में तत्वों की क्रमचय bag2 में मौजूद नंबरों के साथ कोई विरोध उत्पन्न नहीं होगा, जबकि एक द्विआधारी खोज वृक्ष बनाने, एक एक करके जवाब की गणना शुरू शुरू कर सकते हैं करने के लिए (n-1) तत्वों से बाहर bag1 तत्वों उठा permutate और फिर आराम ((n-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;
}