Wataru

Чтобы скопировать массив можно воспользоваться memcpy, или делать это циклом.

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

Если изначальный объект можно удалить, то вам надо переопределить оператор перемещения, а не копирования. Внутри ваши массивы - это просто указатели и их можно перемещать как переменные:

keys_ = node.keys_;
node.keys_ = nullptr;

Не забудьте изначальное место затереть нулевым указателем, чтобы нечайнно потом два раза не удалить.

Так делать при копировании нельзя - ибо вы создаете несколько указателей на один и тот же массив и вообще непонятно, кто потом должен это удалять. Только при перемещении.

Когда вы определили оператор перемещения (или конструктор перемещения), то далее оберните элемент источник в std::move() при присваивании или передаче в конструктор. Тогда вызовется действительно перемещающий метод.

Выход за границу массива там где сортируете. Из этой левой памяти вы и получаете случайное значение.

Смотрите внимательно, к каким индексам вы обращаетесь и какое значение может принимать переменная j.

И еще, можно не сортировать итоговый массив, а формировать его уже отсортированным. Это работает сильно быстрее. Называется - процедура слияния.

Проблема вашего кода в том, что вы берете лишь первые 4 байта из 8 в double.

Копируете в uint64_t. Если надо меньше бит, то можно домножить на большое простое число и потом взять xor младших и старших бит.

Это задача - вариант Subset sum problem.

Она NP-полная - тут нет быстрых и простых решений. В общем случае, возможно только решение полным перебором за N*3^N. Что-то вроде того, что предложил Alexandroppolus, только там вообще не рассматривается случай, что текущее число просто пропускается. Еще можно делать это же без рекурсии на основе битовых масок.

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

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

Это какой-то бред. Начало фразы подразумевает, что ребра есть между всеми парами вершин, продолжение говорит, что все ребра длины 1 между соседними клетками. Я предполагаю что тут именно второй вариант.

Во-первых, занумеруйте все клетки. Подойдет простая формула вроде i+m*j

Вот у вас уже есть n*m вершин в графе. Теперь добавьте ребра. Для каждой клетки (два цикла) посмотрите 4 соседние клетки. Если обе клетки - ., то добавьте из текущей клетки ребро в соседнюю.

Соседей удобно перебирать, если завести константные массивы для смещений:

const int dx[4]= {1, 0, -1, 0};
const int dy[4]= {0, 1, 0, -1};

Тогда для клетки (i, j) можно перебрать всех соседей одним циклом на 4 итерации - (i+dx[k], j+dy[k]). Надо только не забыть проверить на выход за границы матрицы.

Ну и вам надо написать функцию типа AddEdge(int u, int v) которая будет в удобную для вас структуру данных добавлять ребра. Граф удобно хранить в виде списков смежности. На C++ это можно сделать просто std::vector<std::vector<int>> и добавлять соседей через vector::push_back. Это на практике работает быстрее всяких связных списков.

И у вас будет три вложенных цикла - внешние по всем клеткам, а внутренний по четырем направлениям. Внутри вы проверяете, что сосед по этому направлению есть и между клетками можно пройти. В этом случае вызывайте AddEdge.

А можно вообще граф не строить. Берете ваш алгоритм поиска кратчайшего пути (BFS, Dijkstra или A*) и там везде, где перебираются соседи одной вершины, вставляете код проверки четырех направлений через dx/dy. Вершины можно или нумеровать их координатами, и тогда все массивы пометок будут двумерными, или можно использовать формулу u = i+j*m, (i,j) = (u%m, u/m) для преобразования координат в номер вершины и назад.

А еще есть всякие алгоритмы, которые работают сильно быстрее за счет использования того факта, что у вас не произвольный граф, а сетка в матрице. Jump Point Search - один из таких алгоритмов. В нем граф умышленно не строится и работа идет непосредственно в матрице.

У вас в input_matrix выход за границы массива: в массиве n-1 элемент, а вы читаете n.

Массив лежит на стеке, там же где локальная переменная n. Так получилось, что n лежит сразу за matrix (или в пределах восьми байт) и оказывается испорчена. Данные кажутся вам случайными, потому что читаете вы double и какая-то его часть попадает в область памяти int n.

Смотрите внимательно - какие переменные вы выводите и как они меняются в коде. Нормальные названия кстати упростили бы вам поиск ошибки.

sscanf(str, "%d,%d,%d,%d,True", ...);

Да вроде все правильно. Скорее всего опечатка в задании где-то. Так бывает. Или где-то может быть сказано, что углы должны быть в градусах а не радианах. Тогда выражение под синусом/косиносом надо домножать на 180/pi.

В полярной системе координат их позиции вычислить элементарно: у i-того солдата угол 2pi*i/n и радус фиксированный.

Для перехода из полярной системы координат в обычную воспользуйтесь тригонометрическими функциями:

x_i = x_o+cos(alpha_i)*r_i
y_i = y_o+sin(alpha_i)*r_i

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

Т.е. вам надо найти путь из одной клетки в другую, пройдя по как можно меньшему количеству клеток. Можно ходить в 8 направлений - если пересечь угол, то можно за одну точку на ломаной перейти по диагонали.

Немного порисовав вы поймёте, что ответ - миксимум из горизонтального и вертикального расстояний между начальной и конечной клетками.

Надо только аккуратно разобрать случаи, если начальная или конечная точка лежит на границе клетки.

Как-то хитро встроить подсчет циклов в генерацию перестановок никак не получится.

Поэтому, алгоритм простой - посчитать циклы по одному.
Фактически, перестановка - это граф и вам надо подсчитать в нем количество компонент связности. Надо использовать DFS. Но граф очень простой, поэтому DFS выраждается в тупо цикл.

Заведите массив флагов длинной с перестановку. Пройдитесь по всем позициям и, если текущая не помечена, запускайте от нее второй цикл, который пометит ее и перейдет в позицию по перестановке (row[i]) и пометит там и опять перейдет и так далее, пока не наткнется на уже помеченную позицию. Так вы побойдете один цикл и пометите все позиции в нем. Поэтому прибавьте 1 к счетчику, когда будете запускать внутренний цикл.

В решении будет 2 вложенных цикла, внешний - удобнее всего делать for, внутренний можно тоже делать for или while, но в for будет вместо инкримента переход по перестановке. И эти 2 вложенных цикла суммарно обойдут все позиции по одному разу, поэтому время работы алгоритма - линейное.