Algorithm 模式算法的复杂性

我一直在试图找到一种算法来确定图案的复杂度，左边是坐标系，右边是可能的线条：

我试图找到一种算法来确定图案的复杂度，该坐标系位于图片的左侧，可能的线条位于图片的右侧：在此处输入图像描述

构建模式的规则如下所示：

• 只能使用所描绘的线条
• 一条线路不能单独存在，这意味着它必须至少连接到另一条线路
• 将图案分为四段（左上角、右上角、左下角和右下角）时，必须至少有两段被线条覆盖，这将导致最少两条线条

到目前为止，关于模式的定义并不是真正的问题。问题是我想要有三个难度级别的模式（简单、中等和困难）。下面是一些不同难度的不同模式的示例：

---

我一直在试图找到一条内线（从中心展开的线）和外线（边缘上的线）的规则，但我无法想出一个好的算法来确定模式的复杂性。对我来说，行数无疑是其中一种可能性，但我对这一点并不满意，因为根据这一规则，容易和中等之间的区别不会如图所示。我甚至不知道它是否可以用算法来解决，我应该更好地硬编码它吗？我对这个问题有点不知所措，非常感谢您的帮助。谢谢。

我暂时把它放在这里，还没有完成，我将尝试继续处理它，但Python源代码可以帮助：

link_masks = [
  0xB0000, 0xCE000, 0x41800,
  0x28580, 0x15670, 0x02A0C,
  0x00142, 0x000AB, 0x00015
]

easy_patterns = [0xE0C25, 0xC1043, 0xE4F27, 0xF1957]
medium_patterns = [0xD0C67, 0x95E30, 0x95622, 0xC5463]
hard_patterns = [0xE5975, 0xB5E75, 0xF4C75, 0xF5D75]
patterns = [("easy", easy_patterns), ("medium", medium_patterns), ("hard", hard_patterns)]

def getPatternInfos(pattern):
  bs = [True if n == "1" else False for n in str(bin(pattern))[2::]]
  links = {}
  for link in range(len(link_masks)):
    bitwiseLink = str(bin(int(bin(link_masks[link])[2::], 2) & int(bin(pattern)[2::], 2)))[2::]
    links[link] = [True if n == "1" else False for n in bitwiseLink].count(True)
  lines = bs.count(True)
  return bs, links, lines

def checkPatternComplexity(pattern):
  bs, links, lines = getPatternInfos(pattern)
  linksAmount = sum(links.values())
  print("<Pattern>")
  print("Number of lines :", lines)
  printCube(bs)
  print(links)
  print(linksAmount, "links")
  print("Max links :", max(links.values()))
  print("</Pattern>")

def printIfTrue(condition, text = "■ "):
  if condition:
    print(text, end="")
  else:
    print(" "*len(text), end="")

def orOnList(cube, indexes):
  return (sum([cube[i] for i in indexes]) > 0)

def printCube(cube):
  for y in range(9):
    if y == 0: printIfTrue(orOnList(cube, [0, 2, 3]))
    if y == 4: printIfTrue(orOnList(cube, [2, 4, 9, 11, 12]))
    if y == 8: printIfTrue(orOnList(cube, [11, 13, 18]))
    if y in [0, 4, 8]:
      printIfTrue(cube[int((y / 4) + (y * 2))], "■ ■ ■ ")
      if y == 0: printIfTrue(orOnList(cube, [0, 1, 4, 5, 6]))
      if y == 4: printIfTrue(orOnList(cube, [3, 5, 7, 9, 10, 13, 14, 15]))
      if y == 8: printIfTrue(orOnList(cube, [12, 14, 16, 18, 19]))
      printIfTrue(cube[int((y / 4) + (y * 2)) + 1], "■ ■ ■ ")
    elif y in [1, 5]:
      for i in range(7):
        if i in [2, 5]:
          print(" ", end=" ")
        printIfTrue(cube[y * 2 + (1 - (y % 5)) + i])
    elif y in [2, 6]:
      for i in range(5):
        if i in [1, 2, 3, 4]:
          print(" ", end=" ")
        if i in [1, 3]:
          if i == 1 and y == 2:
            printIfTrue(orOnList(cube, [3, 4]))
          elif i == 3 and y == 2:
            printIfTrue(orOnList(cube, [6, 7]))
          if i == 1 and y == 6:
            printIfTrue(orOnList(cube, [12, 13]))
          elif i == 3 and y == 6:
            printIfTrue(orOnList(cube, [15, 16]))
        else:
          printIfTrue(cube[(y * 2 - (1 if y == 6 else 2)) + i + int(i / 4 * 2)])
    elif y in [3, 7]:
      for i in range(7):
        if i in [2, 5]:
          print("  ", end="")
        ri, swap = (y * 2 - 2) + (1 - (y % 5)) + i, [[3, 6, 12, 15], [4, 7, 13, 16]]
        if ri in swap[0]: ri = swap[1][swap[0].index(ri)]
        elif ri in swap[1]: ri = swap[0][swap[1].index(ri)]
        printIfTrue(cube[ri])
    if y == 0: printIfTrue(orOnList(cube, [1, 7, 8]))
    if y == 4: printIfTrue(orOnList(cube, [6, 8, 10, 16, 17]))
    if y == 8: printIfTrue(orOnList(cube, [15, 17, 19]))
    print()

