查找数组中A [i] * A [j]> A [i] + A [j]的对数

Question

For eg if Array A is

A[0] = 0.1
A[1] = 0.6
A[2] = 1.2
A[3] = 1.7
A[4] = 3.5

then for pair (3,4) we have A[3]*A[4] > A[3]+A[4]

I want to find the number of such pairs in an array.

Also A[i] = A1 [i] + A2[i]/1,000,000

Where A1 and A2 are inputs given and A1 and A2 are in sorted order .

Answering with O(n^2) algorithm is trivial. I am told there is O(n) solution for this without using extra space. I am looking for that.

Answer 1

x * y > x + y

divide by x*y (for positive values)

1/x + 1/y < 1

Let's the first cursor (R) points to the right element (minimal 1/a[i] value), and the second cursor (L) points to the left element.
Move L to the right until sum of reciprocals reaches 1.
Add (RL) to result.
Step R to left.
Repeat moving L, until R and L meet each other

Both cursors move at most N steps, so algorithm takes O(N)

Answer 2

As this was not clearly stated in the question I will make the following two assumptions in the following:

• mirrored pairs are only counted once (otherwise (b,a) is another valid pair if (a,b) is and would thus increase the number of valid pairs)
• entries may not be used twice (eg. (3.01,3.01) is not a valid pair)

Both assumptions can be changed with small variations of the code.

A is sorted because A1 and A2 are sorted. For a small example this looks like the following

#include <iostream>
#include <vector>

using namespace std;

int main()
{
   std::vector<double> A({0.1,0.15,0.25,0.29,0.35,0.55,0.65,0.85,1.15,1.44,1.46,1.59,1.88,2.01,2.04,2.05,3.01});
   size_t i=0, j=A.size()-1;
   int result = 0;
   if (A[j] <= 2) return 0;
   while (i != j) {
      if (A[i]*A[j]>A[i]+A[j]) {
        result += j-i;
        cout << A[i] << " to " << A[j] << " for a total of " << result << endl;
        --j;
    } else {
        ++i;
    }
   }
   return 0;
}

outputs 8. http://ideone.com/LaV9Cy

This is O(n) and works because A[i+1] > A[i] , thus (A[i+1] - 1) * (A[j] - 1) > (A[i] - 1) * (A[j] - 1) > 1 if the second > holds. We can therefore simply add the number of elements between the two extremals that we found ( result += ji; ) instead of trying all of them individually.