tsp/X4_3.py

# -*- coding: utf-8 -*-
# Time : 2023/10/30 15:49
# Author : lirunsheng
# User : l'r's
# Software: PyCharm
# File : X4.py
from tkinter import Tk
import random
import math
import time
import tkinter as tk
from tkinter import *
from tkinter import ttk
from tkinter import messagebox
import numpy as np
import networkx as nx
from PIL import Image, ImageTk

MODE = 0
BLUE = "#0080FF"
BLACK = "#000000"
RED = "#FFAAAA"
YELLOW = "#FFFACD"
LINE = '#c8d2c8'
GREY = '#070b19'
GREEN = '#5ba585'
NODE = '#33a8cd'
ZERO = 'gold'
MARK_NODE = 0
Specify_Nodes = ''
Edges_list = []
NAME = []
CLICK = [0, 0, 0]

List_Image = []

class Data:
    def __init__(self, source: int, num: int, mold: int):
        global NAME
        if num <= 0 or num > 10:
            raise ValueError("num must be a positive integer")
        self.styple = mold
        self.edgeinfo = 1  # 是否显示详情
        self.nodes_num = num  # 节点个数
        self.ang = 360 / self.nodes_num  # 圆心顶点角度
        self.R = 300  # 外接圆半径
        self.bc = 2 * self.R * math.sin(math.pi / self.nodes_num)  # 节点之间的正多边形距离
        self.canvas_len = int(2 * self.R + 80)  # 画布边长
        self.center = ((self.canvas_len+220) // 2, (self.canvas_len+230) // 2)  # 画布中心点坐标
        self.drop = []
        self.index = 0
        if source == 3 or source == 2:      # 指定删除
            # name = [str(i) for i in range(1, num + 2)]
            # print(name)
            if source == 2:
                NAME.pop()
            else:
                # print(Specify_Nodes)
                NAME.remove(Specify_Nodes)
            self.name = NAME
            self.coordinate = self.coord_creat()  # 纯节点坐标
            self.Nodes = self.nodes_creat()  # 创建节点列表
            # print(self.Nodes)
            self.Edges = self.edges_delete(source)  # 创建第一条连接
        else:
            if source == 1:
                name = str(int(NAME[-1])+1)
                # print(name)
                NAME.append(name)
            else:
                NAME = [str(i) for i in range(1, num + 1)]
            # print(NAME)
            self.name = NAME
            self.coordinate = self.coord_creat()  # 纯节点坐标
            self.Nodes = self.nodes_creat()  # 创建节点列表
            # print(self.Nodes)
            self.Edges = self.edges_creat(source)  # 创建第一条连接
            self.edge_add(2, source)  # 创建第2条连接
            self.edge_add(3, source)  # 创建第3条连接

    def nodes_creat(self, n_sum=None):
        if n_sum == None:
            n_sum = self.nodes_num
        nodes = []  # 初始化node表
        # 设置画布中心点坐标x0,y0
        x0 = self.center[0]
        y0 = self.center[1]
        for i in range(n_sum):  # 通过几何运算得到多边形各个顶点坐标
            rad = math.radians(i * self.ang)  # 计算第i个点的弧度
            x = int(math.cos(rad) * self.R)  # 计算第i个顶点x坐标
            y = int(math.sin(rad) * self.R)  # 计算第i个顶点y坐标
            # name = '' + str(i + 1)  # 给第i个顶点命名
            name = '' + self.name[i]
            mark = 0  # 节点为未标记
            dominator = 1  # 设置为必经节点
            nodes.append([i, name, mark, (x0 + x, y0 + y), dominator])  # 将当前节点加入node中
        return nodes

    def edges_delete(self, source):
        edges = []  # 初始化所有链接集合
        ser = 0
        # print(str(int(Specify_Nodes) + 1))
        for list_edge in Edges_list:
            # print(list_edge)
            edges.append([ser, list_edge[1], list_edge[2],list_edge[3], list_edge[4],list_edge[5], list_edge[6],
                          list_edge[7], list_edge[8]])  # 将连接加入到边的集合中
            nox = [int(num) for num in edges[ser][5].split('-')]
            # print(nox)
            if len(nox) == 2:
                ss = edges[ser][5]
            else:
                ss = edges[ser][5][:-2]
            # print(ss)
            if source == 2:
                if str(len(self.Nodes)+1) in ss:
                    # print(edges[ser])
                    edges.pop()
                    ser -= 1
            else:
                if Specify_Nodes in ss:
                    # print(edges[ser])
                    edges.pop()
                    ser -= 1
            ser += 1
        return edges

    def edges_creat(self, source):
        edges = []  # 初始化所有链接集合
        ser = 0  # 初始化链接对象编号
        nodes = self.Nodes.copy()  # 复制节点对象
        nodes1 = self.Nodes.copy()  # 复制节点对象
        # print(nodes1)
        self.drop = []
        for node in nodes:  # 遍历节点对象
            if node in nodes1:  # 删除nodes1中当期遍历的节点信息
                nodes1.remove(node)
            # print(nodes1)
            for node1 in nodes1:  # 遍历删除后的节点信息
                n1 = node[0]  # 节点对象编号1
                n2 = node1[0]  # 节点对象编号2
                if self.styple == 1:
                    dist_c = random.randint(1, 99)  # 随机生成距离成本
                    time_c = random.randint(1, 99)  # 随机生成链接的时间
                else:
                    if self.drop.count(n2) > 3 or self.drop.count(n1) > 3:
                        dist_c = random.randint(101, 120)  # 随机生成距离成本
                        time_c = random.randint(101, 120)  # 随机生成链接的时间
                    else:
                        dist_c = random.randint(10, 120)  # 随机生成距离成本
                        time_c = random.randint(10, 120)  # 随机生成链接的时间
                seq = 1  # 链接序号
                mark = False  # 连接是否标记
                tag = f"{NAME[n1]}-{NAME[n2]}"  # 链接标签
                enable = 1  # 连接是否可用
                if dist_c >= 100 or time_c >= 100:  # 设置某些节点为不显示
                    enable = 0
                else:
                    self.drop.append(n1)
                    self.drop.append(n2)
                if source == 1:
                    # print(n2, len(self.Nodes))
                    if n2 == len(self.Nodes)-1:
                        # print('进来了')
                        edges.append([ser, int(NAME[n1])-1, int(NAME[n2])-1, enable, mark, tag, dist_c, time_c, seq])  # 将连接加入到边的集合中
                    else:
                        # print(self.index)
                        edges.append([ser, Edges_list[self.index][1], Edges_list[self.index][2],
                                      Edges_list[self.index][3], Edges_list[self.index][4],
                                      Edges_list[self.index][5],Edges_list[self.index][6],
                                      Edges_list[self.index][7], Edges_list[self.index][8]])  # 将连接加入到边的集合中
                        self.index += 1
                else:
                    edges.append([ser, int(NAME[n1])-1, int(NAME[n2])-1, enable, mark, tag, dist_c, time_c, seq])  # 将连接加入到边的集合中
                ser += 1  # 计数加一
        return edges

    def edge_add(self, no, source):
        nodes = self.Nodes.copy()  # 复制节点对象
        nodes1 = self.Nodes.copy()  # 复制节点对象
        for node in nodes:  # 遍历节点对象
            if node in nodes1:  # 删除nodes1中当期遍历的节点信息
                nodes1.remove(node)
            for node1 in nodes1:  # 遍历删除后的节点信息
                ser = len(self.Edges)  # 链接序号
                n1 = node[0]  # 节点对象编号1
                n2 = node1[0]  # 节点对象编号2
                show = 0  # 设置为不显示
                mark = False  # 连接是否标记
                tag = f"{NAME[n1]}-{NAME[n2]}-{no}"  # 链接标签
                dist_c = random.randint(30, 100)  # 距离成本
                time_c = random.randint(1, 30)  # 链接的时间
                enable = no  # 连接是否可用
                if source == 1:
                    if n2 == len(self.Nodes)-1:
                        # print('进来了')
                        self.Edges.append([ser, int(NAME[n1])-1, int(NAME[n2])-1, show, mark, tag, dist_c, time_c, enable])  # 将连接加入到边的集合中
                    else:
                        # print(no ,self.index)
                        self.Edges.append([ser, Edges_list[self.index][1], Edges_list[self.index][2],
                                      Edges_list[self.index][3], Edges_list[self.index][4],
                                      Edges_list[self.index][5], Edges_list[self.index][6],
                                      Edges_list[self.index][7], Edges_list[self.index][8]])  # 将连接加入到边的集合中

                        self.index += 1
                else:
                    self.Edges.append([ser, int(NAME[n1])-1, int(NAME[n2])-1, show, mark, tag, dist_c, time_c, enable])

    def coord_creat(self):
        '''返回每个节点的坐标'''
        coordinate = []
        x0 = self.center[0]
        y0 = self.center[1]
        for i in range(self.nodes_num):
            rad = math.radians(i * self.ang)
            x = int(math.cos(rad) * self.R)
            y = int(math.sin(rad) * self.R)
            coordinate.append((x0 + x, y0 + y))
        return coordinate

    def node_co(self, key):  # 通过节点编号返回编号的坐标
        """通过节点编号返回编号的坐标"""
        nodes = self.Nodes
        for n in nodes:
            if n[1] == str(key + 1):
                return n[3]

    def node_no(self, key):  # 通过节点编号返回编号的坐标
        """通过节点编号返回编号的坐标"""
        nodes = self.Nodes
        for n in nodes:
            if n[1] == str(key + 1):
                return n[0]
    def node_coordinate(self, n): # 通过节点编号返回矩阵的坐标
        result = []
        for i in range(n):
            for j in range(i + 1, n):
                result.append((i, j))
        return result

# G = Graph()
# print(1)
nodes = 6  # 设置初始节点数量
d = Data(0, nodes, 0)

class Graph:
    # Graph定义
    def edge_info(self, cv: tk.Canvas, info: str, n1: tuple, n2: tuple):  # 显示路径信息
        if d.edgeinfo == 0:  # 若设置为不显示则直接返回
            return
        # print(n1)
        # print(n2)
        x = (n1[0] - n2[0]) // 2 + n2[0]  # 计算中点x坐标
        y = (n1[1] - n2[1]) // 2 + n2[1]  # 计算中点y坐标
        if (n2[1] - n1[1]) != 0:  # 斜率为非0度时的显示
            reat = math.atan((n2[0] - n1[0]) / (n2[1] - n1[1]))  # 根据斜率计算弧度
            ang = round(math.degrees(reat)) + 90  # 根据弧度转角度
            if ang > 89:  # 斜度大于90度调整坐标
                text_x, text_y = x + 15, y
            else:  # 斜度大于90度调整坐标
                text_x, text_y = x, y + 15
        else:  # 斜率为0度时的显示
            ang = round(math.degrees(0))  # 根据弧度转角度
            text_x, text_y = x - 30, y + 10
        # print(info.split(' ')[-1])
        cv.create_text(text_x, text_y, text=f'{info.split()[-2]}', fill="black", font=('微软雅黑', 12), angle=ang)  # 根据信息显示文字

    def draw(self):
        cv.delete('all')  # 清空画布
        cv.create_image(0, 0, image=List_Image[40], anchor=tk.NW)
        dis, tim = self.edges_show(cv, d.Edges)  # 绘制边
        self.lab_show(frame_top, len(d.Nodes), tim, dis)  # 显示边信息
        self.nodes_show(cv)  # 绘制点
        cv.update()  # 更新画布


    def lab_show(self, frame: tk.Frame, nodes: int, time: int, distance: int):
        labs = ["节点数目", "时间", "距离(成本)"]
        x0 = d.canvas_len // 3
        for i in range(len(labs)):
            lab1 = tk.Label(frame, text=labs[i], fg=BLACK, bg='white', font=('微软雅黑', 12))
            if i == 0:
                lab2 = tk.Label(frame, text=f"{nodes}", bg='#F8F8FF', fg=BLACK, font=('微软雅黑', 12))
            elif i == 1:
                lab2 = tk.Label(frame, text=f"{time}", bg='#F8F8FF', fg=BLACK, font=('微软雅黑', 12))
            else:
                lab2 = tk.Label(frame, text=f"{distance}", bg='#F8F8FF', fg=BLACK, font=('微软雅黑', 12))
            lab1.place(x=10 + x0 * i, y=10, width=80, height=30)
            lab2.place(x=10 + x0 * i + 80, y=10, width=80, height=30)
        lab1 = tk.Label(frame, text='分钟', fg=BLACK, bg='white', font=('微软雅黑', 12))
        lab1.place(x=170 + x0, y=10, width=50, height=30)
        lab1 = tk.Label(frame, text='千米', fg=BLACK, bg='white', font=('微软雅黑', 12))
        lab1.place(x=170 + x0 * 2, y=10, width=50, height=30)

    def nodes_show(self, cv: tk.Canvas):
        COL = NODE  # 初始化节点颜色
        for i in d.Nodes:  # 遍历每一个节点
            x, y = i[3]  # 记录该节点坐标
            if i[2] == 1 or i[2] == 2:  # 如果节点被标记，则将节点标为红色
                COL = RED
            elif i[0] == 0:  # 如果节点为起始节点，则将节点标记为特殊颜色
                COL = ZERO
            elif i[2] == 5:  # 如果节点已经被访问，则将节点标记（用户路径功能）
                COL = 'gold'
            else:  # 否则则使用初始颜色
                COL = NODE
            if i[4] == 1:  # 如果是必经节点，则加黑色边框
                w = 1
            else:  # 如果是非必经节点，则没有边框
                w = 0
            # 根据坐标，圆的颜色与是否有边框绘制圆圈来表示节点
            cv.create_oval(x - 20, y - 20, x + 20, y + 20, fill=COL, width=w, )  # outline='#ee28a3')
            cv.create_text(x, y, text=f'{i[1]}', fill=GREY, font=('华文楷体', 18))
        cv.update()

    def edges_show(self, cv: tk.Canvas, edges: d.Edges):
        """
        显示链接
        :param cv: tkcanvas对象
        :return:
        """
        distance = 0  # 初始化被标记的线的总路径
        time1 = 0  # 初始化被标记的线的总时间
        for edge in edges:
            node_1 = d.node_co(edge[1])  # 链接线编号对应的坐标1
            node_2 = d.node_co(edge[2])  # 链接线编号对应的坐标2
            # print(node_1,node_2)
            if edge[8] == 2 and edge[3] == 1:  # 若该链接为两点间第二条连线
                self.more_edge_show(2, edge)
            elif edge[8] == 3 and edge[3] == 1:  # 若为两点间第3条连线
                self.more_edge_show(3, edge)
            if edge[8] == 1 and edge[3] == 1:  # 若为两点间第1条连线且该连接存在
                self.edge_info(cv, f'{edge[5]} {edge[6]} {edge[7]}', node_1, node_2)
            point = [node_1, node_2]
            if edge[4] == 1 and edge[8] == 1 and edge[3] == 1:  # 如果路径被标记，则用绿色绘制
                if MODE == 1:
                    cv.create_line(point, fill=RED, width=4)
                elif MODE == 2:
                    cv.create_line(point, fill=BLUE, width=4)
                else:
                    cv.create_line(point, fill=GREEN, width=4)
                distance += edge[6]  # 更新总路径
                time1 += edge[7]  # 更新总时间
            elif edge[8] == 1 and edge[3] == 1:  # 如果是节点之间的第一条线，则用正常颜色标记
                cv.create_line(point, fill=LINE, width=2)
            if d.Nodes[d.node_no(edge[2])][2] + d.Nodes[d.node_no(edge[2])][2] == 3:  # 若该线被用户选中，则用蓝色虚线标记
                cv.create_line(point, fill=BLUE, width=5, dash=(4, 14))
        return (distance, time1)  # 返回标记路径的总时间与路程

    # def node_edge(self, a, b):  # 根据点的编号找边的编号
    #     if a > b:
    #         x = a
    #         a = b
    #         b = x
    #     return int(a * (2 * len(d.Nodes) - a - 3) / 2 + b - 1)

    def node_edge(self, a, b):  # 根据点的编号找边的编号
        for edge in d.Edges:
            if a == edge[1] and b == edge[2]:
                return edge[0]
            if b == edge[1] and a == edge[2]:
                return edge[0]

    def way_node_edge(self, a, b):  # 根据点的编号找边的编号
        way = []
        for node in d.Nodes:
            way.append(int(node[1]))
        # print(way)
        # print(a, b)
        x, y = way[a]-1, way[b]-1
        for edge in d.Edges:
            if x == edge[1] and y == edge[2]:
                return edge[0]
            if y == edge[1] and x == edge[2]:
                return edge[0]

    def delete_all(self):
        cv.delete('all')  # 清空画布
        cv.create_image(0, 0, image=List_Image[40], anchor=tk.NW)
        self.lab_show(frame_top, 0, 0, 0)  # 显示边信息
        W.user_way = [0]
        window(2)

class Edge:
    def __init__(self):
        self.mark = []
        # 记录已标记的节点数目（连接操作）
        self.user_cur = 0
        # 记录用户所在点

    def node_edge(self, no, n1, n2):  # 根据节点返回编号
        if n1 > n2:
            n = n1
            n1 = n2
            n2 = n
        for e in d.Edges:
            if e[1] == n1 and e[2] == n2 and e[8] == no:
                return e[0]
        return -1
    def edge_del_all(self, mode):
        # mode = 1:优先最短路径
        # mode = 2:优先最短时间
        # cur1 = node_edge()
        if mode == 1:
            for e in d.Edges:
                if (e[8] == 2 and e[3] == 1) or (e[8] == 3 and e[3] == 1):
                    self.edge_merge_cost(e[1], e[2])
        else:
            for e in d.Edges:
                if (e[8] == 2 and e[3] == 1) or (e[8] == 3 and e[3] == 1):
                    self.edge_merge_time(e[1], e[2])
        G.draw()

    def edge_merge_cost(self, n1, n2):
        cur1 = node_edge(n1, n2)  # 初始化三条可能的边的编号
        cur2 = node_edge(n1, n2, 2)  # 初始化三条可能的边的编号
        cur3 = node_edge(n1, n2, 3)  # 初始化三条可能的边的编号
        edges = [(cur1, d.Edges[cur1][6]), (cur2, d.Edges[cur2][6]), (cur3, d.Edges[cur3][6])]  # 提出编号与路径花费
        valid_edges = [(edge, cost) for edge, cost in edges if d.Edges[edge][3] == 1]  # 过滤出存在的边
        valid_edges.sort(key=lambda x: x[1])  # 按照 cost 排序，保留 cost 最小的边
        for idx, (edge, _) in enumerate(valid_edges):
            d.Edges[edge][8] = idx + 1  # 设置边的优先级
            d.Edges[edge][0] = edge  # 确保边的索引正确
        for edge, _ in valid_edges[1:]:  # 对于非最优边，设置其为不显示
            d.Edges[edge][3] = 0
    def edge_merge_time(self, n1, n2):
        cur1 = node_edge(n1, n2)  # 初始化三条可能的边的编号
        cur2 = node_edge(n1, n2, 2)  # 初始化三条可能的边的编号
        cur3 = node_edge(n1, n2, 3)  # 初始化三条可能的边的编号
        edges = [(cur1, d.Edges[cur1][7]), (cur2, d.Edges[cur2][7]), (cur3, d.Edges[cur3][7])]  # 提出编号与路径花费
        valid_edges = [(edge, cost) for edge, cost in edges if d.Edges[edge][3] == 1]  # 过滤出存在的边
        valid_edges.sort(key=lambda x: x[1])  # 按照 cost 排序，保留 cost 最小的边
        for idx, (edge, _) in enumerate(valid_edges):
            d.Edges[edge][8] = idx + 1  # 设置边的优先级
            d.Edges[edge][0] = edge  # 确保边的索引正确
        for edge, _ in valid_edges[1:]:  # 对于非最优边，设置其为不显示
            d.Edges[edge][3] = 0

class Solve:
    def __init__(self):
        self.ans = []  # 记录答案
        self.mutians = []  # 若有多个最短路，则保存在mutians中
        self.way_sum = 0  # 记录遍历的路径数目
        self.minn = float("inf")  # 初始化最小值为正无穷
        self.start = 0  # 起始点
        self.end = 0  # 终点
        self.mark = []  # 记录该点是否已经经过
        self.user_cur = 0  # 记录用户所在点
        self.cura = -1  # 记录用户选择的第一个点
        self.curb = -1  # 记录用户选择的第二个点
        self.con = 0  # 记录必经的节点数目

    def node_greedy(self):  # 贪心
        self.start = time.time()  # 记录开始时间
        self.way_sum = 0
        self.ans.clear()  # 初始化答案列表
        E.edge_del_all(1)  # 两点间仅保留距离最短路径
        for edge in d.Edges:  # 清空标记
            edge[4] = False
        flag = [0] * len(d.Nodes)  # 初始化已经过点
        cur = 0  # 初始化起始点
        flag[cur] = 1  # 将起始点标记为已经过
        l = len(d.Nodes)
        # print(l)
        distances = [[math.inf for _ in range(l)] for _ in range(l)]
        result = d.node_coordinate(l)
        for j in d.Edges:  # 每一步选择当前最短的链接加到路径中去
            if j[0] >= len(result):
                break
            else:
                if j[3] == 1:
                    distances[result[j[0]][0]][result[j[0]][1]] = j[6]
                    distances[result[j[0]][1]][result[j[0]][0]] = j[6]
        # print(distances)
        ways = self.greedy(distances)
        self.ans = ways.copy()
        # 如果找到的路径不合法，则表示贪心法无法求解得到合法路径
        print(self.way_sum)
        # for i in distances:
        #     print(i)
        if len(ways) != l+1 :
            tk.messagebox.askokcancel(title='结果', message='该图不存在贪心算法路径')
            print(ways)
            for way in range(len(ways) - 1):  # 标记一条路径
                d.Edges[G.way_node_edge(ways[way], ways[way + 1])][4] = True
            self.ans.clear()
            self.end = time.time()  # 记录结束时间
            return -1
        for way in range(len(ways) - 1):  # 标记一条路径
            d.Edges[G.way_node_edge(ways[way], ways[way + 1])][4] = True
        # print(ways[len(ways) - 1], i)
        # d.Edges[G.way_node_edge(ways[len(ways) - 1], i)][4] = True  # 标记起点终点形成环线
        # print(ways)
        tk.messagebox.askokcancel(title='结果', message='贪心算法路径')
        self.end = time.time()  # 记录结束时间
    def greedy(self,distances):
        num_cities = len(distances)
        visited = [False] * num_cities
        path = [0]  # 起始城市为0
        visited[0] = True
        for _ in range(num_cities - 1):
            curr_city = path[-1]
            min_distance = float('inf')
            next_city = None

            for city in range(num_cities):
                if not visited[city] and distances[curr_city][city] < min_distance and distances[curr_city][city] != 0:
                    min_distance = distances[curr_city][city]
                    next_city = city
                    self.way_sum += 1  # 遍历路径的数目加一

            if next_city is not None:
                path.append(next_city)
                visited[next_city] = True
        if distances[path[-1]][0] != np.inf:
            path.append(0)  # 回到起始城市形成闭合路径
        # print(path)
        return path

    def tsp_backtracking(self):
        self.start = time.time()  # 记录开始时间
        self.way_sum = 0
        self.ans.clear()  # 初始化答案列表
        E.edge_del_all(1)  # 两点间仅保留距离最短路径
        for edge in d.Edges:  # 清空标记
            edge[4] = False
        flag = [0] * len(d.Nodes)  # 初始化已经过点
        cur = 0  # 初始化起始点
        flag[cur] = 1  # 将起始点标记为已经过
        l = len(d.Nodes)
        # print(l)
        distances = [[math.inf for _ in range(l)] for _ in range(l)]
        result = d.node_coordinate(l)
        for j in d.Edges:  # 每一步选择当前最短的链接加到路径中去
            if j[0] >= len(result):
                break
            else:
                if j[3] == 1:
                    distances[result[j[0]][0]][result[j[0]][1]] = j[6]
                    distances[result[j[0]][1]][result[j[0]][0]] = j[6]
        # print(distances)
        ways = self.backtracking(distances)
        print(self.way_sum)

        if ways: # 判断路径是否存在
            self.ans = ways.copy()
            for way in range(len(ways) - 1):  # 标记一条路径
                d.Edges[G.way_node_edge(ways[way], ways[way + 1])][4] = True
            tk.messagebox.askokcancel(title='结果', message='回溯算法路径')
            self.end = time.time()  # 记录结束时间
        else:
            tk.messagebox.askokcancel(title='结果', message='该图不存在回溯算法路径')
            self.end = time.time()  # 记录结束时间
            return -1

    def backtracking(self, distances):
        num_cities = len(distances)
        path = [0]  # 起始城市为0
        visited = [False] * num_cities
        visited[0] = True
        min_distance = float('inf')
        shortest_path = None

        def backtrack(curr_city, curr_distance, visited, path):
            nonlocal min_distance, shortest_path
            if len(path) == num_cities:
                # 到达所有城市，更新最短路径
                if curr_distance + distances[curr_city][0] < min_distance:
                    min_distance = curr_distance + distances[curr_city][0]
                    shortest_path = path + [0]
            else:
                for next_city in range(num_cities):
                    if not visited[next_city]:
                        # 选择下一个未访问的城市
                        visited[next_city] = True
                        path.append(next_city)
                        new_distance = curr_distance + distances[curr_city][next_city]
                        self.way_sum += 1  # 遍历路径的数目加一
                        # 剪枝条件：当前路径已经大于最短路径，不继续搜索
                        if new_distance < min_distance:
                            backtrack(next_city, new_distance, visited, path)
                        # 回溯
                        visited[next_city] = False
                        path.pop()

        backtrack(0, 0, visited, path)
        return shortest_path

    def auto_solve(self, number):
        global MODE, MARK_NODE
        MARK_NODE = 0
        MODE = 2
        if number == 1:  # 回溯
            self.tsp_backtracking()
        elif number == 2:
            self.node_greedy()  # 贪心
        else:  # 深度优先算法
            self.node_dfs()
        window(1)
        G.draw()

    def node_dfs(self):  # 遍历 深度优先算法
        self.start = time.time()  # 记录开始时间
        self.way_sum = 0
        self.ans.clear()  # 初始化答案列表
        E.edge_del_all(1)  # 两点间仅保留距离最短路径
        for edge in d.Edges:  # 清空标记
            edge[4] = False
        i = 0  # 起始点
        flag = [0] * len(d.Nodes)  # 初始化已经过点
        cur = i  # 初始化起始点
        flag[cur] = 1  # 将起始点标记为已经过
        l = len(d.Nodes)
        distances = [[math.inf for _ in range(l)] for _ in range(l)]
        result = d.node_coordinate(l)
        for j in d.Edges:  # 每一步选择当前最短的链接加到路径中去
            if j[0] >= len(result):
                break
            else:
                if j[3] == 1:
                    distances[result[j[0]][0]][result[j[0]][1]] = j[6]
                    distances[result[j[0]][1]][result[j[0]][0]] = j[6]
        cost, ways = self.dfs(distances)
        print(self.way_sum)
        self.ans = ways.copy()
        if len(ways) != l + 1:
            tk.messagebox.askokcancel(title='结果', message='该图不存在dfs路径')
            # print(ways)
            for way in range(len(ways) - 1):  # 标记一条路径
                d.Edges[G.way_node_edge(ways[way], ways[way + 1])][4] = True
            self.end = time.time()  # 记录结束时间
            self.ans.clear()
            return -1
        for way in range(len(ways) - 1):  # 标记一条路径
            d.Edges[G.way_node_edge(ways[way], ways[way + 1])][4] = True
        tk.messagebox.askokcancel(title='结果', message='dfs算法路径')
        self.end = time.time()  # 记录结束时间


    def dfs_tsp(self,graph, start, current, path,
                visited, cost, min_cost, min_path):
        if len(path) == len(graph) and graph[
            current][start] != np.inf:
            path.append(start)
            cost += graph[current][start]
            if cost < min_cost[0]:
                min_cost[0] = cost
                min_path[0] = path.copy()
            path.pop()
            cost -= graph[current][start]
            return
        for next_node in range(len(graph)):
            if graph[current][next_node] != np.inf and \
                    not visited[next_node]:
                visited[next_node] = True
                path.append(next_node)
                cost += graph[current][next_node]
                self.way_sum += 1  # 遍历路径的数目加一
                self.dfs_tsp(graph, start, next_node, path,
                             visited, cost, min_cost, min_path)
                visited[next_node] = False
                path.pop()
                cost -= graph[current][next_node]
    def dfs(self, graph):
        n = len(graph)
        min_cost = [float('inf')]
        min_path = [[]]

        for start_node in range(n):
            visited = [False] * n
            path = [start_node]
            cost = 0
            visited[start_node] = True
            self.dfs_tsp(graph, start_node, start_node, path,
                         visited, cost, min_cost, min_path)
        return min_cost[0], min_path[0]

    def find_hamiltonian_cycles(self,start, distances):
        n = len(distances)
        path = [start]
        cycles = []

        def is_valid(node, position):
            if distances[path[position - 1]][node] == np.inf:
                return False
            if node in path:
                return False
            return True
        def find_paths(node):
            for next_node in range(n):
                if is_valid(next_node, len(path)):
                    path.append(next_node)
                    if len(path) < n:
                        find_paths(next_node)
                    elif len(path) == n and distances[path[-1]][start] != np.inf:
                        cycles.append(path + [start])
                    path.pop()
        find_paths(start)
        return cycles
    def check(self):
        l = len(d.Nodes)
        distances = [[math.inf for _ in range(l)] for _ in range(l)]
        result = d.node_coordinate(l)
        for j in d.Edges:  # 将路径中的
            if j[0] >= len(result):
                break
            else:
                if j[6] < 99 and j[7] < 99:
                    distances[result[j[0]][0]][result[j[0]][1]] = j[6]
                    distances[result[j[0]][1]][result[j[0]][0]] = j[6]
        all_hamiltonian_cycles = self.find_hamiltonian_cycles(0, np.array(distances))
        l = len(all_hamiltonian_cycles)
        if l:
            for cycles in all_hamiltonian_cycles:
                dis_ans = 0
                for i in range(d.nodes_num):
                    dis_ans += d.Edges[G.way_node_edge(cycles[i], cycles[i + 1])][6]
                print(cycles,dis_ans)
        if all_hamiltonian_cycles:
            tk.messagebox.askokcancel(title='结果', message=f'该图存在 {len(all_hamiltonian_cycles)} 条路径\n')
        else:
            tk.messagebox.askokcancel(title='结果', message='该图不能完全互通')

def node_edge(n1, n2, no=1):  # 根据点的编号找边的编号
    if n1 > n2:  # 为了防止充分编号，让n1小于n2
        n1, n2 = n2, n1
    for e in d.Edges:  # 遍历所有路径，找到符合要求的返回
        if e[1] == n1 and e[2] == n2 and e[8] == no:
            return e[0]
    return -1  # 若找不到，则返回-1

class Ways():
    def __init__(self):
        self.user_way = [0]     # 记录用户路径
        self.user_cur = 0      # 记录用户所在点
        self.user_flag = set() # 记录用户已经过的点
    def auto_ways(self):        # 标记用户路径
        for w in d.Edges:       # 清空路径标记
            w[4] = 0
        for N in d.Nodes:       # 清空节点标记
            N[2] = 0
        for w in self.user_way: # 标记用户已选的点
            d.Nodes[w][2] = 5
        # 标记用户经过的路径
        for w in range(len(self.user_way) - 1):
            d.Edges[G.node_edge(self.user_way[w],self.user_way[w + 1])][4] = 1
        # 如果已经访问所有节点，自动回到初始节点
        if len(set(self.user_way)) == len(d.Nodes):
            d.Edges[G.node_edge(self.user_way[len(self.user_way) - 1], 0)][4] = 1
        G.draw()  # 按照标记重新绘制图形

    def check_user_best(self):  # 检查用户路径是不是最佳路径
        s.node_dfs()
        if not len(s.ans):
            return -1, 0
        # 长度不一样肯定不匹配
        if not len(self.user_way) == len(s.ans):
            return 0, 0
        dis_user = 0
        dis_ans = 0
        num = len(self.user_way)
        for i in range(num - 1):
            dis_user += d.Edges[G.node_edge(self.user_way[i], self.user_way[i+1])][6]
            dis_ans += d.Edges[G.way_node_edge(s.ans[i], s.ans[i + 1])][6]
        return dis_ans, dis_user

    def show_best_ans(self, top, best, user):
        lab1 = tk.Label(top, text="最短路径:", fg=BLACK, font=('微软雅黑', 20))
        b_way = ""
        # print(s.ans)
        for a in s.ans:
            b_way += d.Nodes[a][1]
            b_way += "->"
        b_way += d.Nodes[0][1]
        y0 = 0.05
        lab2 = tk.Label(top, text=f"{b_way}", bg=BLUE, fg=BLACK, font=('微软雅黑', 12), wraplength=200, justify='left')
        lab1.place(relx=0.1, rely=0.50 + y0, width=150, height=30)
        lab2.place(relx=0.4, rely=0.45 + y0, width=200, height=100)

        lab2 = tk.Label(top, text=f"最佳路径总成本：{best}\n用户路径总成本：{user}", bg=BLUE, fg=BLACK,
                        font=('微软雅黑', 12), wraplength=200, justify='left')
        lab2.place(relx=0.4, rely=0.7 + y0, width=200, height=100)

    def show_BEST(self):
        best, user = self.check_user_best()  # 计算最优路径与用户路径的总花费

        if not best:
            lab1 = tk.Label(frame_left, text="不存在最短路径", bg=RED, fg=BLACK, font=('微软雅黑', 12))
            lab1.place(relx=0.3, rely=0.8, width=140, height=30)
        elif best == user:  # 如果最优路径与用户路径的总花费相等，则说明用户路径是最短路径
            lab1 = tk.Label(frame_left, text="用户路径是最短路径", bg=RED, fg=BLACK, font=('微软雅黑', 12))
            lab1.place(relx=0.3, rely=0.8, width=140, height=30)
        else:
            lab1 = tk.Label(frame_left, text="用户路径是不最短路径", bg=RED, fg=BLACK, font=('微软雅黑', 12))
            lab1.place(relx=0.3, rely=0.8, width=140, height=30)
        # else:  # 否则说明用户路径不是最短路径
        #     self.servey_path_display()
    def servey_path_display(self):
        lab1 = tk.Label(frame_left, text="最短路径:", bg=RED, fg=BLACK, font=('微软雅黑', 12))
        lab1.place(relx=0.1, rely=0.75, width=80, height=30)
        # self.auto_ways()
        b_way = ""
        for a in s.ans:
            b_way += d.Nodes[a][1]
            b_way += "->"
        b_way = b_way[:-2]
        lab2 = tk.Label(frame_left, text=f"{b_way}", bg=BLUE, fg=BLACK, font=('微软雅黑', 12), wraplength=200,
                        justify='left')
        lab2.place(relx=0.1, rely=0.8, width=200, height=100)

    def check_user_greey(self):  # 检查用户路径是不是贪心路径,不是的话返回错误点
        s.node_greedy()# 计算贪心路径
        if not len(s.ans):
            return -2
        # 路径长度不一样肯定不匹配，直接返回
        if not len(self.user_way) == len(s.ans):
            # self.auto_ways()
            return 0
        way = [(int(node[1])-1) for node in d.Nodes]
        result1 = list(map(str, self.user_way))
        result1 = ' '.join(result1)
        ways = [way[an] for an in s.ans]
        result2 = list(map(str, ways))
        result3 = ' '.join(result2)
        result2.reverse()  # 倒序排列列表元素
        result4 = ' '.join(result2)
        if result4 == result1 or result3 == result1:
            return -1 #-1表示是贪心路径
        else:
            x_1 = self.find_longest(result1, result4)
            x_2 = self.find_longest(result1, result3)
            return max(x_1, x_2)

    def find_longest(self, list1, list2):
        index = 0
        while index < len(list1) and index < len(list2):
            if list1[index] != list2[index]:
                break
            index += 1
        return index


    def show_greddy_ans(self, top):
        lab1 = tk.Label(top, text="贪心路径:", fg=BLACK, font=('微软雅黑', 20))
        b_way = ""
        for a in s.ans:
            b_way += d.Nodes[a][1]
            b_way += "->"
        b_way += d.Nodes[0][1]
        y0 = 0.05
        lab2 = tk.Label(top, text=f"{b_way}", bg=BLUE, fg=BLACK, font=('微软雅黑', 12), wraplength=200, justify='left')
        lab1.place(relx=0.1, rely=0.50 + y0, width=150, height=30)
        lab2.place(relx=0.4, rely=0.45 + y0, width=200, height=100)

    # 对用户路径进行标记与记录
    def way_route_markings(self, event):
        global MARK_NODE
        MARK_NODE = 2
        # E.newedge_del_all(1)
        for w in frame_left.winfo_children():
            w.destroy()
            # 清除右侧组件

        left_window()
        self.user_way = [0]
        # lab = tk.Label(frame_left, text="路径操作", bg=RED, fg=BLACK, font=('微软雅黑', 20))
        # lab.place(relx=0.18, rely=0.02, width=200, height=30)
        y0 = 0.1
        global entry1,entry2,default_value
        # 定义默认值变量
        default_value = tk.StringVar()
        default_value.set(self.user_way[-1]+1)
        laba1 = tk.Label(frame_left, text="当前节点:", bg='white', fg=BLACK, font=('微软雅黑', 15))
        laba1.place(relx=0.2, rely=0.28 + y0, width=140, height=30)
        # 创建第一个输入框
        entry1 = tk.Entry(frame_left, textvariable=default_value, bg="#F5F5F5")
        entry1.place(relx=0.6, rely=0.28 + y0, width=50, height=30)
        labb1 = tk.Label(frame_left, text="当前下一节点:", bg='white', fg=BLACK, font=('微软雅黑', 15))
        labb1.place(relx=0.2, rely=0.33 + y0, width=140, height=30)
        # 创建第二个输入框
        entry2 = tk.Entry(frame_left, bg="#F5F5F5")
        entry2.place(relx=0.6, rely=0.33 + y0, width=50, height=30)

        labb3 = tk.Label(frame_left, text="是否进行连接:", bg='white', fg=BLACK, font=('微软雅黑', 15))
        labb3.place(relx=0.2, rely=0.4 + y0, width=140, height=30)
        # 按钮
        button = tk.Button(frame_left, relief="flat", image=List_Image[38], bg='white', command=lambda: self.extract_values())  # 确定
        button.place(relx=0.55, rely=0.38 + y0)
        button2 = tk.Button(frame_left, relief="flat", image=List_Image[36], bg='white', command=lambda: self.revoke())  # 撤销
        button2.place(relx=0.18, rely=0.46 + y0)
        button3 = tk.Button(frame_left, relief="flat", image=List_Image[37], bg='white', command=lambda: self.clear_all_paths())  # 清除路径
        button3.place(relx=0.5, rely=0.46 + y0)
        button4 = tk.Button(frame_left, relief="flat", image=List_Image[42], bg='white', command=lambda: self.greedy_path())  # 判断路径是否为贪心路径
        button4.place(relx=0.18, rely=0.55 + y0)
        button5 = tk.Button(frame_left, relief="flat", image=List_Image[43], bg='white', command=lambda: self.shortest_path())  # 判断路径是否为最短路径
        button5.place(relx=0.18, rely=0.62 + y0)

        self.user_path_display()
    def extract_values(self):
        global entry1, entry2, default_value
        global MARK_NODE
        MARK_NODE = 2
        value1 = entry1.get()  # 获取第一个输入框的值
        value2 = entry2.get()  # 获取第二个输入框的值
        try:
            value1 = int(value1)  # 将值转换为整数
            value2 = int(value2)  # 将值转换为整数
            print("值1:", value1)
            print("值2:", value2)
            # 判断两点是否连接
            if abs(value2) > 10 and abs(value1) > 10:
                tk.messagebox.askokcancel(title='错误', message='请重新输入正确的编号！')
                return
            else:
                E = 0
                if value1 < value2:
                    str_route = f'{value1}-{value2}'
                else:
                    str_route = f'{value2}-{value1}'
                for item in d.Edges:
                    if str_route == item[5]:
                        if item[6] < 100 and item[7] < 100:
                            if d.Edges[G.node_edge(value1-1, value2-1)][4]:
                                E = 2
                                tk.messagebox.askokcancel(title='错误', message='城市已连接！')
                            else:
                                if self.user_way[-1] == (value1-1):
                                    E = 1
                                    global MODE
                                    MODE = 1
                                    self.user_way.append(value2 - 1)
                                    default_value.set(value2)
                                    d.Edges[G.node_edge(value1-1, value2-1)][4] = True
                                    entry1.config(textvariable=default_value)  # 更新entry1的默认值
                                    entry2.delete(0, tk.END)
                                else:
                                    E = 3
                                    tk.messagebox.askokcancel(title='错误', message='未连贯！')
                        break
                print(E)
                if E == 1:
                    G.draw()
                    self.user_path_display()
                elif E == 0:
                    tk.messagebox.askokcancel(title='错误', message='城市未连接！')
        except ValueError:
            tk.messagebox.askokcancel(title='错误', message='请输入正确的城市编号！')

    def extract_ligature(self, n1, n2):
        global MARK_NODE
        MARK_NODE = 2
        no = G.way_node_edge(n1, n2)
        flage = False
        if d.Edges[no][4]:
            tk.messagebox.askokcancel(title='错误', message='城市已连接！')
        elif d.Edges[no][3] == 0:
            tk.messagebox.askokcancel(title='错误', message='城市未连接！')
        else:
            if self.user_way[-1] == int(d.Nodes[n2][1]) - 1:
                nx = n1
                n1 = n2
                n2 = nx
            if self.user_way[-1] == int(d.Nodes[n1][1])-1:
                global MODE
                MODE = 1
                self.user_way.append(int(d.Nodes[n2][1]) - 1)
                d.Edges[no][4] = True
                flage = True
            else:
                tk.messagebox.askokcancel(title='错误', message='未连贯！')
        if flage:
            G.draw()
            self.user_path_display()

    def revoke(self):
        global MARK_NODE
        MARK_NODE = 2
        try:
            if len(self.user_way) > 1:
                value1 = int(self.user_way[-1])  # 将值转换为整数
                value2 = int(self.user_way[-2])  # 将值转换为整数
                if value1 < value2:
                    str_route = f'{value1+1}-{value2+1}'
                else:
                    str_route = f'{value2+1}-{value1+1}'
                # print(str_route)
                for item in d.Edges:
                    # print(item)
                    if str_route == item[5]:
                        # print(item)
                        global MODE
                        global entry1, default_value
                        MODE = 1
                        self.user_way.pop()
                        print(self.user_way)
                        d.Edges[G.node_edge(value1, value2)][4] = False
                        default_value.set(value2+1)
                        entry1.config(textvariable=default_value)  # 更新entry1的默认值
                        break
                G.draw()
                self.user_path_display()
            else:
                tk.messagebox.askokcancel(title='提示', message='未进行路径建设！')
        except ValueError:
            tk.messagebox.askokcancel(title='错误', message='请输入正确的城市编号！')

    def clear_all_paths(self):
        global MARK_NODE
        MARK_NODE = 2
        try:
            if len(self.user_way) > 1:
                for i in range(len(self.user_way)-1):
                    value1 = int(self.user_way[-1])  # 将值转换为整数
                    value2 = int(self.user_way[-2])  # 将值转换为整数
                    if value1 < value2:
                        str_route = f'{value1 + 1}-{value2 + 1}'
                    else:
                        str_route = f'{value2 + 1}-{value1 + 1}'
                    # print(str_route)
                    for item in d.Edges:
                        # print(item)
                        if str_route == item[5]:
                            # print(item)
                            global MODE
                            global entry1, default_value
                            MODE = 3
                            self.user_way.pop()
                            print(self.user_way)
                            d.Edges[G.node_edge(value1, value2)][4] = False
                            default_value.set(value2 + 1)
                            entry1.config(textvariable=default_value)  # 更新entry1的默认值
                            break
            else:
                tk.messagebox.askokcancel(title='提示', message='未进行路径建设！')
                for i in range(len(d.Edges)):
                    d.Edges[i][4] = False
            G.draw()
            self.user_path_display()
        except ValueError:
            tk.messagebox.askokcancel(title='错误', message='请输入正确的城市编号！')

    def greedy_path(self):
        g = self.check_user_greey()
        if g == -2:
            # cvx.create_text(0, 0, text="不存在贪心路径")
            lab1 = tk.Label(frame_left, text="不存在贪心路径", bg='white', fg=BLACK, font=('微软雅黑', 12))
            lab1.place(relx=0.3, rely=0.8, width=180, height=30)
        elif g == -1:  # 如果用户路径是贪心路径则显示
            # cvx.create_text(0, 0, text="用户路径是贪心路径")
            lab1 = tk.Label(frame_left, text="用户路径是贪心路径", bg='white', fg=BLACK, font=('微软雅黑', 12))
            lab1.place(relx=0.3, rely=0.8, width=180, height=30)
        # elif g:
        #     self.servey_greedy_path()
        else:
            # print(self.user_way)
            # print(self.user_way[0:g])
            # cvx.create_text(0, 0, text="用户路径不是是贪心路径")
            lab1 = tk.Label(frame_left, text="用户路径不是是贪心路径", bg='white', fg=BLACK, font=('微软雅黑', 12))
            lab1.place(relx=0.3, rely=0.8, width=180, height=30)

    def servey_greedy_path(self):
        lab1 = tk.Label(frame_left, text="最短路径:", bg=RED, fg=BLACK, font=('微软雅黑', 12))
        lab1.place(relx=0.1, rely=0.75, width=80, height=30)
        # self.auto_ways()
        g_way = ''
        for a in s.ans:
            g_way += d.Nodes[a][1]
            g_way += "->"
        g_way = g_way[:-2]
        lab2 = tk.Label(frame_left, text=f"{g_way}", bg=BLUE, fg=BLACK, font=('微软雅黑', 12), wraplength=200,
                        justify='left')
        lab2.place(relx=0.1, rely=0.8, width=200, height=100)



    def shortest_path(self):
        best, user = self.check_user_best()  # 计算最优路径与用户路径的总花费
        if not best:
            lab1 = tk.Label(frame_left, text="不存在最短路径", bg='white', fg=BLACK, font=('微软雅黑', 12))
            lab1.place(relx=0.33, rely=0.8, width=180, height=30)
        elif best == user:  # 如果最优路径与用户路径的总花费相等，则说明用户路径是最短路径
            lab1 = tk.Label(frame_left, text="用户路径是最短路径", bg='white', fg=BLACK, font=('微软雅黑', 12))
            lab1.place(relx=0.33, rely=0.8, width=180, height=30)
        else:
            lab1 = tk.Label(frame_left, text="用户路径是不最短路径", bg='white', fg=BLACK, font=('微软雅黑', 12))
            lab1.place(relx=0.33, rely=0.8, width=180, height=30)
        # if best == user:  # 如果最优路径与用户路径的总花费相等，则说明用户路径是最短路径
        #     lab1 = tk.Label(frame_left, text="用户路径是最短路径", bg=RED, fg=BLACK, font=('微软雅黑', 12))
        #     lab1.place(relx=0.1, rely=0.8, width=180, height=30)
        # else:  # 否则说明用户路径不是最短路径
        #     self.servey_path_display()

    # 用户路径展示
    def user_path_display(self):
        lab1 = tk.Label(frame_left, text="用户路径:", bg='white', fg=BLACK, font=('微软雅黑', 15))
        lab1.place(relx=0.15, rely=0.8, width=80, height=30)
        # self.auto_ways()
        way = ""
        # d_way = []
        # for i in d.Nodes:
        #     d_way.append(i[1])
        for i in range(len(self.user_way)):
            if len(self.user_way)-i > 1:
                way += str(self.user_way[i]+1)
                way += "->"
            else:
                way += str(self.user_way[i]+1)
        lab2 = tk.Label(frame_left, text=f"{way}", bg='#F8F8FF', fg=BLACK, font=('微软雅黑', 12), wraplength=200,
                        justify='left')
        lab2.place(relx=0.18, rely=0.84, width=300, height=100)

    def way_operate(self, event):
        global MARK_NODE
        for i in range(len(d.Edges)):
            d.Edges[i][4] = False
        MARK_NODE = 5
        # E.newedge_del_all(1)
        for w in frame_left.winfo_children():
            w.destroy()
            # 清除左侧组件
        left_window()
        self.user_way = [0]
        y0 = 0.1
        label1 = tk.Label(frame_left, text="节点1:", bg='white', fg=BLACK, font=('微软雅黑', 15))
        label1.place(relx=0.15, rely=0.32 + y0, width=100, height=30)
        global entry3, entry4
        # 创建第一个输入框
        entry3 = tk.Entry(frame_left, bg='#F5F5F5')
        entry3.place(relx=0.6, rely=0.32 + y0, width=50, height=30)

        label2 = tk.Label(frame_left, text="节点2:", bg='white', fg=BLACK, font=('微软雅黑', 15))
        label2.place(relx=0.15, rely=0.37 + y0, width=100, height=30)
        # 创建第二个输入框
        entry4 = tk.Entry(frame_left, bg='#F5F5F5')
        entry4.place(relx=0.6, rely=0.37 + y0, width=50, height=30)
        button1 = tk.Button(frame_left, text='完全图', relief="flat", bg='#00BFFF', fg=BLACK,
                            font=('微软雅黑', 15), command=lambda: self.complete_graph())  # 完全图
        button1.place(relx=0.2, rely=0.43 + y0, width=100, height=30)
        button2 = tk.Button(frame_left, text='可达判断', relief="flat", bg='#00BFFF', fg=BLACK,
                            font=('微软雅黑', 15), command=lambda: self.reachable_judgment())  # 节点可达性判断
        button2.place(relx=0.6, rely=0.43 + y0, width=100, height=30)


        label3 = tk.Label(frame_left, text="是否进行两节点之间操作:", bg='white', fg=BLACK, font=('微软雅黑', 14))
        label3.place(relx=0.15, rely=0.5 + y0, width=240, height=30)
        # 按钮
        button3 = tk.Button(frame_left, relief="flat", image=List_Image[33], bg='white',
                           command=lambda: self.way_add())  # 线路增加
        button3.place(relx=0.2, rely=0.56 + y0)
        button4 = tk.Button(frame_left, relief="flat", image=List_Image[34], bg='white',
                            command=lambda: self.way_change())  # 线路修改
        button4.place(relx=0.2, rely=0.66 + y0)
        button5 = tk.Button(frame_left, relief="flat", image=List_Image[35], bg='white',
                            command=lambda: self.way_delete())  # 线路删除
        button5.place(relx=0.2, rely=0.76 + y0)

    def is_reachable(self, graph, start, target, visited):
        if start == target:
            return True
        visited.add(start)
        for neighbor in graph[start]:
            if neighbor not in visited:
                if self.is_reachable(graph, neighbor, target, visited):
                    return True
        return False

    def complete_graph(self):
        l = len(d.Nodes)
        result = d.node_coordinate(l)
        for index in range(len(result)):
            if d.Edges[index][3] == 0:
                dist_c = random.randint(10, 99)  # 随机生成距离成本
                time_c = random.randint(10, 99)  # 随机生成链接的时间
                d.Edges[index][3] = 1
                d.Edges[index][6] = dist_c
                d.Edges[index][7] = time_c
        G.draw()


    def reachable_judgment(self):
        try:
            a = int(entry3.get())  # 获取第一个输入框的值
            b = int(entry4.get())  # 获取第二个输入框的值
            l = len(d.Nodes)
            index_list = []
            for i in d.Nodes:
                index_list.append(i[1])
            dictionary = {i: [] for i in range(1, l + 1)}
            result = d.node_coordinate(l)
            # 生成无向图
            for i in range(len(result)):
                if d.Edges[i][3] == 1:
                    x = d.Edges[i][5].split('-')[0]
                    y = d.Edges[i][5].split('-')[-1]
                    dictionary[index_list.index(x)+1].append(index_list.index(y)+1)
                    dictionary[index_list.index(y)+1].append(index_list.index(x)+1)
            start_node = index_list.index(str(a))+1
            target_node = index_list.index(str(b))+1
            visited_nodes = set()
            print(dictionary)
            flag = self.is_reachable(dictionary, start_node, target_node, visited_nodes)
            if flag:
                tk.messagebox.askokcancel(title='结果', message=f'{a}到{b}可达')
            else:
                tk.messagebox.askokcancel(title='结果', message=f'{a}到{b}不可达')
        except ValueError:
            tk.messagebox.askokcancel(title='结果', message='请输入节点')

    def way_add(self):
        global entry3, entry4
        value1 = entry3.get()  # 获取第一个输入框的值
        value2 = entry4.get()  # 获取第二个输入框的值
        try:
            value1 = int(value1)  # 将值转换为整数
            value2 = int(value2)  # 将值转换为整数
            print("值1:", value1)
            print("值2:", value2)
            ways_list = [int(node[1]) for node in d.Nodes]
            # 判断两点是否连接
            if abs(value2) > 10 and abs(value1) > 10:
                tk.messagebox.askokcancel(title='错误', message='请重新输入正确的编号！')
                return
            else:
                if value1 < value2:
                    str_route = f'{value1}-{value2}'
                else:
                    str_route = f'{value2}-{value1}'
            if d.drop.count(ways_list.index(value1)) > 4 or d.drop.count(ways_list.index(value2)) > 4:
                print(d.drop)
                tk.messagebox.askokcancel(title='提醒', message='当前节点已经到达最大连接数！')
                return
            no = 0
            for item in d.Edges:
                if str_route == item[5]:
                    no = G.node_edge(value1 - 1, value2 - 1)
                    if d.Edges[no][3] == 1:
                        tk.messagebox.askokcancel(title='提醒', message='当前路线已存在！')
                        return
            top = creat_window(str_route+'路径参数配置')  # 创建弹出窗口
            distance_entry = create_input_box(top, "路程/公里：（1-99）", 101)  # 创建一个输入框，获取卷积核大小
            time_entry = create_input_box(top, "时间/h：（1-99）", 101)  # 创建一个输入框，获取卷积步长

            def get_input():  # 创建
                # 获取输入框的内容
                try:
                    result1 = int(distance_entry.get())
                    result2 = int(time_entry.get())
                    print(result1,result2)
                    if 100 > result1 > 0 and 0 < result2 < 100:
                        d.Edges[no][3] = 1
                        d.Edges[no][6] = result1
                        d.Edges[no][7] = result2
                        top.destroy()  # 关闭窗口
                        G.draw()
                    else:
                        tk.messagebox.askokcancel(title='错误', message='路程与时间范围错误！')
                except ValueError:
                    tk.messagebox.askokcancel(title='错误', message='请输入正确的路程与时间！')
            button = tk.Button(top, text="获取信息", command=get_input)
            button.pack()
        except ValueError:
            tk.messagebox.askokcancel(title='错误', message='请输入正确的城市编号！')

    def way_change(self):
        global entry3, entry4
        value1 = entry3.get()  # 获取第一个输入框的值
        value2 = entry4.get()  # 获取第二个输入框的值
        try:
            value1 = int(value1)  # 将值转换为整数
            value2 = int(value2)  # 将值转换为整数
            print("值1:", value1)
            print("值2:", value2)
            ways_list = [int(node[1]) for node in d.Nodes]
            # 判断两点是否连接
            if abs(value2) > 10 and abs(value1) > 10:
                tk.messagebox.askokcancel(title='错误', message='请重新输入正确的编号！')
                return
            else:
                if value1 < value2:
                    str_route = f'{value1}-{value2}'
                else:
                    str_route = f'{value2}-{value1}'
            no = 0
            for item in d.Edges:
                if str_route == item[5]:
                    no = G.node_edge(value1 - 1, value2 - 1)
                    if d.Edges[no][3] == 0:
                        tk.messagebox.askokcancel(title='提醒', message='当前路线不存在！')
                        return
            top = creat_window(str_route + '路径参数修改')  # 创建弹出窗口
            distance_entry = create_input_box(top, "路程/公里：（1-99）", d.Edges[no][6])  # 创建一个输入框，获取卷积核大小
            time_entry = create_input_box(top, "时间/h：（1-99）", d.Edges[no][7])  # 创建一个输入框，获取卷积步长

            def get_input():  # 创建
                # 获取输入框的内容
                try:
                    result1 = int(distance_entry.get())
                    result2 = int(time_entry.get())
                    print(result1, result2)
                    if 100 > result1 > 0 and 0 < result2 < 100:
                        d.Edges[no][6] = result1
                        d.Edges[no][7] = result2
                        top.destroy()  # 关闭窗口
                        G.draw()
                    else:
                        tk.messagebox.askokcancel(title='错误', message='路程与时间范围错误！')
                except ValueError:
                    tk.messagebox.askokcancel(title='错误', message='请输入正确的路程与时间！')
            button = tk.Button(top, text="获取信息", command=get_input)
            button.pack()
        except ValueError:
            tk.messagebox.askokcancel(title='错误', message='请输入正确的城市编号！')

    def way_delete(self):
        global entry3, entry4
        value1 = entry3.get()  # 获取第一个输入框的值
        value2 = entry4.get()  # 获取第二个输入框的值
        try:
            value1 = int(value1)  # 将值转换为整数
            value2 = int(value2)  # 将值转换为整数
            print("值1:", value1)
            print("值2:", value2)
            ways_list = [int(node[1]) for node in d.Nodes]
            # 判断两点是否连接
            if abs(value2) > 10 and abs(value1) > 10:
                tk.messagebox.askokcancel(title='错误', message='请重新输入正确的编号！')
                return
            else:
                if value1 < value2:
                    str_route = f'{value1}-{value2}'
                else:
                    str_route = f'{value2}-{value1}'
            no = 0
            for item in d.Edges:
                if str_route == item[5]:
                    no = G.node_edge(value1 - 1, value2 - 1)
                    if d.Edges[no][3] == 0:
                        tk.messagebox.askokcancel(title='提醒', message='当前路线不存在！')
                        return
            d.Edges[no][3] = 0
            d.Edges[no][6] = 111
            d.Edges[no][7] = 111
            G.draw()
        except ValueError:
            tk.messagebox.askokcancel(title='错误', message='请输入正确的城市编号！')


class Node:
    # 标记节点按钮
    def node_mark_display(self, event):
        global MARK_NODE, Specify_Nodes
        W.user_way = [0]
        MARK_NODE = 1
        for w in frame_left.winfo_children():
            w.destroy()
            # 清除右侧组件
        left_window()
        curx = -1
        y0 = 0.1
        for i in d.Nodes:
            if i[2] == 1:
                curx = i[0]
        # lab = tk.Label(frame_left, text="节点操作", bg=RED, fg=BLACK, font=('微软雅黑', 20))
        # lab.place(relx=0.18, rely=0.32, width=200, height=30)
        labx1 = tk.Label(frame_left, text=f"当前共有{len(d.Nodes)}个节点", bg='white', fg=BLACK, font=('微软雅黑', 20))
        labx1.place(relx=0.15, rely=0.3 + y0, width=260, height=30)
        lab1 = tk.Label(frame_left, text="当前节点:", bg='white', fg=BLACK, font=('微软雅黑', 20))
        if curx == -1:
            text = "未选择"
        else:
            text = f"{d.Nodes[curx][1]}"
            Specify_Nodes = str(d.Nodes[curx][1])
        lab2 = tk.Label(frame_left, text=text, bg='#F8F8FF', fg=BLACK, font=('微软雅黑', 20))
        lab1.place(relx=0.15, rely=0.4 + y0, width=160, height=50)
        lab2.place(relx=0.6, rely=0.4 + y0, width=100, height=50)

        # 按钮
        button = tk.Button(frame_left, relief="flat", image=List_Image[30], bg='white',
                           command=lambda: self.node_del_exact())  # 删除当前节点
        button.place(relx=0.2, rely=0.5 + y0)
        button2 = tk.Button(frame_left, relief="flat", image=List_Image[32], bg='white',
                            command=lambda: self.node_add())  # 增加一个节点
        button2.place(relx=0.2, rely=0.6 + y0)
        button3 = tk.Button(frame_left, relief="flat", image=List_Image[31], bg='white',
                            command=lambda: self.node_del())  # 减少一个节点
        button3.place(relx=0.2, rely=0.7 + y0)

    def node_add(self):
        global d,Edges_list
        for i in range(len(d.Edges)):
            d.Edges[i][4] = False
        Edges_list = []
        Edges_list = d.Edges
        # print(len(Edges_list))
        # 增加一个节点
        nodes = len(d.Nodes) + 1
        # 如果节点数目大于五，则将连接详细信息改为不显示
        if nodes > 5:
            d.edgeinfo = 0
        if nodes > 10:
            tk.messagebox.askokcancel(title='错误', message='已达到最大节点')
            return
        d = Data(1, nodes, d.styple)
        # for i in d.Edges:
        #     print(i)
        G.draw()
        self.node_mark_display(1)


    def node_del(self):
        global d,Edges_list
        for i in range(len(d.Edges)):
            d.Edges[i][4] = False
        Edges_list = []
        Edges_list = d.Edges
        # print(len(Edges_list))
        if d.nodes_num <= 2:
            tk.messagebox.askokcancel(title='错误', message='节点过少')
            return
        nodes = len(d.Nodes) - 1
        if nodes < 6:
            d.edgeinfo = 1
        d = Data(2, nodes, d.styple)
        # for i in d.Edges:
        #     print(i)
        G.draw()
        self.node_mark_display(1)

    def node_del_exact(self):
        global d,Edges_list
        for i in range(len(d.Edges)):
            d.Edges[i][4] = False
        Edges_list = d.Edges
        if len(Specify_Nodes) == 3:
            tk.messagebox.askokcancel(title='错误', message='未选择节点')
            return
        if d.nodes_num <= 2:# 若删除节点以后节点过少，则直接返回并警告
            tk.messagebox.askokcancel(title='错误', message='节点过少')
            return
        nodes = len(d.Nodes) - 1
        if nodes < 6:
            d.edgeinfo = 1
        d = Data(3, nodes, d.styple)
        # for i in d.Edges:
        #     print(i)
        G.draw()
        self.node_mark_display(1)


def refresh():
    top = creat_window('路径生成')  # 创建弹出窗口
    distance_entry = create_input_box(top, "节点个数：（1-10）", 6)  # 创建一个输入框，获取节点个数
    # 创建一个下拉框，用于选择生成图类型
    mode_combobox = create_dropdown_box(top, "生成图类型", ["TSP", "完全图"])  # 创建一个下拉框，用于选择生成图类型

    def get_input():  # 创建
        # 获取输入框的内容
        try:
            result1 = int(distance_entry.get())
            # 从下拉框中获取池化类型
            result2 = mode_combobox.get()
            print(result1, result2)
            flag = 0
            if result2!=None:
                if result2 == '完全图':
                    flag = 1
            if 10 > result1 > 0:
                global d
                if flag:
                    d = Data(0, result1, 1)
                else:
                    d = Data(0, result1, 0)
                top.destroy()  # 关闭窗口
                G.draw()
                # for i in d.Edges:
                #     print(i)
            else:
                tk.messagebox.askokcancel(title='错误', message='节点数范围错误！')
        except ValueError:
            tk.messagebox.askokcancel(title='错误', message='请输入正确的节点数')

    button = tk.Button(top, text="获取信息", command=get_input)
    button.pack()

def graph_init():
    node = random.randint(4, 10)
    global d, MODE, MARK_NODE
    MARK_NODE = 0
    MODE = 0
    d = Data(0, node,0)
    print(node)
    W.user_way = [0]
    G.draw()
    window(2)

def empty():
    global MARK_NODE
    MARK_NODE = 0
    G.delete_all()

def auto_opera_mu(menu: tk.Menu):
    """TSP问题自动生成与自动求解相关"""
    menu_node = Menu(menu, tearoff=False)
    menu_node.add_command(label="自动随机产生一个TSP问题", command=lambda: graph_init())
    menu_node.add_command(label="重新生成", command=lambda: refresh())
    menu_node.add_command(label="清空", command=lambda: empty())
    menu_node.add_command(label="自动求解最优路径-dfs遍历", command=lambda: s.auto_solve(3))
    menu_node.add_command(label="自动求解优化路径-贪心", command=lambda: s.auto_solve(2))
    menu_node.add_command(label="自动求解优化路径-回溯", command=lambda: s.auto_solve(1))
    menu_node.add_command(label="检查是否存在路径", command=lambda: s.check())
    # 在主目录菜单上新增"文件"选项，并通过menu参数与下拉菜单绑定
    menu.add_cascade(label="TSP问题自动生成与自动求解相关", menu=menu_node)

# 创建弹出窗口
def creat_window(title):
    top = tk.Toplevel(root)
    top.geometry("300x350")
    top.title(title)
    return top

# 输入框
def create_input_box(top, text, value):
    box_label = tk.Label(top, text=text)
    box_label.pack(padx=10, pady=10)
    box_size = tk.IntVar(top, value=value)  # 创建一个IntVar对象，并设置默认值为3
    box_size_entry = tk.Entry(top, textvariable=box_size)  # 关联IntVar对象
    box_size_entry.pack(padx=20, pady=20)
    return box_size_entry

# 下拉框
def create_dropdown_box(top, text, listvalues):
    # 创建一个下拉框，用于选择
    box_mode_label = tk.Label(top, text=text)
    box_mode_label.pack(padx=10, pady=10)
    box_mode_combobox = ttk.Combobox(top)
    box_mode_combobox["values"] = listvalues
    box_mode_combobox.pack(padx=20, pady=15)
    return box_mode_combobox

def dir2(x, y):  # 计算两点间距离
    return (x[0] - y[0]) * (x[0] - y[0]) + (x[1] - y[1]) * (x[1] - y[1])

def left1(event):
    global entry1, entry2, default_value, CLICK, entry3, entry4
    # 查找鼠标左键按下时位置是否在某个节点内
    n = -1
    for node in d.Nodes:
        if dir2([event.x, event.y], [node[3][0], node[3][1]]) < 20 * 20:
            n = node[0]
    # n为点击的节点，若没有则为-1
    m = mode.get()  # 查看现在操作类型
    if m == 1 and not n == -1:
        # 节点操作
        # N.node_mark(n)
        if n >= len(d.Nodes):
            # 弹出对话框
            tk.messagebox.askokcancel(title='错误', message='该节点不存在')
            return
        for node in d.Nodes:
            if node[0] == n:
                node[2] = 1
            else:
                node[2] = 0
        G.draw()
        if MARK_NODE == 1:  # 限制节点操作
            N.node_mark_display(1)
        elif MARK_NODE == 2:  # 若是MARK_NODE==2，则可以进行路线画图操作
            if CLICK[2] == 0:
                CLICK[0] = n
                default_value.set(d.Nodes[n][1])
                entry1.config(textvariable=default_value)  # 更新entry1的默认值
            elif CLICK[2] == 1:
                CLICK[1] = n
                W.extract_ligature(CLICK[0], CLICK[1])
                CLICK[2] = -1
            CLICK[2] += 1
        elif MARK_NODE == 5:  # 若是MARK_NODE==5，则可以进行节点连接操作
            if CLICK[2] == 0:
                CLICK[0] = n
                entry3.delete(0, tk.END)
                # 设置输入框的值为 节点
                entry3.insert(0, d.Nodes[n][1])
            elif CLICK[2] == 1:
                CLICK[1] = n
                # W.extract_ligature(CLICK[0], CLICK[1])
                entry4.delete(0, tk.END)
                # 设置输入框的值为 节点
                entry4.insert(0, d.Nodes[n][1])
                CLICK[2] = -1
            CLICK[2] += 1
        print(n)

def element_reading():
    global List_Image
    folder_path = 'K:/work/traveler/background/'
    image_path = ['1_红.png', '1_绿.png', '1_蓝.png', '2_红.png', '2_绿.png', '2_蓝.png', '3_红.png', '3_绿.png', '3_蓝.png',
                  '4_红.png', '4_绿.png', '4_蓝.png', '5_红.png', '5_绿.png', '5_蓝.png', '6_红.png', '6_绿.png', '6_蓝.png',
                  '7_红.png', '7_绿.png', '7_蓝.png', '8_红.png', '8_绿.png', '8_蓝.png', '9_红.png', '9_绿.png', '9_蓝.png',
                  '10_红.png', '10_绿.png', '10_蓝.png', '删除节点.png', '减少节点.png', '增加节点.png', '线路增加.png',
                  '线路修改.png', '线路删除.png', '撤销.png', '清除路径.png', '确认.png', '编组9.png', '背景.png',
                  '矩形.png', '判断路径是否为贪心路径.png', '判断路径是否为最短路径.png', '矩形2.png', '完全图.png', '可达判断.png']
    for path in image_path[:30]:      # 1-10球加载
        List_Image.append(element(folder_path+path, 50, 50))
    for path in image_path[30:36]:      # 节点操作与连线操作功能按钮
        List_Image.append(element(folder_path + path, 280, 50))
    List_Image.append(element(folder_path + image_path[36], 140, 50))  # 撤销
    List_Image.append(element(folder_path + image_path[37], 140, 50))  # 清除路径
    List_Image.append(element(folder_path + image_path[38], 120, 50))  # 确认
    List_Image.append(element(folder_path + image_path[39], 380, 100))  # 编组_9
    List_Image.append(element(folder_path + image_path[40], 900, 900))  # 背景
    List_Image.append(element(folder_path + image_path[41], 380, 140))  # 小矩形
    List_Image.append(element(folder_path + image_path[42], 300, 50))  # 判断路径是否为贪心路径
    List_Image.append(element(folder_path + image_path[43], 300, 50))  # 判断路径是否为最短路径
    List_Image.append(element(folder_path + image_path[44], 380, 530))  # 大矩形
    List_Image.append(element(folder_path + image_path[45], 140, 50))  # 完全图
    List_Image.append(element(folder_path + image_path[46], 140, 50))  # 可达判断

def element(path, width, height):
    # 加载图元对应的图片文件
    img = Image.open(path)
    # 使用resize方法调整图片
    img = img.resize((width, height))
    # 把Image对象转换成PhotoImage对象
    img = ImageTk.PhotoImage(img)
    # 保存图片的引用，防止被垃圾回收
    root.img = img
    return img

def window(event):
    global MARK_NODE
    MARK_NODE = 0
    for w in frame_left.winfo_children():
        w.destroy()
        # 清除右侧组件
    left_window()
    Label_1 = tk.Label(frame_left, text="遍历节点数目", bg='white', fg=BLACK, font=('微软雅黑', 16))
    Label_1.place(x=50, y=330, width=180, height=40)
    Label_2 = tk.Label(frame_left, text="求解花费时间", bg='white', fg=BLACK, font=('微软雅黑', 16))
    Label_2.place(x=50, y=450, width=180, height=40)
    Label_3 = tk.Label(frame_left, text="最短路径", bg='white', fg=BLACK, font=('微软雅黑', 16))
    Label_3.place(x=50, y=570, width=140, height=40)
    if event == 2:
        lab1 = tk.Label(frame_left, text=f"{0}", bg='#F8F8FF', fg=BLACK, font=('微软雅黑', 12), wraplength=200,
                        justify='left')
        lab1.place(x=80, y=370, width=300, height=60)
        lab2 = tk.Label(frame_left, text=f"{0}", bg='#F8F8FF', fg=BLACK, font=('微软雅黑', 12), wraplength=200,
                        justify='left')
        lab2.place(x=80, y=490, width=300, height=60)
        lab3 = tk.Label(frame_left, text=f"{1}", bg='#F8F8FF', fg=BLACK, font=('微软雅黑', 12), wraplength=200,
                        justify='left')
        lab3.place(x=80, y=610, width=300, height=140)
    else:
        lab1 = tk.Label(frame_left, text=f"{s.way_sum}", bg='#F8F8FF', fg=BLACK, font=('微软雅黑', 12), wraplength=200,
                        justify='left')
        lab1.place(x=80, y=370, width=300, height=60)
        t = round(s.end - s.start, 4)
        lab2 = tk.Label(frame_left, text=f"{t}", bg='#F8F8FF', fg=BLACK, font=('微软雅黑', 12), wraplength=200,
                        justify='left')
        lab2.place(x=80, y=490, width=300, height=60)
        g_way = ''
        if len(s.ans) > 0:
            for a in s.ans:
                g_way += d.Nodes[a][1]
                g_way += "->"
            g_way = g_way[:-2]
        else:
            g_way='1'
        lab3 = tk.Label(frame_left, text=f"{g_way}", bg='#F8F8FF', fg=BLACK, font=('微软雅黑', 12), wraplength=200,
                        justify='left')
        lab3.place(x=80, y=610, width=300, height=140)

def left_window():
    background_button = tk.Label(frame_left, image=List_Image[39], bg='#FFFAF0')  # 编组
    background_button.place(x=50, y=20, width=380, height=100)
    background_button.bind("<Button-1>", window)
    # # 创建 Label 组件来显示背景图片
    background_on = tk.Label(frame_left, bg='#FFFAF0', image=List_Image[41])  # 小矩形背景
    background_on.place(x=50, y=140, width=380, height=140)

    if MARK_NODE == 1:
        background_color = [BLACK, '#DCDCDC', '#DCDCDC']
    elif MARK_NODE == 5:
        background_color = ['#DCDCDC', BLACK, '#DCDCDC']
    elif MARK_NODE == 2:
        background_color = ['#DCDCDC', '#DCDCDC', BLACK]
    else:
        background_color = ['#DCDCDC', '#DCDCDC', '#DCDCDC']
    Label_button1 = tk.Label(frame_left, text="节点操作", bg='white', fg=background_color[0], font=('微软雅黑', 15))
    Label_button1.place(x=60, y=180, width=80, height=50)
    Label_button1.bind("<Button-1>", N.node_mark_display)
    Label_button2 = tk.Label(frame_left, text="连接操作", bg='white', fg=background_color[1], font=('微软雅黑', 15))
    Label_button2.place(x=200, y=180, width=80, height=50)
    Label_button2.bind("<Button-1>", W.way_operate)
    Label_button3 = tk.Label(frame_left, text="路径操作", bg='white', fg=background_color[2], font=('微软雅黑', 15))
    Label_button3.place(x=340, y=180, width=80, height=50)
    Label_button3.bind("<Button-1>", W.way_route_markings)

    background_below = tk.Label(frame_left, bg='#FFFAF0', image=List_Image[44])  # 大矩形背景
    background_below.place(x=50, y=300, width=380, height=530)

if __name__ == '__main__':
    root = Tk()  # 设置主界面
    root.title("旅行商问题")  # 设置标题
    root.geometry("1400x900")  # 设置大小

    root.resizable(0, 0)  # 设置不能调整显示边框
    element_reading()
    frame_top = tk.Frame(root, bg='white', width=1400, height=50, highlightthickness=0)
    frame_top.place(x=0, y=0)  # 绘制信息输出栏

    frame_left = tk.Frame(root, bg='#FFFAF0', highlightthickness=0, width=500, height=850)  # 左边栏
    frame_left.place(x=0, y=50)  # 左边栏

    cv = tk.Canvas(root, bg='#FFFAF0', bd=0, relief="flat", width=900, height=850, highlightthickness=0)
    cv.place(x=500, y=50)    # 放置绘图Canvas画布

    cv.create_image(0, 0, image=List_Image[40], anchor=tk.NW)  # 背景

    G = Graph()
    mode = tk.IntVar(value=1)
    main_menu = tk.Menu(root)
    root.config(menu=main_menu)
    cv.bind('<Button-1>', left1)
    E = Edge()
    W = Ways()
    s = Solve()
    N = Node()
    auto_opera_mu(main_menu)
    window(2)
    G.lab_show(frame_top, 0, 0, 0)  # 显示边信息
    root.mainloop()