👩🏾‍🤝‍👨🏻 🧥 👂 डेटा संरचनाएं, PHP। भाग दो 👨🏽‍🚀 🤟 🕊️

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

पिछले लेख के अंत में , पेड़ों को छुआ गया था, इसलिए चलो ढेर के साथ शुरू करें, क्योंकि ढेर और पेड़ों के बीच आम जड़ें हैं। फिर हम ग्राफ़ पर आगे बढ़ते हैं और डीजकस्ट्रा एल्गोरिदम को लागू करते हैं।

UPD : प्रदर्शन की तुलना जोड़ा गया

एक ढेर एक विशेष, पेड़ जैसी संरचना है जिसमें एक संपत्ति होती है - कोई भी मूल नोड हमेशा अपने वंशजों की तुलना में अधिक या बराबर होता है। इस प्रकार, इस स्थिति के तहत, ढेर का मूल तत्व हमेशा अधिकतम होगा। इस विकल्प को अधिकतम (पूर्ण) हीप या अधिकतम कहा जाता है। एक ढेर जहां मूल तत्व न्यूनतम है और प्रत्येक माता-पिता का नोड अपने वंशजों की तुलना में कम या बराबर है - न्यूनतम ढेर या छोटा।

बाइनरी हीप (मैक्सहैप) को निम्नानुसार दर्शाया जा सकता है:

यह द्विआधारी है क्योंकि प्रत्येक माता-पिता के दो बच्चे हैं।
यह ध्यान देने योग्य है कि यद्यपि ढेर को द्विआधारी पेड़ों के रूप में लागू किया जाता है, उनके पास ऑर्डर देने जैसी कोई चीज नहीं होती है और ट्रावेलर्स के लिए कोई विशिष्ट आदेश नहीं होता है। एक ढेर एक टेबल संरचना का एक प्रकार है, इसलिए, निम्नलिखित बुनियादी संचालन इस पर लागू होते हैं:

create - a खाली ढेर बनाएँ।
isEmpty - निर्धारित करें कि क्या ढेर खाली है या नहीं।
सम्मिलित करें - ढेर में एक तत्व जोड़ें।
अर्क - ढेर से एक तत्व (रूट, वर्टेक्स) को निकालें और निकालें।

चूंकि तत्वों को प्राप्त करने और हटाने के संचालन को एक निष्कर्षण ऑपरेशन में जोड़ा जाता है, इसलिए हम पहले इस पर विचार करेंगे।

एक आइटम को हीप से निकालने का नियम यह है कि केवल रूट आइटम को हटाया जा सकता है। मान लीजिए कि हमने उपर्युक्त उदाहरण से मूल तत्व को हटा दिया (100)। हटाने के बाद, हमें दो अलग-अलग ढेर के साथ छोड़ दिया जाएगा और हमें किसी भी तरह से एक अलग ढेर में पुनर्निर्माण करना होगा। अंतिम नोड को मूल में स्थानांतरित करके ऐसा करना सबसे आसान है, लेकिन इस मामले में इस तरह के ढेर मुख्य स्थिति से उपयुक्त नहीं होंगे। इस तरह के एक गुच्छा को अर्धवृत्त कहा जाता है:

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

हम एक सरणी के रूप में मैक्सहैप को लागू कर सकते हैं। एक बाइनरी ट्री में एक नोड में दो से अधिक बच्चे नहीं हो सकते हैं, इसलिए, किसी भी संख्या में नोड n के लिए, बाइनरी हीप में 2n + 1 नोड होंगे।

हम निम्नानुसार एक गुच्छा लागू करते हैं:

