Largest divisible subset in array

import java.util.*;
class GfG{
    
    // Global result to store the best valid subset
    ArrayList<Integer> res = new ArrayList<>();

    // Function to check if every pair in the subset
    // satisfies the divisibility condition
    boolean isValid(ArrayList<Integer> subset) {
        
        for (int i = 0; i < subset.size(); i++) {
            for (int j = i + 1; j < subset.size(); j++) {
        
                int a = subset.get(i), b = subset.get(j);
                // If neither divides the other, it's invalid
                if (a % b != 0 && b % a != 0)
                    return false;
            }
        }
        return true;
    }

    // Function to compare two lists lexicographically
    // Returns true if 'a' is lexicographically greater than 'b'
    boolean isLexGreater(ArrayList<Integer> a, ArrayList<Integer> b) {
        for (int i = 0; i < a.size(); i++) {
            if (!a.get(i).equals(b.get(i)))
                // If different, compare values
                return a.get(i) > b.get(i);  
        }
        return false; // Lists are equal
    }

    // Recursive DFS function to generate all subsets
    void dfs(int[] arr, ArrayList<Integer> curr, int index) {
        
        // Base case: all elements considered
        if (index >= arr.length) {
        
            // Check if current subset is valid
            if (isValid(curr)) {
        
                // If it's longer than current result, update
                if (curr.size() > res.size()) {
                    res = new ArrayList<>(curr);
                } 
        
                // If same size but lexicographically greater, update
                else if (curr.size() == res.size() &&
                         isLexGreater(curr, res)) {
                    res = new ArrayList<>(curr);
                }
        
            }
            return;
        }

        // Include current element in subset
        curr.add(arr[index]);
        dfs(arr, curr, index + 1);

        // Backtrack: exclude current element and continue
        curr.remove(curr.size() - 1);
        dfs(arr, curr, index + 1);
    }

    // Main function to find the largest divisible subset
    public ArrayList<Integer> largestSubset(int[] arr) {
        
        // Sort for consistent lexicographical order
        Arrays.sort(arr); 
        // Clear previous result
        res.clear();      
        // Start DFS with empty subset
        dfs(arr, new ArrayList<>(), 0);
        // Return the best subset found
        return res;       
    }

    // Optional main method for testing
    public static void main(String[] args) {
        
        GfG sol = new GfG();
        int[] arr = {1, 16, 7, 8, 4};
        ArrayList<Integer> result = sol.largestSubset(arr);
        
        // Output the largest divisible subset
        for (int num : result) {
           System.out.print(num + " ");
        }
    }
}

import java.util.*;

class GfG {

    // Recursive function to explore all subsets and track
    // the largest divisible one
    static void lds(ArrayList<Integer> res, ArrayList<Integer> curr,
                    int i, int prev, int[] arr) {

        // Base case: if we've reached the end of the array
        if (i >= arr.length) {
            // If the current subset is larger than the best so far
            // update it
            if (curr.size() > res.size()) {
                res.clear();
                res.addAll(curr);
            } 
            // If both are of equal size, choose the 
            // lexicographically greater one
            else if (curr.size() == res.size()) {
                for (int j = 0; j < curr.size(); j++) {
                    if (curr.get(j) > res.get(j)) {
                        res.clear();
                        res.addAll(curr);
                        break;
                    } 
                    else if (curr.get(j) < res.get(j)) {
                        // No need to check further if current 
                        // is already smaller
                        break;
                    }
                }
            }
            return;
        }

        // Include arr[i] if it is divisible by 'prev'
        // Or if curr is empty (first element)
        if (curr.isEmpty() || arr[i] % prev == 0) {
            // Choose the current element
            curr.add(arr[i]);                     
            // Recurse with updated prev and index
            lds(res, curr, i + 1, arr[i], arr);   
            // Backtrack: remove last added element
            curr.remove(curr.size() - 1);         
        }

        // Exclude arr[i] and move to next element
        lds(res, curr, i + 1, prev, arr);
    }

