如何不重复的遍历一种框图

# bian li kuangtu 
G={'0_12': ['1_12', '0_13'], '5_14': ['4_14', '5_13'], '0_14': ['1_14', '0_13'], '5_12': ['4_12', '5_13'], '2_12': ['2_13', '1_12', '3_12'], '2_13': ['2_12', '2_14', '1_13', '3_13'], '5_13': ['5_14', '4_13', '5_12'], '2_14': ['2_13', '3_14', '1_14'], '1_14': ['2_14', '0_14', '1_13'], '1_13': ['2_13', '1_12', '1_14', '0_13'], '0_13': ['0_14', '1_13', '0_12'], '4_12': ['3_12', '4_13', '5_12'], '1_12': ['2_12', '1_13', '0_12'], '4_14': ['3_14', '5_14', '4_13'], '3_14': ['2_14', '3_13', '4_14'], '4_13': ['3_13', '4_14', '4_12', '5_13'], '3_13': ['2_13', '3_14', '3_12', '4_13'], '3_12': ['2_12', '3_13', '4_12']}
index=[]

for i,j in G.items():
    index.append(i)
def oriation(a): #将字符坐标分解为x和y
        a_=0
        con_a=a_con=''
        a=list(a)
        for i in range(0,len(a)-1):
            if a[i]=='_':
                  a_=i
        for i in range(0,len(a)):
            if i<a_:
                 a_con=a_con+a[i]
            elif i>a_:
               con_a=con_a+a[i]
        return int(a_con),int(con_a)    
def quick_sort(mylist,start,end):#用于坐标的排序
    if start<end:
        i,j=start,end
        base = mylist[i]
        while i<j:
                while(i<j) and (mylist[j]>=base):
                     j=j-1
                mylist[i]=mylist[j]
                while(i<j) and (mylist[i]<=base):
                      i=i+1
                mylist[j]=mylist[i]
        mylist[i]=base
        quick_sort(mylist,start,i-1)
        quick_sort(mylist,i+1,end)
    return mylist

def create_oriation(a,b):#判断两个坐标是否是相邻点
        a,b=str(a),str(b)
        
        a_=b_=0
        con_a=con_b=a_con=b_con=''
        a,b=list(a),list(b)
        for i in range(0,len(a)-1):
            if a[i]=='_':
                  a_=i
        for i in range(0,len(b)-1):
            if b[i]=='_':
                  b_=i
        for i in range(0,len(a)):
            if i<a_:
                 a_con=a_con+a[i]
            elif i>a_:
               con_a=con_a+a[i]

        for i in range(0,len(b)):
              if i<b_:
                 b_con=b_con+b[i]
              elif i>b_:
               con_b=con_b+b[i]
        #print("a_con",a_con,"con_a:",con_a,"b_con:",b_con,"con_b:",con_b)

        if a_con == b_con and  abs(int(con_a)-int(con_b))==1:
                  #print("success!")
                  return True
        elif con_a==con_b  and abs(int(a_con)-int(b_con))==1:
                   #print("success!")
                   return True
        else:
                   #print("error!")
                   return False 

def compare_vector_size(a,b):#比较两个坐标的相对大小
    a_con,con_a=oriation(a)
    b_con, con_b=oriation(b)
    if a_con==b_con and con_a>con_b:
                  return True 
                  print("a>b")
    elif a_con>b_con and con_a==con_b: 
                  return True        
                  print("a>b")
    elif a_con==b_con and con_a<con_b: 
                  return False        
                  print("a<b") 
    elif a_con<b_con and con_a==con_b:   
                  return False      
                  print("a<b")
    else:
            print("error")
