Akina

Я вижу решение, близкое к желаемому.

Сначала, при старте клиентского интерфейса, выполняется несколько (навскидку - может, и 10 достаточно, а, может, и 100 потребуется, следует определить экспериментально) передач с клиента на сервер, причём используется тот же протокол, который будет впоследствии использован для передачи информации о нажатии, и в каждой передаче в том числе передаётся точное время клиента (с максимально доступной точностью). Приходящие пакеты маркируются точным штампом времени получения (серверное время), с максимально доступной точностью. Полученный массив обрабатывается статистически, и определяется разница точного времени часов клиента и сервера и погрешность этого определения. Если статистическая ошибка велика, процесс повторяется.

Далее, уже в момент нажатия, по той же технологии передаётся пакет с точным клиентским временем нажатия, и по подсчитанной ранее разности определяется точное время нажатия по времени сервера. Для всех клиентов это время сравнивается, и победителем объявляется тот, у кого время нажатия по серверу минимальное.

Такой алгоритм (практически) не зависит от колебания времени доставки пакета от клиента серверу.

Калибровка разности времени при необходимости может повторяться. Частота рекалибровки зависит достижимой точности определения локального и серверного времени и от требуемой точности вычисления разности. По моим очень приблизительным прикидкам, если требуемая точность составляет 100 мс, то рекалибровку следует проводить ежечасно.

Если после 2-3 повторений калибровки установить точное значение разности не удалось - клиенту следует отказать в участии.

Допустим, существует некий алгоритм, который преобразует последовательность X длины M в последовательность Y, причём существует обратное преобразование. Неважно, что это за алгоритм конкретно - сжатие, создание "зерна" и пр. Но очевидно, что:

1. Количество вариантов последовательности X составляет K в степени M, где K - размер словаря, т.е. количество возможных различимых значений одного элемента последовательности X. В случае байтовой последовательности это байт, т.е. K=256.

2. Каждая последовательность X после преобразования даёт последовательность Y, причём две разные последовательности X дают разные последовательности Y.

Соответственно количество возможных последовательностей Y равно количеству возможных последовательностей X. И соответственно если существует хотя бы одна последовательность Y короче последовательности X, то существует хотя бы одна последовательность Y длиннее последовательности X.

Что, собственно, и наблюдается на абсолютно любом алгоритме компрессии - существуют входные данные, для которых результат попытки сжатия имеет бОльший размер, чем исходные данные.

Что же до "зерна", которое разворачивается в гигабайты - во-первых, количество финальных миров определяется количеством значений "зерна", то есть вовсе даже не такое бесконечно большое, как кажется, во-вторых, созданный образ мира содержит значительное число повторяющихся элементов, а создание копий - это немножко не декомпрессия.

Для бОльшей понятности условия будем считать что у нас есть 2 предмета. Оба разбились - эксперименты кончились. И будем считать, что задача - получить ответ за минимальное количество бросков.

Рассмотрим, что у нас есть только один предмет. Очевидно, что придётся его кидать с 1 метра, с 2, с 3... пока не разобьётся. Максимум будет 5000 бросков.

Но у нас есть 2 предмета.

Тогда мы можем бросить первый не с 1 метра, а сразу с какого-то N. Если он разобьётся, то придётся второй кидать с 1, 2, ... и по максимуму второй кинем N-1 раз. а всего будет N бросков.

Но если он не разбился, то мы можем бросить первый уже с бОльшей высоты. Какой? Допустим, он разобьётся. Чтобы получить по максимуму те же N бросков, второй предмет мы уже может бросить N-2 раз, а, значит, первый предмет надо сбрасывать с высоты N+(N-1).

Если первый снова не разбился, на следующем шаге его можно сбросить с высоты N+(N-1)+(N-2)... и так далее.

Лишнего нам тоже не надо. А, значит, надо подобрать такое наименьшее N, при котором N-й бросок первого предмета будет с 5000 метров или выше.

Итого - имеем N+(N-1)+(N-2)+...+1 >= 5000. Сумму арифметической прогрессии знаем, квадратные уравнения решать умеем. Получаем N=100.

rastr, как понимать Ваше

написать не выходит

, если Вы тут же приводите код - который, кстати, способен решить задачу. Ну разве что:

1. Итерация идёт по отдельному столбцу либо строке - так что ставить верхнюю границу для i по всей матрице несколько неправильно
   
2. По i надо итерировать до предпоследнего значения, а по j - от значения на 1 больше текущего i до последнего. Ибо если проверена какая-то пара, то нет смысла проверять её ещё раз "с обратной стороны", а уж равенство элемента самому себе так и вовсе проверять бессмысленно.
   

В общем, приблизительно так (без точного соблюдения синтаксиса)

bool is_adjacency_matrix_correct(const vector<string>& matrix) {
  size=matrix[0].size();
  for (auto i = 0; i < size-1; i++) {
    for (auto j = i+1; j < size; j++) {
      if (matrix[i][j] != matrix[j][i])
        return false;
    }
  }
  return true;
}