庞果网（最小操作数）

从庞果网上，看到一题，是求最小操作数的，具体题目如下：

现用python代码实现如下：

#!usr/bin/env python
#coding:utf-8

def compareWord(A,B):
    wordLen = len(A)
    diff = 0
    for i in range(wordLen):
        if A[i] != B[i]:
            diff += 1
    return diff


def findpath(startD, endD, Dict, dictMatrix):
    paths = dict()
    minDis = min(min([dictMatrix[Dict.index(si)][Dict.index(ei)] for si in startD] for ei in endD))

    if minDis == 0:
        for si in startD:
            for ei in endD:
                bdInd = Dict.index(si)
                edInd = Dict.index(ei)
                if dictMatrix[bdInd][edInd] == 0:
                    paths[si] = ei
        return paths
    elif minDis == 1:
        for si in startD:
            for ei in endD:
                bdInd = Dict.index(si)
                edInd = Dict.index(ei)
                if dictMatrix[bdInd][edInd] == 1:
                    if si not in paths:
                        paths.setdefault(si, {})
                    paths[si] = ei
        return paths
    else:
        for si in startD:
            bdInd = Dict.index(si)
            temp = list()
            tempArray = dictMatrix[bdInd]
            for t in range(len(tempArray)):
                if tempArray[t] == 1:
                    temp.append(Dict[t])
            path = findpath(temp, endD, Dict, dictMatrix)
            paths[si] = path
    return paths


def translate(A, B , Dict):
    diff = compareWord(A,B)
    if diff == 0:
        return []
    paths = list()
    #找到入口
    startD = list()
    #出口
    endD = list()
    for di in Dict:
        diff = compareWord(A, di)
        if diff == 1:
            startD.append(di)
        elif diff == 0:
            startD=[di]
            break
    for di in Dict:
        diff = compareWord(B, di)
        if diff == 1:
            endD.append(di)
        elif diff == 0:
            endD=[di]
            break
    #构建单词集合的矩阵
    dictMatrix = list()
    for di in Dict:
        temp = list()
        for dj in Dict:
            if di == dj:
                temp.append(0)
            else:
                temp.append(compareWord(di,dj))
        dictMatrix.append(temp)

    for di in dictMatrix:
        print di

    #寻找startD到endD的最短路径
    print 'startD:', A, startD
    print 'endD:', B, endD
    paths = findpath(startD, endD, Dict, dictMatrix)
    print paths
    pathSt = [A]
    pathSt = printDict(paths, pathSt)
    pathSt = [pi+'->'+B for pi in pathSt]
    return  pathSt

def printDict(paths, pathSt):
    nextpath = paths.keys()
    pathSt = [ps+'->' for ps in pathSt]
    pathSt = pathSt*len(nextpath)
    for ni in range(len(nextpath)):
        pathSt[ni] += nextpath[ni]
        if type(paths[nextpath[ni]]) is not type(dict()):
            if not pathSt[ni].endswith(paths[nextpath[ni]]):
                pathSt[ni] += '->'+paths[nextpath[ni]]
            #return pathSt
        else:
            pathSt = printDict(paths[nextpath[ni]], pathSt)
    return pathSt

if __name__=='__main__':
    A = 'hog'
    B = 'hog'
    Dict = ['hot', 'dot', 'dog', 'lot', 'log','tog','tit']
    paths = translate(A,B, Dict)
    print paths