def select_start(G):#选择图的起始点
    #print("index:",index )
    te=[]
    test={}
    print("index:",index)
    for i in range(0,len(index)-1):
         add=0
         a_con,con_a =oriation(index[i])
         #print(a_con,con_a)
         add=a_con+con_a
         test[index[i]]=add
         te.append(add)
    #print("test:",test)
    te=quick_sort(te,0,len(te)-1)# from the min to max
    #print(te,te[0],te[len(test)-1],type(te[0]))
    for i in G.keys():
          re=0
          a_con,con_a=oriation(i)
          re = a_con+con_a
          if re==te[0]:
              # print("min:",i)
               min=i
          elif re==te[len(test)-1]:
               #print("max:",i)
               max=i
    return min,max

def sort_vector(key):#坐标排序
    te=[]
    ans=[]
    test={}
    for i in range(0,len(key)):
        add=0
        i_con,con_i=oriation(key[i])
        add=int(i_con)+int(con_i)
        te.append(add)
        test[key[i]]=add
    quick_sort(te,0,len(te)-1)


    for i in range(0,len(te)):
        for h,j in test.items():
               
                if te[i]==j:
                    ans.append(h)
                    break
    return ans 

def add_way(key,start,flag):#生成路径
    way=[]
    print("1111111111key:",key,"start:",start)
    s_con,con_s=oriation(start)
    k0_con,con_k0=oriation(key[0])
    res1=compare_vector_size(start,key[0])
    res2=compare_vector_size(start,key[len(key)-1])
    print(res1,res2)
    if res1==False   and  res2==False  and flag==0:
           for i in key:
              if i not in way:
                   way.append(i) 
    elif res1==True  and  res2==True and flag==0:
            for i in range(len(key)-1,-1,-1):
                 if key[i] not in way: 
                     print("error!")
                     way.append(key[i])
    elif  res1==False and res2==False and  flag==1:
           for i in range(len(key)-1,-1,-1):
                 if key[i] not in way: 
                     print("error!")
                     way.append(key[i])
    elif  res1==True and res2==True  and  flag==1:
         for i in key:
              if i not in way:
                   way.append(i) 
    print("333333way:",way)
    return way
     
def select_vector(a,flag,max,i_x,i_y,a_x,a_y):#生成路径
  visited=[]
  visited.append(a)
  a_con,con_a=oriation(a)
  #while len(way)!=len(index):
  print("way6666:",visited,flag)
  while len(visited)<len(index):
    print( "len(visited)",len(visited),"len(index):",len(index))
    if flag==0:  
         start = visited[len(visited)-1]
         s_con,con_s=oriation(start)
         key=[]
         for i in G.keys():
                i_con,con_i=oriation(i)
                if  i_con!=s_con and con_i==con_s:
                       if i not in visited:
                         key.append(i)
         
         key=sort_vector(key)
         print(key,start)
         re=add_way(key,start,flag)
         visited=visited+re
         print("visited:",visited)
         flag=1    
         


    elif flag==1:
         start = visited[len(visited)-1]
         s_con,con_s=oriation(start)
         key=[]
         for i in G.keys():
                i_con,con_i=oriation(i)
                if  i_con==s_con and con_i!=con_s:
                    if i not in visited:
                         key.append(i) 

         print("key:",key,"start:",start)
         re=add_way(key,start,flag)
         visited=visited+re
         print("visited:",visited)
         
         flag=0             
               
                
def quick_travel(G,min,max): #create four vector 
        i_x,i_y=oriation(min)
        a_x,a_y=oriation(max) 
        print(i_x,i_y,a_x,a_y)
        flag=0
        if abs(i_x-a_x)<abs(i_y-a_y):#the best way is y 
                flag=1  
        else:#  the best way is x
                flag=0 
        print("flag:",flag)         
        select_vector(min,flag,max,i_x,i_y,a_x,a_y)
def main():
    min,max=select_start(G)
    print(min,max)
    quick_travel(G,min,max)
    print("success!")
main()

运行结果:('visited:', ['0_12', '1_12', '2_12', '3_12', '4_12', '5_12', '5_13', '5_14', '4_14', '3_14', '2_14', '1_14', '0_14', '0_13', '1_13', '2_13', '3_13', '4_13'])

猜你喜欢

转载自blog.csdn.net/weixin_42528089/article/details/90243927
今日推荐