[PYTHON] AtCoder AGC 041 C --I was addicted to the full search of Domino Quality

Overview

--It took a long time to search for how to place dominoes when N = 7 and Quality = 3. -When implementing a search for $ 2 ^ {49} \ fallingdotseq 10 ^ {15} $, you need to prun the branches well --Python is more than 20 times slower than C ++ in some conditions

When searching for how to put N = 7 and Quality = 3 in python

Place dominoes from (0,0) and try. The order to try

1. Vertical orientation
2. Sideways
3. Do not put

It took ** about 740 [s] ** to find one suitable placement.

findPattern.py

import sys
import numpy as np
import datetime

sys.setrecursionlimit(10 ** 7)


def cntQuality(N, grids, num, axis):
    q = 0

    if axis == 0:
        g = grids[num, :]
    else:
        g = grids[:, num]

    last = -1

    for i in range(N):
        d = g[i]

        if last == d or d == 0:
            continue

        q += 1
        last = d

    return q


def dfs(N, grids, pos, num, q):
    x = pos // N
    y = pos % N


    if y == 0 and x != 0:
        qx = cntQuality(N, grids, x-1, 0)
        if qx != q:
            return False

    # end grids
    if x == N and y == 0:
        # valid
        for i in range(N):
            qy = cntQuality(N, grids, i, 1)
            if qy != q:
                return False
        return grids

    # not yet
    pos += 1

    # put vertical
    if y < N-1 and grids[x][y] == 0 and grids[x][y+1] == 0:
        v_num = num + 1
        # v_grids = copy.copy(grids)
        grids[x][y] = v_num
        grids[x][y+1] = v_num
        g = dfs(N, grids, pos, v_num, q)
        if g is not False:
            return g
        grids[x][y] = 0
        grids[x][y+1] = 0

    # put horizontal
    if x < N-1 and grids[x][y] == 0 and grids[x+1][y] == 0:
        h_num = num + 1
        # h_grids = copy.copy(grids)
        grids[x][y] = h_num
        grids[x+1][y] = h_num
        g = dfs(N, grids, pos, h_num, q)
        if g is not False:
            return g
        grids[x][y] = 0
        grids[x+1][y] = 0

    # dont put domino
    g = dfs(N, grids, pos, num, q)
    if g is not False:
        return g

    return False


start = datetime.datetime.now()
print("start", start)


N = 7
q = 3
grids = np.zeros((N, N))
g = dfs(N, grids, 0, 0, q)
end = datetime.datetime.now()
print("end", end)

print(g)

Execution result.txt

start 2020-01-07 18:13:18.477510
end 2020-01-07 18:22:35.768316
[[  1.   1.   2.   2.   3.   3.   0.]
 [  4.   4.   5.   5.   6.   0.   0.]
 [  7.   7.   0.   0.   6.   8.   8.]
 [  0.   0.   9.  10.   0.   0.  11.]
 [  0.   0.   9.  10.   0.   0.  11.]
 [  0.   0.   0.   0.  12.  13.  14.]
 [  0.   0.   0.   0.  12.  13.  14.]]

Why did it cost 740 [s]?

It seems that the order of searching was bad.

1. Sideways
2. Vertical orientation
3. Do not put

When searching with, the arrangement was found within 1 [s]. Perhaps in this search order, there are matching branches nearby.

I tried some patterns in Python and C ++

• I have tried it only once at hand, so I think there is some blurring.

Conclusion

――If you can't prun well, there will be a considerable time difference depending on the search order. ――It seems better to use C ++ than Python for this order.