    // Main function to find the largest divisible subset
    static ArrayList<Integer> largestSubset(int[] arr) {
        // Sort array for easier lexicographical comparison
        Arrays.sort(arr);  
        // Final result holder
        ArrayList<Integer> res = new ArrayList<>();   
        // Temporary subset during recursion
        ArrayList<Integer> curr = new ArrayList<>();  
        // Start recursive DFS with initial prev = 1
        lds(res, curr, 0, 1, arr);               
        // Return the largest valid subset found
        return res;                              
    }

    public static void main(String[] args) {
        
        // Input array
        int[] arr = {1, 16, 7, 8, 4}; 

        // Find the largest divisible subset
        ArrayList<Integer> res = largestSubset(arr);

        // Print the result elements space-separated
        for (int num : res) {
            System.out.print(num + " ");
        }
    }
}

import java.util.*;

class GfG {

    // Recursive function to compute the length of the 
    // largest divisible subset ending at index i
    static int lds(int[] arr, int[] memo, int[] parent, int i) {
        
        if (memo[i] != -1) {
            // Return previously computed result
            return memo[i]; 
        }

        int maxLength = 1;
        int bestParent = -1;

        // Try including arr[i] in the subset by checking all j < i
        for (int j = 0; j < i; j++) {
            if (arr[j] % arr[i] == 0) { 
                
                // Condition for divisibility
                int length = lds(arr, memo, parent, j) + 1;
                if (length > maxLength) {
                    maxLength = length;
                    bestParent = j;
                }
            }
        }

        memo[i] = maxLength;
        parent[i] = bestParent;
        return maxLength;
    }

    // Main function to find the largest divisible subset
    static ArrayList<Integer> largestSubset(int[] arr) {
        int n = arr.length;

        // Sort the array in descending order
        Integer[] boxedArr = Arrays.stream(arr).boxed().
                                    toArray(Integer[]::new);
        Arrays.sort(boxedArr, Collections.reverseOrder());

        // Convert back to primitive int array
        for (int i = 0; i < n; i++) {
            arr[i] = boxedArr[i];
        }

        int[] memo = new int[n];     
        int[] parent = new int[n];   
        Arrays.fill(memo, -1);
        Arrays.fill(parent, -1);

        int maxSize = 0;
        int lastIndex = 0;

        // Try starting the subset at each index
        for (int i = 0; i < n; i++) {
            int size = lds(arr, memo, parent, i);
            if (size > maxSize) {
                maxSize = size;
                lastIndex = i;
            }
        }

        // Backtrack to construct the subset
        ArrayList<Integer> res = new ArrayList<>();
        for (int i = lastIndex; i >= 0; i = parent[i]) {
            res.add(arr[i]);
            if (parent[i] == -1) break;
        }

        // Since we built from end to start, no need to reverse
        // (already descending)
        return res;
    }

    public static void main(String[] args) {
        int[] arr = { 1, 16, 7, 8, 4 };

        ArrayList<Integer> res = largestSubset(arr);
        for (int num : res) {
            System.out.print(num + " ");
        }
    }
}

import java.util.*;

class GfG {

    // Function to find the largest divisible subset
    static ArrayList<Integer> largestSubset(int[] arr) {
		
      	int n = arr.length; 
        Arrays.sort(arr);
        
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        // Table to store the size of the 
      	// largest subset
        int[] dp = new int[n];
        Arrays.fill(dp, 1);

        // To keep track of previous elements
        int[] parent = new int[n];
        Arrays.fill(parent, -1);

        // Variables to track the maximum subset
        // size and last index
        int maxSize = 1;
        int lastIndex = 0;

        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (arr[j] % arr[i] == 0
                    && dp[i] < dp[j] + 1) {
                    dp[i] = dp[j] + 1;
                    parent[i] = j;
                }
            }

            // Update maxSize and lastIndex
            if (dp[i] > maxSize) {
                maxSize = dp[i];
                lastIndex = i;
            }
        }

        // Backtrack to construct the subset
        ArrayList<Integer> res = new ArrayList<>();
        for (int i = lastIndex; i >= 0; i = parent[i]) {
            res.add(arr[i]);
            if (parent[i] == -1)
                break;
        }
        return res;
    }

    public static void main(String[] args) {
        int[] arr = { 1, 16, 7, 8, 4 };

        ArrayList<Integer> res = largestSubset(arr);
        for (int num : res) {
            System.out.print(num + " ");
        }
    }
}