सी++ में विवश अनुवर्ती योग

मान लीजिए कि हमारे पास अंक और एक पूर्णांक k नामक एक सरणी है, हमें उस सरणी के एक गैर-रिक्त अनुक्रम का अधिकतम योग इस तरह से खोजना होगा कि बाद में हर दो लगातार संख्याओं के लिए, nums[i] और nums[j], जहां i

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

इसलिए, यदि इनपुट [10,2,-9,5,19] और के =2 जैसा है, तो आउटपुट 36 होगा क्योंकि बाद में [10,2,5,19] होगा।

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

• रिट:=-इन्फ

• एक सरणी dp को परिभाषित करें और उसमें दिए गए सरणी को कॉपी करें

• एक डेक डीक्यू परिभाषित करें

• dq की शुरुआत में v[0] डालें

• n:=वी का आकार

• रिट:=वी[0]

• इनिशियलाइज़ करने के लिए मैं :=1, जब i

  • यदि i> k और dq का प्रथम अवयव dp[i - k-1] के समान है, तो

    • dq से सामने का तत्व हटाएं

  • dp[i] :=अधिकतम dp[i] और (यदि dq खाली है, तो dp[i] + 0, अन्यथा dp + dq[i] का पहला तत्व)

  • जबकि (dq खाली नहीं है और dq का अंतिम तत्व

    • dq से अंतिम तत्व हटाएं

  • dq के अंत में dp[i] डालें

  • रिट :=अधिकतम रिट और डीपी[i]

• वापसी रिट

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

उदाहरण

#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 10;
class Solution {
   public:
   int constrainedSubsetSum(vector<int>& v, int k) {
      int ret = -inf;
      vector<int> dp(v.begin(), v.end());
      deque<int> dq;
      dq.push_front(v[0]);
      int n = v.size();
      ret = v[0];
      for (int i = 1; i < n; i++) {
         if (i > k && dq.front() == dp[i - k - 1])
         dq.pop_front();
         dp[i] = max(dp[i], dq.empty() ? dp[i] + 0 : dp[i] +
         dq.front());
         while (!dq.empty() && dq.back() < dp[i])
         dq.pop_back();
         dq.push_back(dp[i]);
         ret = max(ret, dp[i]);
      }
      return ret;
   }
};
main(){
   Solution ob;
   vector<int> v = {10,2,-9,5,19};
   cout << (ob.constrainedSubsetSum(v, 2));
}

इनपुट

{10,2,-9,5,19}, 2

आउटपुट

36