Saya bangun di sore hari dan memutuskan - sudah saatnya, saatnya untuk membuat fitur baru di perpustakaan saya . Dan untuk satu dan periksa grafik untuk siklus untuk memperbaiki dan mempercepat. Menjelang makan siang pagi saya membuat fitur baru, memperbaiki kode, membuat representasi grafik dalam bentuk yang mudah, dan sampai pada masalah menemukan semua siklus sederhana dalam grafik. Menghirup secangkir air dingin, saya membuka Google, mengetik "cari semua siklus sederhana dalam grafik" dan melihat ...

Saya tidak melihat banyak ... meskipun baru jam 4 pagi. Beberapa link ke algoritma link1 , link2 , dan banyak petunjuk bahwasaatnya untuk tidurMungkin ada banyak siklus dalam grafik, dan dalam kasus umum masalahnya tidak dapat dipecahkan. Dan pertanyaan lain tentang Habré tentang topik ini, jawaban yang tidak menyelamatkan saya juga - saya sudah tahu tentang pencarian secara mendalam.

Tetapi begitu saya selesai, bahkan NP akan memecahkan masalah yang sulit di P , semakin saya minum air, bukan kopi - dan itu tidak bisa berakhir dengan tiba-tiba. Dan saya tahu bahwa dalam kerangka tugas saya, seharusnya mungkin untuk menemukan semua siklus dalam waktu singkat, tanpa superkomputer - bukan urutan besarnya bagi saya.

Mari kita sedikit menyimpang dari detektif, dan memahami mengapa saya membutuhkannya.

Perpustakaan apa ini

Perpustakaan yang disebut DITranquility ditulis dalam Swift dan tugasnya adalah untuk menyuntikkan dependensi . Perpustakaan berupaya dengan tugas injeksi ketergantungan dengan bang, memiliki kemampuan yang tidak dapat dilakukan perpustakaan Swift lainnya, dan melakukannya dengan kecepatan yang baik.

Tetapi mengapa saya harus membiasakan memeriksa loop dalam grafik dependensi?

Demi killerfichi - jika perpustakaan melakukan fungsi utama dengan bang, maka Anda mencari cara untuk meningkatkannya dan membuatnya lebih baik. Sebuah killefic sedang memeriksa grafik ketergantungan untuk kebenaran - ini adalah serangkaian pemeriksaan berbeda yang memungkinkan Anda untuk menghindari masalah selama eksekusi, yang menghemat waktu pengembangan. Dan memeriksa siklus menonjol secara terpisah di antara semua pemeriksaan, karena operasi ini membutuhkan waktu lebih lama. Dan sampai saat ini, tidak beradab lebih banyak waktu.

, , , . , "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.

, .

:

Waktu diukur hanya untuk mencari siklus. Pustaka pihak ketiga mengubah data input menjadi data yang nyaman, tetapi konversi semacam itu seharusnya tidak lebih dari 0,1 detik. Dan seperti yang Anda lihat, waktu berbeda dengan urutan besarnya (dan dalam rilis oleh dua). Dan perbedaan besar seperti itu tidak dapat dikaitkan dengan implementasi yang tidak optimal.

• Seperti yang saya tulis, di perpustakaan saya, edge bukan hanya transisi dari satu titik ke titik lainnya. Informasi tersebut tidak dapat diteruskan ke implementasi pihak ketiga, sehingga jumlah loop yang ditemukan tidak cocok. Karena itu, hasilnya dicari semua siklus unik di sepanjang simpul, tidak termasuk tepi, untuk memastikan bahwa hasilnya cocok.