Сергей Соловьев

Появилась идея алгоритма (по-моему у Кнута видел нечто подобное).
Идея следующая:
- Нужно сгенерировать N чисел
- В диапазоне от L до R

Тогда запускаем рекурсивную функцию:
- Вход: начало диапазона (Start), конец диапазона (End), оставшееся кол-во чисел (Left)

Тело функции:
1. Берем следующее число из указанного диапазона = Current
2. Уменьшаем оставшееся число на 1
3. Вызываем эту же функцию, но с аргументами: начало диапазона = Current + 1, конец диапзона = End - Left, оставшееся число аргументов = Left - 1

Изначально запускаем с аргументами: L, R - N, N.

Можно заметить, что с каждой итерацией правая граница сдивигается на 1 - всегда будет возможность получить следующее число, даже если подойдем вплотную

То что причина в часах понятна. Я вижу тут несколько решений:
1. Синхронизация часов клиента. Возможно какой-нибудь NTP поможет (не работал с ним). Но синхронизировать надо только клиента, т.к. если сервер затронет, то и других клиентов тоже
2. Использовать глобальный синхронизатор (время по gps синхронизировать)
3. Делать бенчмарки + вычисления

Насчет 3 -
1. Предполагаем, что в обе стороны время одинаковое
2. Делаем несколько замеров (например, можно каждые 100 пакетов)
3. Рассчитываем время как avg / 2 , где avg - это среднее время отправки в обе стороны

Первое - если файл отсортирован, то поможет бинарный поиск. Самое "в лоб", но возможно не подойдет.

В качестве индекса можно использовать бинарное дерево. Но здесь, я бы сделал так:
- В узлах храним записи фиксированного размера, чтобы не бегать постоянно и дополнительно высчитывать смещения (все 16 байт для хранения использовать можно)
- Само дерево будет содержать отрезки, т.е. не полный готовый ответ. В противном случае, будет нарушено ограничение на размер (10Гб ты никак не перепрыгнешь)

В итоге, путь будет такой:
1. Идешь в индекс ("дерево отрезков") и находишь левую и правую границу
2. Идешь в целевой файл и запускаешь бинарный поиск по нему

Если хранить индекс в памяти, то будет гораздо быстрее. Но высоту дерева надо найти импирически из-за ограничения в 100Мб в памяти

Нашел этот ответ на SO - https://stackoverflow.com/a/28722407
В кратце, нужно сравнить 2 изображения - с применой фокусировкой и без. Фокусировка реализуется через применения оператора Лапласа

cv::Laplacian(src_gray, dst, CV_64F);

cv::Scalar mu, sigma;
cv::meanStdDev(dst, mu, sigma);

double focusMeasure = sigma.val[0] * sigma.val[0];

Для оптимизации предлагаю следующие варианты:
1. Всегда фокусироваться
2. Через определенные промежутки времени (либо кол-во кадров, не суть), брать сампл изображения и для него вычислять размытость - если изображение размыто, то дальше применяем фокусировку

P.S. под фокусировкой я понял резкость/размытость изображения

Разницы нет. Просто теперь потомки каждого узла лучше представлять в виде массива, по которому нужно итерироваться - без left и right

void Visit(Node node) {
     for (auto child: node.children()) {
           stack.append(child);
     // Не так
     // if (node.left != nullptr) {
     //    stack.append(node.left);
     //  }
     // if (node.right != nullptr) {
     //    stack.append(node.right);
     //  }
   
}

Эта задача - обучение с подкреплением: на вход подается поток входных данных, а алгоритм сам подстраивается и обучается.

Скорее всего здесь подойдет простой MiniMax алгоритм: после каждого шага ему присваивается вес - -1(плохой ход), 0 (просто ход), 1 (хороший ход). В начале это будут случайные ходы, но после обучения они станут более осмысленными.

Проблема в том - как понять, что ход был хороший или плохой. Я видел пример для крестиков-ноликов. Но в Гвинт не играл, поэтому не знаю, какую модель построить.