需要PythonGUI的Tkinter代码，以便在分支绑定和动态编程方法中实现TSP。。

需要PythonGUI的Tkinter代码，以便在分支绑定和动态编程方法中实现TSP。。 下面的代码运行良好，我明天的项目演示需要一个gui平台。 我试着用tkinter编程，但没能很好地理解代码。 在GUI中，我需要文本框来读取城市编号和n*n矩阵。输出屏幕显示路径成本和最佳路线。你们能帮我吗？提前谢谢

import itertools

    INF = 100000000

    best_cost = 0

def reduce(size, w, row, col, rowred, colred):
rvalue = 0
for i in range(size):
    temp = INF
    for j in range(size):
        temp = min(temp, w[row[i]][col[j]])
    if temp > 0:
        for j in range(size):
            if w[row[i]][col[j]] < INF:
                w[row[i]][col[j]] -= temp
        rvalue += temp
    rowred[i] = temp
for j in range(size):
    temp = INF
    for i in range(size):
        temp = min(temp, w[row[i]][col[j]])
    if temp > 0:
        for i in range(size):
            if w[row[i]][col[j]] < INF:
                w[row[i]][col[j]] -= temp
        rvalue += temp
    colred[j] = temp
return rvalue


def bestEdge(size, w, row, col):
mosti = -INF
ri = 0
ci = 0
for i in range(size):
    for j in range(size):
        if not w[row[i]][col[j]]:
            minrowwelt = INF
            zeroes = 0
            for k in range(size):
                if not w[row[i]][col[k]]:
                    zeroes += 1
                else:
                    minrowwelt = min(minrowwelt, w[row[i]][col[k]])
            if zeroes > 1: minrowwelt = 0
            mincolwelt = INF
            zeroes = 0
            for k in range(size):
                if not w[row[k]][col[j]]:
                    zeroes += 1
                else:
                    mincolwelt = min(mincolwelt, w[row[k]][col[j]])
            if zeroes > 1: mincolwelt = 0
            if minrowwelt + mincolwelt > mosti:
                mosti = minrowwelt + mincolwelt
                ri = i
                ci = j
return mosti, ri, ci


def explore(n, w, edges, cost, row, col, best, fwdptr, backptr):
global best_cost

colred = [0 for _ in range(n)]
rowred = [0 for _ in range(n)]
size = n - edges
cost += reduce(size, w, row, col, rowred, colred)
if cost < best_cost:
    if edges == n - 2:
        for i in range(n): best[i] = fwdptr[i]
        if w[row[0]][col[0]] >= INF:
            avoid = 0
        else:
            avoid = 1
        best[row[0]] = col[1 - avoid]
        best[row[1]] = col[avoid]
        best_cost = cost
    else:
        mostv, rv, cv = bestEdge(size, w, row, col)
        lowerbound = cost + mostv
        fwdptr[row[rv]] = col[cv]
        backptr[col[cv]] = row[rv]
        last = col[cv]
        while fwdptr[last] != INF: last = fwdptr[last]
        first = row[rv]
        while backptr[first] != INF: first = backptr[first]
        colrowval = w[last][first]
        w[last][first] = INF
        newcol = [INF for _ in range(size)]
        newrow = [INF for _ in range(size)]
        for i in range(rv): newrow[i] = row[i]
        for i in range(rv, size - 1): newrow[i] = row[i + 1]
        for i in range(cv): newcol[i] = col[i]
        for i in range(cv, size - 1): newcol[i] = col[i + 1]
        explore(n, w, edges + 1, cost, newrow, newcol, best, fwdptr, backptr)
        w[last][first] = colrowval
        backptr[col[cv]] = INF
        fwdptr[row[rv]] = INF
        if lowerbound < best_cost:
            w[row[rv]][col[cv]] = INF
            explore(n, w, edges, cost, row, col, best, fwdptr, backptr)
            w[row[rv]][col[cv]] = 0

for i in range(size):
    for j in range(size):
        w[row[i]][col[j]] = w[row[i]][col[j]] + rowred[i] + colred[j]

#  code for branch & bound 
def bb(w,size):
global best_cost
for i in range(size):
    a[i][i]=INF
print('The cost matrix:')
for i in range(size):
    print(a[i])
col = [i for i in range(size)]
row = [i for i in range(size)]
best = [0 for _ in range(size)]
route = [0 for _ in range(size)]
fwdptr = [INF for _ in range(size)]
backptr = [INF for _ in range(size)]
best_cost = INF

explore(size, w, 0, 0, row, col, best, fwdptr, backptr)

index = 0
for i in range(size):
    route[i] = index
    index = best[index]
index = []
cost = 0

for i in range(size):
    if i != size - 1:
        src = route[i]
        dst = route[i + 1]
    else:
        src = route[i]
        dst = 0
    cost += w[src][dst]
    index.append(src+1)
index.append(1)
print('B&B Minimum cost:',cost)
print('B&B Optimal path:',index)
return

#   code for dynamic programming
def dp(A,N):
v=[x for x in range(1,N)]
s=tuple(itertools.permutations(v,N-1))

l=len(s)
C=[]
for i in range(l):
    t=s[i]
    c=A[0][t[0]]
    for j in range(1,len(t)):
        c+=A[t[j-1]][t[j]]
    c+=A[t[j]][0]
    C=C+[c]

m=min(C)
print('DP Minimum cost:',m)
d={k:p for (k,p) in zip(C,s)}
r=d[m]
r=[x+1 for x in r]
r.insert(0,1)
r.append(1)
print('DPOptimal tour:',r)
return

