Me desperté al final de la tarde y decidí: es todo el tiempo, es hora de crear una nueva función en mi biblioteca . Y para uno y verifique el gráfico para ver los ciclos para arreglar y acelerar. Para el almuerzo de la mañana hice una nueva función, mejoré el código, hice la representación gráfica en una forma conveniente, y llegué al problema de encontrar todos los ciclos simples en el gráfico. Bebí una taza de agua fría, abrí Google, escribí "buscar todos los ciclos simples en un gráfico" y vi ...

No vi mucho ... aunque solo eran las 4 de la mañana. Un par de enlaces a algoritmos link1 , link2 y muchas sugerencias queEs hora de dormirPuede haber muchos ciclos en el gráfico y, en el caso general, el problema no tiene solución. Y otra pregunta sobre Habré sobre este tema, cuya respuesta tampoco me salvó: ya conocía la búsqueda en profundidad.

Pero una vez que haya resuelto, incluso NP resolverá un problema difícil en P , cuanto más bebo agua, no café, y no puede terminar abruptamente. Y sabía que dentro del marco de mi tarea, debería ser posible encontrar todos los ciclos en poco tiempo, sin supercomputadoras, no el orden de magnitud para mí.

Pasemos un poco del detective y comprendamos por qué lo necesito.

¿Qué es esta biblioteca?

La biblioteca llamada DITranquility está escrita en Swift y su tarea es inyectar dependencias . La biblioteca hace frente a la tarea de inyección de dependencia con una explosión, tiene capacidades que otras bibliotecas Swift no pueden y lo hace con buena velocidad.

Pero, ¿por qué debería adquirir el hábito de verificar los bucles en el gráfico de dependencia?

Por el bien de killerfichi: si la biblioteca realiza la funcionalidad principal con una explosión, entonces está buscando formas de mejorarla y mejorarla. Un killefic está verificando la corrección del gráfico de dependencia: es un conjunto de verificaciones diferentes que le permiten evitar problemas durante la ejecución, lo que ahorra tiempo de desarrollo. Y la comprobación de ciclos se destaca por separado entre todas las comprobaciones, ya que esta operación lleva mucho más tiempo. Y hasta hace poco, incivilizado más tiempo.

, , , . , "Graph API" . "Graph API" — , :

• - . , , , .
• , - — graphvis.
• .

— , ...

, :

• MacBook pro 2019, 2,6 GHz 6-Core i7, 32 Gb, Xcode 11.4, Swift 5.2
• Swift 300+ ( )
• 900
• 2000
• 40
• 7000

debug , release, debug.

, 95 .

1.

. , .

, . Graph API , , . . , , , .

, , — . , , , :

• — , .
• — ,
• —

, , , . , — , . — ?

, - :

Graph:
    vertices: [Vertex]
    adjacencyList: [[Edge]]

Vertex:
    more information about vertex

Edge:
    toIndices: [Int]
    information about edge

Vertex , Edge , , .

, . , , , , .

2.

, 4 , , , , , — " , , ". :

func findAllCycles() -> [Cycle] {
  result: [Cycle] = []
  for index in vertices {
    result += findCycles(from: index)
  }

  return result
}

func findCycles(from index: Int) -> [Cycle] {
  result: [Cycle] = []
  dfs(startIndex: index, currentIndex: index, visitedIndices: [], result: &result)

  return result
}

func dfs(startIndex: Int,
         currentIndex: Int,
         // visitedIndices   
         visitedIndices: Set<Int>,
         // result   -  
         result: ref [Cycle]) {
  if currentIndex == startIndex && !visitedIndices.isEmpty {
    result.append(cycle)
    return
  }

  if visitedIndices.contains(currentIndex) {
    return
  }

  visitedIndices += [currentIndex]

  for toIndex in adjacencyList[currentIndex] {
    dfs(startIndex: startIndex, currentIndex: toIndex, visitedIndices: visitedIndices, result: &result)
  }
}

, 10 … , , — - ...

