## Pages

### Codility MaxDoubleSliceSum (naive)

Given a vector of integers, return the maximal sum of any double slice.

What's a double slice is defined in this Codility problem, that you can find in their Maximum slice section, dedicated to exercises that could be solved by the Kadane's algorithm.

In a few words, a double slice is defined by an ordered triplet of indexes of a vector. The elements we have to consider are the ones strictly contained in the sub-intervals. A few examples in form of C++11 GoogleTest test cases should clarify the concept:
```TEST(MaxDoubleSliceSum, Empty)
{
std::vector<int> input { 3, 2, 6 }; // 1
ASSERT_EQ(0, solution(input));
}

TEST(MaxDoubleSliceSum, Minimal)
{
std::vector<int> input { 3, 2, 6, 1 }; // 2
ASSERT_EQ(6, solution(input));
}

TEST(MaxDoubleSliceSum, Given)
{
std::vector<int> input { 3, 2, 6, -1, 4, 5, -1, 2 }; // 3
ASSERT_EQ(17, solution(input));
}
```
1. We can think only of one triplet for this test case, that would contain no element.
2. Two possible interesting triples: (0, 1, 3) and (0, 2, 3). The first one has an empty left sub-interval and a right one containing just the element '6'. The second one has only the left sub-interval non empty, with the element '2' inside. The maximal sum is given by the first case.
3. This is the test case provided by codility. The triplet (0, 3, 6) leads to the best solution.

A naive solution

In this post I provide a natural implementation that ends up to be far too costly to be acceptable on a reasonably large input. I simply check all the possible triples elements:
```int simpleSolution(std::vector<int>& input)
{
if(input.size() < 4) // 1
return 0;

int result = 0;
for(unsigned beg = 1; beg < input.size() - 2; ++beg) // 2
{
for(unsigned end = beg + 2; end < input.size(); ++end) // 3
{
int max = std::accumulate(input.begin() + beg, input.begin() + end, 0); // 4
int tentative = 0;
for(unsigned i = beg; i < end; ++i) // 5
{
tentative = max - input[i];
result = std::max(result, tentative); // 6
}
}
}

return result;
}
```
1. As we have seen in the first test case, if container has less than four elements, there is no interesting double slice.
2. The first element in a triplet could be the second element in the vector. Go from this element up to the last useful one.
3. The possible "end" element (last + 1) for a triplet is in this range.
4. Sum all the element in the beg..end interval.
5. Tentatively remove a single element in the interval, to represent the median element in the triplet.
6. If a better possible solution is found, save it.

This solution works fine against the test cased proposed above. But think what would happen in on a larger input:
```TEST(MaxDoubleSliceSum, Hundreds)
{
std::vector<int> input(601);
std::iota(input.begin(), input.end(), -300);
ASSERT_EQ(44850, solution(input));
}
```
A few hundred elements should be enough to perceive a substantial performance degradation.

Removing the most internal loop (5) doesn't seem complicated, still it won't help much. We still have a O(n**2) algorithm to deal with.

We need to take a completely different way. And Kadane is there to pointing us in the right direction. See next post for details.