Find k pairs with smallest sums in two arrays | Set 2

// Java program to print 
// the k smallest pairs 
// | Set 2
import java.util.*;
class GFG{

static class _pair 
{
  int first, second;
};

// Function to print the K 
// smallest pairs
static void printKPairs(int a1[], int a2[], 
                        int size1, int size2, 
                        int k)
{
  // if k is greater than 
  // total pairs
  if (k > (size2 * size1))
  {
    System.out.print("k pairs don't exist\n");
    return;
  }

  // _pair _one keeps track of
  // 'first' in a1 and 'second' in a2
  // in _two, _two.first keeps track of
  // element in the a2[] and _two.second
  // in a1[]
  _pair _one = new _pair();
  _pair  _two = new _pair();
  _one.first = _one.second = 
  _two.first = _two.second = 0;

  int cnt = 0;

  // Repeat the above process 
  // till all K pairs are printed
  while (cnt < k) 
  {
    // when both the pointers are 
    // pointing to the same elements 
    // (point 3)
    if (_one.first == _two.second && 
        _two.first == _one.second) 
    {
      if (a1[_one.first] < 
          a2[_one.second]) 
      {
        System.out.print("[" +  a1[_one.first] + 
                         ", " +  a2[_one.second] + 
                         "] ");

        // updates according to step 1
        _one.second = (_one.second + 1) % 
                       size2;
        
        // see point 2
        if (_one.second == 0) 
          _one.first = (_one.first + 1) % 
                        size1;

        // updates opposite to step 1
        _two.second = (_two.second + 1) % 
                       size2;
        
        if (_two.second == 0)
          _two.first = (_two.first + 1) % 
                        size2;
      }
      else
      {
        System.out.print("[" +  a2[_one.second] + 
                         ", " +  a1[_one.first] + 
                         "] ");

        // updates according to rule 1
        _one.first = (_one.first + 1) % 
                      size1;
        
        // see point 2
        if (_one.first == 0) 
          _one.second = (_one.second + 1) % 
                         size2;

        // updates opposite to rule 1
        _two.first = (_two.first + 1) % 
                      size2;
        
        // see point 2
        if (_two.first == 0) 
          
          _two.second = (_two.second + 1) % 
                         size1;
      }
    }
    
    // else update as 
    // necessary (point 1)
    else if (a1[_one.first] + 
             a2[_one.second] <= 
             a2[_two.first] + 
             a1[_two.second]) 
    {
      if (a1[_one.first] <
          a2[_one.second]) 
      {
        System.out.print("[" +  a1[_one.first] + 
                         ", " + a2[_one.second] + 
                         "] ");

        // updating according to rule 1
        _one.second = ((_one.second + 1) % 
                        size2);
        
        // see point 2
        if (_one.second == 0) 
          _one.first = (_one.first + 1) % 
                        size1;
      }
      else 
      {
        System.out.print("[" +  a2[_one.second] +
                         ", " + a1[_one.first] + 
                         "] ");

        // updating according to rule 1
        _one.first = ((_one.first + 1) % 
                       size1);
        
        // see point 2
        if (_one.first == 0) 
          _one.second = (_one.second + 1) % 
                         size2;
      }
    }
    else if (a1[_one.first] + 
             a2[_one.second] > 
             a2[_two.first] + 
             a1[_two.second]) 
    {
      if (a2[_two.first] < 
          a1[_two.second]) 
      {
        System.out.print("[" +  a2[_two.first] + 
                         ", " +  a1[_two.second] + 
                         "] ");

        // updating according to rule 1
        _two.first = ((_two.first + 1) % 
                       size2);
        
        // see point 2
        if (_two.first == 0) 
          _two.second = (_two.second + 1) % 
                         size1;
      }
      else {
        System.out.print("[" +  a1[_two.second] + 
                         ", " +  a2[_two.first] + 
                         "] ");

        // updating according to rule 1
        _two.second = ((_two.second + 1) % 
                        size1);
        
        // see point 2
        if (_two.second == 0) 
          _two.first = (_two.first + 1) % 
                        size1;
      }
    }
    cnt++;
  }
}

// Driver Code
public static void main(String[] args)
{
  int a1[] = {2, 3, 4};
  int a2[] = {1, 6, 5, 8};
  int size1 = a1.length;
  int size2 = a2.length;
  int k = 4;
  printKPairs(a1, a2,
              size1, size2, k);
}
}

// This code is contributed by gauravrajput1 

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;

public class Main {
    // Function to find the k smallest pairs from two arrays
    public static List<int[]> kSmallestPairs(int[] a1, int[] a2, int k) {
        // Create a list to store pairs
        List<int[]> pairs = new ArrayList<>();

        // Iterate through the elements of a1 and a2 to generate pairs
        for (int x : a1) {
            for (int y : a2) {
                pairs.add(new int[]{x, y});
            }
        }

        // Sort the pairs based on the sum of elements in each pair
        Collections.sort(pairs, new Comparator<int[]>() {
            @Override
            public int compare(int[] p1, int[] p2) {
                return Integer.compare(p1[0] + p1[1], p2[0] + p2[1]);
            }
        });

        // Return the first k pairs
        if (k < pairs.size()) {
            pairs.subList(k, pairs.size()).clear();
        }

        return pairs;
    }

    public static void main(String[] args) {
        // Example 1
        int[] a1 = {1, 7, 11};
        int[] a2 = {2, 4, 6};
        int k = 3;
        List<int[]> result1 = kSmallestPairs(a1, a2, k);

        System.out.print("Example 1 Output: [");
        for (int i = 0; i < result1.size(); i++) {
            int[] pair = result1.get(i);
            System.out.print("(" + pair[0] + ", " + pair[1] + ")");
            if (i != result1.size() - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");

        // Example 2
        a1 = new int[]{2, 3, 4};
        a2 = new int[]{1, 6, 5, 8};
        k = 4;
        List<int[]> result2 = kSmallestPairs(a1, a2, k);

        System.out.print("Example 2 Output: [");
        for (int i = 0; i < result2.size(); i++) {
            int[] pair = result2.get(i);
            System.out.print("(" + pair[0] + ", " + pair[1] + ")");
            if (i != result2.size() - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");
    }
}