, — ? , ? , dfs , 30 . 900 * 1000000 = 900.000.000 dfs…

? , , … ZZzzz...

3.

, , , , , - … , , , !

, , , , . — , , . , , , - :

func findAllCycles() -> [Cycle] {
  globalVisitedIndices: Set<Int> = []
  result: [Cycle] = []
  for index in vertices {
    if globalVisitedIndices.containts(index) {
      continue
    }
    result += findCycles(from: index, globalVisitedIndices: &globalVisitedIndices)
  }

  return result
}

func findCycles(from index: Int, globalVisitedIndices: ref Set<Int>) -> [Cycle] {
  result: [Cycle] = []
  dfs(currentIndex: index, visitedIndices: [], globalVisitedIndices, &globalVisitedIndices, result: &result)

  return result
}

func dfs(currentIndex: Int,
         // visitedIndices   
         visitedIndices: Set<Int>,
         // globalVisitedIndices   -  
         globalVisitedIndices: ref Set<Int>,
         // result   -  
         result: ref [Cycle]) {

  if visitedIndices.contains(currentIndex) {
    //  visitedIndices ,   ,     
    result.append(cycle)
    return
  }

  visitedIndices += [currentIndex]

  for toIndex in adjacencyList[currentIndex] {
    dfs(currentIndex: toIndex, visitedIndices: visitedIndices, globalVisitedIndices: &globalVisitedIndices, result: &result)
  }
}

" , " … . 10 , , , , :

• , , , .
• "" — , .

, . , , .

4.

, . , , , , , , . , ? . , , run… , — , … , … … , . :

