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.1GHz, n = 17 займає близько 1:30 (приблизно 2 мільйони змій / хвилина).
Я не робив оптимізації, але я не очікував би більше, ніж виграш x3, тому в основному я можу сподіватися досягти, можливо, n = 20 за годину, або n = 24 за день.
Досягнення першої відомої непоправної форми (n = 31) зайняло б від кількох років до десятиліття, якщо не було відключень електроенергії.
Підрахунок фігур
N розмір змія N-1 суглоби.
Кожен суглоб можна залишити прямо або зігнути вліво або вправо (3 можливості).
Таким чином, кількість можливих складок становить 3 N-1 .
Зіткнення дещо зменшить цю кількість, тому фактична кількість близька до 2,7 Н-1
Однак багато таких складок призводять до однакових форм.
дві форми однакові, якщо є або обертання, або симетрія, яка може перетворити одну в іншу.
Давайте визначимо відрізок як будь-яку пряму частину складеного тіла.
Наприклад, змія розміром 5, складена на другому суглобі, мала б 2 сегменти (один - 2 одиниці, а другий - 3 одиниці).
Перший сегмент буде називатися головою , а останній хвостиком .
За домовленістю ми орієнтуємо голову змій горизонтально тілом, вказуючи праворуч (як на першій фігурі ОП).
Позначимо задану фігуру зі списком довжин підписаних відрізків, при цьому додатні довжини вказують на праву складку, а негативні - на ліву.
Початкова тривалість умовно.
Розділення відрізків і вигинів
Якщо ми розглянемо лише різні способи, як змія довжиною N може бути розбита на сегменти, ми закінчимо переділ, ідентичний композиціям Н.
Використовуючи той же алгоритм, що показаний на сторінці wiki, легко створити всі 2 можливі розділи змії N-1 .
Кожна перегородка, в свою чергу, генерує всі можливі складки, застосовуючи вигини вліво або вправо до всіх її стиків. Одне таке складання буде називатися конфігурацією .
Усі можливі розділи можуть бути представлені цілим числом N-1 бітів, де кожен біт являє собою наявність спільного. Ми будемо називати це ціле число генератором .
Обрізка перегородок
Зауваживши, що згинання даної перегородки від голови вниз рівнозначно згинанню симетричної перегородки від хвоста вгору, ми можемо знайти всі пари симетричних перегородок і усунути одну з двох.
Генератор симетричної секції - це генератор розділу, записаний у зворотному порядку бітів, який виявляється тривіально просто та дешево.
Це дозволить виключити майже половину можливих розділів, виняток становлять перегородки з "паліндромними" генераторами, які не змінюються бітною реверсією (наприклад, 00100100).
Догляд за горизонтальними симетріями
За нашими умовами (змія починає вказувати праворуч), саме перший вигин, застосований праворуч, створить сімейство складок, які будуть горизонтальними симетріями від тих, що відрізняються лише першим вигином.
Якщо ми вирішимо, що перший згин завжди буде праворуч, ми усунемо всі горизонтальні симетрики одним великим махом.
Стирання паліндром
Ці два надрізи ефективні, але недостатньо, щоб піклуватися про ці примхливі паліндроми.
Найбільш ретельна перевірка в загальному випадку полягає в наступному:
розглянемо конфігурацію C з паліндромною перегородкою.
- якщо перевернути кожен вигин у C, ми закінчимо горизонтальну симетрику C.
- якщо повернути С (застосувати вигини від хвоста вгору), отримаємо ту саму фігуру, повернуту вправо
- якщо ми обидва повернемо і перевернемо С, отримаємо ту саму фігуру, повернуту вліво.
Ми могли перевірити кожну нову конфігурацію щодо 3 інших. Однак, оскільки ми вже генеруємо лише конфігурації, починаючи з правого повороту, у нас є лише одна можлива симетрія для перевірки:
- перевернутий С почнеться з лівого повороту, який за побудовою неможливо дублювати
- з конвертованих і перевернутих-перевернутих конфігурацій лише одна почнеться з правого повороту.
Це єдина конфігурація, яку ми можемо дублювати.
Усунення дублікатів без зберігання
Моїм початковим підходом було зберігання всіх конфігурацій у величезній хеш-таблиці, щоб усунути дублікати, перевіривши наявність раніше обчисленої симетричної конфігурації.
Завдяки вищезазначеній статті стало зрозуміло, що, оскільки розділи та складки зберігаються як бітові поля, їх можна порівняти, як будь-яке числове значення.
Отже, щоб усунути одного члена симетричної пари, ви можете просто порівняти обидва елементи та систематично зберігати найменший (або найбільший), як вам подобається.
Таким чином, тестування конфігурації на дублювання становить обчислення симетричного розділу, і якщо обидва однакові, то складання. Пам'ять взагалі не потрібна.
Порядок покоління
Очевидно, що перевірка на зіткнення буде найбільш трудомісткою частиною, тому скорочення цих обчислень є головною економією часу.
Можливим рішенням є створення «зграйкою змії», яка запускатиметься в плоскій конфігурації і буде поступово загинатися, щоб уникнути перерахування всієї геометрії змії для кожної можливої конфігурації.
Вибираючи порядок тестування конфігурацій, щоб максимум зберігати регдол для кожної загальної кількості з'єднань, ми можемо обмежити кількість екземплярів N-1.
Я використовую рекурсивне сканування саке з хвоста вниз, додаючи по одному стику на кожному рівні. Таким чином, новий екземпляр ragdoll будується поверх батьківської конфігурації, з одним додатковим вигином.
Це означає, що вигини застосовуються в послідовному порядку, що, здається, достатньо, щоб уникнути самостійних зіткнень майже у всіх випадках.
При виявленні самостійного зіткнення вигини, що призводять до кривдного руху, застосовуються у всіх можливих порядках, поки не буде знайдено законне складання або не вичерпаються всі комбінації.
Статична перевірка
Перш ніж навіть думати про рухомі частини, я вважав більш ефективним перевірити статичну остаточну форму змії для самоперехрещення.
Це робиться малюванням змії на сітці. Кожна можлива точка побудована від голови вниз. Якщо є самоперетин, принаймні пара точок впаде на ту саму локацію. Для цього потрібно рівно N ділянок для будь-якої конфігурації змії, за постійний час O (N).
Основна перевага такого підходу полягає в тому, що тільки статичний тест буде просто вибирати дійсні шляхи самовиключення на квадратній решітці, що дозволяє протестувати весь алгоритм, гальмуючи динамічне виявлення зіткнень і гарантуючи, що ми знайдемо правильний підрахунок таких шляхів.
Динамічна перевірка
Коли змія складеться навколо одного суглоба, кожен обертається сегмент змітає область, форма якої є не що інше, як банальна.
Зрозуміло, що ви можете перевірити зіткнення, перевіривши включення у всіх таких областях окремо. Глобальна перевірка була б більш ефективною, але, враховуючи складність областей, я не можу придумати жодної (крім, можливо, використання графічного процесора для малювання всіх областей та проведення глобальної перевірки хітів).
Оскільки статичне випробування піклується про початкові та кінцеві позиції кожного сегмента, нам просто потрібно перевірити перехрестя з дугами, що прокочуються кожним обертовим сегментом.
Після цікавої дискусії з трихоплаком та трохи JavaScript, щоб отримати підшипники, я придумав цей метод:
Щоб спробувати сказати це кількома словами, якщо ви телефонуєте
- C центр обертання,
- S обертовий відрізок довільної довжини і напрямку, який не містить C ,
- L лінія, що подовжує S
- H лінія, ортогональна до L, що проходить через C ,
- I перетин L і H ,
(джерело: free.fr )
Для будь-якого сегмента, який не містить I , область, що прокочується, пов'язана двома дугами (і 2 сегменти, про які вже піклується статична перевірка).
Якщо я потрапляю в сегмент, дуга, яка прокотилася, я також повинна враховувати.
Це означає, що ми можемо перевірити кожен нерухливий відрізок проти кожного обертового сегмента з 2 або 3 перетином сегмента з дугою
Я використовував векторну геометрію, щоб взагалі уникнути тригонометричних функцій.
Векторні операції створюють компактний і (відносно) читабельний код.
Перетин сегмента до дуги вимагає вектора з плаваючою точкою, але логіка повинна бути несхильною до помилок округлення.
Я знайшов це елегантне та ефективне рішення у неясному дописі на форумі. Цікаво, чому вона не широко розголошується.
Це працює?
Інгібування динамічного виявлення зіткнень призводить до правильної кількості шляхів самовиключення до n = 19, тому я впевнений, що глобальний макет працює.
Динамічне виявлення зіткнень дає стійкі результати, хоча перевірка згинів в іншому порядку відсутня (поки що).
Як наслідок, програма враховує змій, які можна зігнути з голови вниз (тобто зі складеними суглобами в порядку збільшення відстані від голови).
