原创文章，转载请注明出处

导语

最近抖音上突然出现了一个一笔连游戏，规则如下图

当然网上有一些奇葩的解法，比如

实际上往外连也是不允许的，只允许点与相邻点之间相连，不能跨越。

之前我写过一个One Fill游戏的解法(https://blog.csdn.net/weixin_43374551/article/details/83005188)，用这个解法遍历了一下确实是无解的。
但是怎么去证明它是无解的呢？我这里想了一种证明办法，可能跟网上有重复的，权当娱乐了。

证明

总共有24个空格，以数字表示走法，是下面这样的

你会发现，一个奇数的上下左右全是偶数，而一个偶数的上下左右全是奇数。
下面来证明这种属性




可以看到，要回到相邻的空格，经过的回路一定是偶数，因为向下走了一步一定要向上走一步，向左走了一步一定要向右走一步，这样才能回到同行或者同列。
于是矩阵用0、1表示就是这样的

所以完成这个图的走法步数一定是奇数-偶数-奇数-偶数或者偶数-奇数-偶数-奇数。并且走完，奇数和偶数的个数一定只能相差1个，因为是奇数偶数相邻的。
但是可以看到，这里1有11个，而0有13个，相差了2个，所以这是无解的！

逛贴吧的时候遇到了一个趣味问题

这里我再重复一遍问题
如下图所示，不过黑点，把所有白色圆圈用一条线连起来，不能重复，不能斜着连（更不能像上图那样穿墙传送）

把上图用矩阵文本表示出来如下（0代表黑点，即不能连的点）：

1, 0, 1, 1, 1
1, 1, 1, 1, 1
1, 1, 1, 1, 1
1, 1, 1, 1, 1
1, 1, 1, 1, 1

1-思路分析

倘若问题有解，即能够一条线连接所有点
那一条线必然有两个端点，由于左上角的1只有一个相邻点可以连接，必然为一个端点（非端点必须是起码有两个可以连接的相邻点的）
不妨以左上角的1为起点去探索，如果递归尝试所有方向后均不能一条线连接所有点，则说明该问题无解

2-递归实现代码（回溯法）

这里的代码思路和我之前的博客：【教程】python递归三部曲（基于turtle实现可视化）-三、迷宫探索基本是一样的
感兴趣的话，也可以对比着看看
一条线连的探索过程为：
从起点（左上角的1）出发，分别按顺序往上下左右四个方向去探索（即连接上下左右的可以连接的相邻点），
在这一过程中递归地对连接后的相邻点进行进一步四周的探索（即将该相邻点当做新的起点去执行上一步骤，直至探索完成或失败，才开始下一个方向的探索）
探索的具体过程可以分下面几种情况：

1. 该点不可连接（黑点或已经连接过的点）或超出边界，告诉上一步这一步探索失败
2. 没有可以连接的点了，但a) 连完了所有点，探索完成，告诉上一步这一步探索成功 ，b)没连完所有点，探索失败，然后告诉上一步这一步探索是失败的
3. 向某个方向的探索得出的结论是成功的，那么探索完成，不在探索，并且告诉上一步探索这一方向是能够探索成功的
4. 向某个方向的探索得出的结论是失败的，那么换一个方向进行探索

结合以上分析,可以写出探索的递归方法searchNext，全部代码如下

problem_board = [
    [1, 0, 1, 1, 1],
    [1, 1, 1, 1, 1],
    [1, 1, 1, 1, 1],
    [1, 1, 1, 1, 1],
    [1, 1, 1, 1, 1]
]


def check_all_linked(board):
    for row in board:
        for v in row:
            if v == 1:
                return False

    return True


