Wataru

Вы правильно поняли, что у вас вершинами в гарфе являются клетка+направление, по которому пришли.
Но раз у вас вот это вершины, то вам и пометки о песещении вершины надо делать в трехмерном массиве. А начальных и финальных вершин у вас по 4 штуки: клетка x 4 направления (на самом деле, начинать достаточно только с 2 направлений, но неважно).

Ага, ДП тут отлично входит. F(n) - ответ на задачу для префикса длины n. Там перебираете длину последней группы x и берете в качесвте ответа max(a[n-x]..a[n-1]) - min(a[n-x]..a[n-1]) + F(n-x). По всем l<=x<=r выбераете максимум. Если n < l, то ответ - минус бесконечность.

Это будет решение за O(n^2). Что-нибудь за O(n log n) я так сходу придумать не могу.

Минимизируйте стоимость строительства самой дорогой построенной предложенной линии.

не сумма всех взятых ребер, а стоимость максимального из них.

1 2 (2) и 2 3 (1) - максимальная стоимость 2 (max(1,2)).

1 3 (3) - максимальная стоимость 3 max(3). 3 больше 2, значит ответ выше лучше.

Так задача легче, чем с суммой.

Справится. Поиск по словарю с несколькими тысячами слов займет миллисекунду.

int masInt[3][5] - вот такие массивы c фиксированными размерами на самом деле хранятся одним куском и индексацию компилятор вычисляет сам. Это не int**, а int[][5]. Только этот тип нельзя вернуть из функции.

Что бы вернуть именно указатель на указатель, вам надо его так и завести и не забыть выделить по строкам:

int** masInt = new int* [3];
for (int i = 0; i < 3; ++i) {
  masInt[i] = new int[5];
}

Не забудьте только потом удалить все это добро через delete[]:

for (int i = 0; i < 3; ++i) {
  delete[] array[i];
}
delete[] array;

Но вообще, лучше не парить себе мозги и возвращать std::vector<std::array<int,5>>.

Тут не надо никакой многопоточности. Все такие симуляции выполняются в один поток с очередью событий.

Вот в 0 секунд у вас I1..I5 сгенерировали заявки, они пападают в накапители и сразу же из них в каналы. В 3 секунды K1 обработал заявку и свободен. Взял одну из накопителя. В 4 секунды K2 освободился, взял заявку из накопителя. В 5 секунд источники снова сгенерировали заявки... и т.д. Это можно просимулировать.

Реализуется это с помощью приоритетной очереди событий. В нее вы складываете новые события, а в основном цикле достаете оттуда событие с минимальным временем. На c++ это будет что-то вроде:

std::priority_queue<pair<int, Event>, std::vector, std::greater> queue

.

Еще вам надо написать классы для источника, накопителя, блокиратора с условиями (не понял, что это) и накопителя.

Например, источник в момент создания кладет в очередь событие "в 0 секунд я создам заявку". При выполнении этого события, во-первых, создается и кладется в очередь новое событие "в t+5 секунд я создам заявку". Во-вторых, надо посмотреть, куда заявки из этого источника попадают. Если это накопитель, то заявка пихается в него.

Класс накопителя при поступлении в него заявки, если он был пуст, смотрит, какие каналы к нему подключены (их может быть несколько) и, если какой-то из них свободен - сразу передает заявку туда. Если он был не пуст, то просто кладет заявку в очередь.

Класс канала при получении заявки создает событие во время t+время обработки заявки, что он освободится. При вы полнении этого события канал смотрит, к чему он подключен и если там не пустой накопитель, то забирает оттуда первую заявку.

Класс Event должен как-то запоминать какой объект это событие выполняет. А основной цикл должен этот код вызывать (и передавать туда время события).

Есть. Называется python + модуль itertools.

import itertools
import string

def generate_strings(length):
    chars = string.ascii_letters + string.digits
    for item in itertools.product(chars, repeat=length):
        yield "".join(item)

