algorithm-in-python/dataStructure/graph/adjacentList.py

''' mbinary
#########################################################################
# File : adjacentList.py
# Author: mbinary
# Mail: zhuheqin1@gmail.com
# Blog: https://mbinary.xyz
# Github: https://github.com/mbinary
# Created Time: 2018-04-26  10:33
# Description:
#########################################################################
'''

from collections import Iterable, deque


class vertex:
    def __init__(self, mark, firstEdge=None, val=None):
        self.mark = mark
        self.val = val
        self.firstEdge = firstEdge
        self.isVisited = False

    def __str__(self):
        return 'V' + str(self.mark)

    def __repr__(self):
        return str(self)


class edge:
    def __init__(self, adjVertexs, weight=1, nextEdge=None):
        '''adjVertexs:tuple(v.mark,u.mark)'''
        self.weight = weight
        self.adjVertexs = adjVertexs
        self.nextEdge = nextEdge
        self.isVisted = False

    def __add__(self, x):
        return self.weight + x

    def __radd__(self, x):
        return self + x

    def __getitem__(self, k):
        if k != 0 or k != 1: raise IndexError
        return self.adjVertexs[k]

    def __str__(self):
        return '--' + str(self.weight) + '--'

    def __repr__(self):
        return str(self)

    @property
    def v(self):
        return self.adjVertexs[0]

    @property
    def u(self):
        return self.adjVertexs[1]


class graph:
    def __init__(self):
        self.vertexs = {}
        self.edges = {}

    def __getitem__(self, i):
        return self.vertexs[i]

    def __setitem__(selfi, x):
        self.vertexs[i] = x

    def __iter__(self):
        return iter(self.vertexs)

    def __bool__(self):
        return len(self.vertexs) != 0

    def addVertex(self, vertexs):
        '''vertexs is a iterable or just a mark that marks the vertex,whichc can be every imutable type'''
        if not isinstance(vertexs, Iterable): vertexs = [vertexs]
        for i in vertexs:
            if not isinstance(i, vertex) and i not in self.vertexs:
                self.vertexs[i] = vertex(i)
            if isinstance(i, vertex) and i not in self.vertexs:
                self.vertexs[i.mark] = i

    def __getVertex(self, v):
        if not isinstance(v, vertex):
            if v not in self.vertexs:
                self.vertexs[v] = vertex(v)
            return self.vertexs[v]
        return v

    def addEdge(self, v, u, weight=1):
        v = self.__getVertex(v)
        u = self.__getVertex(u)
        arc = self.findEdge(v, u)
        if arc != None:
            return  #examine that if v,u have been already connected
        vertexs = (v, u)
        newEdge = edge(vertexs, weight)
        self.edges[vertexs] = newEdge
        if v.firstEdge == None:
            v.firstEdge = newEdge
        else:
            arc = v.firstEdge.nextEdge
            v.firstEdge = newEdge

    def findEdge(self, v, u):
        v = self.__getVertex(v)
        u = self.__getVertex(u)
        arc = v.firstEdge
        while arc != None and u not in arc:
            arc = arc.nextEdge
        if arc != None: return arc
        arc = u.firstEdge
        while arc != None and v not in arc:
            arc = arc.nextEdge
        return arc

    def delEdge(self, v, u):
        if not isinstance(v, vertex): v = self.vertexs[v]
        if not isinstance(u, vertex): u = self.vertexs[u]
        if u in v.firstEdge:
            v.firstEdge = v.firstEdge.nextEdge
        else:
            arc = v.firstEdge
            while arc.nextEdge != e:
                arc = arc.nextEdge
            if arc != None: arc.nextEdge = arc.nextEdge.nextEdge
            else:
                if v in u.firstEdge:
                    u.firstEdge = u.firstEdge.nextEdge
                else:
                    arc = u.firstEdge
                    while arc.nextEdge != e:
                        arc = arc.nextEdge
                    arc.nextEdge = arc.nextEdge.nextEdge
        del self.edges[(v, u)]

    def revisit(self):
        for i in self.vertexs.values():
            i.isVisited = False
        for i in self.edges.values():
            i.isVisited = False

    def __str__(self):
        arcs = list(self.edges.keys())
        arcs = [str(i[0]) + str(self.edges[i]) + str(i[1]) for i in arcs]
        s = '\n'.join(arcs)
        return s

    def __repr__(self):
        return str(self)

    def minPath(self, v, u):
        if v not in self or u not in self: return -1
        v = self.__getVertex(v)
        u = self.__getVertex(u)
        q = deque([v])
        last = {i: None for i in self.vertexs.values()}
        last[v] = 0
        ds = {i: 1000000 for i in self.vertexs.values()}
        ds[v] = 0
        while len(q) != 0:
            nd = q.popleft()
            nd.isVisited = True
            arc = nd.firstEdge
            while arc != None:
                tgt = None
                if arc.v == nd:
                    tgt = arc.u
                else:
                    tgt = arc.v
                tmp = ds[nd] + arc
                if ds[tgt] > tmp:
                    ds[tgt] = tmp
                    last[tgt] = nd
                if not tgt.isVisited: q.append(tgt)
        '''
        cur = u
        while cur !=v:
            print(str(cur)+'<---',end='')
            cur =last[cur]
        print(str(v))
        '''
        return ds[u]

    def hasCircle(self):
        pass

    def display(self):
        print('vertexs')
        for i in self.vertexs:
            print(i)
        print('edges')
        for i in self.edges:
            arc = self.edges[i]
            print(str(arc.v) + str(arc) + str(arc.u))


if __name__ == '__main__':
    n = int(input())
    while n > 0:
        cities = int(input())
        n -= 1
        g = graph()
        li = {}
        for i in range(cities):
            li[input()] = i + 1
            arc = int(input())
            for j in range(arc):
                s = input().split(' ')
                g.addEdge(i + 1, int(s[0]), int(s[1]))
        ct = int(input())
        for i in range(ct):
            line = input()
            line = line.split(' ')
            v, u = li[line[0]], li[line[1]]
            print(g.minPath(v, u))
            g.revisit()
#http://www.spoj.com/submit/SHPATH/id=20525991
'''
1
4
gdansk
2
2 1
3 3
bydgoszcz
3
1 1
3 1
4 4
torun
3
1 3
2 1
4 1
warszawa
2
2 4
3 1
2
gdansk warszawa
bydgoszcz warszawa
V4<---V3<---V2<---V1
3
V4<---V3<---V2
2
>>> 
'''