इस समस्या में, हमें 2 n . आकार का एक सरणी arr[] दिया जाता है . हमारा काम इसे हल करने के लिए गतिशील प्रोग्रामिंग का उपयोग करके सबसेट पर योग खोजने के लिए एक प्रोग्राम बनाना है।
हमें फ़ंक्शन की गणना करने की आवश्यकता है, F(x) =Σ Ai जैसे कि x&i ==i सभी x के लिए। यानी मैं x का एक बिटवाइज़ उपसमुच्चय है।
समस्या को समझने के लिए एक उदाहरण लेते हैं,
इनपुट: ए[] ={5, 7, 1, 9} , n =2
आउटपुट: 5 12 6 22
स्पष्टीकरण: n =2 के लिए, x के 4 मान हैं। वे 0, 1, 2, 3 हैं।
अब, फ़ंक्शन के मानों की गणना करना:
एफ(0) =ए<उप>0 =5
एफ(1) =ए<उप>0 + ए<उप>1 =5 + 7 =12
एफ(2) =ए<उप>0 + ए<उप>2 =5 + 1 =6
एफ(3) =ए<उप>0 + ए<उप>1 + ए<उप>2 + ए<उप>3 =5 + 7 + 1 + 9 =22
गतिशील प्रोग्रामिंग, . का उपयोग करके इस समस्या का समाधान हम मास्क को देखेंगे और प्रत्येक मास्क का थोड़ा-सा सबसेट पाएंगे। हम डायनेमिक प्रोग्रामिंग का उपयोग करके बिटवाइज़ सबसेट को स्टोर करेंगे, जिससे दोहराव की संख्या कम हो जाएगी। एक इंडेक्स जिसमें एक सेट बिट या एक अनसेट बिट होता है, उस पर 2
n
. द्वारा विजिट किया जाएगा एक से अधिक बार मास्क।
हम i अनुक्रमणिका पर बिट के आधार पर पुनरावृत्ति करेंगे:
जब i-वें बिट सेट हो :
DP(मुखौटा, i) =DP(मुखौटा, i-1) U DP(मास्क 2 i , i-1)
जब i-वें बिट अनसेट हो :
DP(मुखौटा, i) =DP(मुखौटा, i-1)
हमारे समाधान की कार्यप्रणाली को दर्शाने वाला कार्यक्रम,
उदाहरण
#include <iostream>
using namespace std;
const int N = 1000;
void SumOverSubsets(int a[], int n) {
int sum[1 << n] = {0};
int DP[N][N];
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
if (j == 0)
DP[i][j] = a[i] + a[i ^ (1 << j)];
else
DP[i][j] = DP[i][j - 1] + DP[i ^ (1 << j)][j - 1];
} else {
if (j == 0)
DP[i][j] = a[i];
else
DP[i][j] = DP[i][j - 1];
}
}
sum[i] = DP[i][n - 1];
}
for (int i = 0; i < (1 << n); i++)
cout<<sum[i]<<"\t";
}
int main() {
int A[] = {5, 7, 1, 9};
int n = 2;
cout<<"The sum over subsets is \t";
SumOverSubsets(A, n);
return 0;
} आउटपुट
The sum over subsets is 5 12 6 22