for string in generate_strings(3):
    print(string)

Для 8 символов поменяйте 3 в коде на 8.

Можно без перевода в десятичную систему считать. Столбиком, как в начальной школе. Это будет работать даже если ваши числа длиннее 4 байт.

byte summ[N];  // N >= skoll_len+sprice_len.
for (int i = 0; i < skoll_len; ++i ) {
  word carry = 0;
  for (int j = 0; j < sprice_len; ++j) {
    carry += summ[i+j] + (word)skoll[i] * sPrice[j];
    summ[i+j] = carry % 256;
    carry /= 256;
  }
  if (carry > 0)
    summ[x_len + y_len - 1] += carry;
}

Тут три неочевидных момента. При прибавлении одной строки из умножения столбиком все переносы считаются сразу одним проходом. Во-вторых, там может быть какой-то лишний перенос в конце, но только на одну дополнительную ячейку, потому что x < 256^x_len, y <256^x_len, а значит x*y < 256^(x_len+y_len), значит не будет никакой записи дальше ячейки x_len+y_len-1. И последнее, carry по пути нигде ни разу не переполнится, ибо максимальная сумма там может быть 255*255+255+255 < 256*256.

P.s. Но если у вас числа уж очень длинные, то гуглите быстрое преобразование фурье + длинное умножение.

Я правильно понял, что идет обмен между двумя игроками, если их окружности пересекаются?

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

Но это медленно. Для усокрения, надо хранить всех игроков в какой-то трехмерной структуре данных. Например, квадро-дерево. Там для ускорения поиска в каждой вершине храните сколько там игроков есть, и при рекурсивном спуске не идите в те вершины, для которых обрамляющий прямоугольник не пересекается с окружностью для игрока, относительно которого вы соседий ищите. Когда дошли до листа с игроками, каждого из них проверьте - досаточно ли они близки для добавления в ответ. Для упрощения, вы вместо окружности пересекайте с обрамляющим прямоугольником квадрат описанный вокруг окружности. Сильно упрощает код, хоть и даст немного лишних проверок.

Конечно, на эту задачу можно натянуть префиксные деревья (это же вы бор/trie имеете ввиду, да?). Но тут какая-то растянутая сова получается.

Например, можно, действительно, все слова сложить в trie, а потом его обойти. Вам нужно будет в рекурсивном обходе поддерживать количество последних ребер, которые шли по алфавиту. Еще в каждой вершине сразу хранить, сколько раз через нее проходят добавленные строки. Тогда в каждой вершине прибавляйте к ответу произведение двух счетчиков. При рекурсивном вызове или увеличивайте счетчик последних упорядоченных ребер, если следующий символ больше символа к отцу, или передавайте 1.

Но это нисколько не эффективнее наивного итеративного подхода, где вы это же максимальное количество упорядоченных букв поддерживаете идя по строке слева направо, сбрасывая в 0 на пробелах.

Скобки в делителе в переменной numerator пропустили.
Еще, у вас имена переменных кривые. Зачем-то назвали два множителя "числитель" и "делитель". Причем дробь целиком считается в первой.

Код разбиения у вас неверный. Забейте пока на рекурсию, отладьте код до рекурсивных вызовов.

Во-первых, удалите flag. Ужасный, отвратительный подход. Что он означает? Зачем он вам нужен? Разве нельзя обе части выполнять в цикле всегда, вместо того, что бы чередовать их очень не читаемым и запутанным методом?

Далее, надо поддерживать какой-то инвариант. У вас там 2 переменные в цикле first и last. Что вы поддерживаете? Все элементы до first не превосходят pivot, а все после last не меньше его? Определитесь с этим и докажите себе, что после каждой итерации цикла этот инвариант сохранится. Вместо того, чтобы следить за тем, где у вас ведущий элемент, просто запомните в переменную его значение.

Если не разберетесь, смотрите на код в википедии, например.