def search_next(board, ci, ri, v):
    # 1. 该点不可连接（黑点或已经连接过的点）或超出边界，告诉上一步这一步探索失败
    if not (0 <= ci < len(board[0]) and 0 <= ri < len(board)):
        # 超出边界
        return False
    if board[ri][ci] != 1:
        # 黑点或已经连接过的点
        return False

    board[ri][ci] = v + 1

    direction = [
        (1, 0),
        (0, -1),
        (-1, 0),
        (0, 1),
    ]

    for d in direction:
        dc, dr = d

        found = search_next(board, ci + dc, ri + dr, v+1)
        if found:
            # 3. 向某个方向的探索得出的结论是成功的，那么探索完成，不在探索，并且告诉上一步探索这一方向是能够探索成功的
            return True
        else:
            # 4. 向某个方向的探索得出的结论是失败的，那么换一个方向进行探索
            pass

    # 2. 没有可以连接的点了
    # a) 连完了所有点, 探索完成，告诉上一步这一步探索成功
    if check_all_linked(board):
        return True

    # b)没连完所有点**，探索失败，然后告诉上一步这一步探索是失败的
    board[ri][ci] = 1
    return False

r = search_next(problem_board, 0, 0, 1)
print(r)

输出为

False

3-turtle实现可视化

import turtle

# 建立窗体
SCR = turtle.Screen()

SCR.setup(800, 800)  # 设置窗体大小

radius = 40
distance = 120


problem_board = [
    [1, 0, 1, 1, 1],
    [1, 1, 1, 1, 1],
    [1, 1, 1, 1, 1],
    [1, 1, 1, 1, 1],
    [1, 1, 1, 1, 1]
]

simple_problem_board_0 = [
    [1, 0, 1, 1],
    [1, 1, 1, 1],
    [1, 1, 1, 1],
    [1, 1, 1, 1],
]

simple_problem_board_1 = [
    [1, 0, 1],
    [1, 1, 1],
    [1, 1, 1]
]

dot_t = turtle.Turtle()
dot_t.hideturtle()
dot_t.speed(0)
dot_t.width(2)

link_t = turtle.Turtle()
link_t.hideturtle()
link_t.pensize(5)
link_t.penup()
link_t.speed(0)
link_t.color("blue")


def draw_white_dot(x, y):
    dot_t.penup()
    dot_t.goto(x, y - radius)
    dot_t.setheading(0)
    dot_t.pendown()
    dot_t.circle(radius)


def draw_black_dot(x, y):
    dot_t.penup()
    dot_t.goto(x, y - radius)
    dot_t.setheading(0)
    dot_t.pendown()
    dot_t.begin_fill()
    dot_t.circle(radius)
    dot_t.end_fill()


def draw_board(board):
    r = len(board)
    c = len(board[0])

    width = (r-1) * distance
    height = (c-1) * distance

    sx = - width // 2
    sy = height // 2

    link_t.goto(sx, sy)
    link_t.pendown()

    for ri in range(r):
        for ci in range(c):
            xi = sx + ci * distance
            yi = sy - ri * distance
            v = board[ri][ci]

            if v == 0:
                draw_black_dot(xi, yi)
            else:
                draw_white_dot(xi, yi)


def check_all_linked(board):
    for row in board:
        for v in row:
            if v == 1:
                return False

    return True


def search_next(board, ci, ri, v, di):
    # 1. 该点不可连接（黑点或已经连接过的点）或超出边界，告诉上一步这一步探索失败
    if not (0 <= ci < len(board[0]) and 0 <= ri < len(board)):
        # 超出边界
        return False
    if board[ri][ci] != 1:
        # 黑点或已经连接过的点
        return False

    if v > 1:
        link_t.setheading(di * 90)
        link_t.forward(distance)

    board[ri][ci] = v + 1

    # 必须按照右上左下的顺序，与画笔方向才能一致
    direction = [
        (1, 0),
        (0, -1),
        (-1, 0),
        (0, 1),
    ]

    for i, d in enumerate(direction):
        dc, dr = d

        found = search_next(board, ci + dc, ri + dr, v+1, i)
        if found:
            # 3. 向某个方向的探索得出的结论是成功的，那么探索完成，不在探索，并且告诉上一步探索这一方向是能够探索成功的
            return True
        else:
            # 4. 向某个方向的探索得出的结论是失败的，那么换一个方向进行探索
            pass

    # 2. 没有可以连接的点了
    # a) 连完了所有点, 探索完成，告诉上一步这一步探索成功
    if check_all_linked(board):
        return True

    # b)没连完所有点**，探索失败，然后告诉上一步这一步探索是失败的
    board[ri][ci] = 1
    for _ in range(2):
        link_t.undo()
    return False


