0 और 1 के समान संख्या के साथ सभी बाइनरी दृश्यों को कुशलतापूर्वक कैसे उत्पन्न करता है?

लंबाई का एक द्विआधारी अनुक्रम केवल एक क्रमबद्ध अनुक्रम है ताकि प्रत्येक या तो या । इस तरह के सभी बाइनरी दृश्यों को उत्पन्न करने के लिए, एक व्यक्ति निम्नलिखित तरीके से स्पष्ट बाइनरी ट्री संरचना का उपयोग कर सकता है: जड़ "खाली" है, लेकिन प्रत्येक बाएं बच्चा मौजूदा स्ट्रिंग के लिए और दाहिने बच्चे के साथ मेल खाता है। । अब, प्रत्येक बाइनरी अनुक्रम बस लंबाई का एक रास्ता है जो रूट पर शुरू होता है और एक पत्ती पर समाप्त होता है। $n$ $x_1,\ldots,x_n$ $x_j$ $0$ $1$ $0$ $1$ $n+1$

यहाँ मेरा सवाल है:

क्या हम बेहतर कर सकते हैं यदि हम केवल लंबाई सभी द्विआधारी तारों को उत्पन्न करना चाहते हैं जो ठीक शून्य और वाले हैं? $2n$ $n$ $n$

"क्या हम बेहतर कर सकते हैं", मेरा मतलब है कि हमें मूर्खतापूर्ण एल्गोरिथ्म की तुलना में कम जटिलता होनी चाहिए जो पहले ऊपर पूरे पेड़ का निर्माण करती है और फिर "बाएं" और "दाएं" किनारों के बराबर उन रास्तों को खोजने की कोशिश करती है।

algorithms graphs binary-trees

— विदित नंदा
स्रोत

क्या आप 1 से तक संख्याओं के सभी सख्ती से बढ़ते अनुक्रमों को कुशलता से उत्पन्न करने का एक तरीका खोज सकते हैं ?

n

$n$

2 n

$2n$

— कॉर्नेलियस ब्रांड

मैं जटिलता पर टिप्पणी नहीं कर सकता, लेकिन मेरा भोला-भाला एल्गोरिथ्म एक कोने से एक विकर्ण तक एक वर्ग ग्रिड के किनारों के साथ चलता है, जिस तरह की बैकग्राउंड स्कीम का उपयोग किया जाएगा। इसका मतलब है कि 01 और 10 एक ही स्थिति में समाप्त होते हैं (आपके पेड़ के विपरीत) लेकिन बैकट्रैक के साथ हम इस इतिहास को जानते हैं।

— हेंड्रिक जनवरी

संभवतः भिन्न नोट पर, यहां -iterator का जावा कार्यान्वयन है ।

(\binom{n}{k})

${n \choose k}$

— पाएल जीडी जूल

जवाबों:

स्पष्ट रूप से लंबाई के बाइनरी तार । बाइनरी को ट्रेस करने के लिए एक एल्गोरिथ्म को एक बार प्रत्येक नोड पर जाना पड़ता है, अर्थात उसे कदम। $4^{n}$ $2n$

\sum_{i = 0}^{2 n} 2^{i} = 2^{2 n + 1} - 1 = O (4^{n})

$\sum_{i=0}^{2n} 2^i = 2^{2n+1} - 1 = \mathcal{O}(4^n)$

आइए एक पुनरावर्ती एल्गोरिदम पर विचार करें जो आपके द्वारा वर्णित पेड़ का पता लगाता है, लेकिन अपने रास्ते पर लोगों की संख्या और शून्य की गणना करता है, अर्थात यह केवल पेड़ के अच्छे हिस्से को पार करेगा।
लेकिन 0 और 1 वाले कितने ऐसे बाइनरी स्ट्रिंग्स हैं? हम लंबाई हमारे तारों के लिए 1 चुनते हैं और चरण 2 में स्टर्लिंग के सूत्र का उपयोग करते हैं: $n$ $n$ $n$ $2n$

(\binom{2 n}{n}) = \frac{(2 n)!}{(n!)^{2}} = \frac{4^{n}}{\sqrt{π n}} (1 + O (1 / n))

