Π Π΅Π°Π»ΠΈΠ·Π°ΡΠΈΡ 3 Π°Π»Π³ΠΎΡΠΈΡΠΌΠΎΠ² ΠΏΠΎ ΠΏΠΎΠΈΡΠΊΡ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²Π° Π²Π»ΠΎΠΆΠ΅Π½Π½ΡΡ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² Π² Π·Π°Π΄Π°Π½Π½ΠΎΠΉ ΡΠΎΡΠΊΠ΅ Π½Π° ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΠ½ΠΎΠΉ ΠΏΠ»ΠΎΡΠΊΠΎΡΡΠΈ.
ΠΠ°Π½Ρ N
ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² ΠΈ M
ΡΠΎΡΠ΅ΠΊ Π½Π° ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΠ½ΠΎΠΉ ΠΏΠ»ΠΎΡΠΊΠΎΡΡΠΈ. Π₯ΡΠ°Π½Π΅Π½ΠΈΠ΅ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ²
ΠΏΡΠΎΠΈΡΡ
ΠΎΠ΄ΠΈΡ ΠΏΠΎ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΠ°ΠΌ ΡΠΎΡΠ΅ΠΊ Π»Π΅Π²ΠΎΠ³ΠΎ Π½ΠΈΠΆΠ½Π΅Π³ΠΎ (left
) ΠΈ ΠΏΡΠ°Π²ΠΎΠ³ΠΎ Π²Π΅ΡΡ
Π½Π΅Π³ΠΎ ΡΠ³Π»ΠΎΠ² (right
).
class Point (val x: Int, val y: Int)
class Rectangle (val left: Point, val right: Point)
ΠΠ»Ρ ΠΊΠ°ΠΆΠ΄ΠΎΠΉ ΠΈΠ· M
ΡΠΎΡΠ΅ΠΊ ΡΠ·Π½Π°ΡΡ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ Π²Π»ΠΎΠΆΠ΅Π½Π½ΡΡ
ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ².
ΠΠ»Ρ Π°Π²ΡΠΎΠΌΠ°ΡΠΈΠ·Π°ΡΠΈΠΈ ΠΈ ΡΡΠΊΠΎΡΠ΅Π½ΠΈΡ ΠΏΡΠΎΡΠ΅ΡΡΠ° ΡΠ΅ΡΡΠΈΡΠΎΠ²Π°Π½ΠΈΡ Π±ΡΠ»ΠΎ ΡΠ΅ΠΊΠΎΠΌΠ΅Π½Π΄ΠΎΠ²Π°Π½ΠΎ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΡ ΡΠΎΡΠΌΡΠ»Ρ Π΄Π»Ρ Π³Π΅Π½Π΅ΡΠ°ΡΠΈΠΈ Π·Π°Π΄Π°Π½Π½ΠΎΠ³ΠΎ ΡΠΈΡΠ»Π° ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² ΠΈ ΡΠΎΠΎΡΠ²Π΅ΡΡΡΠ²ΡΡΡΠ΅Π³ΠΎ Π½Π°Π±ΠΎΡΠ° ΡΠΎΡΠ΅ΠΊ.
Π€ΠΎΡΠΌΡΠ»Π° Π³Π΅Π½Π΅ΡΠ°ΡΠΈΠΈ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² ΠΏΠΎΠ΄ΡΠ°Π·ΡΠΌΠ΅Π²Π°Π΅Ρ ΡΠΎΠ·Π΄Π°Π½ΠΈΠ΅ N Π²Π»ΠΎΠΆΠ΅Π½Π½ΡΡ Π΄ΡΡΠ³ Π² Π΄ΡΡΠ³Π° ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ².
fun getRectanglesArray(n: Int) : Array<Rectangle> {
val rectangles: Array<Rectangle> = Array(n) { Rectangle(Point(0, 0), Point(0, 0)) }
for (i in 0 until n) {
rectangles[i] = Rectangle(Point(10 * i, 10 * i),
Point(10 * (2 * n - i), 10 * (2 * n - i)))
}
return rectangles
}
Π€ΠΎΡΠΌΡΠ»Π° Π³Π΅Π½Π΅ΡΠ°ΡΠΈΠΈ Π½Π°Π±ΠΎΡΠ° ΡΠΎΡΠ΅ΠΊ ΠΏΠΎΠ΄ΡΠ°Π·ΡΠΌΠ΅Π²Π°Π΅Ρ ΡΠΎΠ·Π΄Π°Π½ΠΈΠ΅ Π½Π΅ΡΠ»ΡΡΠ°ΠΉΠ½ΠΎΠ³ΠΎ Π½Π°Π±ΠΎΡΠ° ΡΠΎΡΠ΅ΠΊ ΡΠ°ΡΠΏΡΠ΅Π΄Π΅Π»ΡΠ½Π½ΡΡ
Π±ΠΎΠ»Π΅Π΅-ΠΌΠ΅Π½Π΅Π΅ ΡΠ°Π²Π½ΠΎΠΌΠ΅ΡΠ½ΠΎ ΠΏΠΎ Π½Π΅Π½ΡΠ»Π΅Π²ΠΎΠΌΡ ΠΏΠ΅ΡΠ΅ΡΠ΅ΡΠ΅Π½ΠΈΡ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² Ρ ΠΏΠΎΠΌΠΎΡΡΡ Ρ
Π΅Ρ ΡΡΠ½ΠΊΡΠΈΠΈ ΠΎΡ i
Ρ ΡΠ°Π·Π½ΡΠΌ Π±Π°Π·ΠΈΡΠΎΠΌ Π΄Π»Ρ x
ΠΈ y
((p * i)^31 % (20 * N)
, Π³Π΄Π΅ p
Π±ΠΎΠ»ΡΡΠΎΠ΅ ΠΏΡΠΎΡΡΠΎΠ΅, ΡΠ°Π·Π½ΠΎΠ΅ Π΄Π»Ρ x
ΠΈ y
).
fun getTestPointsArray(m: Int, n: Int) : Array<Point> {
val testPoints: Array<Point> = Array(m) { Point(0, 0) }
for (i in 0 until m) {
testPoints[i] = Point((((10007 * i).toDouble().pow(31)) % (20 * n)).toInt(),
((10009 * i).toDouble().pow(31) % (20 * n)).toInt())
}
return testPoints
}
ΠΠ»Π³ΠΎΡΠΈΡΠΌ Π½Π΅ ΠΏΠΎΠ΄ΡΠ°Π·ΡΠΌΠ΅Π²Π°Π΅Ρ Π΄ΠΎΠΏΠΎΠ»Π½ΠΈΡΠ΅Π»ΡΠ½ΠΎΠΉ ΠΎΠ±ΡΠ°Π±ΠΎΡΠΊΠΈ Π΄Π°Π½Π½ΡΡ ΠΏΠ΅ΡΠ΅Π΄ Π½Π°ΡΠ°Π»ΠΎΠΌ ΠΏΠΎΠΈΡΠΊΠ° ΠΎΡΠ²Π΅ΡΠΎΠ² ΠΊ Π·Π°Π΄Π°Π½Π½ΡΠΌ ΡΠΎΡΠΊΠ°ΠΌ. ΠΠ΅ΡΡ ΡΠΌΡΡΠ» Π΄Π°Π½Π½ΠΎΠ³ΠΎ Π°Π»Π³ΠΎΡΠΈΡΠΌΠ° Π² ΠΏΠΎΠΎΡΠ΅ΡΡΠ΄Π½ΠΎΠΌ ΠΏΠ΅ΡΠ΅Π±ΠΎΡΠ΅ ΠΊΠ°ΠΆΠ΄ΠΎΠ³ΠΎ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ° ΠΈ ΠΏΡΠΎΠ²Π΅ΡΠΊΠ΅ Π²ΡΠΏΠΎΠ»Π½Π΅Π½ΠΈΡ ΡΡΠ»ΠΎΠ²ΠΈΡ Π½Π° ΡΠΎ, Π»Π΅ΠΆΠΈΡ Π»ΠΈ ΡΠΎΡΠΊΠ° Π² Π³ΡΠ°Π½ΠΈΡΠ°Ρ ΡΠ΅ΠΊΡΡΠ΅Π³ΠΎ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ°.
fun bruteForceAlgorithm(rectangles: Array<Rectangle>, points: Array<Point>) : Array<Int> {
val answersForPoints = Array(points.size) { 0 } // Array of answers to each given point
for (i in points.indices) {
for (j in rectangles.indices) {
if (points[i].x >= rectangles[j].left.x && points[i].x < rectangles[j].right.x &&
points[i].y >= rectangles[j].left.y && points[i].y < rectangles[j].right.y) {
answersForPoints[i]++
}
}
}
return answersForPoints
}
Π‘Π»ΠΎΠΆΠ½ΠΎΡΡΡ: O(N * M)
, Π³Π΄Π΅ N
- ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ², M
- ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΡΠΎΡΠ΅ΠΊ.
ΠΡΠΎΡΠΎΠΉ Π°Π»Π³ΠΎΡΠΈΡΠΌ ΠΏΠΎΠ΄ΡΠ°Π·ΡΠΌΠ΅Π²Π°Π΅Ρ Π΄ΠΎΠΏΠΎΠ»Π½ΠΈΡΠ΅Π»ΡΠ½ΡΡ ΠΏΡΠ΅Π΄ΠΎΠ±ΡΠ°Π±ΠΎΡΠΊΡ Π΄Π°Π½Π½ΡΡ Π² Π²ΠΈΠ΄Π΅ ΠΏΠΎΡΡΡΠΎΠ΅Π½ΠΈΡ ΡΠΆΠ°ΡΠΎΠΉ ΠΊΠ°ΡΡΡ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² Π½Π° ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΠ½ΠΎΠΉ ΠΏΠ»ΠΎΡΠΊΠΎΡΡΠΈ.
ΠΠ»Ρ Π½Π°ΡΠ°Π»Π° Π½Π΅ΠΎΠ±Ρ
ΠΎΠ΄ΠΈΠΌΠΎ ΡΠΆΠ°ΡΡ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΡ Π½Π°ΡΠΈΡ
ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² ΠΏΠΎ ΠΎΠ±Π΅ΠΈΠΌ ΠΎΡΡΠΌ. ΠΠ»Ρ ΡΡΠΎΠ³ΠΎ Π·Π°ΠΏΠΈΡΠ΅ΠΌ
Π²ΡΠ΅ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΡ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² ΠΏΠΎ x
Π² ΠΌΠ°ΡΡΠΈΠ² ΠΈΠΊΡΠΎΠ² zippedX
, Π° ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΡ ΠΏΠΎ y
Π² ΠΌΠ°ΡΡΠΈΠ²
zippedY
. ΠΠ°Π»Π΅Π΅ ΠΎΡΡΠΎΡΡΠΈΡΡΠ΅ΠΌ ΠΈΡ
ΠΏΠΎ Π²ΠΎΠ·ΡΠ°ΡΡΠ°Π½ΠΈΡ ΠΈ ΠΈΠ·Π±Π°Π²ΠΈΠΌΡΡ ΠΎΡ ΠΏΠΎΠ²ΡΠΎΡΠ΅Π½ΠΈΠΉ. ΠΠ° Π²ΡΡ
ΠΎΠ΄Π΅ ΠΏΠΎΠ»ΡΡΠ°Π΅ΠΌ Π΄Π²Π° ΠΌΠ°ΡΡΠΈΠ²Π°, Π² ΠΊΠΎΡΠΎΡΡΡ
ΠΈΠ½Π΄Π΅ΠΊΡΡ Π±ΡΠ΄ΡΡ ΡΠ²Π»ΡΡΡΡΡ ΡΠΆΠ°ΡΡΠΌΠΈ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΠ°ΠΌΠΈ.
fun getZippedCoordinates(rectangles: Array<Rectangle>) : Pair<List<Int>, List<Int>> {
val zippedX = Array(rectangles.size * 2) { 0 }
val zippedY = Array(rectangles.size * 2) { 0 }
var j = 0
// get zipped coordinates for building matrix
for (rectangle in rectangles) {
zippedX[j] = rectangle.left.x
zippedY[j] = rectangle.left.y
zippedX[j + 1] = rectangle.right.x
zippedY[j + 1] = rectangle.right.y
j += 2
}
// sorting zipped coordinates
zippedX.sort()
zippedY.sort()
return Pair(zippedX.distinct(), zippedY.distinct())
}
ΠΠΎΡΠ»Π΅ ΡΠΆΠ°ΡΠΈΡ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°Ρ ΠΌΠΎΠΆΠ½ΠΎ ΠΏΡΠΈΡΡΡΠΏΠ°ΡΡ ΠΊ Π·Π°ΠΏΠΎΠ»Π½Π΅Π½ΠΈΡ ΠΌΠ°ΡΡΠΈΡΡ ΠΊΠ°ΡΡΡ. ΠΠ»Ρ ΠΊΠ°ΠΆΠ΄ΠΎΠ³ΠΎ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ° ΠΈΡΠ΅ΠΌ ΠΈΠ½Π΄Π΅ΠΊΡΡ Π² ΠΌΠ°ΡΡΠΈΡΠ΅ ΠΏΠΎ ΡΠΆΠ°ΡΡΠΌ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΠ°ΠΌ ΠΈ Π΄Π΅Π»Π°Π΅ΠΌ +1 Π² Π½Π°ΠΉΠ΄Π΅Π½Π½ΡΡ Π³ΡΠ°Π½ΠΈΡΠ°Ρ .
fun generateMap(rectangles: Array<Rectangle>, zippedX: List<Int>, zippedY: List<Int>) : Array<Array<Int>> {
// creating empty map
val mapMatrix = Array(zippedY.size) { Array(zippedX.size) { 0 } }
// filling map
for (rectangle in rectangles) {
val indexStartX = findPosition(zippedX, rectangle.left.x)
val indexStartY = findPosition(zippedY, rectangle.left.y)
val indexEndX = findPosition(zippedX, rectangle.right.x)
val indexEndY = findPosition(zippedY, rectangle.right.y)
for (i in indexStartY until indexEndY) {
for (j in indexStartX until indexEndX) {
mapMatrix[i][j]++
}
}
}
return mapMatrix
}
Π‘Π»ΠΎΠΆΠ½ΠΎΡΡΡ ΠΏΠΎΠ΄Π³ΠΎΡΠΎΠ²ΠΊΠΈ: O(N^3)
, Π³Π΄Π΅ N
- ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ².
ΠΠ° ΡΡΠΎΠΌ ΠΏΡΠ΅Π΄ΠΎΠ±ΡΠ°Π±ΠΎΡΠΊΠ° Π·Π°Π²Π΅ΡΡΠ΅Π½Π°, ΠΌΠΎΠΆΠ½ΠΎ ΠΏΡΠ΅ΡΡΡΠΏΠ°ΡΡ ΠΊ ΠΏΠΎΠΈΡΠΊΡ ΠΎΡΠ²Π΅ΡΠΎΠ² ΠΊ ΡΠΎΡΠΊΠ°ΠΌ. ΠΠ°ΠΌ Π½Π΅ΠΎΠ±Ρ ΠΎΠ΄ΠΈΠΌΠΎ ΠΎΠΏΡΠ΅Π΄Π΅Π»ΠΈΡΡ ΡΠ°ΡΠΏΠΎΠ»ΠΎΠΆΠ΅Π½ΠΈΠ΅ ΡΠΎΡΠΊΠΈ Π½Π° Π½Π°ΡΠ΅ΠΉ ΠΊΠ°ΡΡΠ΅. ΠΠ»Ρ ΡΡΠΎΠ³ΠΎ Π½ΡΠΆΠ½ΠΎ Π½Π°ΠΉΡΠΈ ΠΈΠ½Π΄Π΅ΠΊΡΡ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°Ρ ΡΠΎΡΠΊΠΈ Π² ΠΌΠ°ΡΡΠΈΠ²Π΅ ΡΠΆΠ°ΡΡΡ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°Ρ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ². ΠΡΠ²Π΅Ρ Π΄Π»Ρ ΡΠΎΡΠΊΠΈ Π±ΡΠ΄Π΅Ρ Π»Π΅ΠΆΠ°ΡΡ Π² Π½Π°ΡΠ΅ΠΉ ΠΌΠ°ΡΡΠΈΡΠ΅ (ΠΊΠ°ΡΡΠ΅) ΠΏΠΎ ΠΏΠΎΠ»ΡΡΠ΅Π½Π½ΡΠΌ ΠΈΠ½Π΄Π΅ΠΊΡΠ°ΠΌ.
fun getAnswersFromMap(mapMatrix: Array<Array<Int>>, points: Array<Point>, zippedX: List<Int>, zippedY: List<Int>) : Array<Int> {
val answersForPoints = Array(points.size) { 0 }
for (i in points.indices) {
val positionX = findPosition(zippedX, points[i].x) // get indexes of point position on the map
val positionY = findPosition(zippedY, points[i].y) //
if (positionX == -1 || positionY == -1) { // if point out of borders
answersForPoints[i] = 0
} else {
answersForPoints[i] = mapMatrix[positionY][positionX]
}
}
return answersForPoints
}
Π‘Π»ΠΎΠΆΠ½ΠΎΡΡΡ ΠΎΡΠ²Π΅ΡΠ°: O(M*logN)
, Π³Π΄Π΅ M
- ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΡΠΎΡΠ΅ΠΊ, N
- ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ².
Π’ΡΠ΅ΡΠΈΠΉ Π°Π»Π³ΠΎΡΠΈΡΠΌ ΡΠ°ΠΊΠΆΠ΅ ΠΏΠΎΠ΄ΡΠ°Π·ΡΠΌΠ΅Π²Π°Π΅Ρ ΠΏΡΠ΅Π΄ΠΎΠ±ΡΠ°Π±ΠΎΡΠΊΡ Π²Ρ ΠΎΠ΄Π½ΡΡ Π΄Π°Π½Π½ΡΡ Π² Π²ΠΈΠ΄Π΅ ΡΠΆΠ°ΡΠΈΡ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°Ρ, ΡΠΎΠ»ΡΠΊΠΎ Π² ΡΡΠΎΠΌ ΡΠ»ΡΡΠ°Π΅ Π²ΠΌΠ΅ΡΡΠΎ ΠΊΠ°ΡΡΡ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² Π±ΡΠ΄Π΅Ρ ΡΡΡΠΎΠΈΡΡΡΡ ΠΏΠ΅ΡΡΠΈΡΡΠ΅Π½ΡΠ½ΠΎΠ΅ Π΄Π΅ΡΠ΅Π²ΠΎ ΠΎΡΡΠ΅Π·ΠΊΠΎΠ².
ΠΠ»Ρ ΡΠΆΠ°ΡΠΈΡ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°Ρ ΠΈΡΠΏΠΎΠ»ΡΠ·ΡΠ΅ΡΡΡ ΡΠ°ΠΆΠ΅ ΡΡΠ½ΠΊΡΠΈΡ, ΠΎΠΏΠΈΡΠ°Π½Π½Π°Ρ Π²ΡΡΠ΅ (ΡΠΌ. ΠΠ»Π³ΠΎΡΠΈΡΠΌ Π½Π° ΠΊΠ°ΡΡΠ΅ Ρ ΡΠΆΠ°ΡΡΠΌΠΈ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΠ°ΠΌΠΈ).
ΠΠΎΡΠ»Π΅ ΡΠΆΠ°ΡΠΈΡ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°Ρ Π½Π°ΠΌ Π½Π΅ΠΎΠ±Ρ
ΠΎΠ΄ΠΈΠΌΠΎ ΡΠΎΡΡΠ°Π²ΠΈΡΡ ΠΌΠ°ΡΡΠΈΠ² ΡΠΎΠ±ΡΡΠΈΠΉ, ΠΏΡΠΎΠΈΡΡ
ΠΎΠ΄ΡΡΠΈΡ
Π½Π° Π½Π°ΡΠ΅ΠΉ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΠ½ΠΎΠΉ ΠΏΠ»ΠΎΡΠΊΠΎΡΡΠΈ.
ΠΠΎΠ΄ ΡΠΎΠ±ΡΡΠΈΠ΅ΠΌ ΠΏΠΎΠ΄ΡΠ°Π·ΡΠΌΠ΅Π²Π°Π΅ΡΡΡ Π½Π°ΡΠ°Π»ΠΎ ΠΈΠ»ΠΈ ΠΊΠΎΠ½Π΅Ρ ΡΡΡΠ΅ΡΡΠ²ΠΎΠ²Π°Π½ΠΈΡ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ° Π½Π° ΠΏΠ»ΠΎΡΠΊΠΎΡΡΠΈ.
ΠΠ°ΠΆΠ΄ΠΎΠ΅ ΡΠΎΠ±ΡΡΠΈΠ΅ Π²ΠΊΠ»ΡΡΠ°Π΅Ρ Π² ΡΠ΅Π±Ρ x
ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΡ ΡΠΎΠ±ΡΡΠΈΡ, yBegin
- Π½ΠΈΠΆΠ½ΡΡ Π³ΡΠ°Π½ΠΈΡΡ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ°, yEnd
- Π²Π΅ΡΡ
Π½ΡΡ Π³ΡΠ°Π½ΠΈΡΡ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ°
ΠΈ status
ΠΎΠ±ΠΎΠ·Π½Π°ΡΠ°ΡΡΠΈΠΉ ΡΠΈΠΏ ΡΠΎΠ±ΡΡΠΈΡ (1
- Π½Π°ΡΠ°Π»ΠΎ, -1
- ΠΊΠΎΠ½Π΅Ρ).
class Event (val x: Int,
val yBegin: Int,
val yEnd: Int,
val status: Int)
ΠΠΎΡΠ»Π΅ ΡΠΎΡΡΠ°Π²Π»Π΅Π½ΠΈΡ ΠΌΠ°ΡΡΠΈΠ²Π° ΡΠΎΠ±ΡΡΠΈΠΉ ΡΡΡΠΎΠΈΠΌ ΠΏΡΡΡΠΎΠ΅ Π΄Π΅ΡΠ΅Π²ΠΎ ΠΎΡΡΠ΅Π·ΠΊΠΎΠ² Π½Π° ΠΌΠ°ΡΡΠΈΠ²Π΅ 0 Π΄Π»ΠΈΠ½Π½ΠΎΠΉ ΡΠ°Π²Π½ΠΎΠΉ ΠΌΠ°ΡΡΠΈΠ²Ρ ΡΠΆΠ°ΡΡΡ
ΠΈΠ³ΡΠ΅ΠΊΠΎΠ² zippedY
.
ΠΠ°Π»Π΅Π΅ ΠΈΠ΄ΡΠΌ ΠΏΠΎ ΠΌΠ°ΡΡΠΈΠ²Ρ ΡΠΎΠ±ΡΡΠΈΠΉ ΠΈ ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΠΌ ΠΎΠΏΠ΅ΡΠ°ΡΠΈΡ Π΄ΠΎΠ±Π°Π²Π»Π΅Π½ΠΈΡ Π½Π° Π΄Π΅ΡΠ΅Π²Π΅ ΠΎΡΡΠ΅Π·ΠΊΠΎΠ² Ρ ΡΠΎΠ·Π΄Π°Π½ΠΈΠ΅ΠΌ Π½ΠΎΠ²ΡΡ
ΠΏΠ΅ΡΡΠΈΡΡΠ΅Π½ΡΠ½ΡΡ
ΡΠ·Π»ΠΎΠ² ΠΏΡΠΈ ΠΈΠ·ΠΌΠ΅Π½Π΅Π½ΠΈΠΈ.
Π ΡΠ»ΡΡΠ°Π΅ Π΅ΡΠ»ΠΈ status
Ρ Event
ΡΠ°Π²Π΅Π½ 1, ΡΠΎ ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡΡΡ
ΠΎΠΏΠ΅ΡΠ°ΡΠΈΡ +1
Π½Π° ΠΎΡΡΠ΅Π·ΠΊΠ΅ [yBegin; yEnd]
, ΠΈΠ½Π°ΡΠ΅ Π΅ΡΠ»ΠΈ status
ΡΠ°Π²Π΅Π½ -1 ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡΡΡ ΠΎΠΏΠ΅ΡΠ°ΡΠΈΡ -1
Π½Π° ΠΎΡΡΠ΅Π·ΠΊΠ΅.
Π Π΅Π°Π»ΠΈΠ·Π°ΡΠΈΡ Π΄ΠΎΠ±Π°Π²Π»Π΅Π½ΠΈΡ:
fun add(node: Node, start: Int, end: Int, value: Int) : Node {
// if current node is in interval, return *new persistent* node
if (start <= node.leftIndex && node.rightIndex <= end) {
return Node(node.sum + value, node.left, node.right, node.leftIndex, node.rightIndex)
}
// if current node is not in interval, return node
if (node.rightIndex <= start || end <= node.leftIndex) {
return node
}
// creating *new persistent* node
val new = Node(node.sum, node.left, node.right, node.leftIndex, node.rightIndex)
// checking left node
new.left = add(new.left!!, start, end, value)
// checking right node
new.right = add(new.right!!, start, end, value)
// return *new persistent* node
return new
}
ΠΡΠΈ ΠΈΠ·ΠΌΠ΅Π½Π΅Π½ΠΈΠΈ Ρ Event
ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΡ ΠΏΠΎ x
Π΄ΠΎΠ±Π°Π²Π»ΡΠ΅ΠΌ ΡΠ΅ΠΊΡΡΠΈΠΉ ΠΏΠ΅ΡΡΠΈΡΡΠ΅Π½ΡΠ½ΡΠΉ ΠΊΠΎΡΠ΅Π½Ρ Π² ΠΌΠ°ΡΡΠΈΠ² roots
.
ΠΠΎΡΠ»Π΅ ΠΏΠ΅ΡΠ΅Π±ΠΎΡΠ° Π²ΡΠ΅Ρ
ΡΠΎΠ±ΡΡΠΈΠΉ ΠΌΠ°ΡΡΠΈΠ² roots
Π±ΡΠ΄Π΅Ρ Π΄Π»ΠΈΠ½Π½ΠΎΠΉ ΡΠ°Π²Π½ΠΎΠΉ ΠΌΠ°ΡΡΠΈΠ²Ρ zippedX
, ΡΠΎ Π΅ΡΡΡ Π½Π° ΠΊΠ°ΠΆΠ΄ΡΠΉ ΡΠΆΠ°ΡΡΠΉ
x
Ρ Π½Π°Ρ Π±ΡΠ΄Π΅Ρ ΡΠ²ΠΎΠΉ ΠΊΠΎΡΠ΅Π½Ρ Π² ΠΏΠ΅ΡΡΠΈΡΡΠ΅Π½ΡΠ½ΠΎΠΌ Π΄Π΅ΡΠ΅Π²Π΅ ΠΎΡΡΠ΅Π·ΠΊΠΎΠ².
Π‘Π»ΠΎΠΆΠ½ΠΎΡΡΡ ΠΏΠΎΠ΄Π³ΠΎΡΠΎΠ²ΠΊΠΈ: O(N*logN)
, Π³Π΄Π΅ N
- ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ².
ΠΠ»Ρ ΠΎΡΠ²Π΅ΡΠ° ΠΊ ΡΠΎΡΠΊΠ΅ Π½Π΅ΠΎΠ±Ρ
ΠΎΠ΄ΠΈΠΌΠΎ Π½Π°ΠΉΡΠΈ Π½ΡΠΆΠ½ΡΠΉ ΠΊΠΎΡΠ΅Π½Ρ Π² ΠΌΠ°ΡΡΠΈΠ²Π΅ roots
ΡΠ΅ΡΠ΅Π· ΠΏΠΎΠΈΡΠΊ Π½ΡΠΆΠ½ΠΎΠ³ΠΎ ΠΈΠ½Π΄Π΅ΠΊΡΠ° Π² ΠΌΠ°ΡΡΠΈΠ²Π΅ zippedX
ΠΈ ΡΠΏΡΡΡΠΈΡΡΡ
Π² Π΄Π΅ΡΠ΅Π²Π΅ Π΄ΠΎ Π½ΡΠΆΠ½ΠΎΠ³ΠΎ Π»ΠΈΡΡΠ°, ΡΠΎΠ±ΡΠ°Π² ΠΏΠΎ ΠΏΡΡΠΈ Π²ΡΠ΅ Π½ΡΠΆΠ½ΡΠ΅ ΠΌΠΎΠ΄ΠΈΡΠΈΠΊΠ°ΡΠΎΡΡ.
fun getAnswer(node: Node?, target: Int): Int {
// if node == null -> lower level reached
if (node != null) {
val mid = (node.leftIndex + node.rightIndex) / 2
return if (target < mid) {
node.sum + getAnswer(node.left, target)
} else {
node.sum + getAnswer(node.right, target)
}
}
return 0
}
fun getAnswersFromPersistentTree(points: Array<Point>, roots: Array<Node>, zippedX: List<Int>, zippedY: List<Int>) : Array<Int> {
val answersForPoints = Array(points.size) { 0 }
// searching answers for given points
for (i in points.indices) {
val positionX = findPosition(zippedX, points[i].x) // get indexes of point position on the map
val positionY = findPosition(zippedY, points[i].y) //
if (positionX == -1 || positionY == -1) { // if point out of borders
answersForPoints[i] = 0
} else {
answersForPoints[i] = getAnswer(roots[positionX], positionY)
}
}
return answersForPoints
}
Π‘Π»ΠΎΠΆΠ½ΠΎΡΡΡ ΠΎΡΠ²Π΅ΡΠ°: O(M*logN)
, Π³Π΄Π΅ M
- ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΡΠΎΡΠ΅ΠΊ, N
- ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ².
Π’Π΅ΡΡΠΈΡΠΎΠ²Π°Π½ΠΈΠ΅ Π²ΡΠ΅ΠΌΠ΅Π½ΠΈ ΡΠ°Π±ΠΎΡΡ Π°Π»Π³ΠΎΡΠΈΡΠΌΠΎΠ² ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΠ»ΠΎΡΡ Π½Π° ΡΠ»Π΅Π΄ΡΡΡΠ΅ΠΌ Π½Π°Π±ΠΎΡΠ΅ Π΄Π°Π½Π½ΡΡ :
- ΠΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² ΡΠ°Π²Π½ΠΎ
2^i
, Π³Π΄Π΅0 <= i <= 12
- ΠΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΡΠΎΡΠ΅ΠΊ Π΄Π»Ρ ΠΊΠ°ΠΆΠ΄ΠΎΠ³ΠΎ Π½Π°Π±ΠΎΡΠ° ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² ΠΎΠ΄ΠΈΠ½Π°ΠΊΠΎΠ²ΠΎ ΠΈ ΡΠ°Π²Π½ΠΎ
100000
Π’Π°ΠΊ ΠΊΠ°ΠΊ Ρ Π²ΡΠ΅Ρ Π°Π»Π³ΠΎΡΠΈΡΠΌΠΎΠ² ΡΠ°Π·Π»ΠΈΡΠ½Π°Ρ Π°ΡΠΈΠΌΠΏΡΠΎΡΠΈΠΊΠ° ΠΏΡΠ΅Π΄ΠΎΠ±ΡΠ°Π±ΠΎΡΠΊΠΈ ΠΈ ΠΎΡΠ²Π΅ΡΠ° Π½Π° Π·Π°ΠΏΡΠΎΡ, ΠΈΠ·ΠΌΠ΅ΡΠ΅Π½ΠΈΠ΅ Π²ΡΠ΅ΠΌΠ΅Π½ΠΈ ΡΠ°Π±ΠΎΡΡ ΡΡΠΈΡ Π΄Π²ΡΡ ΡΠ°ΡΡΠ΅ΠΉ Π±ΡΠ»ΠΎ ΡΠ°Π·Π΄Π΅Π»Π΅Π½ΠΎ.
ΠΠ· Π΄Π°Π½Π½ΠΎΠ³ΠΎ Π³ΡΠ°ΡΠΈΠΊΠ° Π²ΠΈΠ΄Π½ΠΎ, ΠΊΠ°ΠΊ Π±ΡΡΡΡΠΎ Π½Π°ΡΠΈΠ½Π°Π΅Ρ ΡΠ°ΡΡΠΈ Π²ΡΠ΅ΠΌΡ ΠΏΡΠ΅Π΄ΠΎΠ±ΡΠ°Π±ΠΎΡΠΊΠΈ Π΄Π°Π½Π½ΡΡ
Ρ ΡΠΎΡΡΠΎΠΌ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²Π° ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² Π²ΠΎ Π²ΡΠΎΡΠΎΠΌ Π°Π»Π³ΠΎΡΠΈΡΠΌΠ΅ (Π°Π»Π³ΠΎΡΠΈΡΠΌ Π½Π° ΠΊΠ°ΡΡΠ΅).
Π ΠΏΠ΅ΡΠ²ΡΡ ΠΎΡΠ΅ΡΠ΅Π΄Ρ ΡΡΠΎ ΠΏΡΠΎΠΈΡΡ
ΠΎΠ΄ΠΈΡ ΠΈΠ·-Π·Π° Π΄ΠΎΠ²ΠΎΠ»ΡΠ½ΠΎ Π±ΠΎΠ»ΡΡΠΎΠΉ Π°ΡΠΈΠΌΠΏΡΠΎΡΠΈΠΊΠΈ ΠΏΠΎΡΡΡΠΎΠ΅Π½ΠΈΡ ΠΊΠ°ΡΡΡ (O(N^3)
). ΠΠ½Π° ΠΏΠΎΠ»ΡΡΠ°Π΅ΡΡΡ ΠΈΠ·-Π·Π° ΡΠΎΠ³ΠΎ, ΡΡΠΎ
Π² Ρ
ΡΠ΄ΡΠ΅ΠΌ ΡΠ»ΡΡΠ°Π΅ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΠ΅ ΠΏΡΠΈΠ΄ΡΡΡΡ N
ΡΠ°Π· ΠΏΡΠΎΠΉΡΠΈΡΡ ΠΏΠΎ Π²ΡΠ΅ ΠΌΠ°ΡΡΠΈΡΠ΅ ΠΊΠ°ΡΡΡ ΡΠ°Π·ΠΌΠ΅ΡΠΎΠΌ N * N
ΠΈ ΡΠΆΠ΅ Π½Π° Π΄ΠΎΡΡΠ°ΡΠΎΡΠ½ΠΎ ΠΌΠ°Π»Π΅Π½ΡΠΊΠΈΡ
ΡΠΈΡΠ»Π°Ρ
Π±ΡΠ΄Π΅Ρ Π·Π°Π½ΠΈΠΌΠ°ΡΡ
ΠΎΠ³ΡΠΎΠΌΠ½ΠΎΠ΅ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ Π²ΡΠ΅ΠΌΠ΅Π½ΠΈ. Π§ΡΠΎ ΠΊΠ°ΡΠ°Π΅ΡΡΡ Π΄Π²ΡΡ
Π΄ΡΡΠ³ΠΈΡ
Π°Π»Π³ΠΎΡΠΈΡΠΌΠΎΠ², ΡΠΎ ΡΠΈΡΡΠ°ΡΠΈΡ ΠΎΠ±ΡΡΠΎΠΈΡ Π½Π°ΠΌΠ½ΠΎΠ³ΠΎ Π»ΡΡΡΠ΅. ΠΠΎΡΡΡΠΎΠ΅Π½ΠΈΠ΅ ΠΏΠ΅ΡΡΠΈΡΡΠ΅Π½ΡΠ½ΠΎΠ³ΠΎ Π΄Π΅ΡΠ΅Π²Π° ΠΎΡΡΠ΅Π·ΠΊΠΎΠ² Π½Π° ΠΎΡΠ΅Π½Ρ ΠΌΠ°Π»Π΅Π½ΡΠΊΠΈΡ
ΡΠΈΡΠ»Π°Ρ
Π·Π°Π½ΠΈΠΌΠ°Π΅Ρ ΡΡΠΎΠ»ΡΠΊΠΎ ΠΆΠ΅ ΡΠΊΠΎΠ»ΡΠΊΠΎ ΠΈ ΠΏΠΎΡΡΡΠΎΠ΅Π½ΠΈΠ΅ ΠΊΠ°ΡΡΡ, Π½ΠΎ Π³ΡΠ°ΡΠΈΠΊ ΡΠ°ΡΡΡΡ Π½Π°ΠΌΠ½ΠΎΠ³ΠΎ ΠΌΠ΅Π΄Π»Π΅Π½Π½Π΅Π΅, ΡΡΠΎ Π΄Π΅Π»Π°Π΅Ρ ΠΏΡΠ΅Π΄ΠΎΠ±ΡΠ°Π±ΠΎΡΠΊΡ Π°Π»Π³ΠΎΡΠΈΡΠΌΠ° Π½Π° Π΄Π΅ΡΠ΅Π²Π΅ Π±ΡΡΡΡΠ΅Π΅ ΠΊΠ°ΡΡΡ ΡΠΆΠ΅ Π½Π°
16 ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ°Ρ
ΠΈ Π² Π΄Π΅ΡΡΡΠΊΠΈ ΠΈ ΡΠΎΡΠ½ΠΈ ΡΠ°Π· Π±ΡΡΡΡΠ΅Π΅ Π½Π° Π±ΠΎΠ»ΡΡΠΈΡ
Π΄Π°Π½Π½ΡΡ
. ΠΠ»Π³ΠΎΡΠΈΡΠΌΡ ΠΏΠΎΠ»Π½ΠΎΠ³ΠΎ ΠΏΠ΅ΡΠ΅Π±ΠΎΡΠ° Π½Π΅ ΡΡΠ΅Π±ΡΠ΅ΡΡΡ ΠΊΠ°ΠΊΠ°Ρ-Π»ΠΈΠ±ΠΎ ΠΏΡΠ΅Π΄ΠΎΠ±ΡΠ°Π±ΠΎΡΠΊΠ°, ΠΏΠΎΡΡΠΎΠΌΡ Π²ΡΠ΅ΠΌΡ ~= 0.
ΠΠ° Π³ΡΠ°ΡΠΈΠΊΠ΅ Π²ΠΈΠ΄Π½ΠΎ, ΡΡΠΎ Π½Π° ΠΌΠ°Π»Π΅Π½ΡΠΊΠΈΡ
ΡΠΈΡΠ»Π°Ρ
Π²ΡΠ΅ Π°Π»Π³ΠΎΡΠΈΡΠΌΡ ΡΠ°Π±ΠΎΡΠ°ΡΡ ΠΏΡΠΈΠΌΠ΅ΡΠ½ΠΎ ΠΎΠ΄ΠΈΠ½ΠΎΠΊΠΎΠ³ΠΎ, Π½ΠΎ ΠΊΠ°ΠΊ ΡΠΎΠ»ΡΠΊΠΎ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ²
ΡΡΠ°Π½ΠΎΠ²ΠΈΡΡΡ >16
Π²ΡΠ΅ΠΌΡ ΡΠ°Π±ΠΎΡΡ Π°Π»Π³ΠΎΡΠΈΡΠΌΠ° ΠΏΠΎΠ»Π½ΠΎΠ³ΠΎ ΠΏΠ΅ΡΠ΅Π±ΠΎΡΠ° Π½Π°ΡΠΈΠ½Π°Π΅Ρ ΡΡΡΠ΅ΠΌΠΈΡΠ΅Π»ΡΠ½ΠΎ ΡΠ°ΡΡΠΈ, Π΄Π²Π° Π΄ΡΡΠ³ΠΈΡ
ΠΎΡΡΠ°ΡΡΡΡ ΠΏΡΠΈΠΌΠ΅ΡΠ½ΠΎ Π½Π° ΡΠΎΠΌ ΠΆΠ΅ ΡΡΠΎΠ²Π½Π΅.
ΠΠ°Π½Π½ΡΠΉ Π³ΡΠ°ΡΠΈΠΊ Π½Π°Π³Π»ΡΠ΄Π½ΠΎ ΠΏΠΎΠΊΠ°Π·ΡΠ²Π°Π΅Ρ, Π½Π°ΡΠΊΠΎΠ»ΡΠΊΠΎ ΡΠ»ΠΎΠΆΠ½ΠΎΡΡΡ ΠΎΡΠ²Π΅ΡΠ° Π΄Π»Ρ ΠΎΠ΄Π½ΠΎΠΉ ΡΠΎΡΠΊΠΈ ΠΏΠΎΠ»Π½ΡΠΌ ΠΏΠ΅ΡΠ΅Π±ΠΎΡΠΎΠΌ O(N)
Ρ
ΡΠΆΠ΅ ΡΠ»ΠΎΠΆΠ½ΠΎΡΡΠΈ ΠΎΡΠ²Π΅ΡΠ° ΠΏΠΎ ΠΏΡΠ΅Π΄Π²Π°ΡΠΈΡΠ΅Π»ΡΠ½ΠΎ ΠΏΠΎΠ΄Π³ΠΎΡΠΎΠ²Π»Π΅Π½Π½ΡΠΌ
Π΄Π°Π½Π½ΡΠΌ (Π² Π΄Π²ΡΡ
Π΄ΡΡΠ³ΠΈΡ
Π°Π»Π³ΠΎΡΠΈΡΠΌΠ°Ρ
ΡΠ»ΠΎΠΆΠ½ΠΎΡΡΡ ΠΎΡΠ²Π΅ΡΠ° Π΄Π»Ρ ΠΎΠ΄Π½ΠΎΠΉ ΡΠΎΡΠΊΠΈ O(logN)
). Π’Π°ΠΊΠΆΠ΅ ΡΡΠΎΠΈΡ ΠΏΠΎΠ΄ΡΠΎΠ±Π½Π΅Π΅ ΡΠ°ΡΡΠΌΠΎΡΡΠ΅ΡΡ Π±ΡΡΡΡΡΠ΅ Π°Π»Π³ΠΎΡΠΈΡΠΌΡ ΠΎΡΠ²Π΅ΡΠ°. Π₯ΠΎΡΡ ΠΎΠ½ΠΈ ΠΈ ΠΈΠΌΠ΅ΡΡ ΠΎΠ΄ΠΈΠ½Π°ΠΊΠΎΠ²ΡΡ ΡΠ»ΠΎΠΆΠ½ΠΎΡΡΡ
Π°Π»Π³ΠΎΡΠΈΡΠΌ Π½Π° ΠΊΠ°ΡΡΠ΅ ΡΠΏΡΠ°Π²Π»ΡΠ΅ΡΡΡ ΡΡΠ°Π±ΠΈΠ»ΡΠ½ΠΎ Π±ΡΡΡΡΠ΅Π΅ Π°Π»Π³ΠΎΡΠΈΡΠΌΠ° Π½Π° Π΄Π΅ΡΠ΅Π²Π΅. ΠΡΠΎ ΠΌΠΎΠΆΠ½ΠΎ ΠΎΠ±ΡΡΡΠ½ΠΈΡΡ ΡΠ΅ΠΌ, ΡΡΠΎ Π°Π»Π³ΠΎΡΠΈΡΠΌΡ Π½Π° Π΄Π΅ΡΠ΅Π²Π΅ Π΄Π»Ρ Π½Π°Ρ
ΠΎΠΆΠ΄Π΅Π½ΠΈΡ ΠΎΡΠ²Π΅ΡΠ°
Π΄Π»Ρ ΡΠΎΡΠΊΠΈ Π½Π΅ΠΎΠ±Ρ
ΠΎΠ΄ΠΈΠΌΠΎ ΡΠΎΠ²Π΅ΡΡΠΈΡΡ ΠΏΠΎΠΌΠΈΠΌΠΎ Π΄Π²ΡΡ
Π±ΠΈΠ½Π°ΡΠ½ΡΡ
ΠΏΠΎΠΈΡΠΊΠΎΠ² (O(2*logN)
) ΠΈΠ½Π΄Π΅ΠΊΡΠΎΠ² ΡΠΎΡΠ΅ΠΊ Π² ΠΌΠ°ΡΡΠΈΠ²Π°Ρ
ΡΠΆΠ°ΡΡΡ
ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°Ρ Π΅ΡΡ ΠΈ ΡΠΏΡΡΠΊ ΠΏΠΎ Π΄Π΅ΡΠ΅Π²Ρ (O(logN)
). Π‘Π»Π΅Π΄ΠΎΠ²Π°ΡΠ΅Π»ΡΠ½ΠΎ,
Ρ Π°Π»Π³ΠΎΡΠΈΡΠΌΠ° Π½Π° Π΄Π΅ΡΠ΅Π²Π΅ ΠΏΠΎΠ»ΡΡΠ°Π΅ΡΡΡ ΠΊΠΎΠ½ΡΡΠ°Π½ΡΠ° Π±ΠΎΠ»ΡΡΠ΅, ΡΠ΅ΠΌ Ρ Π°Π»Π³ΠΎΡΠΈΡΠΌΠ° Π½Π° ΠΊΠ°ΡΡΠ΅.
ΠΡΠ°ΡΠΈΠΊ ΠΎΠ±ΡΠ΅Π³ΠΎ Π²ΡΠ΅ΠΌΠ΅Π½ΠΈ ΡΠ°Π±ΠΎΡΡ Π΄Π²ΡΡ Π°Π»Π³ΠΎΡΠΈΡΠΌΠΎΠ² ΠΏΠΎΠΊΠ°Π·ΡΠ²Π°Π΅Ρ, ΡΡΠΎ Π°Π»Π³ΠΎΡΠΈΡΠΌ Π½Π° ΠΊΠ°ΡΡΠ΅ Π½Π° Π±ΠΎΠ»ΡΡΠΈΡ Π΄Π°Π½Π½ΡΡ ΠΏΡΠΎΠΈΠ³ΡΡΠ²Π°Π΅Ρ Π΄Π²ΡΠΌ Π΄ΡΡΠ³ΠΈΠΌ Π°Π»Π³ΠΎΡΠΈΡΠΌΠ°ΠΌ ΠΏΠΎ Π²ΡΠ΅ΠΌΠ΅Π½ΠΈ ΡΠ°Π±ΠΎΡΡ Π½Π΅ΡΠΌΠΎΡΡΡ Π½Π° ΡΠ²ΠΎΡ Π΄ΠΎΡΡΠ°ΡΠΎΡΠ½ΠΎ Π±ΡΡΡΡΡΡ ΡΠΊΠΎΡΠΎΡΡΡ Π½Π°Ρ ΠΎΠΆΠ΄Π΅Π½ΠΈΡ ΠΎΡΠ²Π΅ΡΠ° Π½Π° ΠΊΠ°ΡΡΠ΅ ΠΈ ΡΠΆΠ΅ Π½Π° 256 ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ°Ρ ΡΡΠ°Π½ΠΎΠ²ΠΈΡΡΡ Ρ ΡΠΆΠ΅ ΠΏΠΎΠ»Π½ΠΎΠ³ΠΎ ΠΏΠ΅ΡΠ΅Π±ΠΎΡΠ°. Π ΡΠ²ΠΎΡ ΠΎΡΠ΅ΡΠ΅Π΄Ρ Π²ΡΠ΅ΠΌΡ ΡΠ°Π±ΠΎΡΡ Π°Π»Π³ΠΎΡΠΈΡΠΌΠ° Π½Π° Π΄Π΅ΡΠ΅Π²Π΅ ΡΠ°ΡΡΡΡ ΡΡΠ°Π±ΠΈΠ»ΡΠ½ΠΎ ΠΌΠ΅Π΄Π»Π΅Π½Π½ΠΎ ΠΈ ΡΡΠ°Π½ΠΎΠ²ΠΈΡΡΡΡ ΡΠ°ΠΌΡΠΌ Π»ΡΡΡΠΈΠΌ ΡΠΆΠ΅ Π½Π° 32 ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ°Ρ .
ΠΡΡ ΠΎΠ΄Ρ ΠΈΠ· ΠΏΠΎΠ»ΡΡΠ΅Π½Π½ΡΡ ΡΠ΅Π·ΡΠ»ΡΡΠ°ΡΠΎΠ² ΠΌΠΎΠΆΠ½ΠΎ ΡΠΊΠ°Π·Π°ΡΡ, ΡΡΠΎ Π°Π»Π³ΠΎΡΠΈΡΠΌ Π½Π° ΠΏΠ΅ΡΡΠΈΡΡΠ΅Π½ΡΠ½ΠΎΠΌ Π΄Π΅ΡΠ΅Π²Π΅ ΠΎΡΡΠ΅Π·ΠΊΠΎΠ² Π±ΡΠ΄Π΅Ρ ΡΠΌΠ΅ΡΡΠ΅Π½ ΠΈ ΡΠ°ΡΠΈΠΎΠ½Π°Π»Π΅Π½ Π½Π° Π»ΡΠ±ΡΡ Π΄Π°Π½Π½ΡΡ . Π ΡΠΎ ΠΆΠ΅ Π²ΡΠ΅ΠΌΡ, ΠΈΠ·-Π·Π° Π²ΡΡΠΎΠΊΠΎΠΉ ΡΠ»ΠΎΠΆΠ½ΠΎΡΡΠΈ ΡΠ΅Π°Π»ΠΈΠ·Π°ΡΠΈΠΈ ΠΏΠ΅ΡΡΠΈΡΡΠ΅Π½ΡΠ½ΠΎΠ³ΠΎ Π΄Π΅ΡΠ΅Π²Π° ΠΎΡΡΠ΅Π·ΠΊΠΎΠ², Π±ΡΠ΄Π΅Ρ ΡΠΌΠ΅ΡΡΠ½ΠΎ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΡ Π°Π»Π³ΠΎΡΠΈΡΠΌ Π½Π° ΠΊΠ°ΡΡΠ΅ Π½Π° ΠΎ-ΠΎΡΠ΅Π½Ρ ΠΌΠ°Π»Π΅Π½ΡΠΊΠΎΠΌ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²Π΅ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² ΠΈ ΠΎΠΎΠΎΡΠ΅Π½Ρ Π±ΠΎΠ»ΡΡΠΎΠΌ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²Π΅ Π·Π°ΠΏΡΠ°ΡΠΈΠ²Π°Π΅ΠΌΡΡ ΡΠΎΡΠ΅ΠΊ. Π’Π°ΠΊΠΆΠ΅, Π΅ΡΠ»ΠΈ Π²Ρ ΠΎΠ΄Π½ΡΠ΅ Π΄Π°Π½Π½ΡΠ΅ ΠΏΠΎ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²Ρ ΡΠΎΡΠ΅ΠΊ ΠΈ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠΎΠ² Π΄ΠΎΡΡΠ°ΡΠΎΡΠ½ΠΎ ΠΌΠ°Π»Ρ ΠΌΠΎΠΆΠ½ΠΎ Π²ΠΎΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΡΡΡ ΠΎΠ±ΡΡΠ½ΡΠΌ ΠΏΠ΅ΡΠ΅Π±ΠΎΡΠΎΠΌ Π²Π²ΠΈΠ΄Ρ Π΅Π³ΠΎ ΠΏΡΠΎΡΡΠΎΡΡ ΠΈ ΡΠΊΠΎΡΠΎΡΡΠΈ ΡΠ΅Π°Π»ΠΈΠ·Π°ΡΠΈΠΈ.
Π‘ΡΡΡΠ΅ Π΄Π°Π½Π½ΡΠ΅ Π΄Π»Ρ Π³ΡΠ°ΡΠΈΠΊΠΎΠ², ΡΠΊΡΠΈΠΏΡ Π΄Π»Ρ ΠΈΡ ΠΏΠΎΡΡΡΠΎΠ΅Π½ΠΈΡ ΠΈ ΡΠ°ΠΌΠΈ Π³ΡΠ°ΡΠΈΠΊΠΈ ΠΌΠΎΠΆΠ½ΠΎ Π½Π°ΠΉΡΠΈ ΡΡΡ. ΠΠΎΠ΄ Π·Π°ΠΏΡΡΠΊΠ° ΡΠ΅ΡΡΠΎΠ² Π½Π°Ρ ΠΎΠ΄ΠΈΡΡΡ ΡΡΡ.