# draw_board(simple_problem_board_1)
# search_next(simple_problem_board_1, 0, 0, 1, 0)

# draw_board(simple_problem_board_0)
# search_next(simple_problem_board_0, 0, 0, 1, 0)

draw_board(problem_board)
search_next(problem_board, 0, 0, 1, 0)
turtle.done()

问题是回溯法的时间复杂度过高，所以导致这个绘制动画要耗时很久
这里在第四部做个优化

4-可视化动画优化

在search_next方法中发现圆点已经被连线分成两个不相连的部分的时候，就已经可以说明当前的连线方式有问题，探索失败并通知上一步
故这里将第三部分的代码添加上advanced_search_next方法，待添加的代码如下

def check_board_separated(board):
    check_board = [row[:] for row in board]
    sr = -1
    sc = -1
    for ri in range(len(check_board)):
        for ci in range(len(check_board[0])):
            if check_board[ri][ci] == 1:
                sr = ri
                sc = ci
                break
        if sr >= 0:
            break

    if sr < 0:
        return False

    direction = [
        (1, 0),
        (0, -1),
        (-1, 0),
        (0, 1),
    ]

    check_board[sr][sc] = 2
    to_explore = [(sc, sr)]
    while len(to_explore) > 0:
        new_to_explore = []
        for item in to_explore:
            ci, ri = item
            for i, d in enumerate(direction):
                dc, dr = d
                nc, nr = dc + ci, dr + ri
                if (0 <= nc < len(board[0]) and 0 <= nr < len(board)) and check_board[nr][nc] == 1:
                    check_board[nr][nc] = 2
                    new_to_explore.append((nc, nr))

        to_explore = new_to_explore

    for ri in range(len(check_board)):
        for ci in range(len(check_board[0])):
            if check_board[ri][ci] == 1:
                return True

    return False


def advanced_search_next(board, ci, ri, v, di):
    # 1. 该点不可连接（黑点或已经连接过的点）或超出边界，告诉上一步这一步探索失败
    if not (0 <= ci < len(board[0]) and 0 <= ri < len(board)):
        # 超出边界
        return False
    if board[ri][ci] != 1:
        # 黑点或已经连接过的点
        return False

    if v > 1:
        link_t.setheading(di * 90)
        link_t.forward(distance)

    board[ri][ci] = v + 1

    if check_board_separated(board):
        board[ri][ci] = 1
        if v > 1:
            link_t.undo()
            link_t.undo()

        return False

    # 必须按照右上左下的顺序，与画笔方向才能一致
    direction = [
        (1, 0),
        (0, -1),
        (-1, 0),
        (0, 1),
    ]

    for i, d in enumerate(direction):
        dc, dr = d

        found = advanced_search_next(board, ci + dc, ri + dr, v+1, i)
        if found:
            # 3. 向某个方向的探索得出的结论是成功的，那么探索完成，不在探索，并且告诉上一步探索这一方向是能够探索成功的
            return True
        else:
            # 4. 向某个方向的探索得出的结论是失败的，那么换一个方向进行探索
            pass

    # 2. 没有可以连接的点了
    # a) 连完了所有点, 探索完成，告诉上一步这一步探索成功
    if check_all_linked(board):
        return True

    # b)没连完所有点**，探索失败，然后告诉上一步这一步探索是失败的
    board[ri][ci] = 1
    for _ in range(2):
        link_t.undo()
    return False

最后调用时
把search_next改为advanced_search_next调用就好

5 - 通过逻辑简单证明

实际上，有更简单的方法证明该问题是无解的

