API tools faq
paste
Guest User

Untitled

a guest
Mar 20th, 2018
77
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 20.05 KB | None | 0 0
raw download clone embed print report
  1. '''
  2. Input: str from','to
  3. Output: objeto de tipo Edge
  4.  
  5. Dados string FromTo de tipo str(from)+','+str(to),
  6. EdgeOf regresa el objeto de tipo Edge representado con dicho "nombre"
  7.  
  8. OjO ver quiza habra que modificar el howClansAreSeen*
  9. '''
  10. def EdgeOf(FromTo):
  11. here = False
  12. j=0
  13. while not here and j< len(EdgesNodes):
  14. if FromTo == str(EdgesNodes[j]):
  15. here = True
  16. else:
  17. j+=1
  18. if here:
  19. return EdgesNodes[j]
  20. else:
  21. print 'Edge not found'
  22.  
  23. '''
  24. ND
  25. Para trabajar con un grafo dirigido la funcion tendria que cosiderar las aristas del nodo a los elementos del clan
  26.  
  27. Input: Nodo no visible (str NonVisible), lista de nodos del clan(ClanList), str node
  28. Output: True/False
  29. Copia los nodos del clan a una nueva lista, OurClanList, y elimina de ella el clan no visible.
  30. Obtienen los elementos de tipo Edge que van de node a OurClanList
  31. y ve nodo a nodo, si las aristas del nodo no visible y de node hacia un mismo nodo, estan en la misma clase de equivalencia. De ser asi sohnidica que forman clan.
  32. '''
  33. def ClanWithNonVisible(NonVisible,ClanList,node):
  34. NodeToOurClan = []
  35. NewEdges =[]
  36.  
  37. OurClanList = ClanList[:]
  38. OurClanList.remove(NonVisible)
  39.  
  40. for i in OurClanList:
  41. NodeToOurClan.append(EdgeOf(str(i)+','+node))
  42.  
  43. TheyAreClans = True
  44. j=0
  45. while TheyAreClans and j <len(OurClanList):
  46. n = EdgeOf(str(OurClanList[j])+','+str(NonVisible))
  47. if Find(n)== Find(NodeToOurClan[j]):
  48. j+=1
  49. else:
  50. TheyAreClans = False
  51.  
  52. return TheyAreClans
  53.  
  54. '''
  55. Input: clan.nodes lista de strings y node un str.
  56. Output: True/False, str: el nodo con el que node hace clan
  57. Busca si alguno de los vertices existentes tiene Edges hacia el resto de los nodos que esten en la misma clase de equivalencia que las edges que conectan con node (desde cada vertice del clan)
  58. '''
  59. def ClanWith(ClanList,node):
  60. print 'ClanWith'
  61. NewEdges = []
  62. ClanToNode =[]
  63. for i in ClanList:
  64. ClanToNode.append(EdgeOf(str(i)+','+node))#esto en lugar de #% los ve a todos y no tendria porque tronar
  65. #print 'Aristas encontradas:'
  66. #for i in ClanToNode:
  67. # print str(i)
  68. i=0
  69. ClanFound= False
  70. while not ClanFound and i<len(ClanList):
  71. ActNode = ClanList[i]
  72. same=True
  73. j=0
  74. while same and j <len(ClanList):
  75. if i!=j:
  76. n = EdgeOf(str(ClanList[j])+','+str(ClanList[i]))
  77. if Find(n)== Find(ClanToNode[j]): #ClanToNode[j] =str(ClanList[j])+','+node)
  78. j+=1
  79. else:
  80. same = False
  81. else:
  82. j+=1
  83. if same==False:
  84. i+=1
  85. else:#elif j == len(ClanList):Solo puede hacer clan con un elemento y por lo tanto sale al encontrarlo
  86. ClanFound=True
  87. if ClanFound:
  88. return ClanFound, ClanList[i] #True/False,SomeNode
  89. else:
  90. return False,''
  91.  
  92. '''
  93. Input: Lista de Edges NonVisibleClans, node
  94. Output: Devuelve los nodos ya visibles, separados segun el color por el que son vistos
  95. y devuelve los nodo como nodos individuales en NewNodes y los nodos dentro de clanes en NewClans.
  96. '''
  97. def Split(NonVisibleClans,node):
  98. #print 'Split: ', NonVisibleClans
  99. SplitEdges=[]
  100. SplitD={}
  101. SplitR=[]
  102.  
  103. NewNodes = []
  104. NewClans = []
  105. for i in CCT[0]:
  106. SplitD.setdefault(i, [])
  107.  
  108. for Clan in NonVisibleClans:
  109. #print Clan
  110. SplitEdges.append(str(Clan)+','+node)
  111. #print SplitEdges
  112.  
  113. for i in range(len(SplitEdges)):
  114. #print 'Arista a buscar', SplitEdges[i]
  115. here = False
  116. j = 0
  117. while not here and j< len(EdgesNodes):
  118. if SplitEdges[i] == str(EdgesNodes[j]):
  119. here = True
  120. else:
  121. j+=1
  122. if here:
  123. #print 'Arista encontrada:'
  124. SplitD[Find(EdgesNodes[j])].append(str(EdgesNodes[j].EdgeFrom()))
  125. #SplitR.append(str(EdgesNodes[j].EdgeFrom()))
  126. for i in SplitD.values():
  127. if i!=[] and i not in SplitR:
  128. SplitR.append(i)
  129.  
  130. else:
  131. #print 'Arista no encontrada, split sobre el nodo', NonVisibleClans[i]
  132. SplitR.extend(Split(NonVisibleClans[i],node)[0])
  133.  
  134. for i in SplitR:#lista de listas
  135. if len(i)==1:
  136. SplitR.insert(SplitR.index(i),i[0])
  137. SplitR.remove(i)
  138. if i[0] not in NewNodes:
  139. NewNodes.append(i[0])
  140. #print 'por lo tanto es un nodo'
  141. else:
  142. #print 'por lo tanto es un clan'
  143. if i not in NewClans:
  144. NewClans.append(i)
  145. return SplitR,NewNodes,NewClans
  146.  
  147. '''
  148. Input: Lista de strs que representa los nodos a ser metidos en el clan.
  149. Output: Objeto del tipo MyClan
  150. Segun los nodos en la lista, busca si forma un clan complete o primitive y agrega estos nodos al clan.
  151. '''
  152. def ClanGenerator(NodeList):
  153. if len(NodeList)== 2:
  154. NewClan = MyClan('complete')
  155. NewClan.add_nodes_from(NodeList)
  156. else:#if len(i)>2 :
  157. #print NodeList
  158. #print 'tamanio de i',len(NodeList),'i[0]',NodeList[0],',',NodeList[1],'i[1]'
  159. same = True
  160. InitialColor = Find(EdgeOf(str(NodeList[0])+','+str(NodeList[1])))
  161. n = 0
  162. while same and n <len(NodeList)-1:
  163. j = n+1
  164. while same and j < len(NodeList):
  165. if Find(EdgeOf(str(NodeList[n])+','+str(NodeList[j])))== InitialColor :
  166. j+=1
  167. else:
  168. same = False
  169. if j==len(i):
  170. n+=1
  171. if same:
  172. NewClan = MyClan('complete')
  173. else:
  174. NewClan = MyClan('primitive')
  175. NewClan.add_nodes_from(i)
  176. return NewClan
  177.  
  178. '''
  179. Input: NodeList Lista de str, nodos a compactar
  180. Output: Actualiza EdgesNodes, agregando las aristas que se generan al compactar los nodos de entrada
  181. como decidir si se compacta o no: se compactara cuando en ese momento se tenga almenos un nodo que los haga clan, i.e. que ya los este compactando.
  182. '''
  183. def Pack(NodeList):
  184. #print 'Make a clan to:'
  185. for k in NodeList:
  186. print k
  187.  
  188. Edges = []
  189. for i in EdgesNodes:
  190. frm = i.EdgeFrom()
  191. to = i.EdgeTo()
  192. for j in NodeList:
  193. if str(j) == frm and '[' not in to and i not in Edges:
  194. notinNodeList = True
  195. c=0
  196. while notinNodeList and c<len(NodeList):
  197. if to in NodeList[c]:
  198. notinNodeList = False
  199. else:
  200. c+=1
  201. if notinNodeList:
  202. Edges.append(i)
  203.  
  204. #print '_______elementos de NodeList en:____________'
  205. #for i in Edges:
  206. # print str(i), Find(i)
  207.  
  208. i = 0
  209. while i < len(Edges):
  210. edge = str(Edges[i])
  211. to = Edges[i].EdgeTo()
  212. j = i+1
  213. pack = True
  214. ine = False
  215. InitialColor = Find(Edges[i])
  216. while pack and j<len(Edges):
  217. thisto = Edges[j].EdgeTo()
  218. if to == thisto:
  219. if InitialColor == Find(Edges[j]):
  220. ine = True
  221. j+=1
  222. else:
  223. pack = False
  224. else:
  225. j+=1
  226. if pack and ine:
  227. k = Edge(str(NodeList),',',to)
  228. l = Edge( to,',',str(NodeList))
  229. EdgesNodes.append(k)
  230. EdgesNodes.append(l)
  231. MakeSet(k)
  232. MakeSet(l)
  233. Union(Edges[i],k)
  234. Union(Edges[i],l)
  235. elif pack == False:
  236. #Eliminar todas las Edges con ese to
  237. #Edges.remove(Edges[j])
  238. l=j
  239. while l< len(Edges):
  240. thisto = Edges[l].EdgeTo()
  241. if to == thisto:
  242. Edges.remove(Edges[l])
  243. l+=1
  244. i+=1
  245.  
  246. #print '--------Aristas finales----------'
  247. #for i in EdgesNodes:
  248. # print str(i), Find(i)
  249.  
  250. '''
  251. Input: Lista de objetos Edge
  252. Output: Devuelve true si todas las aristas en EdgeList tienen el mismo color
  253. '''
  254. def EdgesHaveSameColor(EdgeList):
  255. Same = True
  256. InitialColor= Find(EdgeList[0])
  257. i = 1
  258. while Same and i < len(EdgeList):
  259. if InitialColor != Find(EdgeList[i]):
  260. Same = False
  261. else:
  262. i+=1
  263. return Same
  264.  
  265. '''
  266. Input: MyClan Clan,str node
  267. Output: 2 Lists of Edge type y una listas de string q representa los nodos no visibles desde node.
  268. SameColorAsClan, VisibleClans, NonVisibleClans
  269. '''
  270. def HowClansAreSeen(Clan,node):#MyClan Clan, str node
  271. NewEdges=[]
  272. EdgesNodesList =[]
  273.  
  274. SameColorAsClan=[]
  275. VisibleClans=[]
  276. NonVisibleClans=[]
  277. SameColorTo = []
  278. for i in Clan.nodes:
  279. NewEdges.append(str(i)+','+node)
  280.  
  281. for i in range(len(NewEdges)):
  282. print NewEdges[i]
  283. here = False
  284. j=0
  285. while not here and j< len(EdgesNodes):
  286. if NewEdges[i] == str(EdgesNodes[j]):
  287. here = True
  288. else:
  289. j+=1
  290. if here:
  291. EdgesNodesList.append(EdgesNodes[j])
  292. else:
  293. to = Clan.nodes[i]
  294. NonVisibleClans.append(to)
  295.  
  296. if Clan.clantype == 'complete':
  297. #encuentra el color del clan
  298. e = str(Clan.nodes[0])+','+str(Clan.nodes[1])
  299. j = 0
  300. i = EdgesNodes[j]
  301. while e != str(i) and j<len(EdgesNodes):
  302. i = EdgesNodes[j]
  303. j+=1
  304. colorclan =Find(i)
  305.  
  306. for c in range(len(EdgesNodesList)):
  307. if colorclan != Find(EdgesNodesList[c]):
  308. VisibleClans.append(EdgesNodesList[c])
  309. else:
  310. SameColorAsClan.append(EdgesNodesList[c])
  311. else:
  312. for c in range(len(EdgesNodesList)):
  313. VisibleClans.append(EdgesNodesList[c])
  314. return SameColorAsClan,VisibleClans, NonVisibleClans
  315.  
  316. '''
  317. Input: Clan de tipo MyCLan, str node que sera el nodo a aniadir
  318. Output:el Clan actualizado.
  319. Funcion que agrega un nuevo nodo a un clan existente.eje
  320. '''
  321. #Hacer Pack cuando se crean nuevos clanes
  322. def AddNode(Clan,node): #MyClan Clan, str node
  323. print 'Clan nodes: ',Clan.nodes
  324. print 'Clan type: ',Clan.clantype
  325. if len(Clan.nodes)==1:
  326. #print Clan.nodes[0]
  327. if '[' not in str(Clan.nodes[0]):
  328. Clan.add_node(node)
  329. #print 'un nodo habia'
  330. else:
  331. #print 'un clan habia'
  332. ActualNode = Clan.nodes[0]
  333. for i in ActualNode:
  334. Clan.add_node(i)
  335. Clan.remove_node(ActualNode)
  336. AddNode(Clan,node)
  337. else:
  338. HCAS = HowClansAreSeen(Clan,node)
  339. SameColorAsClan = HCAS[0]
  340. VisibleClans = HCAS[1]
  341. NonVisibleClans = HCAS[2]
  342.  
  343. if Clan.clantype=='complete':
  344. if len(SameColorAsClan)==len(Clan.nodes):
  345. #print 'El nodo ve a todos los elementos del mismo color que el color del clan'
  346. Clan.add_node(node)
  347.  
  348. elif len(SameColorAsClan)!= 0:
  349. ListNodesSameColor = []
  350. ListNodesDiferentColor = []
  351. for i in SameColorAsClan:
  352. ListNodesSameColor.append(i.EdgeFrom())
  353. #print 'El nodo ve a algunos elementos del clan del mismo color que el color del clan'
  354. #print 'los elementos son:'
  355. #print ListNodesSameColor
  356.  
  357. NodesInClan = Clan.nodes[:]
  358. for i in NodesInClan:
  359. if str(i) not in ListNodesSameColor:
  360. ListNodesDiferentColor.append(i)
  361. #print 'Elementos del clan que no son vistos del mismo color:', ListNodesDiferentColor
  362.  
  363. ClanNotSameColor = MyClan('complete')
  364. for i in ListNodesDiferentColor:
  365. Clan.remove_node(i)
  366. if '[' in i: #Se trata de un clan
  367. ci = i.replace('[','')
  368. ci = ci.replace(']','')
  369. ci = ci.split(', ')
  370. print ci
  371. clan_i = Clan.getclanwithnodes(ci)
  372. ClanNotSameColor.add_clan(ci)
  373. else:
  374. ClanNotSameColor.add_node(i)
  375.  
  376. #print Clan.nodes
  377. #print '*********************'
  378. AddNode(ClanNotSameColor,node)
  379.  
  380. #print ClanNotSameColor.nodes
  381. #print '++++++'
  382. #print Clan.nodes
  383. Clan.add_clan(ClanNotSameColor)
  384. #print 'clan final', Clan.nodes
  385. Pack(ClanNotSameColor.nodes)
  386. #print '************************************* compacta a: ', ClanNotSameColor.nodes
  387.  
  388. elif len(NonVisibleClans)!=0:
  389. #print 'El nodo no puede ver a ',len(NonVisibleClans) ,' elementos del clan y estos son:', NonVisibleClans
  390. Clan.add_node(node)
  391. Clan.remove_nodes_from(NonVisibleClans)
  392. Clan.clantype = 'primitive'
  393. #print 'Nodos del Clan antes del Split: ', Clan.nodes
  394. #for i in NonVisibleClans:
  395. # print 'nodo en NonVisibleClans: ', i
  396. S=Split(NonVisibleClans,node)
  397. #print 'Nuevos nodos', S[1]
  398. Clan.add_nodes_from(S[1])
  399. #print 'Nuevos clanes', S[2]
  400. for i in S[2]:
  401. CG = ClanGenerator(i)
  402. Clan.add_clan(CG)
  403. #print 'Nodos del Clan despues del Split: ', Clan.nodes,'***'
  404. else:
  405. if EdgesHaveSameColor(VisibleClans):
  406. #print 'El nodo ve con el mismo color a todos los elementos del clan, y este color es distintos al color del clan.'
  407. NodesInVisibleClans =Clan.nodes[:]
  408. Clan.add_node(node)
  409. Clan.remove_nodes_from(NodesInVisibleClans)
  410. NewClan = MyClan('complete')
  411. NewClan.add_nodes_from(NodesInVisibleClans)
  412. Clan.add_clan(NewClan)
  413. Pack(NodesInVisibleClans)
  414. #print 'Los nodos del clan resultante son: ', Clan.nodes, '\n **********************************mismos que se compactaron'
  415. else:#Si ve a k nodos del mismo color estos se deben agrupar y no se estan agrupando... revisar esto con un ejemplo
  416. #print 'los ve de distinto color'
  417. Nodes = Clan.nodes[:]
  418. Clan.remove_nodes_from(Nodes)
  419. Clan.add_node(node)
  420. Clan.clantype = 'primitive'
  421. S=Split(Nodes,node)
  422. #print 'Nuevos nodos', S[1]
  423. Clan.add_nodes_from(S[1])
  424. #print 'Nuevos clanes', S[2]
  425. for i in S[2]:
  426. CG = ClanGenerator(i)
  427. Clan.add_clan(CG)
  428. #print 'Nodos en el Clan despues de Split', Clan.nodes
  429. #No se hace pack ya que se compactara hasta que llegue un fondo que los vea a todos igual
  430.  
  431. else:#primitive
  432. if len(NonVisibleClans) != 0:
  433. #print 'Hay elementos no visibles y son:'
  434. #for n in NonVisibleClans:
  435. # print n
  436. #print 'si el tamanio del non visible es uno, ver si hace clan con este, sino colocarlo como uno mas y hacer split'
  437. if len(NonVisibleClans) == 1 and ClanWithNonVisible(NonVisibleClans[0],Clan.nodes,node):
  438. #print 'hay un nodo/clan no visible y hace clan con el, es:', NonVisibleClans[0]
  439. #print 'buscarlo en: ', Clan.nodes
  440. ClanAux = Clan.getclanwithnodes(NonVisibleClans[0])
  441. AddNode(ClanAux,node)#Aqui se hace pack segun donde deba compactarse
  442. Clan.remove_node(NonVisibleClans[0])
  443. Clan.add_clan(ClanAux)
  444. else:
  445. #print 'Hay un nodo/clan (pero no forma clan con el) o mas nodos/clanes no visibles desde node'
  446. Clan.add_node(node)
  447. Clan.remove_nodes_from(NonVisibleClans)
  448. S = Split(NonVisibleClans,node)
  449. #print 'Nuevos nodos', S[1]
  450. Clan.add_nodes_from(S[1])
  451. #print 'Nuevos clanes', S[2]
  452. for i in S[2]:
  453. CG = ClanGenerator(i)
  454. Clan.add_clan(CG)
  455. #print 'Nodos en el Clan despues de Split', Clan.nodes
  456.  
  457. elif EdgesHaveSameColor(VisibleClans):
  458. #print 'El nodo ve a todos los elementos del clan primitive del mismo color.'
  459. NodesInVisibleClans =Clan.nodes[:]
  460. Clan.remove_nodes_from(NodesInVisibleClans)
  461. Clan.add_node(node)
  462. Clan.clantype = 'complete'
  463.  
  464. NewClan= MyClan('primitive')
  465. NewClan.add_nodes_from(NodesInVisibleClans)
  466. Clan.add_clan(NewClan)
  467. Pack(NodesInVisibleClans)#Se compactan porque ya el node los esta compactando.
  468. else:
  469. #print 'Buscar si hace clan con alguno y sino colocarlo como un nodo mas'
  470. CW =ClanWith(Clan.nodes,node)
  471. if CW[0]:
  472. #print 'hizo clan con un node/clan'
  473. if '[' in CW[1]:
  474. #print 'hizo clan con un clan'
  475. AuxClan = Clan.getclanwithnodes(CW[1])
  476. Clan.remove_clan(AuxClan)
  477. else:
  478. #print 'hizo clan con un nodo'
  479. AuxClan=MyClan('complete')
  480. AuxClan.add_node(CW[1])
  481. Clan.remove_node(CW[1])
  482.  
  483. AddNode(AuxClan,node)
  484. Pack(AuxClan.nodes)
  485. Clan.add_clan(AuxClan)
  486.  
  487. else:
  488. #print 'no hizo clan, solo se agrega el nodo y el clan se mantiene primitive'
  489. Clan.add_node(node)
  490.  
  491. class MyClan:
  492.  
  493. def __init__ (self,typeof):
  494. self.clantype = typeof
  495. self.nodes=[]
  496. self.clanlist = []
  497.  
  498. def nodes(self):
  499. return self.nodes
  500.  
  501. def remove_node(self,node):
  502. self.nodes.remove(node)
  503.  
  504. def add_node(self,node):
  505. self.nodes.append(node)
  506.  
  507. def add_nodes_from(self,nodelist):
  508. for n in nodelist:
  509. self.nodes.append(n)
  510.  
  511. def remove_nodes_from(self,nodelist):
  512. for n in nodelist:
  513. self.nodes.remove(n)
  514.  
  515. def add_clan(self, clan):
  516. self.add_node(clan.nodes)
  517. self.clanlist.append(clan)
  518.  
  519. def remove_clan(self,clan):
  520. self.remove_node(clan.nodes)
  521. self.clanlist.remove(clan)
  522.  
  523. def getclanwithnodes(self,nodes):
  524. for k in self.clanlist:
  525. print 'lista de nodes en clanes:', k.nodes, type(k.nodes)
  526. print 'los nodos que se buscan:',nodes, type(nodes)
  527.  
  528. found = False
  529. c = 0
  530. while not found and c < len(self.clanlist):
  531. #if nodes == self.clanlist[c].nodes:
  532. if nodes == str(self.clanlist[c].nodes):
  533. found = True
  534. else:
  535. c+=1
  536. if found:
  537. return self.clanlist[c]
  538. else:
  539. print 'no se encontro el clan'
  540.  
  541. class Edge:
  542. def __init__ (self, labelFrom,sep,labelTo):
  543. self.label = labelFrom+sep+labelTo
  544. self.labelFrom = labelFrom
  545. self.labelTo = labelTo
  546.  
  547. def __str__(self):
  548. return self.label
  549.  
  550. def EdgeFrom(self):
  551. return self.labelFrom
  552.  
  553. def EdgeTo(self):
  554. return self.labelTo
  555.  
  556.  
  557.  
  558. """
  559. MakeSet(x) initializes the decomposition
  560. Find(x) returns representative object of the set containing x
  561. Union(x,y) makes two sets containing x and y respectively into one set
  562. """
  563.  
  564. def MakeSet(x):
  565. x.parent = x
  566. x.rank = 0
  567.  
  568. def Union(x, y):
  569. xRoot = Find(x)
  570. yRoot = Find(y)
  571. if xRoot.rank > yRoot.rank:
  572. yRoot.parent = xRoot
  573. elif xRoot.rank < yRoot.rank:
  574. xRoot.parent = yRoot
  575. elif xRoot != yRoot: # Unless x and y are already in same set, merge them
  576. yRoot.parent = xRoot
  577. xRoot.rank = xRoot.rank + 1
  578.  
  579. def Find(x):
  580. if x.parent == x:
  581. return x
  582. else:
  583. x.parent = Find(x.parent)
  584. return x.parent
  585. ''''''''''''''''''
  586.  
  587. def ElementInX(x,ElementsList): #regresa los elementos de ElementsList que tienen raiz x
  588. xRoot=Find(x)
  589. l=[]
  590. for i in range(xRoot.rank+1):
  591. l.append([])
  592. for element in ElementsList:
  593. if str(Find(element))== str(x):
  594. l[element.rank].append(str(element))
  595. return l
  596.  
  597. def ConstructColorTrees(ColorMatrix,EdgesNodes):
  598. ListColors = []
  599. ListParents= []
  600. for i in range(len(ColorMatrix)):
  601. for j in range(len(ColorMatrix[i])):
  602. FromTo=str(i)+','+str(j)
  603. n = Edge(str(i),',',str(j))
  604. #n = Edge(FromTo)
  605. EdgesNodes.append(n)
  606. MakeSet(n)
  607. if ColorMatrix[i][j] in ListColors:
  608. Index= ListColors.index(ColorMatrix[i][j])
  609. Union(ListParents[Index],n)
  610. else:
  611. ListParents.append(n)
  612. ListColors.append(ColorMatrix[i][j])
  613.  
  614. for i in ListParents:
  615. print ElementInX(i,EdgesNodes)
  616. return ListParents,ListColors
  617. #Usa Pack 1
  618. #MyGraph_1=[['None','black','blue','black','black','black','black'],['black','None','red','black','black','black','black'],['blue','red','None','black','black','black','black'],['black','black','black','None','blue','blue','blue'],['black','black','black','blue','None','black','red'],['black','black','black','blue','black','None','blue'],['black','black','black','blue','red','blue','None']]
  619. #Usa Split/Pack/ClanWith uno no visible
  620. #MyGraph_1=[['None','black','black','red','black','red','red'],['black','None','blue','red','black','red','black'],['black','blue','None','red','black','red','red'],['red','red','red','None','black','red','blue'],['black','black','black','black','None','blue','black'],['red','red','red','red','blue','None','red'],['red','black','red','blue','black','red','None']]
  621. #Pack/ClanWith un nodo visible(el ultimo) 3
  622. #MyGraph_1=[['None','red','blue','blue'],['red','None','black','black'],['blue','black','None','black'],['blue','black','black','None']]
  623. #Pack/ClanWith un clan visible(el ultimo) 4
  624. #MyGraph_1=[['None','red','blue','blue','blue','blue'],['red','None','black','black','black','black'],['blue','black','None','red','red','black'],['blue','black','red','None','red','black'],['blue','black','red','red','None','black'],['blue','black','black','black','black','None']]
  625. #Pack/ClanWith un clan visible(el ultimo) 5
  626. #MyGraph_1=[['None','red','blue','blue','blue','blue'],['red','None','black','black','black','black'],['blue','black','None','red','red','red'],['blue','black','red','None','red','red'],['blue','black','red','red','None','red'],['blue','black','red','red','red','None']]
  627. #primitive y el ultimo nodo no ve a varios nodos 6
  628. #MyGraph_1=[['None','red','blue','black','red','blue','black'],['red','None','black','red','blue','black','red'],['blue','black','None','blue','black','red','blue'],['black','red','blue','None','red','blue','black'],['red','blue','black','red','None','black','blue'],['blue','black','red','blue','black','None','red'],['black','red','blue','black','blue','red','None']]
  629. #2 clanes no visibles 7
  630. #MyGraph_1=[['None','red','red','red','black','red','red','red','black'],['red','None','red','red','red','red','red','red','black'],['red','red','None','black','red','red','red','black','red'],['red','red','black','None','red','red','red','black','black'],['black','red','red','red','None','red','red','red','red'],['red','red','red','red','red','None','black','red','red'],['red','red','red','red','red','black','None','red','red'],['red','red','black','black','red','red','red','None','black'],['black','black','red','black','red','red','red','black','None']]
  631. EdgesNodes =[]
  632. CCT=ConstructColorTrees(MyGraph_1,EdgesNodes)
  633.  
  634. '''
  635. EdgesNodes tiene objetos Edge, sobre los cuales operan directamente MakeSet, y asi Find y Union
  636. '''
  637.  
  638. ActualClan = MyClan('complete')
  639. ActualClan.add_node(str(0))
  640. for i in range(1,len(MyGraph_1)):
  641. AddNode(ActualClan,str(i))
  642. #ActualClan.add_node(str(i))
  643.  
  644. print ActualClan.nodes
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!