Tic-tac-toe con solo cruces lo más rápido posible

10

Según la solicitud de Luke y la adición de Peter Taylor a este desafío.

Introducción

Todos conocen el juego de tres en raya, pero en este desafío, vamos a introducir un pequeño giro. Solo vamos a usar cruces . La primera persona que coloca tres cruces seguidas pierde. Un hecho interesante es que la cantidad máxima de cruces antes de que alguien pierda, es igual a 6 :

X X -
X - X
- X X

Eso significa que para un tablero de 3 x 3, la cantidad máxima es 6 . Entonces, para N = 3, necesitamos generar 6.

Otro ejemplo, para N = 4, o un tablero de 4 x 4:

X X - X
X X - X
- - - -
X X - X

Esta es una solución óptima, puede ver que la cantidad máxima de cruces es igual a 9 . Una solución óptima para una placa de 12 x 12 es:

X - X - X - X X - X X -
X X - X X - - - X X - X
- X - X - X X - - - X X
X - - - X X - X X - X -
- X X - - - X - - - - X
X X - X X - X - X X - -
- - X X - X - X X - X X
X - - - - X - - - X X -
- X - X X - X X - - - X
X X - - - X X - X - X -
X - X X - - - X X - X X
- X X - X X - X - X - X

Esto da como resultado 74 .

La tarea

Su tarea es calcular los resultados lo más rápido posible. Ejecutaré su código en el caso de prueba 13. Esto se hará 5 veces y luego se tomará el promedio de los tiempos de ejecución. Ese es tu puntaje final. Cuanto más bajo, mejor.

Casos de prueba

N     Output
1       1
2       4
3       6
4       9
5       16
6       20
7       26
8       36
9       42
10      52
11      64
12      74
13      86
14      100
15      114

Se puede encontrar más información en https://oeis.org/A181018 .

Reglas

  • Este es , por lo que gana la presentación más rápida.
  • Debe proporcionar un programa completo .
  • Indique también cómo tengo que ejecutar el programa. No estoy familiarizado con todos los lenguajes de programación y cómo funcionan, así que necesito un poco de ayuda aquí.
  • Por supuesto, su código necesita calcular el resultado correcto para cada caso de prueba.

Presentaciones:

  • Feersum (C ++ 11): 28s
  • Peter Taylor (Java): 14m 31s
Adnan
fuente
¿No es solo una trampa de la segunda pregunta , por lo que puedo decir, acabas de cambiar la condición ganadora?
Azul
1
@muddyfish Aunque el desafío en sí se ve igual, puedo asegurarle que el enfoque para este desafío es muy diferente al de mi otro desafío.
Adnan
3
@muddyfish Meta discusión relevante. "Solo cambiar la condición ganadora" puede ser un cambio sustancial para un desafío. A pesar de que no tiene sentido para publicar un código de golf , más rápido algoritmo y más rápida de código para cada posible desafío, hay algunos casos en los que la exploración de un problema desde dos ángulos puede añadir mucho valor al sitio. Creo que este es un caso así.
Martin Ender
1
Maravilloso desafío! (+1)

Respuestas:

5

C ++ 11, 28s

Esto también utiliza un enfoque de programación dinámica basado en filas. Me tomó 28 segundos correr con el argumento 13 para mí. Mi truco favorito es la nextfunción que utiliza un poco de bashing para encontrar la disposición lexicográfica de la siguiente fila que satisface una máscara y la regla de no 3 en fila.

Instrucciones

  1. Instale el último MinGW-w64 con hilos SEH y Posix
  2. Compila el programa con g++ -std=c++11 -march=native -O3 <filename>.cpp -o <executable name>
  3. Corre con <executable name> <n>
#include <vector>
#include <stddef.h>
#include <iostream>
#include <string>

#ifdef _MSC_VER
#include <intrin.h>
#define popcount32 _mm_popcnt_u32
#else
#define popcount32 __builtin_popcount
#endif


using std::vector;

using row = uint32_t;
using xcount = uint8_t;

