Skip to content

university lab - implementation and analysis of the effectiveness of algorithms for counting the number of rectangles to which a given point belongs

Notifications You must be signed in to change notification settings

mibaryshev/Algorithms-Lab-2

Folders and files

NameName
Last commit message
Last commit date

Latest commit

Β 

History

14 Commits
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 

Repository files navigation

АиБД - Лабораторная Ρ€Π°Π±ΠΎΡ‚Π° β„–2

РСализация 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 ΠΏΡ€ΡΠΌΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠ°Ρ….

Π˜ΡΡ…ΠΎΠ΄Ρ ΠΈΠ· ΠΏΠΎΠ»ΡƒΡ‡Π΅Π½Π½Ρ‹Ρ… Ρ€Π΅Π·ΡƒΠ»ΡŒΡ‚Π°Ρ‚ΠΎΠ² ΠΌΠΎΠΆΠ½ΠΎ ΡΠΊΠ°Π·Π°Ρ‚ΡŒ, Ρ‡Ρ‚ΠΎ Π°Π»Π³ΠΎΡ€ΠΈΡ‚ΠΌ Π½Π° пСрсистСнтном Π΄Π΅Ρ€Π΅Π²Π΅ ΠΎΡ‚Ρ€Π΅Π·ΠΊΠΎΠ² Π±ΡƒΠ΄Π΅Ρ‚ умСстСн ΠΈ Ρ€Π°Ρ†ΠΈΠΎΠ½Π°Π»Π΅Π½ Π½Π° Π»ΡŽΠ±Ρ‹Ρ… Π΄Π°Π½Π½Ρ‹Ρ…. Π’ Ρ‚ΠΎ ΠΆΠ΅ врСмя, ΠΈΠ·-Π·Π° высокой слоТности Ρ€Π΅Π°Π»ΠΈΠ·Π°Ρ†ΠΈΠΈ пСрсистСнтного Π΄Π΅Ρ€Π΅Π²Π° ΠΎΡ‚Ρ€Π΅Π·ΠΊΠΎΠ², Π±ΡƒΠ΄Π΅Ρ‚ умСстно ΠΈΡΠΏΠΎΠ»ΡŒΠ·ΠΎΠ²Π°Ρ‚ΡŒ Π°Π»Π³ΠΎΡ€ΠΈΡ‚ΠΌ Π½Π° ΠΊΠ°Ρ€Ρ‚Π΅ Π½Π° ΠΎ-ΠΎΡ‡Π΅Π½ΡŒ малСньком количСствС ΠΏΡ€ΡΠΌΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠΎΠ² ΠΈ ΠΎΠΎΠΎΡ‡Π΅Π½ΡŒ большом количСствС Π·Π°ΠΏΡ€Π°ΡˆΠΈΠ²Π°Π΅ΠΌΡ‹Ρ… Ρ‚ΠΎΡ‡Π΅ΠΊ. Π’Π°ΠΊΠΆΠ΅, Ссли Π²Ρ…ΠΎΠ΄Π½Ρ‹Π΅ Π΄Π°Π½Π½Ρ‹Π΅ ΠΏΠΎ количСству Ρ‚ΠΎΡ‡Π΅ΠΊ ΠΈ ΠΏΡ€ΡΠΌΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠΎΠ² достаточно ΠΌΠ°Π»Ρ‹ ΠΌΠΎΠΆΠ½ΠΎ Π²ΠΎΡΠΏΠΎΠ»ΡŒΠ·ΠΎΠ²Π°Ρ‚ΡŒΡΡ ΠΎΠ±Ρ‹Ρ‡Π½Ρ‹ΠΌ ΠΏΠ΅Ρ€Π΅Π±ΠΎΡ€ΠΎΠΌ Π²Π²ΠΈΠ΄Ρƒ Π΅Π³ΠΎ простоты ΠΈ скорости Ρ€Π΅Π°Π»ΠΈΠ·Π°Ρ†ΠΈΠΈ.

Π‘Ρ‹Ρ€Ρ‹Π΅ Π΄Π°Π½Π½Ρ‹Π΅ для Π³Ρ€Π°Ρ„ΠΈΠΊΠΎΠ², скрипт для ΠΈΡ… построСния ΠΈ сами Π³Ρ€Π°Ρ„ΠΈΠΊΠΈ ΠΌΠΎΠΆΠ½ΠΎ Π½Π°ΠΉΡ‚ΠΈ Ρ‚ΡƒΡ‚. Код запуска тСстов находится Ρ‚ΡƒΡ‚.

About

university lab - implementation and analysis of the effectiveness of algorithms for counting the number of rectangles to which a given point belongs

Topics

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Contributors 2

  •  
  •