# Largest Divisible Subset in C++

C++Server Side ProgrammingProgramming

#### C in Depth: The Complete C Programming Guide for Beginners

45 Lectures 4.5 hours

#### Practical C++: Learn C++ Basics Step by Step

Most Popular

50 Lectures 4.5 hours

#### Master C and Embedded C Programming- Learn as you go

66 Lectures 5.5 hours

Suppose we have a set of distinct positive integers, we have to find the largest subset such that every pair like (Si, Sj) of elements in this subset satisfies: Si mod Sj = 0 or Sj mod Si = 0.

So if the input is like [1,2,3], the possible result may come like [1,2] or [1,3]

To solve this, we will follow these steps −

• Create an array ret, set endpoint := 0, retLen := 1, n := size of nums

• if n is 0, then return empty set

• sort nums array

• create two arrays len and par of size n, initialize len by 1, and par with 0

• for i in range 1 to n – 1

• par[i] := i

• for j in range 0 to i – 1

• if nums[i] mod nums[j] = 0 and len[j] + 1 > len[i], then

• len[i] := len[j] + 1

• par[i] := j

• if len[j] > retLen, then retLen := len[i] and endpoint := i

• insert nums[endPoint] into ret

• while endpoint is not same as par[endPoint]

• endpoint := par[endPoint]

• insert nums[endPoint] into ret

• reverse the list ret and return ret

## Example(C++)

Let us see the following implementation to get better understanding −

Live Demo

#include <bits/stdc++.h>
using namespace std;
void print_vector(vector<auto> v){
cout << "[";
for(int i = 0; i<v.size(); i++){
cout << v[i] << ", ";
}
cout << "]"<<endl;
}
class Solution {
public:
vector<int> largestDivisibleSubset(vector<int>& nums) {
vector <int> ret;
int endPoint = 0;
int retLen = 1;
int n = nums.size();
if(!n) return {};
sort(nums.begin(), nums.end());
vector <int> len(n, 1);
vector <int> par(n, 0);
for(int i = 1; i < n; i++){
par[i] = i;
for(int j = 0; j < i; j++){
if(nums[i] % nums[j] == 0 && len[j] + 1 > len[i]){
len[i] = len[j] + 1;
par[i] = j;
}
}
if(len[i] > retLen){
retLen = len[i];
endPoint = i;
}
}
ret.push_back(nums[endPoint]);
while(endPoint != par[endPoint]){
endPoint = par[endPoint];
ret.push_back(nums[endPoint]);
}
reverse(ret.begin(), ret.end());
return ret;
}
};
main(){
Solution ob;
vector<int> v = {1,2,3};
print_vector(ob.largestDivisibleSubset(v));
}

## Input

[1,2,3]

## Output

[1, 2, ]