1. 先把左上角的圆圈标为A
2. A的上下左右相邻的可以连接的圆圈标为B
3. B的上下左右相邻的可以连接的圆圈标为A
4. 重复2、3步直至所有可以连接的圆圈都被标上A或B
   如下图所示
   
   图中有13个A，11个B
   由于A只能连B，B只能连A，所以假设能一条线连接24个点的话（该线的一个端点必然为左上角的A点）
   故该线段对应的必然是ABAB…这样AB交错的顺序，这种顺序，AB点的个数要么相等（如ABAB），要么A点比B点多1个点（如ABABA）
   但是13个A点，11个B点，必然有起码一个A点是无法通过AB交错的方式连接起来，
   即无法通过一条线来连接

首语：很多人都想可以有人把自己的名字可以找到【一笔一划教你写一签名】的大师，网上可能也有软件，但是应该不是手写的，今天咱们就来说说手写的一笔一划教你写一签名。希望可以帮助大家解决问题!

一笔一划教你写一签名

如果大家是找我们设计签名的。

可以百度：三秒艺术签名网：【海量免费签名等你来选!】

是可以给你拍摄写签名的视频的，而且就想说的那样是一笔一划的。慢放视频，可以重复的观看。

这样估计在你学习自己签名的时候，就会更加方便和有效了。

虽然不能亲自给你们做示范，但是有视频在我想大家都是聪明人一定会自己学会的。

而且，设计的款式也都是不一样的。大家如果想知道自己的姓名怎么写好看，如何设计艺术签名。

下面就分享几张签名给大家欣赏!

核心提示：　　可选中1个或多个下面的关键词，搜索相关资料。也可直接点搜索资料搜索整个问题。　　这一类就是平常写法，但又不是正规正矩

可选中1个或多个下面的关键词，搜索相关资料。也可直接点“搜索资料”搜索整个问题。

这一类就是平常写法，但又不是正规正矩的一个字一个的写.这其中必须要有一定创意，否则就谈不上个性与独特了，更没有设计含量而言。

李佳轩：李字一横特意写斜，一撇一捺写成两点，而且与轩字一高一低产生对比，中间佳字相对小一些，但与李的下部，和轩的上部分基本在一个水平面，这样整体给人一种灵动谐调的美感。因为整体轮廓像一个90度的Z字，而Z字是个中心对称图。这就是布局的讲究。

胡勇华：主要是连笔效果，一笔完成(也叫一笔连，当然最后一两点，一两笔不算属正常).大家仔细看，也用了借用笔画和省略笔画方式：古字右边与月字左边公用笔画，月字两点省掉。月字右边与勇字左边公用笔画，勇字右边与华字左边公用笔画。

也叫POP类，或图画类，就是手绘海报和涂鸦的效果。具有夸张随意的特性。但也讲究结构比例，否则就不好看。

例如吴苗，左上角夸大，右下角也夸大，中间的天与艹也差不多的小，整体轮廓也是中心对称图形。这就是POP类的随性。

郭俊岭一款(第一步里第6款)，很明显像图画，因为名字中有个岭字，所以把三个字上面写的像山峰。李月一款(第一步里第7款)，也属图画类，因为此人是个女孩子，所以就把月字直接写成可爱月亮形。

这一类就是把名字的几个字写得挤在一块，不需太大技巧去把字变形，堆叠在一起，造成辨认难度就OK了.当然也可以运用一点简化类方法进去。

反写类其实并没有多大的创意。只要带有连笔效果的，反过来练习熟了就成功了(写在纸上从反面看的那种效果)。

1、签名注意首尾二字。其实，怎么把名字写得好看一些，一些简单的技巧。首尾二字，最为重要，因为它们决定了名字的整体效果。首尾二字写好了，签名便成功了一半。

2、适当的让笔画夸张一些，张弛有度。签名其实无关书法，当然，有一定书法基础自然对字的结构把握的要熟练一些，有时候也不必墨守成规，适当的让一些竖、捺，横等笔画夸张一些，让整体协调美观。

3、巧妙连笔，能简则简。有时候，随意所写的字反而有些部分会让人觉得好看，则是因为在无心的时候，随手的连笔，让整个字变得灵动起来。

4、勤练习，多摸索说到底，签名始终是个人的事情，可以多模仿，并在基础上多练习，假以时日，也会签出自己独特风格的名字。