if visitedIndices.contains(currentIndex) {

, , . :

B->E->C , if . , :

A->B->E->C->B!.. C, . A->B->D->A.

A->C->B->D->A , C .

, dfs , .

5.

, . , , , dfs 30 , 1-2 . :

"Big" - , A.

! Big C, , A B, , C , , A.

? , , , . . O(N^2) , .

, :

func findAllCycles() -> [Cycle] {
  reachableIndices: [Set<Int>] = findAllReachableIndices()
  result: [Cycle] = []
  for index in vertices {
    result += findCycles(from: index, reachableIndices: &reachableIndices)
  }

  return result
}

func findAllReachableIndices() -> [Set<Int>] {
  reachableIndices: [Set<Int>] = []
  for index in vertices {
    reachableIndices[index] = findAllReachableIndices(for: index)
  }
  return reachableIndices
}

func findAllReachableIndices(for startIndex: Int) -> Set<Int> {
  visited: Set<Int> = []
  stack: [Int] = [startIndex]
  while fromIndex = stack.popFirst() {
    visited.insert(fromIndex)

    for toIndex in adjacencyList[fromIndex] {
      if !visited.contains(toIndex) {
        stack.append(toIndex)
      }
    }
  }

  return visited
}

func findCycles(from index: Int, reachableIndices: ref [Set<Int>]) -> [Cycle] {
  result: [Cycle] = []
  dfs(startIndex: index, currentIndex: index, visitedIndices: [], reachableIndices: &reachableIndices, result: &result)

  return result
}

func dfs(startIndex: Int,
         currentIndex: Int,
         visitedIndices: Set<Int>,
         reachableIndices: ref [Set<Int>],
         result: ref [Cycle]) {
  if currentIndex == startIndex && !visitedIndices.isEmpty {
    result.append(cycle)
    return
  }

  if visitedIndices.contains(currentIndex) {
    return
  }

  if !reachableIndices[currentIndex].contains(startIndex) {
    return
  }

  visitedIndices += [currentIndex]

  for toIndex in adjacencyList[currentIndex] {
    dfs(startIndex: startIndex, currentIndex: toIndex, visitedIndices: visitedIndices, result: &result)
  }
}

, , , 5 — . — 15 , 6-7 . , , , — .

6. ?

, , — - . , , - .

, , , .

— " , , , ?". . 5 .

, 250, , , :

func findAllCycles() -> [Cycle] {
  reachableIndices: [Set<Int>] = findAllReachableIndices()
  result: [Cycle] = []
  for index in vertices {
    result += findCycles(from: index, reachableIndices: &reachableIndices)
  }

  return result
}

func findAllReachableIndices() -> [Set<Int>] {
  reachableIndices: [Set<Int>] = []
  for index in vertices {
    reachableIndices[index] = findAllReachableIndices(for: index)
  }
  return reachableIndices
}

func findAllReachableIndices(for startIndex: Int) -> Set<Int> {
  visited: Set<Int> = []
  stack: [Int] = [startIndex]
  while fromIndex = stack.popFirst() {
    visited.insert(fromIndex)

    for toIndex in adjacencyList[fromIndex] {
      if !visited.contains(toIndex) {
        stack.append(toIndex)
      }
    }
  }

  return visited
}

func findCycles(from index: Int, reachableIndices: ref [Set<Int>]) -> [Cycle] {
  result: [Cycle] = []
  dfs(startIndex: index, currentIndex: index, visitedIndices: [], reachableIndices: &reachableIndices, result: &result)

  return result
}

func dfs(startIndex: Int,
         currentIndex: Int,
         visitedIndices: Set<Int>,
         reachableIndices: ref [Set<Int>],
         result: ref [Cycle]) {
  if currentIndex == startIndex && !visitedIndices.isEmpty {
    result.append(cycle)
    return
  }

  if visitedIndices.contains(currentIndex) {
    return
  }

  if currentIndex < startIndex || !reachableIndices[currentIndex].contains(startIndex) {
    return
  }

  visitedIndices += [currentIndex]

  for toIndex in adjacencyList[currentIndex] {
    dfs(startIndex: startIndex, currentIndex: toIndex, visitedIndices: visitedIndices, result: &result)
  }
}

: if currentIndex < startIndex.

, run, , — … 6 ? , … .

, , , . — , A, , A . A, .

, , /.

— , . 5-10% .

6.

5-6 , , ! . , Swift , .

, , 6 … , . — " ? ...". — . — , .

3 , , . , Apple , (, , ). Swift popLast(), . .

var visited: Set<Int> = []
var stack: [Int] = [startVertexIndex]
while let fromIndex = stack.first {
  stack.removeFirst()

  visited.insert(fromIndex)
  for toIndex in graph.adjacencyList[fromIndex].flatMap({ $0.toIndices }) {
    if !visited.contains(toIndex) {
      stack.append(toIndex)
    }
  }
}

return visited

var visited: Set<Int> = []
var stack: [Int] = [startVertexIndex]
while let fromIndex = stack.popLast() {
  visited.insert(fromIndex)
  for toIndex in graph.adjacencyList[fromIndex].flatMap({ $0.toIndices }) {
    if !visited.contains(toIndex) {
      stack.insert(toIndex, at: 0)
    }
  }
}

return visited

, , — , Swift 5-10%.

? — 95 , 2.5-3 , .

, , — .

, , 15 , .

— , , , .

Swift .

, , , .

, "" -. , - :

• graphvis — .
• — , , , .
• , .

P.S. 5 , . , 1.5 — 4.5 . .

P.P.S. , . , , //.

UPD: . dot , .

.

UPD: banshchikov Donald B. Johnson. swift.

, .

:

El tiempo se midió solo para la búsqueda de ciclos. Una biblioteca de terceros convierte los datos de entrada en uno conveniente, pero dicha conversión no debería tomar más de 0.1 segundos. Y como puede ver, el tiempo difiere en un orden de magnitud (y en el lanzamiento en dos). Y una gran diferencia no puede atribuirse a una implementación no óptima.

• Como escribí, en mi biblioteca, los bordes no son solo una transición de un vértice a otro. Dicha información no se puede pasar a una implementación de terceros, por lo que el número de bucles encontrados no coincide. Debido a esto, se buscan los resultados para todos los ciclos únicos a lo largo de los vértices, excluyendo los bordes, para asegurarse de que el resultado coincida.