${2n \choose n} = \frac{(2n)!}{(n!)^2} = \frac{4^n}{\sqrt{\pi n}} (1 + \mathcal{O}(1/n))$

EDIT
पीटर शोर की टिप्पणियों के लिए धन्यवाद, हम दूसरे एल्गोरिथ्म द्वारा आवश्यक कदमों की संख्या का विश्लेषण भी कर सकते हैं, जो 1 और 0 की गणना करता है। मैं नीचे से उनकी टिप्पणी का हवाला दे रहा हूं:

हम बिल्कुल 0 और 1 के साथ सभी बाइनरी अनुक्रमों को खोजना चाहते हैं । हम द्विआधारी पेड़ को पार करते हैं, जहां प्रत्येक नोड में अधिकतम 0 और 1 का अनुक्रम होता है । हमें 0 से अधिक या 1 से अधिक के साथ किसी भी नोड पर जाने की आवश्यकता नहीं है । हमें कितने नोड्स पर जाने की आवश्यकता है? कर रहे हैं के साथ तार 0 की और 1 की। इस सब को , । अब, हमें इन नोड्स में से प्रत्येक पर लगातार औसत लागत प्रति नोड पर जाने की आवश्यकता है। हम प्रत्येक बाएं बच्चे को पहले, और प्रत्येक दाएं बच्चे को दूसरे पर जाकर ऐसा कर सकते हैं। $n$ $n$ $2n$ $n$ $n$ ${i+j \choose i}$ $i$ $j$ $i,j \leq n$ $\sum_{i=0}^n \sum_{j=0}^n {i+j \choose i} = {2n+2 \choose n+1} − 1$

स्टर्लिंग के सूत्र का उपयोग करके हम फिर से नए एल्गोरिथ्म के चल रहे समय के रूप में।

(\binom{2 n + 2}{n + 1}) - 1 = 4^{n + 1} \frac{1}{\sqrt{n + 1}} (1 + O (1 / n)) - 1 = O (\frac{4^{n}}{\sqrt{n}})

${2n + 2 \choose n + 1} - 1 = 4^{n+1} \frac{1}{\sqrt{n+1}} (1 + \mathcal{O}(1/n)) - 1 = \mathcal{O}(\frac{4^n}{\sqrt{n}})$

— tranisstor
स्रोत

आपको थोड़ा अधिक सावधान रहना होगा। संभवतः प्रत्येक स्ट्रिंग को उत्पन्न करने के बाद, हम इसे समय में संसाधित करते हैं । तो बस सभी संतुलित तारों को संसाधित करने में समय लगता है । यदि अनुकूलित "मूर्खतापूर्ण" पीढ़ी का एल्गोरिथ्म वास्तव में , तो बग के लिए अवसरों के अलावा, एक चालाक एल्गोरिथ्म पर स्विच करने से बहुत कुछ हासिल नहीं होगा।

Ω (n)

$\Omega(n)$

Ω (4^{n} \sqrt{n})

$\Omega(4^n \sqrt{n})$

O (4^{n})

$O(4^n)$

— युवल फिल्मस

@ युवल फिल्मस: वास्तव में आपका क्या मतलब है "स्ट्रिंग प्रोसेसिंग"? यदि आप आउटपुट पर खर्च किए गए समय का मतलब है, जो निश्चित रूप से , तो आपको उस कारक पर "मूर्खतापूर्ण" एल्गोरिथ्म के चलने के समय में भी विचार करना होगा, जो तब ।

Θ (n)

$\Theta(n)$

O (4^{n} n)

$O(4^n n)$

— ट्रांसनिस्टोरोर

मेरा कहना था कि यदि आप और बीच के अंतर से चिंतित हैं , तो न्यूनतम रनिंग टाइम के लिए आपको एक न्यूनतम के रूप में बताना होगा; दो एल्गोरिदम के बीच किसी भी संभावित अंतर को प्रकट करने के लिए पर्याप्त नहीं है। इसके अलावा, आपको अपने प्रस्तावित नए एल्गोरिदम का विश्लेषण करने में सावधान रहना होगा, यह देखने के लिए कि ये "नगण्य" छोटे कारक इसे तुच्छ एल्गोरिथ्म की तुलना में धीमा नहीं बनाते हैं।

