Перестановки без повторений с диапазоном

#include <vector>

using std::vector;

// Таак, тут будет крутое описание.
// Допустим у нас есть вектор их элементов
// {first, second, third, forth, fifth, sixt, seventh, eight, nine, tan}
// Тогда класс позволит получить все ветора,
// где каждый элемент находится в пределах n позиций от начального положения
//
// Т.е. Пример: {1, 2, 3}, position = 1
// Варианты: {1, 2, 3} {2, 1, 3} {1, 3, 2}
// Все символы сдвинулись не более чем на одну позицию от своего начального положения

template <class Type>
class BruteForce {
    vector<Type> _start;

    // Текущее состояние. Будет указывать на
    vector<Type> _state;

    // Дистанция, на которую можно сдвинуть каждый элемент
    size_t _maxDistance;

public:
    // Инициализируем начальное значение и текущее
    BruteForce(vector<Type> start, size_t distance) :
        _start(start), _state(start), _maxDistance(distance) {};

    vector<Type> get() {
        return _state;
    }

    bool checkPosition() {
        // На старте символ _start[i] был на i-той позиции
        // Ищем где он сейчас
        for (int i = 0; i < _start.size(); i++) {
            int pos = std::distance(_state.begin(), find(_state.begin(), _state.end(), _start[i]));
            int distance = std::abs(i - pos);
            if (distance > _maxDistance) return false;
        }
        return true;
    }

    // Формула для генерации перестановок
    // С проверкой на то, что каждый символ удален
    // от начального положения не дальше, чем на _position
    // @return false - если перестановки закончились
    bool next() {
        bool end;
        bool result = false;

        while (result == false) {
            end = nextStep();
            if (end == false) break;

            result = checkPosition();
        }
        return result;
        return true;
    }

    // Legacy code. Отправить на переработку в ад.
    bool nextStep() {
        int j = _start.size() - 2;
        while (j != -1 && _state[j] >= _state[j + 1]) j--;
        if (j == -1)
            return false; // больше перестановок нет
        int k = _start.size() - 1;
        while (_state[j] >= _state[k]) k--;
        std::swap(_state[j], _state[k]);
        int l = j + 1, r = _start.size() - 1; // сортируем оставшуюся часть последовательности
        while (l < r)
            std::swap(_state[l++], _state[r--]);
        return true;
    }
};



// ПРИЕМР
int main() {
    std::vector<int> arr = { 1, 2, 3, 4 };

    BruteForce<int> bf(arr, 2);

    while (bf.next()) {
        for (auto a : bf.get()) {
            std::cout << a << " ";
        }
        std::cout << std::endl;
    }
}

/**
 * На выходе получаем:
 * 1 2 4 3
 * 1 3 2 4
 * 1 3 4 2
 * 1 4 2 3
 * 1 4 3 2
 * 2 1 3 4
 * 2 1 4 3
 * 2 3 1 4
 * 2 4 1 3
 * 3 1 2 4
 * 3 1 4 2
 * 3 2 1 4
 * 3 4 1 2
 */