A non-empty array A consisting of N integers is given.
A monotonic pair is a pair of integers (P, Q), such that 0 ≤ P ≤ Q < N and A[P] ≤ A[Q].
The goal is to find the monotonic pair whose indices are the furthest apart. More precisely, we should maximize the value Q − P. It is sufficient to find only the distance.
For example, consider array A such that:
A[0] = 5 A[1] = 3 A[2] = 6 A[3] = 3 A[4] = 4 A[5] = 2There are eleven monotonic pairs: (0,0), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (3, 3), (3, 4), (4, 4), (5, 5). The biggest distance is 3, in the pair (1, 4).
Write a function:
class Solution { public int solution(int[] A); }
that, given a non-empty array A of N integers, returns the biggest distance within any of the monotonic pairs.
For example, given:
A[0] = 5 A[1] = 3 A[2] = 6 A[3] = 3 A[4] = 4 A[5] = 2the function should return 3, as explained above.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..300,000];
- each element of array A is an integer within the range [−1,000,000,000..1,000,000,000].
// you can also use imports, for example:
// import java.math.*;
import java.util.*;
class Solution {
public int solution(int[] A) {
if(A.length == 1)
{
return 0;
}
IndicesComparator comparator = new IndicesComparator(A);
Integer[] indices = comparator.createIndicesArray();
Arrays.sort(indices, comparator);
int max = 0;
int curI;
for(int i = 0; i < indices.length; i++)
{
curI = i;
for(int j = curI + 1; j < indices.length; j++)
{
i++;
if(indices[j] >= indices[curI])
{
max = Math.max(max, (indices[j] - indices[curI]));
}
else
{
max = Math.max(max, (indices[j - 1] - indices[curI]));
break;
}
}
}
return max;
}
}
class IndicesComparator implements Comparator<Integer>
{
private final int[] array;
public IndicesComparator(int[] a)
{
this.array = a;
}
@Override
public int compare(Integer index1, Integer index2)
{
if(array[index1] > array[index2])
{
return 1;
}
else if(array[index1] < array[index2])
{
return -1;
}
else
{
return 0;
}
}
public Integer[] createIndicesArray()
{
Integer[] indices = new Integer[array.length];
for(int i = 0; i < array.length; i++)
{
indices[i] = i;
}
return indices;
}
}
// you can also use imports, for example:
// import java.math.*;
import java.util.*;
class Solution {
public int solution(int[] A) {
if(A.length == 1)
{
return 0;
}
IndicesComparator comparator = new IndicesComparator(A);
Integer[] indices = comparator.createIndicesArray();
Arrays.sort(indices, comparator);
int max = 0;
int curI;
for(int i = 0; i < indices.length; i++)
{
curI = i;
for(int j = curI + 1; j < indices.length; j++)
{
i++;
if(indices[j] >= indices[curI])
{
max = Math.max(max, (indices[j] - indices[curI]));
}
else
{
max = Math.max(max, (indices[j - 1] - indices[curI]));
i = j - 1;
break;
}
}
}
return max;
}
}
class IndicesComparator implements Comparator<Integer>
{
private final int[] array;
public IndicesComparator(int[] a)
{
this.array = a;
}
@Override
public int compare(Integer index1, Integer index2)
{
if(array[index1] > array[index2])
{
return 1;
}
else if(array[index1] < array[index2])
{
return -1;
}
else
{
return 0;
}
}
public Integer[] createIndicesArray()
{
Integer[] indices = new Integer[array.length];
for(int i = 0; i < array.length; i++)
{
indices[i] = i;
}
return indices;
}
}
// you can also use imports, for example:
// import java.math.*;
import java.util.*;
class Solution {
public int solution(int[] A) {
if(A.length == 1)
{
return 0;
}
IndicesComparator comparator = new IndicesComparator(A);
Integer[] indices = comparator.createIndicesArray();
Arrays.sort(indices, comparator);
int max = 0;
int curI;
for(int i = 0; i < indices.length; i++)
{
curI = i;
for(int j = curI + 1; j < indices.length; j++)
{
i++;
if(indices[j] >= indices[curI])
{
max = Math.max(max, (indices[j] - indices[curI]));
}
else
{
max = Math.max(max, (indices[j - 1] - indices[curI]));
i = j - 1;
break;
}
}
}
return max;
}
}
class IndicesComparator implements Comparator<Integer>
{
private final int[] array;
public IndicesComparator(int[] a)
{
this.array = a;
}
@Override
public int compare(Integer index1, Integer index2)
{
if(array[index1] > array[index2])
{
return 1;
}
else if(array[index1] < array[index2])
{
return -1;
}
else
{
return 0;
}
}
public Integer[] createIndicesArray()
{
Integer[] indices = new Integer[array.length];
for(int i = 0; i < array.length; i++)
{
indices[i] = i;
}
return indices;
}
}
// you can also use imports, for example:
// import java.math.*;
import java.util.*;
class Solution {
public int solution(int[] A) {
if(A.length == 1)
{
return 0;
}
IndicesComparator comparator = new IndicesComparator(A);
Integer[] indices = comparator.createIndicesArray();
Arrays.sort(indices, comparator);
int max = 0;
int curI;
for(int i = 0; i < indices.length; i++)
{
curI = i;
for(int j = curI + 1; j < indices.length; j++)
{
i++;
if(indices[j] >= indices[curI])
{
max = Math.max(max, (indices[j] - indices[curI]));
}
else
{
max = Math.max(max, (indices[j - 1] - indices[curI]));
i = j - 1;
break;
}
}
}
return max;
}
}
class IndicesComparator implements Comparator<Integer>
{
private final int[] array;
public IndicesComparator(int[] a)
{
this.array = a;
}
@Override
public int compare(Integer index1, Integer index2)
{
if(array[index1] > array[index2])
{
return 1;
}
else if(array[index1] < array[index2])
{
return -1;
}
else
{
return 0;
}
}
public Integer[] createIndicesArray()
{
Integer[] indices = new Integer[array.length];
for(int i = 0; i < array.length; i++)
{
indices[i] = i;
}
return indices;
}
}
The solution obtained perfect score.