💀
Второй курс РПО
Разработка программных модулей
Разработка программных модулей
  • Модели разработки
  • Ошибки и отладка программ
  • Средства разработки алгоритмов
    • Основные принципы и стадии тестирования
  • Сложностные классы
  • Эмуляторы операционных систем
  • Сложность сортировки
  • Уровни тестирования
  • Задание №1
  • Регрессионное тестирование
  • Тестирование «белым ящиком»
  • Как делать оценку сложности?
  • Алгоритмы и сложность
  • Тестирование "белым ящиком" №2
  • Сложность алгоритмов
  • Тестирование "белым ящиком" №3
  • Тестирование "Чёрным ящиком»" №1
  • Тестирование "Черным ящиком" №2
  • Оценка сложности эвристических алгоритмов
  • Принципы ООП
  • Тестирование "Черным ящиком" №3
  • КТ - В3
  • Модульное тестирование
    • С кодами
  • Модульное тестирование
  • Абстрактные классы и интерфейсы в Python
  • Структуры в Python по аналогии с C++
    • Диалоги гениев
  • Делегаты в Python
    • Ещё более не смешные диалоги
  • Регулярные выражения в Python от простого к сложному
  • Python: Коллекции
  • Параметризованные классы (шаблоны)
  • Указатели и операции со списками в Python
  • Интеграционное тестирование
  • Работа с классами. Перегрузка методов
  • Определение операций в классе.
  • Создание наследованных классов
  • Интеграционное тестирование
  • Работа с объектами через интерфейсы
  • Использование стандартных интерфейсов
  • Работа с типом данных "Структура"
  • Коллекции. Параметризованные классы
  • Использование регулярных выражений
  • Операции со списками
  • Что такое паттерны проектирования?
  • Шпаргалка по шаблонам проектирования
    • [Habr] Шпаргалка
  • UML-диаграммы проектирования
  • Использование основных шаблонов.
  • Использование каких то там шаблонов
  • 15-я Практическая
  • 16-я Практическая
  • Graphviz Online
  • 17-я Практическая
  • Введение в теорию программирования: Объектно-ориентированный подход
  • Документирование софта и стандарты
  • C# Ввод и вывод
  • Оптимизация кода: просто о главном
  • Автоматизация разработки технической документации
  • Автоматизированное документирование и первичные данные
  • ADO.NET что это?
Powered by GitBook
On this page
  • ости эвристических алгоритмов
  • Основные аспекты оценки сложности
  • Пример: Жадный алгоритм для задачи коммивояжёра
  • Оценка сложности других эвристических методов

Сложность алгоритмов

28.11.2024

PreviousТестирование "белым ящиком" №2NextТестирование "белым ящиком" №3

Last updated 6 months ago

ости эвристических алгоритмов

— это алгоритмы, которые находят приближённые решения задач, где точное решение найти сложно или невозможно за разумное время. В данном конспекте рассматривается, как оценивать их сложность с примерами.


Основные аспекты оценки сложности

1

Анализ времени выполнения

  • Описание: Оценивается, как время выполнения изменяется в зависимости от размера входных данных.

  • Ключевые категории:

    • Худший случай: Максимальное время выполнения.

    • Средний случай: Усреднённое время для случайных входных данных.

    • Лучший случай: Минимальное время выполнения.

2

Анализ потребления памяти

  • Описание: Измеряется объём памяти, необходимый алгоритму для работы.

  • Факторы:

    • Объём входных данных.

    • Использование вспомогательных структур (массивы, кэш, списки).

3

Число итераций

  • Описание: Количество шагов, необходимых для достижения решения.

  • Применение: Часто используется в итерационных алгоритмах (например, жадный алгоритм, генетические алгоритмы).

4

Качество решения

  • Описание: Оценивается точность приближённого решения относительно оптимального.

  • Метрические показатели:

    • Отклонение от оптимального решения.

    • Время достижения приемлемого качества.


Пример: Жадный алгоритм для задачи коммивояжёра