for pattern_group in patterns:
  print("Current Real Complexity :", pattern_group[0])
  for pattern in pattern_group[1]:
    checkPatternComplexity(pattern)

我还将编码后的12个形状放在这里：

X :  1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20

1 :  1  1  1  0  0  0  0  0  1   1   0   0   0   0   1   0   0   1   0   1
2 :  1  1  0  0  0  0  0  1  0   0   0   0   0   1   0   0   0   0   1   1
3 :  1  1  1  0  0  1  0  0  1   1   1   1   0   0   1   0   0   1   1   1
4 :  1  1  1  1  0  0  1  0  1   0   0   1   0   1   0   1   0   1   1   1
5 :  1  1  0  1  0  0  0  0  1   1   0   0   0   1   1   0   0   1   1   1
6 :  1  0  0  1  0  1  0  1  1   1   1   0   0   0   1   1   0   1   0   0
7 :  1  0  0  1  0  1  0  1  0   1   1   0   0   0   1   0   0   0   1   0
8 :  1  1  0  0  0  1  0  1  0   1   0   0   0   1   1   0   0   0   1   1
9 :  1  1  1  0  0  1  0  1  1   0   0   1   0   1   1   1   0   1   0   1
10 : 1  0  1  1  0  1  0  1  1   1   1   0   0   1   1   1   0   1   0   1
11 : 1  1  1  1  0  1  0  0  1   1   0   0   0   1   1   1   0   1   0   1
12 : 1  1  1  1  0  1  0  1  1   1   0   1   0   1   1   1   0   1   0   1

下面是我如何对点/链接进行编码的：

---

如果链接存在，则为1，否则为0。

以下是一些关于模式复杂性标准的想法：

行数

连接到单个点的最大线数

使用的对角线数

“子部分”的数量（三角形、正方形等的数量，但编码有点困难）

至少一条线覆盖的点数

---

至少在看了你们的例子后，我想到了这一点。（硬模式和简单模式之间惊人的差异）

你做得不对。首先找出是什么使模式“容易”、“中等”或“沉重”，然后提出一个算法。完全不清楚是什么使模式符合这两种复杂性。如果让我猜的话，我会说这是对称性和线数的混合，但这只是一个猜测。哇，非常感谢你的回答。因为我已经习惯了Java，所以我必须先稍微了解一下Python，以便理解您的代码。但我肯定会检验一下。

X : 1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20


1 : 1  0  1  1  0  0  0  0  0   0   0   0   0   0   0   0   0   0   0   0
2 : 1  1  0  0  1  1  1  0  0   0   0   0   0   0   0   0   0   0   0   0
3 : 0  1  0  0  0  0  0  1  1   0   0   0   0   0   0   0   0   0   0   0
4 : 0  0  1  0  1  0  0  0  0   1   0   1   1   0   0   0   0   0   0   0
5 : 0  0  0  1  0  1  0  1  0   1   1   0   0   1   1   1   0   0   0   0
6 : 0  0  0  0  0  0  1  0  1   0   1   0   0   0   0   0   1   1   0   0
7 : 0  0  0  0  0  0  0  0  0   0   0   1   0   1   0   0   0   0   1   0
8 : 0  0  0  0  0  0  0  0  0   0   0   0   1   0   1   0   1   0   1   1
9 : 0  0  0  0  0  0  0  0  0   0   0   0   0   0   0   1   0   1   0   1

X :  1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20

1 :  1  1  1  0  0  0  0  0  1   1   0   0   0   0   1   0   0   1   0   1
2 :  1  1  0  0  0  0  0  1  0   0   0   0   0   1   0   0   0   0   1   1
3 :  1  1  1  0  0  1  0  0  1   1   1   1   0   0   1   0   0   1   1   1
4 :  1  1  1  1  0  0  1  0  1   0   0   1   0   1   0   1   0   1   1   1
5 :  1  1  0  1  0  0  0  0  1   1   0   0   0   1   1   0   0   1   1   1
6 :  1  0  0  1  0  1  0  1  1   1   1   0   0   0   1   1   0   1   0   0
7 :  1  0  0  1  0  1  0  1  0   1   1   0   0   0   1   0   0   0   1   0
8 :  1  1  0  0  0  1  0  1  0   1   0   0   0   1   1   0   0   0   1   1
9 :  1  1  1  0  0  1  0  1  1   0   0   1   0   1   1   1   0   1   0   1
10 : 1  0  1  1  0  1  0  1  1   1   1   0   0   1   1   1   0   1   0   1
11 : 1  1  1  1  0  1  0  0  1   1   0   0   0   1   1   1   0   1   0   1
12 : 1  1  1  1  0  1  0  1  1   1   0   1   0   1   1   1   0   1   0   1