C++ में एक-दूसरे को अलग-अलग टोपियां पहनने के तरीकों की संख्या

मान लीजिए कि n लोग हैं और 40 विभिन्न प्रकार की टोपियां हैं जिन्हें 1 से 40 तक लेबल किया गया है। अब एक 2डी सूची दी गई है जिसे टोपियां कहा जाता है, जहां टोपियां[i] सभी टोपियों की एक सूची है i-वें व्यक्ति द्वारा पसंद किया जाता है। हमें उन तरीकों की संख्या का पता लगाना है जिनसे n लोग एक-दूसरे को अलग-अलग टोपियाँ पहनते हैं। उत्तर बहुत बड़ा हो सकता है, इसलिए उत्तर मॉड्यूल 10^9 + 7 लौटाएं।

इसलिए, यदि इनपुट [[4,6,2], [4,6]] जैसा है, तो आउटपुट 4 होगा, क्योंकि चुनने के 4 अलग-अलग तरीके हैं, ये हैं [4,6], [6, 4], [2,4], [2,6]।

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

• मी =10^9 + 7

• 55 x 2^11

  आकार के 2D सरणी dp को परिभाषित करें

• एक 2डी सरणी को परिभाषित करें v

• फ़ंक्शन ऐड () को परिभाषित करें, इसमें a, b,

  . लगेगा

• वापसी ((एक मॉड एम) + (बी मॉड एम)) मॉड एम

• एक फ़ंक्शन हल करें () को परिभाषित करें, यह idx, मास्क,

  लेगा

• यदि मास्क req के समान है, तो -

  • वापसी 1

• यदि idx 42 के समान है, तो -

  • वापसी 0

• अगर dp[idx, mask] -1 के बराबर नहीं है, तो -

  • वापसी डीपी [आईडीएक्स, मुखौटा]

• रिट:=जोड़ें (रिट, हल करें (आईडीएक्स + 1, मास्क))

• सभी के लिए मैं v[idx]sk में))

  • अगर (शिफ्ट मास्क i बिट टू राइट) सम है, तो

    • रिट =जोड़ें (रिट, हल करें (idx + 1, मास्क या 2^i))

• dp[idx, mask] :=ret

• वापसी रिट

• मुख्य विधि से निम्न कार्य करें -

• -1 के साथ dp को इनिशियलाइज़ करें

• n :=x का आकार

• v अपडेट करें ताकि इसमें 50 तत्व शामिल हो सकें

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

  • x[i]

    . में सभी j के लिए

    • v[j]

      . के अंत में i डालें

• अनुरोध :=(2^n) - 1

• रिट:=हल करें (0, 0)

• वापसी रिट

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

उदाहरण

#include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
int m = 1e9 + 7;
int dp[55][1 << 11];
class Solution {
   public:
   vector<vector<int> > v;
   int req ;
   int add(lli a, lli b){
      return ((a % m) + (b % m)) % m;
   }
   int solve(int idx, int mask){
      if (mask == req)
      return 1;
      if (idx == 42)
      return 0;
      if (dp[idx][mask] != -1) {
         return dp[idx][mask];
      }
      int ret = add(ret, solve(idx + 1, mask));
      for (int i : v[idx]) {
         if (!((mask >> i) & 1)) {
            ret = add(ret, solve(idx + 1, mask | (1 << i)));
         }
      }
      return dp[idx][mask] = ret;
   }
   int numberWays(vector<vector<int>>& x){
      memset(dp, -1, sizeof dp);
      int n = x.size();
      v.resize(50);
      for (int i = 0; i < x.size(); i++) {
         for (int j : x[i]) {
            v[j].push_back(i);
         }
      }
      req = (1 << n) - 1;
      int ret = solve(0, 0);
      return ret;
   }
};
main(){
   Solution ob;
   vector<vector<int>> v = {{4,6,2},{4,6}};
   cout << (ob.numberWays(v));
}

इनपुट

{{4,6,2},{4,6}}

आउटपुट

4