C ++ 11 - почти работает :)
Прочитав эту статью , я собрал кусочки мудрости у того парня, который, по-видимому, 25 лет работал над менее сложной проблемой подсчета самоуничтожающихся путей на квадратной решетке.
#include <cassert>
#include <ctime>
#include <sstream>
#include <vector>
#include <algorithm> // sort
using namespace std;
// theroretical max snake lenght (the code would need a few decades to process that value)
#define MAX_LENGTH ((int)(1+8*sizeof(unsigned)))
#ifndef _MSC_VER
#ifndef QT_DEBUG // using Qt IDE for g++ builds
#define NDEBUG
#endif
#endif
#ifdef NDEBUG
inline void tprintf(const char *, ...){}
#else
#define tprintf printf
#endif
void panic(const char * msg)
{
printf("PANIC: %s\n", msg);
exit(-1);
}
// ============================================================================
// fast bit reversal
// ============================================================================
unsigned bit_reverse(register unsigned x, unsigned len)
{
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
return((x >> 16) | (x << 16)) >> (32-len);
}
// ============================================================================
// 2D geometry (restricted to integer coordinates and right angle rotations)
// ============================================================================
// points using integer- or float-valued coordinates
template<typename T>struct tTypedPoint;
typedef int tCoord;
typedef double tFloatCoord;
typedef tTypedPoint<tCoord> tPoint;
typedef tTypedPoint<tFloatCoord> tFloatPoint;
template <typename T>
struct tTypedPoint {
T x, y;
template<typename U> tTypedPoint(const tTypedPoint<U>& from) : x((T)from.x), y((T)from.y) {} // conversion constructor
tTypedPoint() {}
tTypedPoint(T x, T y) : x(x), y(y) {}
tTypedPoint(const tTypedPoint& p) { *this = p; }
tTypedPoint operator+ (const tTypedPoint & p) const { return{ x + p.x, y + p.y }; }
tTypedPoint operator- (const tTypedPoint & p) const { return{ x - p.x, y - p.y }; }
tTypedPoint operator* (T scalar) const { return{ x * scalar, y * scalar }; }
tTypedPoint operator/ (T scalar) const { return{ x / scalar, y / scalar }; }
bool operator== (const tTypedPoint & p) const { return x == p.x && y == p.y; }
bool operator!= (const tTypedPoint & p) const { return !operator==(p); }
T dot(const tTypedPoint &p) const { return x*p.x + y * p.y; } // dot product
int cross(const tTypedPoint &p) const { return x*p.y - y * p.x; } // z component of cross product
T norm2(void) const { return dot(*this); }
// works only with direction = 1 (90° right) or -1 (90° left)
tTypedPoint rotate(int direction) const { return{ direction * y, -direction * x }; }
tTypedPoint rotate(int direction, const tTypedPoint & center) const { return (*this - center).rotate(direction) + center; }
// used to compute length of a ragdoll snake segment
unsigned manhattan_distance(const tPoint & p) const { return abs(x-p.x) + abs(y-p.y); }
};
struct tArc {
tPoint c; // circle center
tFloatPoint middle_vector; // vector splitting the arc in half
tCoord middle_vector_norm2; // precomputed for speed
tFloatCoord dp_limit;
tArc() {}
tArc(tPoint c, tPoint p, int direction) : c(c)
{
tPoint r = p - c;
tPoint end = r.rotate(direction);
middle_vector = ((tFloatPoint)(r+end)) / sqrt(2); // works only for +-90° rotations. The vector should be normalized to circle radius in the general case
middle_vector_norm2 = r.norm2();
dp_limit = ((tFloatPoint)r).dot(middle_vector);
assert (middle_vector == tPoint(0, 0) || dp_limit != 0);
}
bool contains(tFloatPoint p) // p must be a point on the circle
{
if ((p-c).dot(middle_vector) >= dp_limit)
{
return true;
}
else return false;
}
};
// returns the point of line (p1 p2) that is closest to c
// handles degenerate case p1 = p2
tPoint line_closest_point(tPoint p1, tPoint p2, tPoint c)
{
if (p1 == p2) return{ p1.x, p1.y };
tPoint p1p2 = p2 - p1;
tPoint p1c = c - p1;
tPoint disp = (p1p2 * p1c.dot(p1p2)) / p1p2.norm2();
return p1 + disp;
}
// variant of closest point computation that checks if the projection falls within the segment
bool closest_point_within(tPoint p1, tPoint p2, tPoint c, tPoint & res)
{
tPoint p1p2 = p2 - p1;
tPoint p1c = c - p1;
tCoord nk = p1c.dot(p1p2);
if (nk <= 0) return false;
tCoord n = p1p2.norm2();
if (nk >= n) return false;
res = p1 + p1p2 * (nk / n);
return true;
}
// tests intersection of line (p1 p2) with an arc
bool inter_seg_arc(tPoint p1, tPoint p2, tArc arc)
{
tPoint m = line_closest_point(p1, p2, arc.c);
tCoord r2 = arc.middle_vector_norm2;
tPoint cm = m - arc.c;
tCoord h2 = cm.norm2();
if (r2 < h2) return false; // no circle intersection
tPoint p1p2 = p2 - p1;
tCoord n2p1p2 = p1p2.norm2();
// works because by construction p is on (p1 p2)
auto in_segment = [&](const tFloatPoint & p) -> bool
{
tFloatCoord nk = p1p2.dot(p - p1);
return nk >= 0 && nk <= n2p1p2;
};
if (r2 == h2) return arc.contains(m) && in_segment(m); // tangent intersection
//if (p1 == p2) return false; // degenerate segment located inside circle
assert(p1 != p2);
tFloatPoint u = (tFloatPoint)p1p2 * sqrt((r2-h2)/n2p1p2); // displacement on (p1 p2) from m to one intersection point
tFloatPoint i1 = m + u;
if (arc.contains(i1) && in_segment(i1)) return true;
tFloatPoint i2 = m - u;
return arc.contains(i2) && in_segment(i2);
}
// ============================================================================
// compact storage of a configuration (64 bits)
// ============================================================================
struct sConfiguration {
unsigned partition;
unsigned folding;
explicit sConfiguration() {}
sConfiguration(unsigned partition, unsigned folding) : partition(partition), folding(folding) {}
// add a bend
sConfiguration bend(unsigned joint, int rotation) const
{
sConfiguration res;
unsigned joint_mask = 1 << joint;
res.partition = partition | joint_mask;
res.folding = folding;
if (rotation == -1) res.folding |= joint_mask;
return res;
}
// textual representation
string text(unsigned length) const
{
ostringstream res;
unsigned f = folding;
unsigned p = partition;
int segment_len = 1;
int direction = 1;
for (size_t i = 1; i != length; i++)
{
if (p & 1)
{
res << segment_len * direction << ',';
direction = (f & 1) ? -1 : 1;
segment_len = 1;
}
else segment_len++;
p >>= 1;
f >>= 1;
}
res << segment_len * direction;
return res.str();
}
// for final sorting
bool operator< (const sConfiguration& c) const
{
return (partition == c.partition) ? folding < c.folding : partition < c.partition;
}
};
// ============================================================================
// static snake geometry checking grid
// ============================================================================
typedef unsigned tConfId;
class tGrid {
vector<tConfId>point;
tConfId current;
size_t snake_len;
int min_x, max_x, min_y, max_y;
size_t x_size, y_size;
size_t raw_index(const tPoint& p) { bound_check(p); return (p.x - min_x) + (p.y - min_y) * x_size; }
void bound_check(const tPoint& p) const { assert(p.x >= min_x && p.x <= max_x && p.y >= min_y && p.y <= max_y); }
void set(const tPoint& p)
{
point[raw_index(p)] = current;
}
bool check(const tPoint& p)
{
if (point[raw_index(p)] == current) return false;
set(p);
return true;
}
public:
tGrid(int len) : current(-1), snake_len(len)
{
min_x = -max(len - 3, 0);
max_x = max(len - 0, 0);
min_y = -max(len - 1, 0);
max_y = max(len - 4, 0);
x_size = max_x - min_x + 1;
y_size = max_y - min_y + 1;
point.assign(x_size * y_size, current);
}
bool check(sConfiguration c)
{
current++;
tPoint d(1, 0);
tPoint p(0, 0);
set(p);
for (size_t i = 1; i != snake_len; i++)
{
p = p + d;
if (!check(p)) return false;
if (c.partition & 1) d = d.rotate((c.folding & 1) ? -1 : 1);
c.folding >>= 1;
c.partition >>= 1;
}
return check(p + d);
}
};
// ============================================================================
// snake ragdoll
// ============================================================================
class tSnakeDoll {
vector<tPoint>point; // snake geometry. Head at (0,0) pointing right
// allows to check for collision with the area swept by a rotating segment
struct rotatedSegment {
struct segment { tPoint a, b; };
tPoint org;
segment end;
tArc arc[3];
bool extra_arc; // see if third arc is needed
// empty constructor to avoid wasting time in vector initializations
rotatedSegment(){}
// copy constructor is mandatory for vectors *but* shall never be used, since we carefully pre-allocate vector memory
rotatedSegment(const rotatedSegment &){ assert(!"rotatedSegment should never have been copy-constructed"); }
// rotate a segment
rotatedSegment(tPoint pivot, int rotation, tPoint o1, tPoint o2)
{
arc[0] = tArc(pivot, o1, rotation);
arc[1] = tArc(pivot, o2, rotation);
tPoint middle;
extra_arc = closest_point_within(o1, o2, pivot, middle);
if (extra_arc) arc[2] = tArc(pivot, middle, rotation);
org = o1;
end = { o1.rotate(rotation, pivot), o2.rotate(rotation, pivot) };
}
// check if a segment intersects the area swept during rotation
bool intersects(tPoint p1, tPoint p2) const
{
auto print_arc = [&](int a) { tprintf("(%d,%d)(%d,%d) -> %d (%d,%d)[%f,%f]", p1.x, p1.y, p2.x, p2.y, a, arc[a].c.x, arc[a].c.y, arc[a].middle_vector.x, arc[a].middle_vector.y); };
if (p1 == org) return false; // pivot is the only point allowed to intersect
if (inter_seg_arc(p1, p2, arc[0]))
{
print_arc(0);
return true;
}
if (inter_seg_arc(p1, p2, arc[1]))
{
print_arc(1);
return true;
}
if (extra_arc && inter_seg_arc(p1, p2, arc[2]))
{
print_arc(2);
return true;
}
return false;
}
};
public:
sConfiguration configuration;
bool valid;
// holds results of a folding attempt
class snakeFolding {
friend class tSnakeDoll;
vector<rotatedSegment>segment; // rotated segments
unsigned joint;
int direction;
size_t i_rotate;
// pre-allocate rotated segments
void reserve(size_t length)
{
segment.clear(); // this supposedly does not release vector storage memory
segment.reserve(length);
}
// handle one segment rotation
void rotate(tPoint pivot, int rotation, tPoint o1, tPoint o2)
{
segment.emplace_back(pivot, rotation, o1, o2);
}
public:
// nothing done during construction
snakeFolding(unsigned size)
{
segment.reserve (size);
}
};
// empty default constructor to avoid wasting time in array/vector inits
tSnakeDoll() {}
// constructs ragdoll from compressed configuration
tSnakeDoll(unsigned size, unsigned generator, unsigned folding) : point(size), configuration(generator,folding)
{
tPoint direction(1, 0);
tPoint current = { 0, 0 };
size_t p = 0;
point[p++] = current;
for (size_t i = 1; i != size; i++)
{
current = current + direction;
if (generator & 1)
{
direction.rotate((folding & 1) ? -1 : 1);
point[p++] = current;
}
folding >>= 1;
generator >>= 1;
}
point[p++] = current;
point.resize(p);
}
// constructs the initial flat snake
tSnakeDoll(int size) : point(2), configuration(0,0), valid(true)
{
point[0] = { 0, 0 };
point[1] = { size, 0 };
}
// constructs a new folding with one added rotation
tSnakeDoll(const tSnakeDoll & parent, unsigned joint, int rotation, tGrid& grid)
{
// update configuration
configuration = parent.configuration.bend(joint, rotation);
// locate folding point
unsigned p_joint = joint+1;
tPoint pivot;
size_t i_rotate = 0;
for (size_t i = 1; i != parent.point.size(); i++)
{
unsigned len = parent.point[i].manhattan_distance(parent.point[i - 1]);
if (len > p_joint)
{
pivot = parent.point[i - 1] + ((parent.point[i] - parent.point[i - 1]) / len) * p_joint;
i_rotate = i;
break;
}
else p_joint -= len;
}
// rotate around joint
snakeFolding fold (parent.point.size() - i_rotate);
fold.rotate(pivot, rotation, pivot, parent.point[i_rotate]);
for (size_t i = i_rotate + 1; i != parent.point.size(); i++) fold.rotate(pivot, rotation, parent.point[i - 1], parent.point[i]);
// copy unmoved points
point.resize(parent.point.size()+1);
size_t i;
for (i = 0; i != i_rotate; i++) point[i] = parent.point[i];
// copy rotated points
for (; i != parent.point.size(); i++) point[i] = fold.segment[i - i_rotate].end.a;
point[i] = fold.segment[i - 1 - i_rotate].end.b;
// static configuration check
valid = grid.check (configuration);
// check collisions with swept arcs
if (valid && parent.valid) // ;!; parent.valid test is temporary
{
for (const rotatedSegment & s : fold.segment)
for (size_t i = 0; i != i_rotate; i++)
{
if (s.intersects(point[i+1], point[i]))
{
//printf("! %s => %s\n", parent.trace().c_str(), trace().c_str());//;!;
valid = false;
break;
}
}
}
}
// trace
string trace(void) const
{
size_t len = 0;
for (size_t i = 1; i != point.size(); i++) len += point[i - 1].manhattan_distance(point[i]);
return configuration.text(len);
}
};
// ============================================================================
// snake twisting engine
// ============================================================================
class cSnakeFolder {
int length;
unsigned num_joints;
tGrid grid;
// filter redundant configurations
bool is_unique (sConfiguration c)
{
unsigned reverse_p = bit_reverse(c.partition, num_joints);
if (reverse_p < c.partition)
{
tprintf("P cut %s\n", c.text(length).c_str());
return false;
}
else if (reverse_p == c.partition) // filter redundant foldings
{
unsigned first_joint_mask = c.partition & (-c.partition); // insulates leftmost bit
unsigned reverse_f = bit_reverse(c.folding, num_joints);
if (reverse_f & first_joint_mask) reverse_f = ~reverse_f & c.partition;
if (reverse_f > c.folding)
{
tprintf("F cut %s\n", c.text(length).c_str());
return false;
}
}
return true;
}
// recursive folding
void fold(tSnakeDoll snake, unsigned first_joint)
{
// count unique configurations
if (snake.valid && is_unique(snake.configuration)) num_configurations++;
// try to bend remaining joints
for (size_t joint = first_joint; joint != num_joints; joint++)
{
// right bend
tprintf("%s -> %s\n", snake.configuration.text(length).c_str(), snake.configuration.bend(joint,1).text(length).c_str());
fold(tSnakeDoll(snake, joint, 1, grid), joint + 1);
// left bend, except for the first joint
if (snake.configuration.partition != 0)
{
tprintf("%s -> %s\n", snake.configuration.text(length).c_str(), snake.configuration.bend(joint, -1).text(length).c_str());
fold(tSnakeDoll(snake, joint, -1, grid), joint + 1);
}
}
}
public:
// count of found configurations
unsigned num_configurations;
// constructor does all the work :)
cSnakeFolder(int n) : length(n), grid(n), num_configurations(0)
{
num_joints = length - 1;
// launch recursive folding
fold(tSnakeDoll(length), 0);
}
};
// ============================================================================
// here we go
// ============================================================================
int main(int argc, char * argv[])
{
#ifdef NDEBUG
if (argc != 2) panic("give me a snake length or else");
int length = atoi(argv[1]);
#else
(void)argc; (void)argv;
int length = 12;
#endif // NDEBUG
if (length <= 0 || length >= MAX_LENGTH) panic("a snake of that length is hardly foldable");
time_t start = time(NULL);
cSnakeFolder snakes(length);
time_t duration = time(NULL) - start;
printf ("Found %d configuration%c of length %d in %lds\n", snakes.num_configurations, (snakes.num_configurations == 1) ? '\0' : 's', length, duration);
return 0;
}
Сборка исполняемого файла
Скомпилируйте с
использованием MinGW под Win7 с g ++ 4.8 для сборок "linux", поэтому переносимость не гарантируется на 100%.g++ -O3 -std=c++11
Это также работает (вроде) со стандартным проектом MSVC2013
Отменив определение NDEBUG, вы получаете следы выполнения алгоритма и сводку найденных конфигураций.
Выступления
с хеш-таблицами или без них компилятор Microsoft работает ужасно: сборка g ++ происходит в 3 раза быстрее .
Алгоритм практически не использует памяти.
Поскольку проверка столкновений примерно в O (n), время вычислений должно быть в O (nk n ), где k немного меньше 3.
На моем i3-2100@3.1 ГГц n = 17 занимает около 1:30 (около 2 миллионов) змеи / мин).
Я не закончил оптимизацию, но я не ожидал бы большего, чем прирост в 3 раза, поэтому в принципе я могу надеяться достичь n = 20 за час или n = 24 за день.
Достижение первой известной несгибаемой формы (n = 31) займет от нескольких лет до десятилетия, при условии отсутствия перебоев в электроснабжении.
Подсчет фигур
N размер змея N-1 суставы.
Каждый сустав может быть оставлен прямым или согнутым влево или вправо (3 варианта).
Таким образом, число возможных складываний составляет 3 N-1 .
Столкновения несколько уменьшат это число, поэтому фактическое число близко к 2,7 N-1
Однако многие такие складки приводят к одинаковым формам.
две формы идентичны, если есть вращение или симметрия, которая может преобразовать одну в другую.
Давайте определим сегмент как любую прямую часть сложенного тела.
Например, змея размера 5, сложенная во 2-м суставе, будет иметь 2 сегмента (один длиной 2 единицы, а второй длиной 3 единицы).
Первый сегмент будет назван голова , а последний хвост .
По договоренности мы ориентируем голову змей горизонтально, направив тело вправо (как на первом рисунке ОП).
Мы обозначаем данную фигуру списком длин сегментов со знаком, причем положительные длины указывают на сворачивание справа, а отрицательные - на сворачивание слева.
Начальная длина положительна по соглашению.
Разделение сегментов и изгибов
Если мы рассмотрим только различные способы, которыми змея длины N может быть разбита на сегменты, мы получим перераспределение, идентичное композициям N.
Используя тот же алгоритм, который показан на вики-странице, легко сгенерировать все 2 N-1 возможных раздела змеи.
Каждая перегородка, в свою очередь, генерирует все возможные сгибы, применяя левый или правый изгибы ко всем своим соединениям. Одно такое складывание будет называться конфигурацией .
Все возможные разделы могут быть представлены целым числом из N-1 битов, где каждый бит представляет наличие соединения. Мы назовем это целое число генератором .
Обрезка перегородок
Заметив, что сгибание данного раздела от головы вниз эквивалентно сгибанию симметричного раздела от хвоста вверх, мы можем найти все пары симметричных разделов и устранить одно из двух.
Генератор симметричного раздела - это генератор раздела, записанный в обратном битовом порядке, который легко и дешево обнаружить.
Это исключит почти половину возможных разделов, за исключением разделов с «палиндромными» генераторами, которые остаются неизменными при обращении битов (например, 00100100).
Забота о горизонтальной симметрии
С нашими соглашениями (змея начинает указывать вправо), самый первый изгиб, примененный справа, создаст семейство сгибов, которое будет горизонтальной симметрией от тех, которые отличаются только первым сгибом.
Если мы решим, что первый изгиб всегда будет направо, мы устраняем все горизонтальные симметрии одним большим ударом.
Зачистка палиндромов
Эти два сокращения эффективны, но их недостаточно, чтобы позаботиться об этих надоедливых палиндромах.
Наиболее тщательная проверка в общем случае выглядит следующим образом:
рассмотрим конфигурацию C с палиндромной перегородкой.
- если мы инвертируем каждый изгиб в C, мы получим горизонтальную симметрию C.
- если мы повернем C (применяя изгибы от хвоста вверх), мы получим ту же фигуру повернутой вправо
- если мы оба повернем и инвертируем C, мы получим одну и ту же фигуру повернутой влево.
Мы могли бы проверить каждую новую конфигурацию против 3 других. Однако, поскольку мы уже генерируем только конфигурации, начиная с правого поворота, у нас есть только одна возможная симметрия для проверки:
- перевернутая буква C начнется с левого поворота, который по конструкции невозможно воспроизвести
- из перевернутой и перевернутой конфигурации только одна будет начинаться с правого поворота.
Это единственная конфигурация, которую мы можем дублировать.
Устранение дубликатов без хранения
Мой первоначальный подход состоял в том, чтобы хранить все конфигурации в огромной хеш-таблице, чтобы исключить дубликаты путем проверки наличия ранее вычисленной симметричной конфигурации.
Благодаря вышеупомянутой статье стало ясно, что, поскольку разделы и свертки хранятся в виде битовых полей, их можно сравнивать как любое числовое значение.
Таким образом, чтобы исключить одного члена из симметричной пары, вы можете просто сравнить оба элемента и систематически оставить самый маленький (или самый большой, как вам нравится).
Таким образом, тестирование конфигурации на дублирование равнозначно вычислению симметричного раздела, а если оба идентичных, - свертывание. Память не нужна вообще.
Порядок генерации
Очевидно, что проверка столкновений будет наиболее трудоемкой частью, поэтому сокращение этих вычислений значительно экономит время.
Возможное решение состоит в том, чтобы иметь «змею Рэгдолла», которая будет начинаться в плоской конфигурации и постепенно изгибаться, чтобы избежать пересчета всей геометрии змеи для каждой возможной конфигурации.
Выбирая порядок, в котором тестируются конфигурации, так что для каждого общего количества соединений может храниться не более ragdoll, мы можем ограничить количество экземпляров N-1.
Я использую рекурсивное сканирование сакэ с хвоста вниз, добавляя по одному суставу на каждом уровне. Таким образом, новый экземпляр ragdoll создается поверх родительской конфигурации с одним дополнительным изгибом.
Это означает, что изгибы применяются в последовательном порядке, что, по-видимому, достаточно, чтобы избежать самопроизвольных столкновений почти во всех случаях.
Когда обнаруживается самостолкновение, изгибы, которые приводят к нарушающему ходу, применяются во всех возможных порядках, пока не будет найдено законное сворачивание или пока не исчерпаны все комбинации.
Статическая проверка
Прежде чем думать о движущихся деталях, я обнаружил, что эффективнее проверить статическую окончательную форму змеи на самопересечение.
Это делается путем рисования змеи на сетке. Каждая возможная точка изображена с головы вниз. Если есть самопересечение, по крайней мере, пара точек попадет в одно и то же место. Это требует ровно N графиков для любой конфигурации змеи в течение постоянного O (N) времени.
Основным преимуществом этого подхода является то, что один только статический тест просто выберет действительные пути самообращения на квадратной решетке, что позволяет протестировать весь алгоритм, запретив динамическое обнаружение столкновений и убедившись, что мы находим правильное количество таких путей.
Динамическая проверка
Когда змея складывается вокруг одного сустава, каждый повернутый сегмент охватывает область, форма которой совсем не тривиальна.
Очевидно, что вы можете проверять столкновения, проверяя включение во всех таких областях по отдельности. Глобальная проверка была бы более эффективной, но, учитывая сложность областей, о которой я не могу думать (за исключением, может быть, использования графического процессора для рисования всех областей и выполнения глобальной проверки попадания).
Так как статический тест заботится о начальной и конечной позиции каждого сегмента, нам просто нужно проверить пересечения с дугами, проходящими по каждому вращающемуся сегменту .
После интересной дискуссии с trichoplax и небольшим количеством JavaScript, чтобы разобраться, я разработал этот метод:
Чтобы попытаться изложить это в нескольких словах, если вы звоните
- С центр вращения,
- S вращающийся сегмент произвольной длины и направления, который не содержит C ,
- L линия, продолжающая S
- H линия, ортогональная L, проходящая через C ,
- Я пересечение L и H ,
(источник: free.fr )
Для любого сегмента, который не содержит I , область развертки ограничена 2 дугами (и 2 сегментами, уже проверенными статической проверкой).
Если я попадаю в сегмент, дуга, пройденная мной, также должна быть принята во внимание.
Это означает, что мы можем проверить каждый неподвижный сегмент на каждом вращающемся сегменте с 2 или 3 пересечениями сегмент с дугой
Я использовал векторную геометрию, чтобы вообще избежать тригонометрических функций.
Векторные операции создают компактный и (относительно) читаемый код.
Пересечение сегмента с дугой требует вектора с плавающей запятой, но логика должна быть защищена от ошибок округления.
Я нашел это элегантное и эффективное решение в неясном сообщении на форуме. Интересно, почему это не так широко освещается.
Это работает?
Ингибирование динамического обнаружения столкновений приводит к правильному самодостаточному количеству путей до n = 19, так что я уверен, что глобальный макет работает.
Динамическое обнаружение столкновений дает согласованные результаты, хотя проверка изгибов в другом порядке отсутствует (на данный момент).
Как следствие, программа подсчитывает змей, которые могут быть согнуты от головы вниз (то есть со сложенными суставами в порядке увеличения расстояния от головы).