####    getting inputs from user
n=int(input('Enter the no.of cities:'))
a=[[0 for i in range(n)]for j in range(n)]
print('Enter the cost matrix:')
for i in range(n):
for j in range(n):
    a[i][j]=int(input())
# calling branch & bound
bb(a,n)
#calling dynamic programming
dp(a,n)

导入itertools
INF=100000000
最佳成本=0
def减少（大小、宽度、行、列、行、列、列、列）：
右值=0
对于范围内的i（尺寸）：
温度=INF
对于范围内的j（尺寸）：
温度=最小值（温度，w[行[i]][列[j]]）
如果温度>0：
对于范围内的j（尺寸）：
如果w[row[i]][col[j]]0：
对于范围内的i（尺寸）：
如果w[row[i]][col[j]]1:minrowwelt=0
mincolwelt=INF
零=0
对于范围内的k（尺寸）：
如果不是w[行[k]][列[j]]：
零+=1
其他：
mincolwelt=min（mincolwelt，w[row[k]][col[j]]）
如果零>1:mincolwelt=0
如果minrowwelt+mincolwelt>mosti：
mosti=minrowwelt+mincolwelt
ri=i
ci=j
返回mosti、ri、ci
def探索（n、w、边缘、成本、行、列、最佳、fwdptr、backptr）：
全球最佳成本
colred=[0表示范围（n）]
rowred=[0表示范围内的u（n）]
大小=n-边
成本+=减少（大小，w，行，列，列，列，列）
如果成本<最佳成本：
如果边==n-2：
对于范围（n）中的i：最佳[i]=fwdptr[i]
如果w[row[0]][col[0]]>=INF：
避免=0
其他：
避免=1
最佳[行[0]]=列[1-避免]
最佳[行[1]]=列[避免]
最佳成本=成本
其他：
mostv、rv、cv=最佳边缘（尺寸、宽度、行、列）
lowerbound=成本+mostv
fwdptr[行[rv]]=列[cv]
backptr[col[cv]]=行[rv]
最后一个=列[cv]
而fwdptr[上次]！=INF:last=fwdptr[last]
第一个=行[rv]
而backptr[first]！=INF:first=backptr[first]
colrowval=w[最后一个][第一个]
w[最后一个][第一个]=INF
newcol=[INF表示范围内的uu（大小）]
newrow=[INF表示范围内的uu（大小）]
对于范围内的i（rv）：新行[i]=行[i]
对于范围内的i（rv，尺寸-1）：新行[i]=行[i+1]
对于范围内的i（cv）：newcol[i]=col[i]
对于范围内的i（cv，大小-1）：newcol[i]=col[i+1]
探索（n、w、边+1、成本、新行、新列、最佳、fwdptr、背面）
w[最后一次][第一次]=colrowval
backptr[col[cv]]=INF
fwdptr[行[rv]]=INF
如果下限<最佳成本：
w[行[rv]][列[cv]]=INF
探索（n、w、边缘、成本、行、列、最佳、fwdptr、背面）
w[行[rv]][列[cv]]=0
对于范围内的i（尺寸）：
对于范围内的j（尺寸）：
w[row[i]][col[j]]=w[row[i][col[j]]+rowred[i]+colred[j]
#分支和绑定代码
def bb（宽，尺寸）：
全球最佳成本
对于范围内的i（尺寸）：
a[i][i]=INF
打印（'成本矩阵：'）
对于范围内的i（尺寸）：
打印（a[i]）
col=[i代表范围内的i（大小）]
行=[i代表范围内的i（大小）]
最佳=[0表示范围内（大小）]
路由=[0用于范围内（大小）]
fwdptr=[INF用于范围内（大小）]
backptr=[INF用于范围内（大小）]
最佳成本=INF
探索（大小、宽度、0、0、行、列、最佳、fwdptr、背面PTR）
索引=0
对于范围内的i（尺寸）：
路由[i]=索引
索引=最佳[索引]
索引=[]
成本=0
对于范围内的i（尺寸）：
如果我尺寸-1：
src=路线[i]
dst=路线[i+1]
其他：
src=路线[i]
dst=0
成本+=w[src][dst]
index.append（src+1）
追加索引（1）
打印（'B&B最低成本：'，成本）
打印（'B&B最佳路径：'，索引）
返回
#动态规划代码
def dp（A，N）：
v=[x代表范围（1，N）内的x]
s=元组（itertools.置换（v，N-1））
l=len（s）
C=[]
对于范围（l）中的i：
t=s[i]
c=A[0][t[0]]
对于范围（1，len（t））内的j：
c+=A[t[j-1][t[j]]
c+=A[t[j][0]
C=C+[C]
m=最小值（C）
打印（'DP最低成本：'，m）
d={k:p表示zip（C，s）中的（k，p）}
r=d[m]
r=[x+1表示r中的x]
r、 插入（0,1）
r、 附加（1）
打印（'DPR:'，r）
返回
####从用户获取输入
n=int（输入（'输入城市编号：'））
a=[[0代表范围（n）中的i]代表范围（n）中的j]
打印（'输入成本矩阵：'）
对于范围（n）中的i：
对于范围（n）内的j：
a[i][j]=int（输入（））
#呼叫分支和绑定
bb（a，n）
#调用动态规划
dp（a，n）

这基本上是要求某人为您编写应用程序

对于一些人来说，Tkinter可能很难掌握，但它应该不会超过几个小时。如果您编写一个单独的应用程序，在按下按钮时只显示“hello world”，就像您将要学习的那样，那么这只是一个重复代码并使您的逻辑适合的例子

当代码不符合您的想法时，社区将乐于帮助您。尝试浏览教程，然后返回您的问题

请注意：在发帖时在代码中添加更多的空格/注释，这将使答案更快、更相关

那么你的具体问题是什么