ฉันเห็นวิธีการแก้ปัญหาที่เป็นไปได้ต่อไปนี้:
- ทฤษฎีหนัก ฉันรู้ว่ามีบางวรรณกรรมเกี่ยวกับชีวิตบนพรู แต่ฉันไม่ได้อ่านมาก
- กำลังเดินหน้าอย่างดุเดือด: สำหรับทุกบอร์ดที่เป็นไปได้ตรวจสอบคะแนน นี่เป็นสิ่งที่แมทธิวและคี ธ ทำอยู่ถึงแม้ว่าคี ธ จะลดจำนวนกระดานเพื่อตรวจสอบด้วยปัจจัย 4
- การเพิ่มประสิทธิภาพ: การแสดงแบบบัญญัติ หากเราสามารถตรวจสอบได้ว่าบอร์ดนั้นมีภาพมาตรฐานที่รวดเร็วกว่าที่เราคาดไว้หรือไม่เราสามารถเพิ่มความเร็วได้ถึง 8N ^ 2 (นอกจากนี้ยังมีวิธีการบางส่วนที่มีคลาสความเท่าเทียมขนาดเล็ก)
- การเพิ่มประสิทธิภาพ: DP แคชคะแนนสำหรับแต่ละบอร์ดดังนั้นแทนที่จะเดินผ่านพวกเขาจนกว่าพวกเขาจะมาบรรจบกันหรือแตกต่างเราเพิ่งเดินจนกว่าเราจะพบกระดานที่เราเคยเห็นมาก่อน ในหลักการนี้จะให้ความเร็วโดยปัจจัยของคะแนนเฉลี่ย / ความยาวรอบ (อาจ 20 หรือมากกว่า) แต่ในทางปฏิบัติเรามีแนวโน้มที่จะแลกเปลี่ยนอย่างหนัก เช่นสำหรับ N = 6 เราต้องการความสามารถสำหรับ 2 ^ 36 คะแนนซึ่งเป็นไบต์ต่อคะแนนคือ 16GB และเราต้องการการเข้าถึงแบบสุ่มดังนั้นเราจึงไม่คาดหวังว่าจะมีพื้นที่แคชที่ดี
- รวมทั้งสอง สำหรับ N = 6 การเป็นตัวแทนแบบบัญญัติเต็มรูปแบบจะช่วยให้เราสามารถลดแคช DP ลงได้ประมาณ 60 ล้านคะแนน นี่เป็นวิธีที่มีแนวโน้ม
- กำลังดุร้ายย้อนหลัง สิ่งนี้ดูแปลกในตอนแรก แต่ถ้าเราคิดว่าเราสามารถหาสิ่งมีชีวิตได้อย่างง่ายดายและเราสามารถสลับการ
Next(board)ทำงานได้อย่างง่ายดายเราเห็นว่ามันมีประโยชน์บางอย่างแม้ว่าจะไม่มากเท่าที่ฉันหวังไว้ในตอนแรก
- เราไม่ต้องกังวลกับกระดานที่แยกออกเลย ไม่ค่อยประหยัดเพราะค่อนข้างหายาก
- เราไม่จำเป็นต้องเก็บคะแนนสำหรับบอร์ดทั้งหมดดังนั้นควรมีความกดดันหน่วยความจำน้อยกว่าวิธีการส่งต่อ DP
- การย้อนกลับเป็นเรื่องง่ายมากโดยการปรับเปลี่ยนเทคนิคที่ฉันเห็นในวรรณกรรมในบริบทของการแจกแจงภาพนิ่ง มันทำงานโดยการรักษาแต่ละคอลัมน์เป็นตัวอักษรในตัวอักษรแล้วสังเกตว่าลำดับของตัวอักษรสามตัวเป็นตัวกำหนดกลางหนึ่งในรุ่นต่อไป เส้นขนานที่มีการแจกแจงภาพนิ่งยังคงใกล้เคียงกันมากที่ฉันได้จัดทำใหม่ด้วยวิธีที่น่าอึดอัดใจเล็กน้อยเท่านั้น
Prev2 .
- มันอาจดูเหมือนว่าเราสามารถยอมรับสิ่งมีชีวิตนิ่งเฉยและรับความเร็ว 8N ^ 2 ด้วยค่าใช้จ่ายเพียงเล็กน้อย อย่างไรก็ตามสังเกตุเรายังคงได้รับการลดจำนวนมากพิจารณาถ้าเรากำหนดมาตรฐานในแต่ละขั้นตอน
- สัดส่วนที่สูงอย่างน่าประหลาดใจของบอร์ดมีคะแนน 2 หรือ 3 ดังนั้นยังคงมีแรงกดดันของหน่วยความจำ ฉันพบว่าจำเป็นต้องได้รับการยอมรับอย่างรวดเร็วมากกว่าการสร้างคนรุ่นก่อนหน้า อาจเป็นเรื่องที่น่าสนใจในการลดการใช้หน่วยความจำโดยทำการค้นหาในเชิงลึกมากกว่าการค้นหาแบบกว้างแรก แต่การทำเช่นนั้นโดยไม่ล้นสแต็คและไม่ต้องทำการคำนวณซ้ำซ้อนต้องใช้แนวทางร่วม
ฉันไม่คิดว่าการเพิ่มประสิทธิภาพแบบไมโครจะให้ฉันตามโค้ดของ Keith แต่เพื่อประโยชน์ฉันจะโพสต์สิ่งที่ฉันมี วิธีนี้จะแก้ปัญหา N = 5 ในเวลาประมาณหนึ่งนาทีบนเครื่อง 2GHz โดยใช้ Mono 2.4 หรือ. Net (ไม่มี PLINQ) และในประมาณ 20 วินาทีโดยใช้ PLINQ; N = 6 ทำงานเป็นเวลาหลายชั่วโมง
using System;
using System.Collections.Generic;
using System.Linq;
namespace Sandbox {
class Codegolf9393 {
internal static void Main() {
new Codegolf9393(4).Solve();
}
private readonly int _Size;
private readonly uint _AlphabetSize;
private readonly uint[] _Transitions;
private readonly uint[][] _PrevData1;
private readonly uint[][] _PrevData2;
private readonly uint[,,] _CanonicalData;
private Codegolf9393(int size) {
if (size > 8) throw new NotImplementedException("We need to fit the bits in a ulong");
_Size = size;
_AlphabetSize = 1u << _Size;
_Transitions = new uint[_AlphabetSize * _AlphabetSize * _AlphabetSize];
_PrevData1 = new uint[_AlphabetSize * _AlphabetSize][];
_PrevData2 = new uint[_AlphabetSize * _AlphabetSize * _AlphabetSize][];
_CanonicalData = new uint[_Size, 2, _AlphabetSize];
InitTransitions();
}
private void InitTransitions() {
HashSet<uint>[] tmpPrev1 = new HashSet<uint>[_AlphabetSize * _AlphabetSize];
HashSet<uint>[] tmpPrev2 = new HashSet<uint>[_AlphabetSize * _AlphabetSize * _AlphabetSize];
for (int i = 0; i < tmpPrev1.Length; i++) tmpPrev1[i] = new HashSet<uint>();
for (int i = 0; i < tmpPrev2.Length; i++) tmpPrev2[i] = new HashSet<uint>();
for (uint i = 0; i < _AlphabetSize; i++) {
for (uint j = 0; j < _AlphabetSize; j++) {
uint prefix = Pack(i, j);
for (uint k = 0; k < _AlphabetSize; k++) {
// Build table for forwards checking
uint jprime = 0;
for (int l = 0; l < _Size; l++) {
uint count = GetBit(i, l-1) + GetBit(i, l) + GetBit(i, l+1) + GetBit(j, l-1) + GetBit(j, l+1) + GetBit(k, l-1) + GetBit(k, l) + GetBit(k, l+1);
uint alive = GetBit(j, l);
jprime = SetBit(jprime, l, (count == 3 || (alive + count == 3)) ? 1u : 0u);
}
_Transitions[Pack(prefix, k)] = jprime;
// Build tables for backwards possibilities
tmpPrev1[Pack(jprime, j)].Add(k);
tmpPrev2[Pack(jprime, i, j)].Add(k);
}
}
}
for (int i = 0; i < tmpPrev1.Length; i++) _PrevData1[i] = tmpPrev1[i].ToArray();
for (int i = 0; i < tmpPrev2.Length; i++) _PrevData2[i] = tmpPrev2[i].ToArray();
for (uint col = 0; col < _AlphabetSize; col++) {
_CanonicalData[0, 0, col] = col;
_CanonicalData[0, 1, col] = VFlip(col);
for (int rot = 1; rot < _Size; rot++) {
_CanonicalData[rot, 0, col] = VRotate(_CanonicalData[rot - 1, 0, col]);
_CanonicalData[rot, 1, col] = VRotate(_CanonicalData[rot - 1, 1, col]);
}
}
}
private ICollection<ulong> Prev2(bool stillLife, ulong next, ulong prev, int idx, ICollection<ulong> accum) {
if (stillLife) next = prev;
if (idx == 0) {
for (uint a = 0; a < _AlphabetSize; a++) Prev2(stillLife, next, SetColumn(0, idx, a), idx + 1, accum);
}
else if (idx < _Size) {
uint i = GetColumn(prev, idx - 2), j = GetColumn(prev, idx - 1);
uint jprime = GetColumn(next, idx - 1);
uint[] succ = idx == 1 ? _PrevData1[Pack(jprime, j)] : _PrevData2[Pack(jprime, i, j)];
foreach (uint b in succ) Prev2(stillLife, next, SetColumn(prev, idx, b), idx + 1, accum);
}
else {
// Final checks: does the loop round work?
uint a0 = GetColumn(prev, 0), a1 = GetColumn(prev, 1);
uint am = GetColumn(prev, _Size - 2), an = GetColumn(prev, _Size - 1);
if (_Transitions[Pack(am, an, a0)] == GetColumn(next, _Size - 1) &&
_Transitions[Pack(an, a0, a1)] == GetColumn(next, 0)) {
accum.Add(Canonicalise(prev));
}
}
return accum;
}
internal void Solve() {
DateTime start = DateTime.UtcNow;
ICollection<ulong> gen = Prev2(true, 0, 0, 0, new HashSet<ulong>());
for (int depth = 1; gen.Count > 0; depth++) {
Console.WriteLine("Length {0}: {1}", depth, gen.Count);
ICollection<ulong> nextGen;
#if NET_40
nextGen = new HashSet<ulong>(gen.AsParallel().SelectMany(board => Prev2(false, board, 0, 0, new HashSet<ulong>())));
#else
nextGen = new HashSet<ulong>();
foreach (ulong board in gen) Prev2(false, board, 0, 0, nextGen);
#endif
// We don't want the still lifes to persist or we'll loop for ever
if (depth == 1) {
foreach (ulong stilllife in gen) nextGen.Remove(stilllife);
}
gen = nextGen;
}
Console.WriteLine("Time taken: {0}", DateTime.UtcNow - start);
}
private ulong Canonicalise(ulong board)
{
// Find the minimum board under rotation and reflection using something akin to radix sort.
Isomorphism canonical = new Isomorphism(0, 1, 0, 1);
for (int xoff = 0; xoff < _Size; xoff++) {
for (int yoff = 0; yoff < _Size; yoff++) {
for (int xdir = -1; xdir <= 1; xdir += 2) {
for (int ydir = 0; ydir <= 1; ydir++) {
Isomorphism candidate = new Isomorphism(xoff, xdir, yoff, ydir);
for (int col = 0; col < _Size; col++) {
uint a = canonical.Column(this, board, col);
uint b = candidate.Column(this, board, col);
if (b < a) canonical = candidate;
if (a != b) break;
}
}
}
}
}
ulong canonicalValue = 0;
for (int i = 0; i < _Size; i++) canonicalValue = SetColumn(canonicalValue, i, canonical.Column(this, board, i));
return canonicalValue;
}
struct Isomorphism {
int xoff, xdir, yoff, ydir;
internal Isomorphism(int xoff, int xdir, int yoff, int ydir) {
this.xoff = xoff;
this.xdir = xdir;
this.yoff = yoff;
this.ydir = ydir;
}
internal uint Column(Codegolf9393 _this, ulong board, int col) {
uint basic = _this.GetColumn(board, xoff + col * xdir);
return _this._CanonicalData[yoff, ydir, basic];
}
}
private uint VRotate(uint col) {
return ((col << 1) | (col >> (_Size - 1))) & (_AlphabetSize - 1);
}
private uint VFlip(uint col) {
uint replacement = 0;
for (int row = 0; row < _Size; row++)
replacement = SetBit(replacement, row, GetBit(col, _Size - row - 1));
return replacement;
}
private uint GetBit(uint n, int bit) {
bit %= _Size;
if (bit < 0) bit += _Size;
return (n >> bit) & 1;
}
private uint SetBit(uint n, int bit, uint value) {
bit %= _Size;
if (bit < 0) bit += _Size;
uint mask = 1u << bit;
return (n & ~mask) | (value == 0 ? 0 : mask);
}
private uint Pack(uint a, uint b) { return (a << _Size) | b; }
private uint Pack(uint a, uint b, uint c) {
return (((a << _Size) | b) << _Size) | c;
}
private uint GetColumn(ulong n, int col) {
col %= _Size;
if (col < 0) col += _Size;
return (_AlphabetSize - 1) & (uint)(n >> (col * _Size));
}
private ulong SetColumn(ulong n, int col, uint value) {
col %= _Size;
if (col < 0) col += _Size;
ulong mask = (_AlphabetSize - 1) << (col * _Size);
return (n & ~mask) | (((ulong)value) << (col * _Size));
}
}
}