4^{n}

$4^n$

4^{n} / \sqrt{n}

$4^n/\sqrt{n}$

\tilde{O} (4^{n})

$\tilde{O}(4^n)$

— युवल फिल्मस

आप केवल "खराब भागों" को शामिल किए बिना पेड़ के "अच्छे हिस्से" का निर्माण कैसे करते हैं? आपको पेड़ के सभी नोड्स को शामिल करने की आवश्यकता है जिनके पास रूट से बाएँ बच्चे या दाएँ बच्चे से अधिक नहीं हैं । यह काम करता है, लेकिन आपको यह दिखाने के लिए एक अतिरिक्त तर्क की आवश्यकता है कि यह काम करता है। विशेष रूप से, आपको सूत्र ।

n

$n$

n

$n$

\sum_{i = 0}^{n} \sum_{j = 0}^{n} (\binom{i + j}{i}) = (\binom{2 n + 2}{n + 1}) - 1

$\sum_{i=0}^n \sum_{j=0}^n {i+j \choose i} = {2n+2 \choose n+1} -1$

— पीटर शोर

हम बिल्कुल 0 और 1 के साथ सभी बाइनरी अनुक्रमों को खोजना चाहते हैं । हम द्विआधारी पेड़ को पार करते हैं, जहां प्रत्येक नोड में अधिकतम 0 और 1 का अनुक्रम होता है । हमें 0 से अधिक या 1 से अधिक के साथ किसी भी नोड पर जाने की आवश्यकता नहीं है । हमें कितने नोड्स पर जाने की आवश्यकता है? कर रहे हैं के साथ तार 0 की और 1 की। इस सब को , । अब, हमें इन नोड्स में से प्रत्येक पर लगातार औसत लागत प्रति नोड पर जाने की आवश्यकता है। हम प्रत्येक बाएं बच्चे को पहले, और प्रत्येक दाएं बच्चे को दूसरे पर जाकर ऐसा कर सकते हैं।

n

$n$

n

$n$

2 n

$2n$

n

$n$

n

$n$

(\binom{i + j}{i})

$i+j \choose i$

i

$i$

j

$j$

i, j \leq n

$i,j \leq n$

\sum_{i = 0}^{n} \sum_{j = 0}^{n} (\binom{i + j}{i}) = (\binom{2 n + 2}{n + 1}) - 1

$\sum_{i=0}^n \sum_{j=0}^n {i+j \choose i}={2n+2 \choose n+1}-1$

— पीटर शोर

शायद मैं मोटा हो रहा हूं, लेकिन मूल प्रश्न लंबाई 2n के सभी "संतुलित" बाइनरी अनुक्रमों को उत्पन्न करने का तरीका पूछा गया जो कि लंबाई 2n के सभी बाइनरी अनुक्रमों के एक पेड़ को ट्रेस करने से अधिक कुशल थे और केवल जो संतुलित थे उन्हें आउटपुट करते हैं। तो एक पेड़ का उपयोग क्यों करें?

यहाँ एक पुनरावर्ती एल्गोरिदम के लिए छद्मकोड है जो इस तरह के सभी अनुक्रम उत्पन्न करता है (कीवर्ड "उपज" आउटपुट के लिए एक अनुक्रम भेजता है:

function all-balanced(n) {
  all-specified( "", n, n );
};

function all-specified( currentString, zeroes, ones ) {

  if (zeroes == 0) {
    for i = 0 to ones {
      currentString += "1";
    };
    yield currentString;
    return;
  };

  if (ones == 0) {
    for i = 0 to zeroes {
      currentString += "0";
    };
    yield currentString;
    return;
  };

  all-specified( currentString+"0", zeroes-1, ones );
  all-specified( currentString+"1", zeroes, ones-1 );
  return;
};

अगर मैं कुछ गलत समझ रहा हूं, तो कृपया मुझे बताएं, लेकिन मुझे ऐसा लगता है कि यह वास्तव में सामने आई समस्या के सबसे कुशल उत्तर के बारे में है, जिसने कभी भी पेड़ के उपयोग को निर्दिष्ट नहीं किया है।

— afeldspar
स्रोत