Find permutation which generates lexicographically largest Array of GCD of Prefixes

import java.util.*;

public class Main {
    public static void main(String[] args) {
         int[] A = {2, 1, 4, 8, 16, 32, 5};
        
        // Call the findPermutation method on A and store the result
        int[][] result = findPermutation(A);
        
        // Print the lexicographically greatest permutation of A and its corresponding B
        System.out.print("A = ");
        for (int i = 0; i < result[1].length; i++) {
            System.out.print(result[1][i] + " ");
        }
        System.out.println();
        System.out.print("B = ");
        for (int i = 0; i < result[0].length; i++) {
            System.out.print(result[0][i] + " ");
        }
    }

    public static int[][] findPermutation(int[] A) {
               // Create an ArrayList to store all possible values of B and its corresponding permutation

      List<int[][]> sv = new ArrayList<>();

        // Sort the input array
        Arrays.sort(A);

        // This section uses permutation to go through all permutations of the sorted array A.
        List<int[]> permArr = permute(A);

       // Iterate through each permutation and calculate its corresponding B
        for (int i = 0; i < permArr.size(); i++) {
            // Get the current permutation
            int[] permutation = permArr.get(i);
            
            // Initialize variables to calculate the greatest common divisor and B
            int x = 0;
            int[] B = new int[A.length];

            // Iterate through each element in the current permutation and calculate B
            for (int j = 0; j < permutation.length; j++) {
                // Calculate the greatest common divisor
                x = gcd(x, permutation[j]);
                
                // Set the corresponding element in B to the greatest common divisor
                B[j] = x;
            }

            // Add the current B and its corresponding permutation to the ArrayList
            sv.add(new int[][]{B, permutation});
        }


        // Sort the results to find the best result
        Collections.sort(sv, (a, b) -> {
            int aSum = 0;
            int bSum = 0;
            for (int i = 0; i < a[0].length; i++) {
                aSum += a[0][i];
                bSum += b[0][i];
            }
            return Integer.compare(bSum, aSum);
        });

        // Return the first result because this is lexicographically greatest.
        return sv.get(0);
    }

    public static List<int[]> permute(int[] perms) {
        // Create an ArrayList to store all permutations
        List<int[]> results = new ArrayList<>();

        // If the input array has length 0 or 1, return it as a single permutation
        if (perms.length <= 1) {
            results.add(perms);
            return results;
        }

        // Iterate through each element in the input array
        for (int i = 0; i < perms.length; i++) {
            // Get the current element
            int current = perms[i];
            
            // Create a new array with all elements except the current one
            int[] remaining = new int[perms.length - 1];
            System.arraycopy(perms, 0, remaining, 0, i);
            System.arraycopy(perms, i + 1, remaining, i, perms.length - i - 1);
            
            // Recursively generate all permutations of the remaining elements
            List<int[]> innerPermutations = permute(remaining);
            for (int j = 0; j < innerPermutations.size(); j++) {
                int[] innerPermutation = innerPermutations.get(j);
                int[] res = new int[perms.length];
                res[0] = current;
                System.arraycopy(innerPermutation, 0, res, 1, innerPermutation.length);
                results.add(res);
            }
        }

        return results;
    }

    public static int gcd(int a, int b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }
}

// Java code to implement the approach
import java.io.*;
import java.util.*;

class pair {
  List<Integer> first = new ArrayList<>();
  List<Integer> second = new ArrayList<>();
  public pair(List<Integer> first, List<Integer> second)
  {
    this.first = first;
    this.second = second;
  }
}

class GFG {

  static int gcd(int a, int b)
  {
    if (b == 0)
      return a;
    return gcd(b, a % b);
  }

  // Function to  find the permutation
  static pair Findpermutation(int[] A)
  {
    
    // This array to mark the elements
    // as used so we don't use again.
    boolean[] used = new boolean[A.length];
    Arrays.fill(used, Boolean.FALSE);

    List<Integer> ansA = new ArrayList<>();
    List<Integer> ansB = new ArrayList<>();

    int x = 0;

    for (int i = 0; i < A.length; i++) {

      // This code segment finds
      // the next best element for
      // max gcd of prefix
      int temp = 0, mx_gcd = 0, index = -1;

      // We start with temp, mx_gcd as 0
      // because of gcd property
      // GCD(0, x) = x
      for (int j = 0; j < A.length; j++) {
        if (!used[j])
        {
          
          // We are taking gcd with x
          temp = gcd(x, A[j]);

          // If this gcd is better than before
          // then take this as new index.
          if (temp > mx_gcd) {
            mx_gcd = temp;
            index = j;
          }
        }
      }

      // Take the new best gcd and
      // merge with the previous result
      x = gcd(x, mx_gcd);

      // Mark the element as used
      used[index] = true;

      // Add the element to answer
      ansB.add(x);
      ansA.add(A[index]);
    }

    return new pair(ansA, ansB);
  }

  public static void main(String[] args)
  {

    int[] A = { 2, 1, 4, 8, 16, 32, 5 };

    // Function call
    pair ans = Findpermutation(A);

    System.out.print("A = ");
    for (int i = 0; i < ans.first.size(); i++) {
      System.out.print(ans.first.get(i) + " ");
    }
    System.out.println();

    System.out.print("B = ");
    for (int i = 0; i < ans.second.size(); i++) {
      System.out.print(ans.second.get(i) + " ");
    }
  }
}

// This is contributed by lokesh