Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> C++

C++ का उपयोग करके दो स्ट्रिंग्स को समान बनाने के लिए आवश्यक न्यूनतम संख्या में ऑपरेशन।

समस्या कथन

दो स्ट्रिंग्स str1 और str2 को देखते हुए, दोनों स्ट्रिंग्स में 'a' और 'b' अक्षर होते हैं। दोनों तार समान लंबाई के हैं। दोनों स्ट्रिंग्स में एक _ (रिक्त स्थान) है। कार्य निम्न कार्यों की न्यूनतम संख्या करके पहली स्ट्रिंग को दूसरी स्ट्रिंग में परिवर्तित करना है -

  • यदि _ स्थिति I पर है तो _ को i+1 या i-1 की स्थिति वाले वर्ण से बदला जा सकता है

  • यदि स्थिति i+1 और i+2 पर वर्ण भिन्न हैं तो _ को i+1 या i+2 स्थिति वाले वर्ण से बदला जा सकता है

  • इसी तरह, यदि स्थिति i-1 और i-2 पर वर्ण भिन्न हैं तो _ को i-1 या i-2 स्थिति वाले वर्ण से बदला जा सकता है

अगर str1 ="aba_a" और str2 ="_baaa" तो हमें str1 को str2 में बदलने के लिए 2 चालों की आवश्यकता होती है -

1. str1 = “ab_aa” (Swapped str1[2] with str1[3])
2. str2 = “_baaa” (Swapped str1[0] with str1[2])

एल्गोरिदम

1. Apply a simple Breadth First Search over the string and an element of the queue used for BFS will contain the pair str, pos where pos is the position of _ in the string str.
2. Also maintain a map namely ‘vis’ which will store the string as key and the minimum moves to get to the string as value.
3. For every string str from the queue, generate a new string tmp based on the four conditions given and update the vis map as vis[tmp] = vis[str] + 1.
4. Repeat the above steps until the queue is empty or the required string is generated i.e. tmp == B
5. If the required string is generated, then return vis[str] + 1 which is the minimum number of operations required to change A to B.

उदाहरण

#include <iostream>
#include <string>
#include <unordered_map>
#include <queue>
using namespace std;
int transformString(string str, string f){
   unordered_map<string, int> vis;
   int n;
   n = str.length();
   int pos = 0;
   for (int i = 0; i < str.length(); i++) {
      if (str[i] == '_') {
         pos = i;
         break;
      }
   }
   queue<pair<string, int> > q;
   q.push({ str, pos });
   vis[str] = 0;
   while (!q.empty()) {
      string ss = q.front().first;
      int pp = q.front().second;
      int dist = vis[ss];
      q.pop();
      if (pp > 0) {
         swap(ss[pp], ss[pp - 1]);
         if (!vis.count(ss)) {
            if (ss == f) {
               return dist + 1;
               break;
            }
            vis[ss] = dist + 1;
            q.push({ ss, pp - 1 });
         }
         swap(ss[pp], ss[pp - 1]);
      }
      if (pp < n - 1) {
         swap(ss[pp], ss[pp + 1]);
         if (!vis.count(ss)) {
         if (ss == f) {
            return dist + 1;
            break;
         }
         vis[ss] = dist + 1;
         q.push({ ss, pp + 1 });
      }
      swap(ss[pp], ss[pp + 1]);
   }
   if (pp > 1 && ss[pp - 1] != ss[pp - 2]) {
      swap(ss[pp], ss[pp - 2]);
      if (!vis.count(ss)) {
         if (ss == f) {
            return dist + 1;
            break;
         }
         vis[ss] = dist + 1;
         q.push({ ss, pp - 2 });
      }
      swap(ss[pp], ss[pp - 2]);
   }
   if (pp < n - 2 && ss[pp + 1] != ss[pp + 2]) {
      swap(ss[pp], ss[pp + 2]);
      if (!vis.count(ss)) {
         if (ss == f) {
            return dist + 1;
            break;
         }
         vis[ss] = dist + 1;
         q.push({ ss, pp + 2 });
      }
      swap(ss[pp], ss[pp + 2]);
      }
   }
   return 0;
}
int main(){
   string str1 = "aba_a";
   string str2 = "_baaa";
   cout << "Minimum required moves: " << transformString(str1, str2) << endl;
   return 0;
}

आउटपुट

जब आप उपरोक्त प्रोग्राम को संकलित और निष्पादित करते हैं। यह निम्न आउटपुट उत्पन्न करता है -

Minimum required moves: 2

  1. C++ में दो न्यूमेरिक स्ट्रिंग्स को एक समान बनाने की न्यूनतम लागत

    मान लीजिए कि हमारे पास दो अंकीय तार ए और बी हैं। हमें ए और बी को समान बनाने के लिए न्यूनतम लागत का पता लगाना है। हम केवल एक ही ऑपरेशन कर सकते हैं, यानी हम स्ट्रिंग से अंकों को हटा सकते हैं, संख्या से एक अंक को हटाने की लागत अंकों के मूल्य के समान है। मान लीजिए कि स्ट्रिंग A =6789, B =7859, तो हमें A

  1. C++ में कैरेक्टर को हटाए बिना दो स्ट्रिंग्स एनाग्राम बनाने के लिए आवश्यक न्यूनतम जोड़तोड़

    मान लीजिए कि हमारे पास समान लंबाई के दो तार हैं, हमें किसी भी वर्ण को हटाए बिना दो स्ट्रिंग विपर्यय बनाने के लिए आवश्यक न्यूनतम संख्या में परिवर्तन करना होगा। विपर्यय दो तार होते हैं जिनमें वर्णों का एक ही सेट होता है। मान लीजिए कि दो स्ट्रिंग हैलो हैं, और वर्ल्ड यहां आवश्यक परिवर्तनों की संख्या 3 ह

  1. पायथन में दो स्ट्रिंग्स को बराबर बनाने के लिए आवश्यक प्रीप्रोसेस चालों की न्यूनतम संख्या ज्ञात करें

    मान लीजिए कि हमारे पास समान लंबाई के दो स्ट्रिंग्स P और Q हैं, जिनमें केवल लोअर केस लेटर्स हैं, हमें स्ट्रिंग P पर प्री-प्रोसेसिंग मूव्स की न्यूनतम संख्या को गिनना होगा, इसे नीचे के ऑपरेशनों को लागू करने के बाद स्ट्रिंग Q के बराबर बनाने के लिए आवश्यक है - कोई भी अनुक्रमणिका i चुनें और वर्ण pi और