<p>Given an integer array nums, return all the triplets <code>[nums[i], nums[j], nums[k]]</code> such that <code>i != j</code>, <code>i != k</code>, and <code>j != k</code>, and <code>nums[i] + nums[j] + nums[k] == 0</code>.</p>

<p>Notice that the solution set must not contain duplicate triplets.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [-1,0,1,2,-1,-4]
<strong>Output:</strong> [[-1,-1,2],[-1,0,1]]
<strong>Explanation:</strong> 
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0.
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0.
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0.
The distinct triplets are [-1,0,1] and [-1,-1,2].
Notice that the order of the output and the order of the triplets does not matter.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [0,1,1]
<strong>Output:</strong> []
<strong>Explanation:</strong> The only possible triplet does not sum up to 0.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> nums = [0,0,0]
<strong>Output:</strong> [[0,0,0]]
<strong>Explanation:</strong> The only possible triplet sums up to 0.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>3 &lt;= nums.length &lt;= 3000</code></li>
	<li><code>-10<sup>5</sup> &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
</ul>

#include <execution>

const size_t POOL_SIZE = std::pow(1024, 3) * 0.1; // 1 GB
void* gPool = std::malloc(POOL_SIZE);
void* gPoolPtr = gPool;

void* operator new(size_t size) {
    // Определяем выравнивание
    const size_t alignment = alignof(std::max_align_t);

    // Определяем доступное количество памяти
    size_t space = (char*)gPool + POOL_SIZE - (char*)gPoolPtr;

    // Выравниваем указатель
    void* p = gPoolPtr;
    if (std::align(alignment, size, p, space)) {
        gPoolPtr = (char*)p + size;
        //std::cout << "Custom new: Allocating " << size << " bytes" << std::endl;
        return p;
    }
    return 0;
}

void operator delete(void* p) noexcept {
    // Реально память пула не освобождается, т.к. это пул статического размера
}


class Solution {
public:



std::vector<std::vector<int>> threeSum(std::vector<int>& nums) {
    using value_t = typename std::remove_reference_t<decltype(nums)>::value_type;
std::vector<std::vector<value_t>> result;
const auto size = nums.size();
if (size < 3) {
    return result;
}

std::sort(nums.data(), nums.data() + size);
auto tmp = nums.data();
{
    auto nums = tmp;
    for (size_t i = 0; i < size - 2; i++) {
        if (i != 0 && nums[i - 1] == nums[i]) {
            continue;
        }
        size_t l = i + 1;
        size_t r = size - 1;
        while (l < r) {
            value_t sum = nums[i] + nums[l] + nums[r];
            if (sum == 0) {
                result.emplace_back(std::vector{ nums[i], nums[l], nums[r] });
                l++;
                r--;
                while (l < r && nums[l] == nums[l - 1]) l++;
                while (l < r && nums[r] == nums[r + 1]) r--;
            }
            else if (sum > 0) {
                r--;
            }
            else {
                l++;
            }
        }
    }
}
return result;
}




};
27255