<?php class BinaryHeap { protected $heap; public function __construct() { $this->heap = array(); } public function isEmpty() { return empty($this->heap); } public function count() { //    return count($this->heap) - 1; } public function extract() { if ($this->isEmpty()) { throw new RunTimeException(' !'); } //           $root = array_shift($this->heap); if (!$this->isEmpty()) { //        //         $last = array_pop($this->heap); array_unshift($this->heap, $last); //     $this->adjust(0); } return $root; } public function compare($item1, $item2) { if ($item1 === $item2) { return 0; } //     minheap return ($item1 > $item2 ? 1 : -1); } protected function isLeaf($node) { //    2n + 1   "" return ((2 * $node) + 1) > $this->count(); } protected function adjust($root) { //     if (!$this->isLeaf($root)) { $left = (2 * $root) + 1; //   $right = (2 * $root) + 2; //   $h = $this->heap; //      if ( (isset($h[$left]) && $this->compare($h[$root], $h[$left]) < 0) || (isset($h[$right]) && $this->compare($h[$root], $h[$right]) < 0) ) { //    if (isset($h[$left]) && isset($h[$right])) { $j = ($this->compare($h[$left], $h[$right]) >= 0) ? $left : $right; } else if (isset($h[$left])) { $j = $left; //   } else { $j = $right; //   } //     list($this->heap[$root], $this->heap[$j]) = array($this->heap[$j], $this->heap[$root]); //     //    $j $this->adjust($j); } } } }

सम्मिलित करें, इसके विपरीत, निष्कर्षण का सटीक विपरीत है: हम एक तत्व को ढेर के नीचे सम्मिलित करते हैं और इसे बढ़ाते हैं जब तक कि यह संभव न हो और मुख्य स्थिति संतुष्ट हो। चूंकि हम जानते हैं कि एक पूर्ण बाइनरी ट्री में n / 2 + 1 नोड्स होते हैं, हम एक सरल बाइनरी खोज का उपयोग करके ढेर को बायपास कर सकते हैं।

 public function insert($item) { //       $this->heap[] = $item; //     $place = $this->count(); $parent = floor($place / 2); //        while ( $place > 0 && $this->compare( $this->heap[$place], $this->heap[$parent]) >= 0 ) { //   list($this->heap[$place], $this->heap[$parent]) = array($this->heap[$parent], $this->heap[$place]); $place = $parent; $parent = floor($place / 2); } }

आइए देखें कि क्या हुआ और ढेर में कई मान डालने की कोशिश करें:

 <?php $heap = new BinaryHeap(); $heap->insert(19); $heap->insert(36); $heap->insert(54); $heap->insert(100); $heap->insert(17); $heap->insert(3); $heap->insert(25); $heap->insert(1); $heap->insert(67); $heap->insert(2); $heap->insert(7);

यदि हम यह सब करने की कोशिश करते हैं, तो हमें निम्नलिखित मिलते हैं:

 Array ( [0] => 100 [1] => 67 [2] => 54 [3] => 36 [4] => 19 [5] => 7 [6] => 25 [7] => 1 [8] => 17 [9] => 2 [10] => 3 )

जैसा कि आप देख सकते हैं, आदेश नहीं देखा गया है और सामान्य तौर पर यह हमारी अपेक्षा से कुछ अलग है। हालांकि, यदि हम ढेर से तत्वों को निकालने के लिए मुड़ते हैं, तो सब कुछ ठीक हो जाएगा:

 <?php while (!$heap->isEmpty()) { echo $heap->extract() . "n"; }

 100 67 54 36 25 19 17 7 3 2 1

SplMaxHeap और SplMinHeap

सौभाग्य से, हमारे पास पहले से ही SplHeap, SplMaxHeap और SplMinHeap के तैयार कार्यान्वयन हैं। बस हमें उन्हें विरासत में देना होगा और तुलना विधि को इस तरह से ओवरराइड करना होगा:

 <?php class MyHeap extends SplMaxHeap { public function compare($item1, $item2) { return (int) $item1 - $item2; } }

यह विधि दो नोड्स की किसी भी तुलना का प्रदर्शन करेगी और SplMaxHeap के मामले में यह एक सकारात्मक संख्या देता है यदि $ item1 $ item2 से अधिक है, 0 यदि वे एक-दूसरे के बराबर हैं और यदि $ 2 आइटम $ item1 से अधिक है तो नकारात्मक। अगर हमें SplMinHeap विरासत में मिलती है, तो यह एक सकारात्मक संख्या लौटाएगा यदि $ item1 $ item2 से कम है।

ढेर में कई समान तत्वों को रखने की सिफारिश नहीं की जाती है, क्योंकि उनकी स्थिति निर्धारित करना मुश्किल होगा

SplPyerityQueue - प्राथमिकता कतार

प्राथमिकता कतार एक विशेष सार डेटा प्रकार है जो एक कतार की तरह व्यवहार करता है, लेकिन एक ढेर के रूप में कार्यान्वित किया जाता है। SplPriorityQueue के संबंध में यह अधिकतम होगा। प्राथमिकता कतार में कुछ वास्तविक अनुप्रयोग हैं, उदाहरण के लिए, एक टिकट प्रणाली या एक हेल्प डेस्क।

SplHeap के साथ के रूप में, आपको बस SplPyerityQueue को इनहेरिट करना होगा और तुलना विधि को ओवरराइड करना होगा:

 <?php class PriQueue extends SplPriorityQueue { public function compare($p1, $p2) { if ($p1 === $p2) return 0; //    ,   //    return ($p1 < $p2) ? 1 : -1; } }

SplPyerityQueue में मुख्य अंतर यह है कि जब आप सम्मिलित करते हैं, तो तत्व के मूल्य के अलावा, इस तत्व की प्राथमिकता भी अपेक्षित है। डालने का कार्य प्राथमिकता का उपयोग करता है ताकि आपके तुलनित्र रिटर्न के आधार पर ढेर को बहाया जा सके।

प्राथमिकता कतार की जाँच करें, संख्या के रूप में प्राथमिकता निर्धारित करें:

 <?php $pq = new PriQueue(); $pq->insert('A', 4); $pq->insert('B', 3); $pq->insert('C', 5); $pq->insert('D', 8); $pq->insert('E', 2); $pq->insert('F', 7); $pq->insert('G', 1); $pq->insert('H', 6); $pq->insert('I', 0); while ($pq->valid()) { print_r($pq->current()); echo "n"; $pq->next(); }

जो अंततः हमें निम्नलिखित देगा:

 I G E B A C H F D

इस मामले में, हमारे तत्व प्राथमिकता के घटते क्रम में हैं - उच्चतम से निम्नतम (एक कम मूल्य एक उच्च प्राथमिकता है)। आप उस क्रम को बदल सकते हैं जिसमें आइटम केवल तुलना विधि को बदलकर लौटाए जाते हैं ताकि यह एक सकारात्मक संख्या लौटाए यदि $ p1 $ P2 से अधिक हो।

डिफ़ॉल्ट रूप से, केवल आइटम का मान पुनर्प्राप्त किया जाता है। यदि आप केवल प्राथमिकता मान, या मान और उनकी प्राथमिकता प्राप्त करना चाहते हैं, तो आपको संबंधित निष्कर्षण ध्वज सेट करने की आवश्यकता है:

 <?php //    $pq->setExtractFlags(SplPriorityQueue::EXTR_PRIORITY); //    (   //   ) $pq->setExtractFlags(SplPriorityQueue::EXTR_BOTH);

गिनता

ग्राफ़ के पीछे कुछ वास्तविक अनुप्रयोग हैं - नेटवर्क अनुकूलन, रूटिंग या सोशल नेटवर्क विश्लेषण। Google पेजरैंक, अमेज़ॅन की सिफारिशें उनके उपयोग के कुछ उदाहरण हैं। लेख के इस भाग में मैं दो समस्याओं की व्याख्या करने की कोशिश करूंगा जिनमें उनका उपयोग किया गया है - एक छोटा रास्ता खोजने की समस्याएं और कम से कम संख्या में रुकना।

एक ग्राफ एक गणितीय निर्माण है जिसका उपयोग कुंजी-मूल्य जोड़े के बीच संबंधों का प्रतिनिधित्व करने के लिए किया जाता है। एक ग्राफ में कोने (नोड्स) का एक सेट होता है और नोड्स के बीच एक साथ संख्याओं का एक मनमाना जुड़ाव होता है। ये कनेक्शन दिशात्मक (उन्मुख) और गैर-दिशात्मक हो सकते हैं। एक निर्देशित कनेक्शन दो नोड्स के बीच एक कनेक्शन है और A → B कनेक्शन B → A के समान नहीं है। अप्रत्यक्ष कनेक्शन की कोई दिशा नहीं है, इसलिए कनेक्शन एबी और बीए समान हैं। इन नियमों के आधार पर, हम कह सकते हैं कि पेड़ अप्रत्यक्ष रेखांकन में से एक हैं, जहां प्रत्येक शीर्ष एक साधारण कनेक्शन द्वारा नोड्स में से एक से जुड़ा हुआ है।

काउंट का वजन भी हो सकता है। एक भारित ग्राफ या नेटवर्क, एक ऐसा ग्राफ है जिसमें प्रत्येक लिंक के लिए एक भार होता है (नोड ए से नोड के लिए संक्रमण का "मूल्य")। इस तरह के निर्माण व्यापक रूप से सबसे इष्टतम पथ, या दो बिंदुओं के बीच सबसे "सस्ते" पथ को निर्धारित करने के लिए उपयोग किए जाते हैं। GoogleMap में पथ बिछाने को ठीक से भारित ग्राफ़ का उपयोग करके किया जाता है।

स्टॉप की न्यूनतम संख्या (छलांग)

ग्राफ़ सिद्धांत का एक सामान्य अनुप्रयोग दो नोड्स के बीच स्टॉप की न्यूनतम संख्या का पता लगाने के लिए उपयोग किया जाता है। पेड़ों के लिए के रूप में, यहाँ ग्राफ दो दिशाओं में - गहराई या चौड़ाई में पेड़ को पीछे हटाने में मदद करते हैं। पिछली बार जब हमने खोज की गहराई से जांच की थी, अब आइए एक और विधि देखें।

निम्नलिखित ग्राफ की कल्पना करें:

सादगी के लिए, हम सहमत हैं कि यह ग्राफ गैर-दिशात्मक है। कार्य किसी भी दो नोड्स के बीच न्यूनतम संख्या के स्टॉप को खोजना है। चौड़ाई में खोज करते समय, हम रूट से शुरू करते हैं (अच्छी तरह से, या दूसरे नोड से, जिसे हमने रूट के रूप में निर्दिष्ट किया है) और नीचे स्तर से पेड़ के स्तर पर जाते हैं। इसे महसूस करने के लिए, हमें नोड्स की एक सूची के आयोजन के लिए एक कतार की आवश्यकता है जिसे हमने अभी तक इसे वापस करने और इसे हर स्तर पर संसाधित करने के लिए बाईपास नहीं किया है। सामान्य एल्गोरिथ्म इस प्रकार है:

1. एक कतार बनाएँ
2. वहां रूट एलीमेंट को जोड़ें और इसे विज़िट के अनुसार चिह्नित करें
3. जब तक कतार खाली न हो जाए:
- 3 ए। वर्तमान नोड पुनः प्राप्त करें
- 3 बी। यदि वर्तमान नोड वांछित है - बंद करो
- 3c। अन्यथा हम प्रत्येक असमान पड़ोसी नोड को कतार में जोड़ते हैं और इसे विज़िट के रूप में चिह्नित करते हैं

लेकिन हम यह कैसे जानते हैं कि ग्राफ़ को दरकिनार किए बिना कौन से नोड पड़ोसी या बिना परिकल्पित हैं? यह हमें इस सवाल पर लाता है कि रेखांकन कैसे मॉडलिंग किया जा सकता है।

ग्राफ दृश्य

आमतौर पर, ग्राफ़ को दो तरीकों से दर्शाया जाता है - एक टेबल या मैट्रिक्स, जो पड़ोसी नोड्स का वर्णन करता है।
पहले उदाहरण के लिए यह कैसा दिखता है:

मैट्रिक्स में, नोड्स के चौराहे पर, "1" सेट है यदि नोड्स पड़ोसी हैं।

सूची सुविधाजनक है यदि अधिकांश कोने में आपस में कनेक्शन नहीं है, जबकि मैट्रिक्स तेजी से खोज प्रदान करता है। अंत में, ग्राफ के प्रतिनिधित्व का प्रकार इस बात पर निर्भर करता है कि ग्राफ़ के साथ कौन से संचालन किए जाएंगे। हम सूची का उपयोग करेंगे।

 <?php $graph = array( 'A' => array('B', 'F'), 'B' => array('A', 'D', 'E'), 'C' => array('F'), 'D' => array('B', 'E'), 'E' => array('B', 'D', 'F'), 'F' => array('A', 'E', 'C'), );

और हमारी चौड़ाई-पहली खोज लिखें:

 <?php class Graph { protected $graph; protected $visited = array(); public function __construct($graph) { $this->graph = $graph; } //     ()  2  public function breadthFirstSearch($origin, $destination) { //      foreach ($this->graph as $vertex => $adj) { $this->visited[$vertex] = false; } //   $q = new SplQueue(); //           $q->enqueue($origin); $this->visited[$origin] = true; //          $path = array(); $path[$origin] = new SplDoublyLinkedList(); $path[$origin]->setIteratorMode( SplDoublyLinkedList::IT_MODE_FIFO|SplDoublyLinkedList::IT_MODE_KEEP ); $path[$origin]->push($origin); $found = false; //         while (!$q->isEmpty() && $q->bottom() != $destination) { $t = $q->dequeue(); if (!empty($this->graph[$t])) { //     foreach ($this->graph[$t] as $vertex) { if (!$this->visited[$vertex]) { //     ,       $q->enqueue($vertex); $this->visited[$vertex] = true; //      $path[$vertex] = clone $path[$t]; $path[$vertex]->push($vertex); } } } } if (isset($path[$destination])) { echo " $origin  $destination  ", count($path[$destination]) - 1, " "; $sep = ''; foreach ($path[$destination] as $vertex) { echo $sep, $vertex; $sep = '->'; } echo "n"; } else { echo "   $origin  $destinationn"; } } }

इस उदाहरण को चलाने से हमें निम्नलिखित मिलते हैं:

गिनती पर फिर से नज़र डालें

 <?php $g = new Graph($graph); //     D  C $g->breadthFirstSearch('D', 'C'); // : //  D  C  3  // D->E->F->C //     B  F $g->breadthFirstSearch('B', 'F'); // : //  B  F  2  // B->A->F //     A  C $g->breadthFirstSearch('A', 'C'); // : //  A  C  2  // A->F->C //     A  G $g->breadthFirstSearch('A', 'G'); // : //   A  G

यदि हम कतार के बजाय स्टैक का उपयोग करते हैं, तो बाईपास गहराई में होगा।

सबसे अच्छा तरीका के लिए खोजें

एक और आम समस्या किसी भी दो नोड्स के बीच का इष्टतम रास्ता ढूंढना है। इससे पहले, मैंने पहले ही इस समस्या को हल करने के एक उदाहरण के रूप में GoogleMaps में एक मार्ग बनाने के बारे में बात की थी। वैकल्पिक रूप से, यह कार्य रूटिंग, ट्रैफ़िक प्रबंधन, और इसी तरह लागू किया जा सकता है।

इस समस्या को हल करने के उद्देश्य से प्रसिद्ध एल्गोरिदम में से एक का आविष्कार 1959 में एक 29 वर्षीय वैज्ञानिक द्वारा किया गया था जिसका नाम एड्सेजर वेइबे डेज्क्ट्रा था । आप विकिपीडिया पर एल्गोरिथ्म के बारे में अधिक जानकारी प्राप्त कर सकते हैं या इसे स्प्लिटफेस से हबफेस में देख सकते हैं । सामान्य शब्दों में, दिज्क्स्ट्रा का समाधान नोड्स के सभी संभावित जोड़े के बीच हर कनेक्शन की जाँच करने के लिए नीचे आता है, शुरुआती नोड से शुरू होता है, और नोड्स के सेट को लक्ष्य नोड तक पहुंचने तक कम से कम दूरी तक अद्यतन रखने के लिए, यदि संभव हो तो।

इस समाधान को लागू करने के कई तरीके हैं, साथ ही साथ उनके अतिरिक्त भी हैं। उनमें से कुछ ने उत्पादकता में सुधार किया, जबकि अन्य ने केवल दिज्क्स्ट्रा के समाधान की कमियों को इंगित किया, क्योंकि यह केवल सकारात्मक भारित रेखांकन के साथ काम करता है - वे जहां लिंक पर कोई नकारात्मक भार नहीं हैं।

एक उदाहरण के रूप में, हम निम्नलिखित सकारात्मक ग्राफ लेते हैं और इसे एक सूची के माध्यम से पेश करते हैं, जहां हम अपने बीच नोड्स के संबंध को इंगित करते हैं:

 <?php $graph = array( 'A' => array('B' => 3, 'D' => 3, 'F' => 6), 'B' => array('A' => 3, 'D' => 1, 'E' => 3), 'C' => array('E' => 2, 'F' => 3), 'D' => array('A' => 3, 'B' => 1, 'E' => 1, 'F' => 2), 'E' => array('B' => 3, 'C' => 2, 'D' => 1, 'F' => 5), 'F' => array('A' => 6, 'C' => 3, 'D' => 2, 'E' => 5), );

हम सभी "गैर-अनुकूलित" नोड्स की सूची बनाने के लिए प्राथमिकता कतार का उपयोग करके एल्गोरिथ्म को लागू करते हैं:

 <?php class Dijkstra { protected $graph; public function __construct($graph) { $this->graph = $graph; } public function shortestPath($source, $target) { //       $d = array(); //  ""    $pi = array(); //     $Q = new SplPriorityQueue(); foreach ($this->graph as $v => $adj) { $d[$v] = INF; //      $pi[$v] = null; //     foreach ($adj as $w => $cost) { //      $Q->insert($w, $cost); } } //      - 0 $d[$source] = 0; while (!$Q->isEmpty()) { //    $u = $Q->extract(); if (!empty($this->graph[$u])) { //      foreach ($this->graph[$u] as $v => $cost) { //        $alt = $d[$u] + $cost; //     if ($alt < $d[$v]) { $d[$v] = $alt; // update minimum length to vertex        $pi[$v] = $u; //       } } } } //       //    $S = new SplStack(); //     $u = $target; $dist = 0; //       while (isset($pi[$u]) && $pi[$u]) { $S->push($u); $dist += $this->graph[$u][$pi[$u]]; //     $u = $pi[$u]; } //   ,     if ($S->isEmpty()) { echo "   $source  $targetn"; } else { //        //   (LIFO)  $S->push($source); echo "$dist:"; $sep = ''; foreach ($S as $v) { echo $sep, $v; $sep = '->'; } echo "n"; } } }

आप देख सकते हैं कि दिज्क्स्ट्रा का समाधान एक सरल चौड़ाई-पहला खोज विकल्प है। आइए उदाहरण पर वापस जाएं और इसे आज़माएं:

 <?php $g = new Dijkstra($graph); $g->shortestPath('D', 'C'); // 3:D->E->C $g->shortestPath('C', 'A'); // 6:C->E->D->A $g->shortestPath('B', 'F'); // 3:B->D->F $g->shortestPath('F', 'A'); // 5:F->D->A $g->shortestPath('A', 'G'); //    A  G

वह सब है। इस पर, जाहिरा तौर पर, संरचनाओं पर इग्नेशियस टीओ के लेख समाप्त हो गए। मैं उन सभी को धन्यवाद देता हूं जिन्होंने इसे पढ़ा, मुझे उम्मीद नहीं थी कि इतने सारे लोग पसंदीदा में पहला भाग जोड़ेंगे, हालांकि हम सभी जानते हैं कि पसंदीदा शायद ही कभी पढ़े जाते हैं और सभी पोस्ट हमेशा के लिए रहते हैं :)

यहाँ से कॉपी किए गए इन संरचनाओं के कार्यान्वयन के प्रदर्शन के बेंचमार्क

देख लेना

पिछले लेख के विपरीत, यहां सामान्य सरणियों पर एसपीएल कार्यान्वयन के पक्ष में चुनाव स्पष्ट है - उनका उपयोग अधिक संचालन देता है जिसे दूसरे + कम मेमोरी में किया जा सकता है।

हमेशा की तरह, पीएम पाठ, अनुवाद, परस्पर विरोधी जानकारी, साथ ही अभिमानी झूठ में मेरी त्रुटियों को स्वीकार करते हैं।
टिप्पणियाँ चर्चा और लेख में जोड़ने के लिए बाद के परिवर्धन का स्वागत करती हैं।