Python实现 温差问题

温差最小路径：

题目大意：

一些村庄由许多条小路连接，由于每条小路处于不同的地理位置，因此每条小路上的温度是不一样的。村民们要前往另一村庄时，对这条路径的绝对温度没有要求，但若一条路径的最大温度与最低温度之间的温差过大，会导致感冒。
请你找出两个村庄间的温差最小的路径。
输入：
第一行是一个正整数q,表示测试例数量。
对每个测试例，第一行有2个整数n(1<n400)和m(m2000)，表示有n个村庄和m条小路。
接下来m行都是3个正整数，分别是小路起始村庄号，小路终止村庄号，小路上的温度T（T2000000）。
然后有一个正整数P(P10)，表示寻路次数。
接下来P行，每行有2个正整数，分别表示村民的起始村庄号，村民的目的村庄号。
输出：
每个寻路打印一行，表示温差最小的温差，若不能到达，输出-1.
输入样例：
1
5 5
1 2 2
1 5 6
2 5 7
3 4 4
3 5 8
2
1 3
1 2

输出结果：
2
0

问题分析：

利用类似kruskal算法思路，先进行边的排序，在进行加入边，利用DFS判断连通性，连通即可返回。

代码实现如下：

import sys, time,math
edgeLinks=dict()
edgeLinks_dfs=dict()
stack = []
edgeWeightsAbout=dict()
edgeWeightsAbout1=dict()
edgeWeight=dict()
Cu=[]
J=[]
S=[]
Path=[]
start=[]
end=[]
stack=[]
T=[]
Q=[]

start_1=time.time()
def DFS(start,end):
    global stack,T,edgeLinks_dfs,p
    stack.append(start)
    if start == end:
        p = 1
        # print("%d 找到路径:%s" %(item12, stack))
        stack.clear()
    else:
        if len(edgeLinks_dfs)!=0:
            if start in edgeLinks_dfs:
                for nextPoint in edgeLinks_dfs[start]:# start不为全局变量 在递归后就变为了nextPoint
                    if nextPoint not in stack:
                        DFS(nextPoint, end)
                        if p == 1:
                            stack.clear()
                            return
                    else:
                        p=-1
                stack.pop()
            else:
                stack.pop()


C=int(input())
for item1 in range(C):
    global p
    p=0
    V,P=map(int,input().split())

    if V>1 and V<=400 and P<=2000:
        for item2 in range(P):
            a,b,c=map(int,input().split())
            wi=int(c)
            if str(a) not in edgeLinks: edgeLinks[str(a)] = set()
            if str(b) not in edgeLinks: edgeLinks[str(b)] = set()
            edgeLinks[str(a)].add(str(b))
            edgeLinks[str(b)].add(str(a))
            # 进行权重分类 权重一样的放到一个集合里面
            if wi not in edgeWeightsAbout.keys():
                edgeWeightsAbout[wi] = []
            if {str(a), str(b)} not in edgeWeightsAbout[wi]:
                edgeWeightsAbout[wi].append({str(a), str(b)})
            if str(a) not in edgeWeight:
                edgeWeight[str(a)] = dict()
            if str(b) not in edgeWeight:
                edgeWeight[str(b)] = dict()
            edgeWeight[str(a)].update({str(b): c})
            edgeWeight[str(b)].update({str(a): c})
        NP = int(input())
        for item3 in range(NP):
            m,n=map(int,input().split())
            start.append(str(m))
            end.append(str(n))
        for item12 in range(NP):
            edgeWeightsAbout1.clear()
            T.clear()
            Cu.clear()
            edgeLinks_dfs.clear()

            S = sorted(edgeWeightsAbout.keys(), reverse=False)
            for item6 in range(len(S)):
                edgeWeightsAbout1.update({S[item6]: edgeWeightsAbout[S[item6]]})
            for item7 in range(len(S)):
                for item8 in range(len(edgeWeightsAbout1[S[item7]])):
                    for item11 in edgeWeightsAbout1[S[item7]][item8]:
                        J.append(item11)
                    if J[0] not in edgeLinks_dfs: edgeLinks_dfs[J[0]] = set()
                    if J[1] not in edgeLinks_dfs: edgeLinks_dfs[J[1]] = set()
                    edgeLinks_dfs[J[0]].add(J[1])
                    edgeLinks_dfs[J[1]].add(J[0])
                    Cu.append(str(J[0]))
                    Cu.append(str(J[1]))
                    J .clear()
                    if (len(edgeLinks_dfs) == 0):
                        break
                    else:
                        if (len(edgeLinks_dfs) == 0):
                            break
                        else:
                            if start[item12] in Cu and end[item12] in Cu:
                                DFS(start[item12], end[item12])
                                if (p == 1):
                                    while p != -1:
                                        if (len(Cu) < 2):
                                            break
                                        else:
                                            if (p == 1):
                                                if start[item12] in Cu and end[item12] in Cu:
                                                    T.append(abs(edgeWeight[Cu[len(Cu) - 2]][Cu[len(Cu) - 1]] -
                                                                 edgeWeight[Cu[0]][Cu[1]]))
                                            t = 0
                                            if (len(edgeLinks_dfs) == 0):
                                                break
                                            else:
                                                for yuan in list(edgeLinks_dfs[Cu[0]]):
                                                    if (yuan == Cu[0] or yuan == Cu[1]):
                                                        if (t == 0):
                                                            t = 1
                                                            if (len(edgeLinks_dfs[Cu[0]]) == 1 or len(
                                                                    edgeLinks_dfs[Cu[0]]) == 0):
                                                                del edgeLinks_dfs[Cu[0]]
                                                            else:
                                                                edgeLinks_dfs[Cu[0]].remove(yuan)
                                                            if (len(edgeLinks_dfs[yuan]) == 1 or len(
                                                                    edgeLinks_dfs[yuan]) == 0):
                                                                del edgeLinks_dfs[yuan]
                                                            else:
                                                                edgeLinks_dfs[yuan].remove(Cu[0])
                                                Cu.pop(0)
                                                Cu.pop(0)
                                                if start[item12] in Cu and end[item12] in Cu:
                                                    p = -1
                                                    DFS(start[item12], end[item12])
                                                if len(Cu) == 0:
                                                    T.sort()
            print(T[0])
end_1 = time.time()
print('Running time: %s Seconds' % (end_1 - start_1))

读取如下：
1
5 5
1 2 2
1 5 6
2 5 7
3 4 4
3 5 8
2
1 3
1 2
结果如下：（不用这么多空格）