Рекурсия, итерация и оценки сложности алгоритмов

Основы оценок сложности алгоритмов

Нам уже известно, что правильность — далеко не единственное качество, которым должна обладать хорошая программа. Одним из важнейших является эффективность, характеризующая прежде всего время выполнения программы для различных входных данных (параметра ).

Нахождение точной зависимости для конкретной программы — задача достаточно сложная. По этой причине обычно ограничиваются асимптотическими оценками этой функции, то есть описанием ее примерного поведения при больших значениях параметра . Иногда для асимптотических оценок используют традиционное отношение (читается "О большое") между двумя функциями , определение которого можно найти в любом учебнике по математическому анализу, хотя чаще применяют отношение эквивалентности (читается "тэта большое"). Его формальное определение есть, например, в книге [8], хотя нам пока достаточно будет понимания данного вопроса в общих чертах.

В качестве первого примера вернемся к только что рассмотренным программам нахождения факториала числа. Легко видеть, что количество операций, которые должны быть выполнены для нахождения факториала ! числа в первом приближении прямо пропорционально этому числу, ибо количество повторений цикла (итераций) в данной программе равно . В подобной ситуации принято говорить, что программа (или алгоритм) имеет линейную сложность (сложность или ).

Можно ли вычислить факториал быстрее? Оказывается, да. Можно написать такую программу, которая будет давать правильный результат для тех же значений , для которых это делают все приведенные выше программы, не используя при этом ни итерации, ни рекурсии. Ее сложность будет , что фактически означает организацию вычислений по некоторой формуле без применения циклов и рекурсивных вызовов!

Не менее интересен и пример вычисления -го числа Фибоначчи. В процессе ее исследования фактически уже было выяснено, что ее сложность является экспоненциальной и равна . Подобные программы практически не применимы на практике. В этом очень легко убедиться, попробовав вычислить с ее помощью 40-е число Фибоначчи. По этой причине вполне актуальна следующая задача.

Задача 5.4. Напишите программу, печатающую -ое число Фибоначчи, которая имела бы линейную сложность.

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

Текст программы

public class FibIv1 {
    public static void main(String[] args) throws Exception {    
        int n = Xterm.inputInt("Введите n -> ");
        Xterm.print("f(" + n + ")");
        if (n < 0) {
            Xterm.print(" не определено\n");
        } else if (n < 2) {
            Xterm.println(" = " + n);
        } else {
            long i = 0;  
            long j = 1;  
            long k;
            int  m = n;  
            while (--m > 0) {
                k  = j;
                j += i;
                i  = k;
            }	    
            Xterm.println(" = " + j);
        }
    }
}

Следующий вопрос вполне естественен — а можно ли находить числа Фибоначчи еще быстрее?

После изучения определенных разделов математики совсем просто вывести следующую формулу для -ого числа Фибоначчи , которую легко проверить для небольших значений :

Может показаться, что основываясь на ней, легко написать программу со сложностью , не использующую итерации или рекурсии.

Текст программы

public class FibIv2 {
    public static void main(String[] args) throws Exception {    
        int    n = Xterm.inputInt("Введите n -> ");
        double f = ( 1.0 + Math.sqrt(5.) ) / 2.0;
        int    j = (int)( Math.pow(f,n) / Math.sqrt(5.) + 0.5 );

        Xterm.println("f(" + n + ") = " + j);
    }
}

На самом деле эта программа использует вызов функции возведения в степень { Math.pow(f,n) }, которая не может быть реализована быстрее, чем за логарифмическое время ( ). Про алгоритмы, в которых количество операций примерно пропорционально (в информатике принято не указывать основание двоичного логарифма) говорят, что они имеет логарифмическую сложность ( ).

Для вычисления -го числа Фибоначчи существует такой алгоритм, программную реализацию которого мы приведем без дополнительных комментариев, — иначе нужно объяснять слишком много (связь чисел Фибоначчи со степенями некоторой матрицы порядка два, использование классов для работы с матрицами, алгоритм быстрого возведения матрицы в степень).

Задача 5.5. Напишите программу, печатающую -ое число Фибоначчи, которая имела бы логарифмическую сложность.

Текст программы

public class FibIv3 {
    public static void main(String[] args) throws Exception {    
        int n = Xterm.inputInt("Введите n -> ");
        Xterm.print("f(" + n + ")");
        if (n < 0) {
            Xterm.println(" не определено");
        } else if (n < 2) {
            Xterm.println(" = " + n);
        } else {
            Matrix b = new Matrix(1, 0, 0, 1);
            Matrix c = new Matrix(1, 1, 1, 0);
            while (n>0) {
                if ((n&1) == 0) {
                    n >>>= 1; c.square();
                } else {
                    n  -=  1; b.mul(c);
                }
            }
            Xterm.println(" = " + b.fib());
        }
    }
}
class Matrix {
    private long a, b, c, d;
    
    public Matrix(long a, long b, long c, long d) {
        this.a = a; this.b = b; this.c = c; this.d = d;
    }
    public void mul(Matrix m) {	
        long a1 = a*m.a+b*m.c;  long b1 = a*m.b+b*m.d;
        long c1 = c*m.a+d*m.c;  long d1 = c*m.b+d*m.d;
        a = a1; b = b1; c = c1; d = d1;
    }
    public void square() {
        mul(this);
    }
    public long fib() {
        return b;
    }
}

Если попробовать посчитать десятимиллионное число Фибоначчи с помощью этой и предыдущей программ, то разница во времени счета будет вполне очевидной. К сожалению, результат будет неверным (в обоих случаях) в силу ограниченности диапазона чисел типа long.

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

Рассмотрим четыре алгоритма решения одной и той же задачи, имеющие сложности , , и соответственно. Предположим, что второй из этих алгоритмов требует для своего выполнения на некотором компьютере при значении параметра ровно одну минуту времени. Тогда времена выполнения всех этих четырех алгоритмов на том же компьютере при различных значениях параметра будут примерно такими, как в таблице 5.1.

Когда начинающие программисты тестируют свои программы, то значения параметров, от которых они зависят, обычно невелики. Поэтому даже если при написании программы был применен неэффективный алгоритм, это может остаться незамеченным. Однако, если подобную программу попытаться применить в реальных условиях, то ее практическая непригодность проявится незамедлительно.

С увеличением быстродействия компьютеров возрастают и значения параметров, для которых работа того или иного алгоритма завершается за приемлемое время. Таким образом, увеличивается среднее значение величины , и, следовательно, возрастает величина отношения времен выполнения быстрого и медленного алгоритмов. Чем быстрее компьютер, тем больше относительный проигрыш при использовании плохого алгоритма!