Algorithm time optimization for a very simple algorithm - algorithm

Question

I have this piece of code I developed in an algorithm.
It finds the first element of an array that is greater than a given one for a fixed amount.
It iterates using all the array elements as a comparing item and print the result for any given comparing item
for(i=0; i<N; i++) {
for (t = i + 1; t < N - 1; t++) {
if (H[t] - H[i] > VSQR)
break;
}
printf("%d ", t - 1); // print the result
}
The algorithm results too slow for big arrays, but I cannot find any optimization.

Answer 1

The idea of the O(nlogn) algorithm:
First we need to realize that only the heights we can see from some position matter (assuming bigger heights hide smaller heights, similar to the sky scraper logic puzzle). That's because if an height is high enough and meets our constraints we would stop there and if it isn't high enough then surely the smaller heights behind it don't matter.
If we only look at the heights that matter, they will be ordered from smallest to highest. So if we only have those heights we can do a binary search on them. We get the heights that matter by going backwards and discarding all heights behind us that are smaller or equal to the current height.
After that we do a binary search on the remaining heights to find the correct one.
Finally we insert the current height into the heights that matter.
We can implement this using arrays. The heights that matter will be stored in decreasing order (highest first, lowest last). This means that to discard all heights smaller or equal to the current one we can do a binary search and just set the size to a different value, so all smaller ones are not in our scope any more. Then we can do a binary search on that array to find the correct height. We use a second array just to store the index of the heights that matter, so we can get the result immediately. Finally to insert the current height we just add it at the end of the heights array, because it is now the smallest height that matters and the array is sorted in decreasing order.
The time complexity is O(nlogn) because the binary search to find the values to discard is O(logn) and the binary search to find the result is also O(logn). We do this n times. O(n) * (O(logn) + O(logn)) = O(2nlogn) = O(nlogn)
So it could be implemented like this:
int[] heights = new int[N]; // we need to add at most N values
int[] indices = new int[N]; // therefore just make array length N
int[] result = new int[N];
heights[0] = H[N - 1];
indices[0] = N - 1;
result[N - 1] = N - 1;
int size = 1;
for (int i = N - 2; i >= 0; i--) {
size = binarySearch(heights, H[i], 0, size) + 1; // discards all values <= H[i]
if (size == 0) {
result[i] = N - 1;
} else {
int x = binarySearch(heights, H[i] + VSQR, 0, size); // find result
result[i] = x < 0 ? N - 1 : indices[x] - 1;
}
heights[size] = H[i]; // add height at the end
indices[size] = i;
size++;
}
// binarySearch(array, value, from, to) returns the index of the smallest
// number which is greater than 'value' in the range 'from' <= i < 'to'
// or returns -1 if there is none
Old answer, before realizing AVL tree is not needed:
It is possible to get O(nlogn) instead of O(n^2) by using an AVL tree and going backwards.
The height value is used for the positioning in the tree, but along with this value we also store the index in the node. Also create an array for the results.
Then for each height (going backwards from the last one until the first one) do the following:
Remove all items <= H[i] from the tree. Find and set the result using the tree (that's why we also need the index in the node, so we can get the result easily). The value we are looking for is the smallest value > H[i] + VSQR (if the tree is empty or if there is no value big enough then the result is N - 1). Insert H[i] into the tree.

Answer 2

After you posting more info this is what you can do:
find all local min,max O(n)
so loop through your array and create an list of indexes for local min and local max the edges included. This will create a set of ranges 2 per each hill.
for given i binary search t so it matches your wanted result O(log(n))
binary search is applicable only on sorted array however you got the list of ranges where each range is ordered so binary search can be used. So find your range (also can be binary search of the ranges) and then binary search in the found range.
So this will lead to O(N+log(N)) complexity however The first step is needed to be done just once so if that is considered as part of initialization and you make many queries like this you can consider your resulting (amortized) complexity to be O(log(N))
In case your query can go pass one hill to another you need to search also neighboring ranges which would lead to O(M.log(N)) where M is the number of ranges which is also 2*hills and usually M << N.

Answer 3

I see your code is c++. if then this code will help you.
#include <iostream>
#include <vector>
using namespace std;
struct Item
{
int index;
int value;
};
int find_index(vector<Item> arr, int n, int K, int start = 0)
{
// Lower and upper bounds
int end = n - 1;
// Traverse the search space
while (start <= end)
{
int mid = (start + end) / 2;
// If K is found
if (arr[mid].value == K)
return mid;
else if (arr[mid].value < K)
start = mid + 1;
else
end = mid - 1;
}
// Return insert position
return end + 1;
}
int firstGreaterIndex[1000000];
int anyFirstGreaterIndex[1000000];
vector<Item>
greaterValues[1000000];
void fillGreaterValuesAtBinaryIndex(int arr[], int N)
{
int i, j, wi, iEndV;
struct Item iItem;
for (i = 0; i < N; i++)
{
greaterValues[i].empty();
wi = i + 1;
iItem.index = i;
iItem.value = arr[i];
greaterValues[i]
.push_back(iItem);
while (wi)
{
iEndV = greaterValues[wi - 1].back().value;
if (iEndV < arr[i])
{
iItem.index = i;
iItem.value = arr[i];
greaterValues[wi - 1].push_back(iItem);
}
wi = (wi - 1) & wi;
}
}
}
void fillBehindFirstGreaterIndex(int arr[], int N, int VSQR)
{
int i, wi;
for (i = 0; i < N; i++)
{
wi = i + 1;
firstGreaterIndex[i] = -1;
while (wi <= N)
{
int firstPosition = -1;
if (wi - 1 == i)
{
firstPosition = find_index(greaterValues[wi - 1], greaterValues[wi - 1].size(), arr[i] + VSQR, 1);
}
else
{
firstPosition = find_index(greaterValues[wi - 1], greaterValues[wi - 1].size(), arr[i] + VSQR);
}
if (firstPosition >= 0 && firstPosition < greaterValues[wi - 1].size())
{
firstGreaterIndex[i] = greaterValues[wi - 1][firstPosition].index;
break;
}
wi = (wi << 1) - ((wi - 1) & wi);
}
}
}
void fillAnyFirstGreaterIndex(int arr[], int N, int VSQR)
{
int i, wi;
for (i = 0; i < N; i++)
{
wi = 1;
anyFirstGreaterIndex[i] = -1;
while (wi <= N)
{
int firstPosition = -1;
if (wi - 1 == i)
{
firstPosition = find_index(greaterValues[wi - 1], greaterValues[wi - 1].size(), arr[i] + VSQR, 1);
}
else
{
firstPosition = find_index(greaterValues[wi - 1], greaterValues[wi - 1].size(), arr[i] + VSQR);
}
if (firstPosition >= 0 && firstPosition < greaterValues[wi - 1].size())
{
anyFirstGreaterIndex[i] = greaterValues[wi - 1][firstPosition].index;
break;
}
wi = (wi << 1) - ((wi - 1) & wi);
}
}
}
int main()
{
int i;
int N = 10, VSQR = 2;
int H[] = {5, 7, 14, 8, 9, 10, 11, 12, 1, 20};
fillGreaterValuesAtBinaryIndex(H, N);
fillBehindFirstGreaterIndex(H, N, VSQR);
fillAnyFirstGreaterIndex(H, N, VSQR);
for (i = 0; i < N; i++)
{
cout << i << " behind first greater index: " << firstGreaterIndex[i] << endl;
cout << i << " any first greater index: " << anyFirstGreaterIndex[i] << endl;
/* code */
}
}
if javascript:
function find_index(arr, n, K, start = 0)
{
// Lower and upper bounds
let end = n - 1;
// Traverse the search space
while (start <= end)
{
let mid = Math.floor((start + end) / 2);
// If K is found
if (arr[mid].value == K)
return mid;
else if (arr[mid].value < K)
start = mid + 1;
else
end = mid - 1;
}
// Return insert position
return end + 1;
}
function fillGreaterValuesAtBinaryIndex(arr, N)
{
let i, wi, iEndV;
let iItem = {};
let greaterValues = [];
for (i = 0; i < N; i++)
{
greaterValues.push([]);
wi = i + 1;
greaterValues[i]
.push({index: i, value: arr[i]});
while (wi)
{
iEndV = greaterValues[wi - 1][greaterValues[wi - 1].length - 1].value;
if (iEndV < arr[i])
{
iItem.index = i;
iItem.value = arr[i];
greaterValues[wi - 1].push({index: i, value: arr[i]});
}
wi = (wi - 1) & wi;
}
}
return greaterValues;
}
function fillBehindFirstGreaterIndex(arr, N, VSQR, greaterValues)
{
let i, wi;
let firstGreaterIndex = [];
for (i = 0; i < N; i++)
{
wi = i + 1;
firstGreaterIndex[i] = -1;
while (wi <= N)
{
let firstPosition = -1;
if (wi - 1 == i)
{
firstPosition = find_index(greaterValues[wi - 1], greaterValues[wi - 1].length, arr[i] + VSQR, 1);
}
else
{
firstPosition = find_index(greaterValues[wi - 1], greaterValues[wi - 1].length, arr[i] + VSQR);
}
if (firstPosition >= 0 && firstPosition < greaterValues[wi - 1].length)
{
firstGreaterIndex[i] = greaterValues[wi - 1][firstPosition].index;
break;
}
wi = (wi << 1) - ((wi - 1) & wi);
}
}
return firstGreaterIndex;
}
function fillAnyFirstGreaterIndex(arr, N, VSQR, greaterValues)
{
let i, wi;
let anyFirstGreaterIndex = [];
for (i = 0; i < N; i++)
{
wi = 1;
anyFirstGreaterIndex[i] = -1;
while (wi <= N)
{
let firstPosition = -1;
if (wi - 1 == i)
{
firstPosition = find_index(greaterValues[wi - 1], greaterValues[wi - 1].length, arr[i] + VSQR, 1);
}
else
{
firstPosition = find_index(greaterValues[wi - 1], greaterValues[wi - 1].length, arr[i] + VSQR);
}
if (firstPosition >= 0 && firstPosition < greaterValues[wi - 1].length)
{
anyFirstGreaterIndex[i] = greaterValues[wi - 1][firstPosition].index;
break;
}
wi = (wi << 1) - ((wi - 1) & wi);
}
}
return anyFirstGreaterIndex;
}
function main()
{
let i;
let N = 10, VSQR = 2;
let H = [5, 7, 14, 8, 9, 10, 11, 12, 1, 20];
let greaterValues = fillGreaterValuesAtBinaryIndex(H, N);
let behindFirstGreaterIndex = fillBehindFirstGreaterIndex(H, N, VSQR, greaterValues);
let anyFirstGreaterIndex = fillAnyFirstGreaterIndex(H, N, VSQR, greaterValues);
console.log("behindFirstGreaterIndex", behindFirstGreaterIndex);
console.log("anyFirstGreaterIndex", anyFirstGreaterIndex);
}
main();