Trình tự OEIS "đẹp" mới nhất , A328020 , vừa được xuất bản vài phút trước.

Số lượng gạch riêng biệt của một hình vuông n X n với n-polyominoes miễn phí.

Trình tự này đếm nghiêng đến đối xứng của hình vuông. Trình tự có sáu điều khoản, nhưng tôi muốn xem liệu mọi người ở đây có thể mở rộng nó hơn nữa không.

Thí dụ

Vì n=4có 22 lưới như vậy, như thể hiện trong hình ảnh này từ OEIS. Tín dụng: Jeff Bowermaster, Minh họa của A328020 (4).

Thử thách

Giống như thử thách trước đó , mục tiêu của thử thách này là tính toán càng nhiều thuật ngữ càng tốt trong chuỗi này, bắt đầu 1, 1, 2, 22, 515, 56734và trong đó thuật ngữ thứ n là số độ nghiêng của lưới n X n với n-polyominoes.

Chạy mã của bạn miễn là bạn muốn. Người chiến thắng trong thử thách này sẽ là người dùng đăng hầu hết các điều khoản của chuỗi, cùng với mã của họ để tạo ra nó. Nếu hai người dùng đăng cùng một số điều khoản, thì bất cứ ai đăng kỳ hạn cuối cùng của họ đều thắng.

Một phần mở rộng cho mã @ Grimy được N = 8

Điều này chỉ nhấn mạnh rằng @Grimy xứng đáng nhận tiền thưởng:

Tôi có thể cắt tỉa cây tìm kiếm bằng cách mở rộng mã để kiểm tra, sau mỗi polyomino đã hoàn thành, không gian trống còn lại không được phân chia thành các thành phần có kích thước không chia hết cho N.

Trên máy có mã gốc mất 2m11s cho N = 7, quá trình này mất 1m4 và N = 8 được tính trong 33h46m. Kết quả là 23437350133.

Đây là bổ sung của tôi như là một khác biệt:

--- tilepoly.c  2019-10-11 12:37:49.676351878 +0200
+++ tilepolyprune.c     2019-10-13 04:28:30.518736188 +0200
@@ -51,6 +51,30 @@
     return 1;
 } 

+static int check_component_sizes(u64 occupied, u64 total){
+    u64 queue[N*N];
+    while (total<N*N){
+        u64 count = 1;
+        u64 start = ctz(~occupied);
+        queue[0] = start;
+        occupied |= 1ul << start;
+        for(u64 current=0; current<count; ++current){
+            u64 free_adjacent = adjacency_matrix[queue[current]] & ~occupied;
+            occupied |= free_adjacent;
+            while (free_adjacent){
+                u64 next = ctz(free_adjacent);
+                free_adjacent &= ~(1ul << next);
+                queue[count++] = next;
+            }
+        }
+        if (count % N){
+            return 0;
+        }
+        total += count;
+    }
+    return 1;
+}
+
 static void recurse(u64 mino, u64 cell, u64 occupied, u64 adjacent, u64 forbidden)
 {
     if (cell >= N) {
@@ -61,6 +85,9 @@
             return;
         }

+        if(!check_component_sizes(occupied,N*mino))
+            return;
+
         u64 next = ctz(~occupied);
         board[next] = mino;
         recurse(mino, 1, occupied | 1ul << next, adjacency_matrix[next], 0);

Hãy thử trực tuyến!

C, 7 điều khoản

Nhiệm kỳ thứ bảy là 19846102 . (Sáu đầu tiên là 1, 1, 2, 22, 515, 56734, như đã nêu trong câu hỏi).

#include <stdio.h>
#include <string.h>
#include <stdint.h>

#define N 7
#define ctz __builtin_ctzl

typedef uint64_t u64;

static u64 board[N*N] = { 0 };
static u64 adjacency_matrix[N*N] = { 0 };
static u64 count = 0;

static u64 check_symmetry()
{
    static const u64 symmetries[7][3] = {
        { 0,     +N, +1 },
        { N-1,   -1, +N },
        { N-1,   +N, -1 },
        { N*N-1, -1, -N },
        { N*N-1, -N, -1 },
        { N*N-N, +1, -N },
        { N*N-N, -N, +1 },
    };

    int order[N];

    for (u64 i = 0; i < 7; ++i) {
        u64 start = symmetries[i][0];
        u64 dcol = symmetries[i][1];
        u64 drow = symmetries[i][2];
        memset(order, 0xFF, N*sizeof(int));

        for (u64 row = 0, col = 0; col < N || (col = 0, ++row < N); ++col) {
            u64 base = board[col + N*row];
            u64 symmetry = board[start + dcol*col + drow*row];
            u64 lex = 0;

            while (order[lex] != symmetry && order[lex] != -1)
                ++lex;
            order[lex] = symmetry;

            if (lex < base)
                return 0;

            if (base < lex)
                break;
        }
    }

    return 1;
} 

static void recurse(u64 mino, u64 cell, u64 occupied, u64 adjacent, u64 forbidden)
{
    if (cell >= N) {
        ++mino;

        if (mino == N) {
            count += check_symmetry();
            return;
        }

        u64 next = ctz(~occupied);
        board[next] = mino;
        recurse(mino, 1, occupied | 1ul << next, adjacency_matrix[next], 0);
        return;
    }

    adjacent &= ~occupied & ~forbidden;
    while (adjacent) {
        u64 next = ctz(adjacent);
        adjacent &= ~(1ul << next);
        forbidden |= 1ul << next;
        board[next] = mino;
        recurse(mino, cell + 1, occupied | 1ul << next, adjacent | adjacency_matrix[next], forbidden);
    }
}

int main(void)
{
    for (u64 i = 0; i < N*N; ++i) {
        if (i % N)
            adjacency_matrix[i] |= 1ul << (i - 1);
        if (i / N)
            adjacency_matrix[i] |= 1ul << (i - N);
        if (i % N != N - 1)
            adjacency_matrix[i] |= 1ul << (i + 1);
        if (i / N != N - 1)
            adjacency_matrix[i] |= 1ul << (i + N);
    }

    recurse(0, 2, 3, 4 | 3 << N, 0);
    printf("%ld\n", count);
}

Hãy thử trực tuyến! (với N = 6, vì N = 7 sẽ hết thời gian.)

Trên máy của tôi, N = 6 mất 0,171 và N = 7 mất 2m23. N = 8 sẽ mất một vài tuần.