सी++ में लाभदायक योजनाएं

मान लीजिए कि G लोगों के साथ एक गिरोह है और विभिन्न अपराधों की एक सूची है जो वे कर सकते हैं। i-th अपराध एक लाभ मूल्य लाभ उत्पन्न करता है [i] और समूह [i] गिरोह के सदस्यों को भाग लेने की आवश्यकता होती है।

यदि गिरोह का कोई सदस्य एक अपराध में भाग ले रहा है, तो वह दूसरे अपराध में भाग नहीं ले सकता। आइए अब हम इन अपराधों के किसी भी उपसमूह को लाभप्रद योजना परिभाषित करें जो कम से कम P लाभ उत्पन्न करता है, और अपराधों के उस उपसमूह में भाग लेने वाले सदस्यों की कुल संख्या अधिकतम G है।

हमें यह पता लगाना होगा कि कितनी योजनाओं को चुना जा सकता है? उत्तर बहुत बड़ा हो सकता है, इसलिए इसे मॉड्यूलो 10^9 + 7 लौटाएं।

इसलिए, यदि इनपुट G =5, P =3 और समूह =[2,2], लाभ =[2,3] जैसा है, तो आउटपुट 2

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

• रिट:=0

• एक 2D सरणी dp आकार (G + 1) x (P + 1)

  . को परिभाषित करें

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

• इनिशियलाइज़ k :=0 के लिए, जब k <ग्रुप का आकार, अपडेट करें (1 से k बढ़ाएँ), करें -

  • पी:=लाभ [के], जी:=समूह [के]

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

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

      • dp[i + g, न्यूनतम P और j + p]

      • dp[i + g, न्यूनतम P और j + p]

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

  • रिट:=रिट + डीपी [i, पी]

  • रिट:=रिट मॉड एम

• वापसी रिट

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

उदाहरण

#include <bits/stdc++.h>
using namespace std;
const int m = 1e9 + 7;
class Solution {
   public:
   int profitableSchemes(int G, int P, vector<int> &group, vector<int> &lprofit) {
      int ret = 0;
      vector<vector<int>> dp(G + 1, vector<int>(P + 1));
      dp[0][0] = 1;
      for (int k = 0; k < group.size(); k++) {
         int p = profit[k];
         int g = group[k];
         for (int i = G - g; i >= 0; i--) {
            for (int j = P; j >= 0; j--) {
               dp[i + g][min(P, j + p)] += dp[i][j];
               dp[i + g][min(P, j + p)] %= m;
            }
         }
      }
      for (int i = 0; i <= G; i++) {
         ret += dp[i][P];
         ret %= m;
      }
      return ret;
   }
};
main(){
   Solution ob;
   vector<int> v = {2,2}, v1 = {2,3};
   cout << (ob.profitableSchemes(5,3,v, v1));
}

इनपुट

5, 3, [2,2], [2,3]

आउटपुट

2