C++ में आसन्न तत्वों वाले सरणियों की गिनती जहां एक दूसरे को विभाजित करता है

समस्या विवरण

दो पूर्णांक one और another दिए गए हैं। लक्ष्य संभावित सरणियों की संख्या ज्ञात करना है जैसे कि:

सरणी में तत्व 1 और another के बीच की रेंज में हैं।
सरणी के सभी तत्व ऐसे हैं कि arr[i], arr[i+1] को विभाजित करता है या arr[i+1], arr[i+2] को विभाजित करता है... और इसी तरह।
सरणी की लंबाई one है।

उदाहरण

इनपुट

one = 3, another = 2

आउटपुट

आसन्न तत्वों वाले सरणियों की गिनती: 8

व्याख्या

सरणियां होंगी: [1,1,1], [1,1,2], [1,2,1], [1,2,2], [2,1,1], [2,1,2], [2,2,1], [2,2,2]

इनपुट

one = 2, another = 3

आउटपुट

आसन्न तत्वों वाले सरणियों की गिनती: 7

व्याख्या

सरणियां होंगी: [1,1], [2,2], [3,3], [1,2], [1,3], [2,2], [3,3]

दृष्टिकोण

हम जानते हैं कि प्रत्येक सरणी का पहला तत्व रेंज [1, another] में कोई भी संख्या हो सकती है। अगला तत्व हमेशा पिछले का गुणक या गुणनखंड होगा ताकि विभाज्यता की शर्त बनी रहे। साथ ही गुणनखंड या गुणक another से कम होना चाहिए। हम गणनाओं को संग्रहीत करने के लिए डायनामिक प्रोग्रामिंग का उपयोग करेंगे। इसके लिए हम सरणी arr[][] का उपयोग करते हैं। arr[1][another] 1 होगा क्योंकि वे एकल तत्व सरणियां होंगी। arr[i][j] = arr[i-1][j] + पिछले तत्व के गुणनखंड + पिछले तत्व के गुणक (another से कम)।

एल्गोरिदम चरण

पूर्णांक one और another इनपुट के रूप में लें।
फंक्शन adjacent_elements(int first, int second) उन सरणियों की गिनती लौटाता है जिनमें सभी आसन्न तत्व ऐसे हैं कि एक दूसरे को विभाजित करता है।
प्रारंभिक गिनती 0 और सरणी arr[size][size] लें।
memset का उपयोग करके सभी गिनती को 0 से प्रारंभ करें।
दो वेक्टर लें - vec गुणनखंड संग्रहीत करने के लिए और vec_2 गुणक संग्रहीत करने के लिए।
दो for लूप का उपयोग करके i=1 से i=second और j=2*i से j=second तक पार करें। j को i से बढ़ाएं।
i को vec[j] में जोड़ें और j को vec_2[i] में जोड़ें। j लूप के बाद i को vec[i] में भी जोड़ें।
for लूप का उपयोग करके arr[1][i] सेट करें।
सरणी को फिर से पार करें और अब vec और vec_2 को पार करें और गुणनखंड और गुणक को arr[i][j] में जोड़ें।
अंत में सभी arr[first][i] को गिनती में जोड़ें और vec[i] और vec_2[i] को साफ़ करें।
परिणाम के रूप में गिनती लौटाएं।

C++ कोड उदाहरण

#include <bits/stdc++.h>
using namespace std;
#define SIZE 1000

int adjacent_elements(int first, int second) {
    int count = 0;
    int arr[SIZE][SIZE];
    memset(arr, 0, sizeof arr);
    vector<int> vec[SIZE], vec_2[SIZE];
    
    for (int i = 1; i <= second; i++) {
        for (int j = 2*i; j <= second; j += i) {
            vec[j].push_back(i);
            vec_2[i].push_back(j);
        }
        vec[i].push_back(i);
    }
    
    for (int i = 1; i <= second; i++) {
        arr[1][i] = 1;
    }
    
    for (int i = 2; i <= first; i++) {
        for (int j = 1; j <= second; j++) {
            arr[i][j] = 0;
            for (auto it: vec[j]) {
                arr[i][j] += arr[i-1][it];
            }
            for (auto it : vec_2[j]) {
                arr[i][j] += arr[i-1][it];
            }
        }
    }
    
    for (int i = 1; i <= second; i++) {
        count = count + arr[first][i];
        vec[i].clear();
        vec_2[i].clear();
    }
    return count;
}

int main() {
    int one = 2, another = 2;
    cout << "आसन्न तत्वों वाले सरणियों की गिनती: " << adjacent_elements(one, another);
    return 0;
}

आउटपुट

आसन्न तत्वों वाले सरणियों की गिनती: 4