uint16_t rev16(uint16_t x) { // slow
    static const uint8_t revbyte[] {0,128,64,192,32,160,96,224,16,144,80,208,48,176,112,240,8,136,72,200,40,168,104,232,24,152,88,216,56,184,120,248,4,132,68,196,36,164,100,228,20,148,84,212,52,180,116,244,12,140,76,204,44,172,108,236,28,156,92,220,60,188,124,252,2,130,66,194,34,162,98,226,18,146,82,210,50,178,114,242,10,138,74,202,42,170,106,234,26,154,90,218,58,186,122,250,6,134,70,198,38,166,102,230,22,150,86,214,54,182,118,246,14,142,78,206,46,174,110,238,30,158,94,222,62,190,126,254,1,129,65,193,33,161,97,225,17,145,81,209,49,177,113,241,9,137,73,201,41,169,105,233,25,153,89,217,57,185,121,249,5,133,69,197,37,165,101,229,21,149,85,213,53,181,117,245,13,141,77,205,45,173,109,237,29,157,93,221,61,189,125,253,3,131,67,195,35,163,99,227,19,147,83,211,51,179,115,243,11,139,75,203,43,171,107,235,27,155,91,219,59,187,123,251,7,135,71,199,39,167,103,231,23,151,87,215,55,183,119,247,15,143,79,207,47,175,111,239,31,159,95,223,63,191,127,255};
    return uint16_t(revbyte[x >> 8]) | uint16_t(revbyte[x & 0xFF]) << 8;
}

// returns the next number after r that does not overlap the mask or have three 1's in a row
row next(row r, uint32_t m) {
    m |= r >> 1 & r >> 2;
    uint32_t x = (r | m) + 1;
    uint32_t carry = x & -x;
    return (r | carry) & -carry;
}

template<typename T, typename U> void maxequals(T& m, U v) {
    if (v > m)
        m = v;
}

struct tictac {
    const int n;
    vector<row> rows;
    size_t nonpal, nrows_c;
    vector<int> irow;
    vector<row> revrows;

    tictac(int n) : n(n) { }

    row reverse(row r) {
        return rev16(r) >> (16 - n);
    }

    vector<int> sols_1row() {
        vector<int> v(1 << n);
        for (uint32_t m = 0; !(m >> n); m++) {
            auto m2 = m;
            int n0 = 0;
            int score = 0;
            for (int i = n; i--; m2 >>= 1) {
                if (m2 & 1) {
                    n0 = 0;
                } else {
                    if (++n0 % 3)
                        score++;
                }
            }
            v[m] = score;
        }
        return v;
    }

    void gen_rows() {
        vector<row> pals;
        for (row r = 0; !(r >> n); r = next(r, 0)) {
            row rrev = reverse(r);
            if (r < rrev) {
                rows.push_back(r);
            } else if (r == rrev) {
                pals.push_back(r);
            }
        }
        nonpal = rows.size();
        for (row r : pals) {
            rows.push_back(r);
        }
        nrows_c = rows.size();
        for (int i = 0; i < nonpal; i++) {
            rows.push_back(reverse(rows[i]));
        }
        irow.resize(1 << n);
        for (int i = 0; i < rows.size(); i++) {
            irow[rows[i]] = i;
        }
        revrows.resize(1 << n);
        for (row r = 0; !(r >> n); r++) {
            revrows[r] = reverse(r);
        }
    }

    // find banned locations for 1's given 2 above rows
    uint32_t mask(row a, row b) {
        return ((a & b) | (a >> 1 & b) >> 1 | (a << 1 & b) << 1) /*& ((1 << n) - 1)*/;
    }

    int calc() {
        if (n < 3) {
            return n * n;
        }
        gen_rows();
        int tdim = n < 5 ? n : (n + 3) / 2;
        size_t nrows = rows.size();
        xcount* t = new xcount[2 * nrows * nrows_c]{};
#define tb(nr, i, j) t[nrows * (nrows_c * ((nr) & 1) + (i)) + (j)]

        // find optimal solutions given 2 rows for n x k grids where 3 <= k <= ceil(n/2) + 1

        {
            auto s1 = sols_1row();
            for (int i = 0; i < nrows_c; i++) {
                row a = rows[i];
                for (int j = 0; j < nrows; j++) {
                    row b = rows[j];
                    uint32_t m = mask(b, a) & ~(1 << n);
                    tb(3, i, j) = s1[m] + popcount32(a << 16 | b);
                }
            }
        }
        for (int r = 4; r <= tdim; r++) {
            for (int i = 0; i < nrows_c; i++) {
                row a = rows[i];
                for (int j = 0; j < nrows; j++) {
                    row b = rows[j];
                    bool rev = j >= nrows_c;
                    auto cj = rev ? j - nrows_c : j;
                    uint32_t m = mask(a, b);
                    for (row c = 0; !(c >> n); c = next(c, m)) {
                        row cc = rev ? revrows[c] : c;
                        int count = tb(r - 1, i, j) + popcount32(c);
                        maxequals(tb(r, cj, irow[cc]), count);
                    }
                }
            }
        }
        int ans = 0;
        if (tdim == n) { // small sizes
            for (int i = 0; i < nrows_c; i++) {
                for (int j = 0; j < nrows; j++) {
                    maxequals(ans, tb(n, i, j));
                }
            }
        } else {
            int tdim2 = n + 2 - tdim;
            // get final answer by joining two halves' solutions down the middle
            for (int i = 0; i < nrows_c; i++) {
                int apc = popcount32(rows[i]);
                for (int j = 0; j < nrows; j++) {
                    row b = rows[j];
                    int top = tb(tdim2, i, j);
                    int bottom = j < nrows_c ? tb(tdim, j, i) : tb(tdim, j - nrows_c, i < nonpal ? i + nrows_c : i);
                    maxequals(ans, top + bottom - apc - popcount32(b));
                }
            }
        }
        delete[] t;
        return ans;
    }
};


