C++ में दिए गए स्ट्रिंग से k अद्वितीय परिणाम खोजने के बाद लागत का पता लगाने का कार्यक्रम

मान लीजिए, हमारे पास एक स्ट्रिंग s और दूसरा मान k है। हमें s के कुछ बाद के क्रमों का चयन करना होगा, ताकि हम k अद्वितीय अनुगामी प्राप्त कर सकें। यहां, बाद के चयन की लागत (ओं) की लंबाई (अनुक्रम) की लंबाई के बराबर होती है। इसलिए, हमें k अद्वितीय अनुक्रमों का चयन करने के बाद संभव न्यूनतम कुल लागत का पता लगाना होगा। यदि हम इस सेट का पता नहीं लगा पाते हैं, तो हम -1 पर लौट आएंगे। हम खाली स्ट्रिंग को एक मान्य बाद के रूप में मानेंगे।

इसलिए, यदि इनपुट s ="pqrs", k =4 जैसा है, तो आउटपुट 3 होगा।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

• n :=s का आकार

• एक 2D सरणी dp आकार (n + 1) x (n + 1) परिभाषित करें और इसे 0

  से प्रारंभ करें

• एक मानचित्र को अंतिम परिभाषित करें

• डीपी [0, 0] :=1

• इनिशियलाइज़ i :=0 के लिए, जब i

  • डीपी [i + 1, 0]:=1

  • इनिशियलाइज़ j :=(i + 1) के लिए, जब j>=1, अपडेट करें (j को 1 से घटाएं), करें -

    • डीपी [i + 1, j]:=dp [i, j] + dp [i, j - 1]

  • यदि s[i] अंतिम का अंतिम तत्व नहीं है, तो -

    • इनिशियलाइज़ j :=0 के लिए, जब j <=last[s[i]], अपडेट करें (j को 1 से बढ़ाएँ), करें -

      • डीपी [i + 1, j + 1] - =dp [अंतिम [s[i]], j]

  • अंतिम [एस [i]]:=मैं

• लागत :=0

• प्रारंभ करने के लिए i :=n, जब i>=0, अद्यतन करें (i से 1 घटाएं), करें -

  • वैल :=न्यूनतम k और dp[n, i]

  • लागत :=लागत + (वैल * (n - i))

  • के:=के - डीपी [एन, आई]

  • अगर के <=0, तो -

    • लूप से बाहर आएं

• अगर के <=0, तो -

  • वापसी लागत

• वापसी -1

उदाहरण

आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

#include <bits/stdc++.h>
using namespace std;
int solve(string s, int k) {
   int n = s.size();
   vector<vector<int>> dp(n + 1, vector<int>(n + 1, 0));
   unordered_map<char, int> last;
   dp[0][0] = 1;
   for (int i = 0; i < n; i++) {
      dp[i + 1][0] = 1;
      for (int j = (i + 1); j >= 1; j--) {
         dp[i + 1][j] = dp[i][j] + dp[i][j - 1];
      }
      if (last.find(s[i]) != last.end()) {
         for (int j = 0; j <= last[s[i]]; j++) {
            dp[i + 1][j + 1] -= dp[last[s[i]]][j];
         }
      }
      last[s[i]] = i;
   }
   int cost = 0;
   for (int i = n; i >= 0; i--) {
      int val = min(k, dp[n][i]);
      cost += (val * (n - i));
      k -= dp[n][i];
      if (k <= 0) {
         break;
      }
   }
   if (k <= 0) {
      return cost;
   }
   return -1;
}
int main(){
   cout << solve("pqrs",4) << endl;
   return 0;
}

इनपुट:

"pqrs", 4

आउटपुट

3