Код алгоритма на Python

import random


def generate_cities(n):
    return [(random.randint(0, 100), random.randint(0, 100)) for _ in range(n)]


def distance(a, b):
    return ((a[0] - b[0])**2 + (a[1] - b[1])**2) ** 0.5


def greedy_tsp(cities):
    n = len(cities)
    visited = [False] * n
    path = [0]  
    visited[0] = True
    
    for _ in range(n - 1):
        last = path[-1]
        next_city = min(
            ((i, distance(cities[last], cities[i])) for i in range(n) if not visited[i]),
            key=lambda x: x[1]
        )[0]
        path.append(next_city)
        visited[next_city] = True
    
    return path


cities = generate_cities(5)  
path = greedy_tsp(cities)
print("Маршрут:", path)

Шаги анализа сложности

Временная сложность:

  1. Внешний цикл работает n−1n - 1n−1 раз, где nnn — число городов.

  2. На каждой итерации выполняется поиск ближайшего города среди оставшихся, что занимает O(n)O(n)O(n) времени.

Итоговая сложность:

O(n2)O(n^2)O(n2)

Почему квадрат^2?
  1. Внешний цикл:

    for _ in range(n - 1):

    Выполняется n−1n - 1 раз, по одному шагу для каждого города, кроме начального.

  2. Внутренний поиск ближайшего города:

    min(((i, distance(...)) for i in range(n) if not visited[i]), ...)

    На каждой итерации проверяются расстояния до всех оставшихся городов O(n)O(n)O(n).

  3. Общий результат: Внутренний поиск O(n)O(n)O(n) выполняется n−1n - 1n−1 раз, давая сложность:

    O(n)⋅O(n)=O(n2)O(n)⋅O(n) = O(n^2)O(n)⋅O(n)=O(n2)

Памятная сложность:

  • Массив visitedvisitedvisited для хранения статуса посещённых городов O(n)O(n)O(n).

  • Общая сложность памяти: O(n)O(n)O(n).

Качество решения:

  • Жадный алгоритм не гарантирует оптимальное решение, но на практике часто даёт хорошие результаты.


Оценка сложности других эвристических методов

1. Генетический алгоритм

  • Временная сложность: зависит от размера популяции PPP и числа поколений GGG.

O(P⋅G⋅F(n))O(P⋅G⋅F(n))O(P⋅G⋅F(n))

где F(n)F(n)F(n) — время вычисления фитнес-функции.

  • Памятная сложность: O(P⋅n)O(P⋅n)O(P⋅n), где nnn — размер индивида.

2. Алгоритм имитации отжига

  • Временная сложность: зависит от числа итераций T, температуры охлаждения и времени вычисления фитнес-функции.

O(T⋅F(n))O(T⋅F(n))O(T⋅F(n))

  • Памятная сложность: O(1)O(1)O(1), так как хранится только текущее решение.


Сравнительная таблица эвристических алгоритмов

Алгоритм
Временная сложность
Памятная сложность
Особенности

Жадный алгоритм

Быстрое, но не всегда точное решение.

Генетический алгоритм

Эффективен для сложных задач.

Имитация отжига

Гибкость, но требует настройки параметров.


График маршрута коммивояжёра

На графике ниже показан пример маршрута, найденного жадным алгоритмом для случайно сгенерированных 10 городов:

Описание графика:

  • Синие точки — это города (случайные координаты на плоскости).

  • Красные цифры — порядковые номера городов.

  • Зелёная линия — маршрут, найденный алгоритмом.

Маршрут начинается с точки 00 и возвращается в неё после посещения всех остальных городов.

O(n2)O(n^2)O(n2)
O(n)O(n)O(n)
O(P⋅G⋅F(n))O(P \cdot G \cdot F(n))O(P⋅G⋅F(n))
O(P⋅n)O(P⋅n)O(P⋅n)
O(T⋅F(n))O(T⋅F(n))O(T⋅F(n))
O(1)O(1)O(1)
Маршрут коммивояжёра