int main(int argc, char** argv) {
    int n;
    if (argc < 2 || (n = std::stoi(argv[1])) < 0 || n > 16) {
        return 1;
    }
    std::cout << tictac{ n }.calc() << '\n';
    return 0;
}
Feersum
fuente
7

Java, 14m 31s

Este es esencialmente el programa que publiqué en OEIS después de usarlo para extender la secuencia, por lo que es una buena referencia para otras personas. Lo modifiqué para tomar el tamaño del tablero como el primer argumento de la línea de comandos.

public class A181018 {
    public static void main(String[] args) {
        int n = Integer.parseInt(args[0]);
        System.out.println(calc(n));
    }

    private static int calc(int n) {
        if (n < 0) throw new IllegalArgumentException("n");
        if (n < 3) return n * n;

        // Dynamic programming approach: given two rows, we can enumerate the possible third row.
        // sc[i + rows.length * j] is the greatest score achievable with a board ending in rows[i], rows[j].
        int[] rows = buildRows(n);
        byte[] sc = new byte[rows.length * rows.length];
        for (int j = 0, k = 0; j < rows.length; j++) {
            int qsc = Integer.bitCount(rows[j]);
            for (int i = 0; i < rows.length; i++) sc[k++] = (byte)(qsc + Integer.bitCount(rows[i]));
        }

        int max = 0;
        for (int h = 2; h < n; h++) {
            byte[] nsc = new byte[rows.length * rows.length];
            for (int i = 0; i < rows.length; i++) {
                int p = rows[i];
                for (int j = 0; j < rows.length; j++) {
                    int q = rows[j];
                    // The rows which follow p,q cannot intersect with a certain mask.
                    int mask = (p & q) | ((p << 2) & (q << 1)) | ((p >> 2) & (q >> 1));
                    for (int k = 0; k < rows.length; k++) {
                        int r = rows[k];
                        if ((r & mask) != 0) continue;

                        int pqrsc = (sc[i + rows.length * j] & 0xff) + Integer.bitCount(r);
                        int off = j + rows.length * k;
                        if (pqrsc > nsc[off]) nsc[off] = (byte)pqrsc;
                        if (pqrsc > max) max = pqrsc;
                    }
                }
            }

            sc = nsc;
        }

        return max;
    }

    private static int[] buildRows(int n) {
        // Array length is a tribonacci number.
        int c = 1;
        for (int a = 0, b = 1, i = 0; i < n; i++) c = a + (a = b) + (b = c);

        int[] rows = new int[c];
        int i = 0, j = 1, val;
        while ((val = rows[i]) < (1 << (n - 1))) {
            if (val > 0) rows[j++] = val * 2;
            if ((val & 3) != 3) rows[j++] = val * 2 + 1;
            i++;
        }

        return rows;
    }
}

Guardar A181018.java; compilar como javac A181018.java; correr como java A181018 13. En mi computadora, se tarda unos 20 minutos en ejecutar esta entrada. Probablemente valdría la pena ponerlo en paralelo.

Peter Taylor
fuente
¿Cuánto tiempo llevas corriendo? Todavía estoy agregando términos al OEIS, ya veo.
mbomb007
1
@ mbomb007, todavía no lo estoy ejecutando. Como puede ver por las fechas de OEIS, tardó varios días en ejecutarse n=16; Extrapolé que tomaría alrededor de un mes n=17, así que no intenté ejecutarlo para eso. El uso de la memoria también se estaba convirtiendo en una molestia importante. (PD: Actualmente estoy usando 2 de mis 4 núcleos para un desafío de programación que no es PPCG: azspcs.com/Contest/Tetrahedra/Standings )
Peter Taylor