यह मानते हुए कि हम अनुमति दिए जा रहे मूल्यों पर लेक्सोग्राफ़िक आदेश के बारे में बात कर रहे हैं, दो सामान्य दृष्टिकोण हैं जिनका आप उपयोग कर सकते हैं:
- तत्वों के एक क्रमपरिवर्तन को अगले क्रमपरिवर्तन (श्रीवत्सआर के रूप में पोस्ट किया गया), या
- सीधे 0 से ऊपर की
nगिनती करते हुए, वें क्रमपरिवर्तन की गणना करें n।
उन लोगों के लिए (मेरी तरह ;-) जो मूल निवासी के रूप में c ++ नहीं बोलते हैं, दृष्टिकोण 1 को निम्नलिखित छद्म कोड से लागू किया जा सकता है, "बाएं" पर सूचकांक शून्य के साथ एक सरणी के शून्य-आधारित अनुक्रमण को मानते हुए (कुछ अन्य संरचना का प्रतिस्थापन) , एक सूची के रूप में, "अभ्यास के रूप में छोड़ दिया जाता है";;
1. scan the array from right-to-left (indices descending from N-1 to 0)
1.1. if the current element is less than its right-hand neighbor,
call the current element the pivot,
and stop scanning
1.2. if the left end is reached without finding a pivot,
reverse the array and return
(the permutation was the lexicographically last, so its time to start over)
2. scan the array from right-to-left again,
to find the rightmost element larger than the pivot
(call that one the successor)
3. swap the pivot and the successor
4. reverse the portion of the array to the right of where the pivot was found
5. return
यहां एक उदाहरण है जो CADB के वर्तमान क्रमांकन से शुरू होता है:
1. scanning from the right finds A as the pivot in position 1
2. scanning again finds B as the successor in position 3
3. swapping pivot and successor gives CBDA
4. reversing everything following position 1 (i.e. positions 2..3) gives CBAD
5. CBAD is the next permutation after CADB
दूसरे दृष्टिकोण के लिए ( nवें क्रमपरिवर्तन की प्रत्यक्ष गणना ), याद रखें कि तत्वों के N!क्रमपरिवर्तन Nहैं। इसलिए, यदि आप Nतत्वों की अनुमति दे रहे हैं, तो पहले (N-1)!क्रमपरिवर्तन सबसे छोटे तत्व से (N-1)!शुरू होना चाहिए , अगले क्रमपरिवर्तन दूसरे सबसे छोटे से शुरू होना चाहिए, और इसी तरह। यह निम्नलिखित पुनरावर्ती दृष्टिकोण की ओर जाता है (फिर से छद्म कोड में, क्रमपरिवर्तन और 0 से स्थितियां):
To find permutation x of array A, where A has N elements:
0. if A has one element, return it
1. set p to ( x / (N-1)! ) mod N
2. the desired permutation will be A[p] followed by
permutation ( x mod (N-1)! )
of the elements remaining in A after position p is removed
इसलिए, उदाहरण के लिए, ABCD का 13 वां क्रमांकन निम्नानुसार पाया जाता है:
perm 13 of ABCD: {p = (13 / 3!) mod 4 = (13 / 6) mod 4 = 2
C followed by perm 1 of ABD {because 13 mod 3! = 13 mod 6 = 1}
perm 1 of ABD: {p = (1 / 2!) mod 3 = (1 / 2) mod 2 = 0
A followed by perm 1 of BD {because 1 mod 2! = 1 mod 2 = 1}
perm 1 of BD: {p = (1 / 1!) mod 2 = (1 / 1) mod 2 = 1
D followed by perm 0 of B {because 1 mod 1! = 1 mod 1 = 0}
B (because there's only one element)
DB
ADB
CADB
संयोग से, तत्वों को "हटाने" को बूलियंस के समानांतर सरणी द्वारा दर्शाया जा सकता है जो इंगित करता है कि कौन से तत्व अभी भी उपलब्ध हैं, इसलिए प्रत्येक पुनरावर्ती कॉल पर एक नया सरणी बनाना आवश्यक नहीं है।
तो, ABCD के क्रमपरिवर्तन को पार करने के लिए, बस 0 से 23 (4--1) तक की गणना करें और सीधे इसी क्रमपरिवर्तन की गणना करें।