将给定的伪代码复杂度从O（N ^ 4）减少到O（NlogN）或更小

Question

I recently came across this HackerRank contest problem ( Coolguy and Two Subsequences ). The question is to reduce the given pseudocode complexity from O ( N ⁴ ) to something much lesser.

//f(a, b) is a function that returns the minimum array element in interval [a, b]

array = [...] (of length n)

ans = 0

for a -> [1, n]
    for b -> [a, n]
        for c -> [b + 1, n]
            for d -> [c, n]
                ans = ans + min(f(a, b), f(c, d))

Given editorial solution achieves a complexity of O ( N log N ). I found the problem an interesting concept to learn. Unfortunately, I had difficulty in understanding the editorial solution which uses segment trees to store sub solutions in a given range and finally merge it give the final solution. Specifically I did not understand the significance of each term in the segment tree.

I understand that the question has alternative solutions too. Can someone please explain an approach to do the question. Code is not required but you can add it if it helps you in explaining the solution better.

Answer 1

Without looking at the editorial solution, here's a path to an O(N log N)-time solution.

Let's say that we have an input like

[3, 1, 4, 5, 9, 2, 6].

Delete the numbers from least to greatest, tracking sublists that were originally contiguous with a binary tree.

A [3, 1, 4, 5, 9, 2, 6]
B [3]   [4, 5, 9, 2, 6]
C [3]   [4, 5, 9]   [6]
D       [4, 5, 9]   [6]
E          [5, 9]   [6]
F             [9]   [6]
G             [9].

At each step, we count the number of loop iterations that use only remaining numbers (call these A, B, C, D, E, F, G ). The answer is

1 (A - B) + 2 (B - C) + 3 (C - D) + 4 (D - E) + 5 (E - F) + 6 (F - G) + 9 G.

The count at each step is a symmetric polynomial in the lengths of the originally contiguous sublists.

A [7]
B [1, 5]
C [1, 3, 1]
D [3, 1]
F [2, 1]
G [1, 1]
H [1]

This symmetric polynomial can be expressed in a constant number of operations by adding and multiplying power sums, eg, for C , those would be

0: 1^0 + 3^0 + 1^0
1: 1^1 + 3^1 + 1^1
2: 1^2 + 3^2 + 1^2.

We can keep the relevant power sums up to date as we delete. When we replace 7 with 1, 5 , we subtract 7^2 from the sum of squares and add 1^2 + 5^2 .

Something like this in C++ (untested):

#include <algorithm>
#include <iostream>
#include <set>
#include <utility>
#include <vector>

int main(void) {
  int n;
  if (!(std::cin >> n) || n < 1 || n > 200000) {
    return 1;
  }
  std::vector<std::pair<int, int>> a(n);
  for (int i = 0; i < n; i++) {
    int a_i;
    if (!(std::cin >> a_i)) {
      return 1;
    }
    a[i] = std::make_pair(a_i, i);
  }
  std::sort(a.begin(), a.end());
  std::set<int> endpoints = {-1, n};
  int sum1 = n;
  int sum2 = n * n;
  int sum3 = n * n * n;
  int sum4 = n * n * n * n;
  int previous_count = (n + 2) * (n + 1) * n * (n - 1) / 24;
  int answer = 0;
  for (const auto &p : a) {
    const int a_i = p.first;
    const int i = p.second;
    const auto it = endpoints.insert(i).first;
    auto left = it;
    --left;
    auto right = it;
    ++right;
    const int minus = *right - (*left + 1);
    sum1 -= minus;
    sum2 -= minus * minus;
    sum3 -= minus * minus * minus;
    sum4 -= minus * minus * minus * minus;
    const int plus_left = *right - (i + 1);
    sum1 += plus_left;
    sum2 += plus_left * plus_left;
    sum3 += plus_left * plus_left * plus_left;
    sum4 += plus_left * plus_left * plus_left * plus_left;
    const int plus_right = i - (*left + 1);
    sum1 += plus_right;
    sum2 += plus_right * plus_right;
    sum3 += plus_right * plus_right * plus_right;
    sum4 += plus_right * plus_right * plus_right * plus_right;
    const int count =
        ((sum2 + sum1) * (sum2 + sum1) - (sum4 + 2 * sum3 + sum2)) / 8 +
        (sum4 + 2 * sum3 - sum2 - 2 * sum1) / 24;
    answer += (previous_count - count) * a_i;
    previous_count = count;
  }
  std::cout << answer << '\n';
  return 0;
}

Answer 2

Additional details(for anyone interested) regarding derivation of "count" in any iteration(number of loop iterations that use only remaining numbers):

Following from code posted in David Eisenstat's answer:

Consider following originally contiguous sub lists: C => [... X .. Y .. Z ...]

Selection of indices of form [a,b][c,d] can be obtained from at most 2(any) sub lists.

Let, X(i) = Number of ways of selecting i indices from contiguous sub list X = x(C)i (x= length of X)

Total ways of doing this from any two sub lists X,Y:
X(2)*Y(2) =>     [a,b] selected from sublist X, [c,d] selected from sublist Y.
X(4)+Y(4) =>     [a,b][c,d] selected from sublist X and Y.
X(1)*Y(2) + X(2)*Y(1)    =>      [a,a] selected from X, [c,d] selected from Y. [a,b] selected from X,[c,c] selected from Y.
2*(X(3)+Y(3))            =>      [a,a][b,c]/[a,b][c,c] selected from X and Y.
X(1)*Y(1)                =>     [a,a] selected from X and [b,b] selected from Y.    
X(2) + Y(2)              =>     [a,a][b,b] selected from X and Y.   

Total ways of selection("count", mentioned in program):

(i) X(2)*Y(2) + X(1)*Y(2) + X(2)*Y(1); For all sub list pairs X,Y in list C.

+

(ii) X(2) + 2*X(3) + X(4) ; For all sub lists X in C.

Due to symmetric nature of polynomials obtained,

(i) X(2)*Y(2)  + X(1)*Y(2) + X(2)*Y(1) = [(sum1+sum2)*(sum1+sum2)-(sum1+2*sum3+sum4)]/8

(ii) X(2) + 2*X(3) + X(4) = [sum4+2*sum3-sum2-2*sum1]/24

Note: sum1, sum2, sum3, sum4 as defined by program.