## Wednesday, May 25, 2016

### Pairs across 2 sorted arrays with K largest sum

https://discuss.leetcode.com/topic/17/pairs-across-2-sorted-arrays-with-k-largest-sum
Find the pairs across 2 sorted arrays with K largest sum
ex : // A={1, 2, 4, 5, 6}, B={3, 5, 7, 9} K = 3 result = (1, 3),(2, 3),(1, 5)
You can reuse each individual element from either array, but the pair itself should not be reused.
What if an array contains duplicates?
A = [1,1,2]
B = [1,2,3]
Should the answer be: (1,1), (1,1), (1,2)?

``````static class Pair{
int aValue;
int bValue;
int aIndex;
int bIndex;
public Pair(int aValue,int bValue,int aIndex,int bIndex){
this.aValue = aValue;
this.bValue = bValue;
this.aIndex = aIndex;
this.bIndex = bIndex;
}
public boolean equals(Object other){
return ((Pair)other).aValue+((Pair)other).bValue==this.bValue+this.aValue;
}

public String toString(){
return "(" + this.aValue+" , "+this.bValue+")";
}
}

public static void main(String[] args) {
int [] A={1,1, 2, 4, 5, 6};
int [] B={3,3, 5, 7, 9};
int k =3;

ArrayList<Pair> parkedPairs = new ArrayList<Pair>();
int solutionFound =1;
int Aindex =0;
int Bindex = 0;
ArrayList<Pair> solution = new ArrayList<Pair>();
while(solutionFound<k){
if(Aindex<A.length && Bindex< B.length ){
int AincrementSolution = A[Aindex+1] + B[Bindex] ;
int BincrementSolution = A[Aindex] + B[Bindex+1] ;
int stackSolution = Integer.MAX_VALUE;
Pair solutionPair =null;
if(!parkedPairs.isEmpty()){
Pair parked = parkedPairs.get(0);
stackSolution = parked.aValue+parked.bValue;
}

if(AincrementSolution <= BincrementSolution && AincrementSolution < stackSolution){
Aindex = Aindex+1;
solutionPair = new Pair(A[Aindex],B[Bindex],Aindex,Bindex);

}
else{
if(BincrementSolution < AincrementSolution && BincrementSolution < stackSolution){
Bindex = Bindex+1;
solutionPair = new Pair(A[Aindex],B[Bindex],Aindex,Bindex);
}
else{

solutionPair = parkedPairs.remove(0);

}
}

if(!solution.contains(solutionPair)){
solutionFound++;
}

}
}``````

``````class Pair {
int a; int b;

public Pair(int a, int b) {
this.a = a;
this.b = b;
}
}

public Pair[] KPairs(int[] array1, int[] array2, int n) {

class PairComparator implements Comparator<Pair> {

@Override
public int compare(Pair p1, Pair p2) {
return (array1[p1.a] + array2[p1.b]) - (array1[p2.a] + array2[p2.b]);
}
}

Pair[] result = new Pair[100];

boolean[][] visitedPairs = new boolean[array1.length][array2.length];

PriorityQueue<Pair> pairs = new PriorityQueue<>(array1.length * array2.length, new PairComparator());

pairs.offer(new Pair(0, 0));
visitedPairs[0][0] = true;

for (int position = 0; position < n; position++) {

//poll the minimum element and add to the result
Pair peek = pairs.poll();
result[position] = new Pair(array1[peek.a], array2[peek.b]);

int i = peek.a;
int j = peek.b;

if (i < array1.length - 1 && !visitedPairs[i + 1][j]) {
pairs.offer(new Pair(i + 1, j));
visitedPairs[i + 1][j] = true;

}
if (j < array2.length - 1 && !visitedPairs[i][j + 1]) {
pairs.offer(new Pair(i, j + 1));
visitedPairs[i][j + 1] = true;
}
}

return result;
}``````