devkuma – Algorithm

アルゴリズムプログラミング(Algorithm Programming)入門

kc@example.com (kc kim) — Wed, 30 Mar 2022 09:27:00 +0900

アルゴリズム

データ構造に蓄積されたデータを活用して、ある問題を解決するための複数の動作の集まりである。
問題を解決する手順を意味する。
入力、出力、明確性、有効性、効率性を満たす必要がある。
アルゴリズムは論理であり数学であり、実際の開発に適用される基礎的な考え方である。

アルゴリズム講座

実践アルゴリズム講座 | YouTube
- 資料: https://blog.naver.com/ndb796/221226794899

アルゴリズム問題サイト

韓国サイト
海外サイト
- Codility
- LeetCode
- HackerRank
- CodeSignal
- Codewars
- LintCode

ビッグオー(Big O)記法 | 時間計算量、空間計算量

kc@example.com (kc kim) — Tue, 06 Jul 2021 09:58:55 +0900

時間計算量、空間計算量

時間計算量

時間計算量は、ソースコードロジックの実行時間(Execution Time)を予測し、どれほど効率的なコードかを表す概念である。実行時間は演算(Operation)に比例して長くなる。CPU使用量と関係がある。

空間計算量

空間計算量は、コードがメモリ空間をどれほど効率的に使うかに関する概念である。静的配列やハッシュテーブルのように、あらかじめ空間を確保するデータ構造でよく登場する概念である。RAM使用量と関係がある。

ソースコードロジックはまず動作しなければならないが、動作だけでなく時間・空間計算量を計算することで、どれほど効率的なコードかが判断される。

ビッグオー(Big O)記法とは

ビッグオー(Big-O)は、時間・空間計算量を数学的に表す代表的な方法である。ただし、コードの実際の実行時間を示すものではなく、入力データの増加率に応じたアルゴリズム性能を論理的に予測するために使う。ビッグオー記法には次の2つの規則がある。

最も高い次数だけを残す。

O(n² + 2n) -> O(n²)

係数と定数は大胆に捨てる。

O(4n + 5) -> O(n)

ビッグオー記法で時間計算量を区分する

O(1) (Constant)

入力データの大きさに関係なく、常に一定時間かかるアルゴリズムを表す。データが増えても性能にはほとんど影響しない。

O(log₂ n) (Logarithmic)

入力データの大きさが大きくなるほど、処理時間がログ(log: 指数関数の逆関数)分だけ増えるアルゴリズムである。例えばデータが10倍になると、処理時間は2倍になる。二分探索が代表的であり、再帰が有効に働く場合も該当する。

O(n) (Linear)

入力データの大きさに比例して処理時間が増加するアルゴリズムである。例えばデータが10倍になると、処理時間も10倍になる。線形探索アルゴリズムが代表的である。

O(n log₂ n) (Linear-Logarithmic)

データが多くなるほど、処理時間がログ(log)倍だけさらに増えるアルゴリズムである。例えばデータが10倍になると、処理時間は約20倍になる。ソートアルゴリズムであるMerge sort、Quick sortの平均時間計算量である。

O(n²) (Quadratic)

データが多くなるほど、処理時間が急激に増えるアルゴリズムである。例えばデータが10倍になると、処理時間は最大100倍になる。二重ループ(n² matrix)が代表的である。ただし、mがnより小さい場合は、必ずO(nm)と表記するのが望ましい。

O(2ⁿ) (Exponential)

データ量が多くなるほど、処理時間が幾何級数的に増えるアルゴリズムである。代表的にはフィボナッチ数列があり、再帰が逆効果になる場合も該当する。

時間計算量の計算方法

命令が終わるたびに実行回数を書いてみる。

基本計算方法

public static void basic() {
    int[] a = {7, 3, 6, 3, 3, 5, 6, 9};          // 1
    for (int i = 0; i < a.length - 1; i++) {     // n             [i > 0 to n-1 : n times called]
        for (int j = i + 1; j < a.length; j++) { // (n-1) * n     [j > 1 to n   : n times called]
            if (a[i] == a[j]) {                  // (n-1) * (n-1) [if文は結局n-1回だけ実行]
                a[j] = 0;
            }
        }
    }

    for (int i : a) {
        System.out.println(i);
    }
}

命令語の実行回数をすべて足すと2n²-2n+2となる。定数を省略し、最高次項だけを考えるとO(n²)と表記される。

再帰関数の時間計算量の計算方法

public static int factorial(int n) {
    System.out.println("n:" + n);
    if (n == 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

再帰呼び出しは以下のようにn回呼び出される。したがってO(n)と表記される。

factorial(n) -> factorial(n -1) .... ->factorial(2) -> factorial(1)

Algorithm | 合計、平均、最大値、最小値、データ交換

kc@example.com (kc kim) — Sat, 02 Apr 2022 21:55:00 +0900

合計

配列のすべての要素を合計した値を求める。
要素を1つずつ取り出してsumに加えていく方式である。

package com.devkuma.algorithum.programming.basic;

public class Sum {

    int sum(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        return sum;
    }

    public static void main(String[] args) {
        Sum sum = new Sum();

        int[] nums = {1, 4, 3, 8, 5};
        System.out.println("합계: " + sum.sum(nums));
    }
}

実行結果:

합계: 21

平均

総値をデータ数で割った値が平均値である。

package com.devkuma.algorithum.programming.basic;

public class Average {
    int average(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        return sum / nums.length;
    }

    public static void main(String[] args) {
        Average average = new Average();

        int[] nums = {1, 4, 3, 8, 5};
        System.out.println("평균:" + average.average(nums));
    }
}

実行結果:

합계: 21

最大値

package com.devkuma.algorithum.programming.basic;

public class Max {
    int max(int[] nums) {
        int max = 0;
        for (int num : nums) {
            if (max < num) {
                max = num;
            }
        }
        return max;
    }

    public static void main(String[] args) {
        Max max = new Max();

        int[] nums = {1, 4, 3, 8, 5};
        System.out.println("최대값:" + max.max(nums));
    }
}

実行結果:

합계: 21

最小値

package com.devkuma.algorithum.programming.basic;

public class Min {
    int min(int[] nums) {
        int min = Integer.MAX_VALUE;
        for (int num : nums) {
            if (min > num) {
                min = num;
            }
        }
        return min;
    }

    public static void main(String[] args) {
        Min min = new Min();

        int[] nums = {1, 4, 3, 8, 5};
        System.out.println("최소값:" + min.min(nums));
    }
}

データ交換

単純に2つのデータを入れ替えるときは、そのデータが入った変数と一時変数(temp)を1つ用意する。
理由は、2つしかない場合、一方を変更すると、もう一方に入れるべきデータがすでに上書きされてしまうためである。

package com.devkuma.algorithum.programming.basic;

public class Swap {

    public static void main(String[] args) {
        int a = 1;
        int b = 2;

        int temp = a;
        a = b;
        b = temp;

        System.out.println("a:" + a); // 2
        System.out.println("b:" + b); // 1
    }
}

実行結果:

합계: 21

Algorithm | 再帰関数(Recursion Function)

kc@example.com (kc kim) — Wed, 30 Mar 2022 09:27:00 +0900

再帰関数

再帰関数は、処理中に自分自身を呼び出す関数を指す。
例えば、1からNまでの合計を求める関数は、再帰を使って次のように定義できる。

public class SumRecursion {

    public int sum(int n) {
        if(n == 0) {
            return 0;
        }
        return n + sum(n - 1);
    }

    public static void main(String[] args) {
        SumRecursion recursion = new SumRecursion();
        int result = recursion.sum(10);
        System.out.println(result); // 55
    }
}

実行結果:

注意点は、sum(10)を呼び出しているが、最初に値を返すのはsum(0)である。そして最後にsum(10)の値が返される。

ユークリッドの互除法

ユークリッドの互除法は、2つの整数m、nの最大公約数(GCD(m, n))を求めるアルゴリズムである。

mをnで割ったとき、余りをrとすると、以下のように定義される。

GCD(m, n) = GCD(n, r)

再帰関数を使うと、数学で有名なユークリッドの互除法アルゴリズムを書ける。

public class GcdRecursion {

    public int gcd(int m, int n) {
        if(n == 0) {
            return m;
        }
        return gcd(n,  m % n);
    }

    public static void main(String[] args) {
        GcdRecursion recursion = new GcdRecursion();
        int result = recursion.gcd(30, 7);
        System.out.println(result); // 1
    }
}

実行結果:

フィボナッチ数列

フィボナッチ数列のアルゴリズムは再帰を2回使って作ることができ、以下のように定義される。

F0 = 0
F1 = 1
Fn = Fn-1 + Fn-2 (n = 2, 3, ...)

public class FibonacciRecursion {
    
    public int fibonacci(int n) {
        if (n == 0) {
            return 0;
        } else if (n == 1) {
            return 1;
        }
        return fibonacci(n - 1) + fibonacci(n - 2);
    }

    public static void main(String[] args) {
        FibonacciRecursion recursion = new FibonacciRecursion();
        int result = recursion.fibonacci(10);
        System.out.println(result); // 55
    }
}

実行結果:

ここで作成したフィボナッチ数列のアルゴリズムの計算量はO((1+√5)^n/2)である。

aからbまでの合計を求める

以下のコードは、aからbまでの合計を求める例である。

package com.devkuma.algorithum.programming.recursion;

public class SumRangeRecursion {

    int sumRange(int a, int b) {
        if (a == b) {
            return a;
        }
        return sumRange(a, b - 1) + b;
    }

    public static void main(String[] args) {
        SumRangeRecursion recursion = new SumRangeRecursion();
        int result = recursion.sumRange(1, 3);
        System.out.println(result); // 6
    }
}

実行結果:

上の例では、1 + 2 + 3 + 4 + 5 = 15のように計算される。

これを展開すると以下のようになる。

sumRange(1, 5) = sumRange(1, 5 - 1) + 5 > sumRange(1, 4) + 5 > 10 + 5 = 15
sumRange(1, 4) = sumRange(1, 4 - 1) + 4 > sumRange(1, 3) + 4 > 6 + 4 = 10
sumRange(1, 3) = sumRange(1, 3 - 1) + 3 > sumRange(1, 2) + 3 > 3 + 3 = 6
sumRange(1, 2) = sumRange(1, 2 - 1) + 2 > sumRange(1, 1) + 2 > 1 + 2 = 3
sumRange(1, 1) = 1

素数かどうかの判定

以下のコードは、素数かどうかを判定する例である。

public class PrimeRecursion {

    boolean hasDivisor(int n, int i) {
        if (i == n) {
            return false;
        }
        if (n % i == 0) {
            return true;
        }
        return hasDivisor(n, i + 1);
    }

    boolean isPrime(int n) {
        if (n == 1) {
            return false;
        } else if (n == 2) {
            return true;
        } else {
            return !hasDivisor(n, 2);
        }
    }

    public static void main(String[] args) {
        PrimeRecursion recursion = new PrimeRecursion();
        boolean result1 = recursion.isPrime(7);
        System.out.println(result1); // true

        boolean result2 = recursion.isPrime(4);
        System.out.println(result2); // false
    }

}

実行結果:

true
false

相互再帰: 奇数・偶数判定

以下のコードは、奇数と偶数を判定する例であり、メソッド同士が互いに呼び出し合う相互再帰関数として実装されている。

package com.devkuma.algorithum.programming.recursion;

public class EvenOddRecursion {

    boolean isEven(int n) {
        if (n == 0) {
            return true;
        }
        return isOdd(n-1);
    }

    boolean isOdd(int n) {
        if (n == 0) {
            return false;
        }
        return isEven(n-1);
    }

    public static void main(String[] args) {
        EvenOddRecursion recursion = new EvenOddRecursion();

        System.out.println(recursion.isEven(8)); // true
        System.out.println(recursion.isEven(9)); // false
        System.out.println(recursion.isOdd(8)); // false
        System.out.println(recursion.isOdd(9)); // true
    }
}

実行結果:

true
false
false
true

配列から最大値を求める

以下のコードは、入力された配列aで個数nまでの最大値を求める例である。

public class MaxArrayRecursion {

    public static int max(int[] a, int n) {
        int x;
        if (n == 1) {
            return a[0];
        } else {
            x = max(a, n - 1);
        }

        if (x > a[n - 1]) {
            return x;
        }
        return a[n - 1];
    }

    public static void main(String[] args) {
        int arr[] = {0, 80, 60, 40, 20, 100};
        System.out.println(max(arr, 3));
    }
}

実行結果:

入力された配列aで3番目までを見ると"0, 80, 60"であり、その中で最も大きい値は"80"になる。

Algorithm | 線形探索(順次検索, Linear search)

kc@example.com (kc kim) — Sat, 02 Apr 2022 20:39:00 +0900

線形探索アルゴリズム(順次検索, Linear search algorithm)

探したい値をリストの先頭から末尾まで順番に探していくアルゴリズムである。

メリット: 検索方法の中で最も単純で実装しやすく、ソートされていないリストでも使える。
デメリット: 検索するリストの長さが長いと非効率である。

package com.devkuma.algorithum.programming.search.linear;

public class LinearSearch {

    void search(int[] nums, int target) {
        int index = -1;
        for(int i = 0; i < nums.length; i++) {
            if (nums[i] == target) {
                index = i + 1;
                break;
            }
        }
        if (index > 0) {
            System.out.println(target + "은 " + index + "번째 있습니다.");
        } else {
            System.out.println(target + "은 없습니다.");
        }
    }

    public static void main(String[] args) {
        LinearSearch search = new LinearSearch();
        search.search(new int[]{1, 5, 3, 2, 8, 9}, 8);
        search.search(new int[]{1, 5, 3, 2, 8, 9}, 4);
    }
}

実行結果:

8은 5번째 있습니다.
4은 없습니다.

線形探索アルゴリズムで最小値を求める

以下のコードは、すべての要素についてminValueより小さい値が見つかるたびにminValueを更新して最小値を求める。 (最大値も同じアルゴリズムである)

package com.devkuma.algorithum.programming.search.linear;

public class MinLinearSearch {

    void searchMinimum(int[] nums) {
        int minValue = Integer.MAX_VALUE; // 最大値
        for(int i = 0; i < nums.length; i++) {
            if (nums[i] < minValue) {
                minValue = nums[i];
            }
        }
        System.out.println("최소값은 " + minValue + "입니다.");
    }

    public static void main(String[] args) {
        MinLinearSearch search = new MinLinearSearch();
        search.searchMinimum(new int[]{1, 5, 3, 2, 8, 9});
        search.searchMinimum(new int[]{2, 7, 8, 6, 5, 4});
    }
}

実行結果:

최소값은 1입니다.
최소값은 2입니다.

線形探索アルゴリズムで問題を解く

線形探索アルゴリズムを使って問題を解いてみる。

問題
N個の整数a(0), a(1), ..., a(N-1)とb(0), b(1), ..., b(N-1)があるとき、この2つの数列からそれぞれ1つずつ数a(i), b(j) [i = 0, 1, ..., N-1, j = 0, 1, ..., N-1]を選び、その和が整数R以上となる範囲での最小値を求めよ。

解決方法

package com.devkuma.algorithum.programming.linearsearch;

public class LinearSearchQuiz1 {

    void minSum(int[] aNums, int[] bNums, int r) {
        int minSum = Integer.MAX_VALUE; // 最大値
        for(int i = 0; i < aNums.length; i++) {
            for(int j = 0; j < bNums.length; j++) {
                int sum = aNums[i] + bNums[j];
                if (sum >= r && minSum > sum) {
                    minSum = sum;
                }
            }
        }
        System.out.println("최소값은 " + minSum + "입니다.");
    }

    public static void main(String[] args) {
        LinearSearchQuiz1 search = new LinearSearchQuiz1();

        int[] aNums =   new int[]{9, 5, 3, 7, 8, 9};
        int[] bNums =   new int[]{3, 9, 5, 8, 3, 5};
        int r = 7;
        search.minSum(aNums, bNums, 7);
    }
}

実行結果:

최소값은 8입니다.

上記の例の計算量はO(N^2)になる。

Algorithm | 二分探索(二分検索, Binary search)

kc@example.com (kc kim) — Sat, 02 Apr 2022 21:24:00 +0900

二分探索(二分検索, Binary search)

昇順にソートされているリストで特定の値を探すとき、最初に中央の値を任意の値として選び、その値と探したい値の大小を比較する方式である。

メリット: 検索が繰り返されるたびに目標値を見つける確率が2倍になるため速い。
デメリット: ソートされたリストでしか使えない。

反復文を利用した方法

package com.devkuma.algorithum.programming.search.binary;

public class BinarySearchWhile {

    int search(int[] nums, int target) {
        int startIndex = 0;
        int endIndex = nums.length - 1;

        int middle = 1;

        while (startIndex <= endIndex) {
            middle = (startIndex + endIndex) / 2;
            if (nums[middle] == target)
                return middle + 1;
            else if (nums[middle] > target)
                endIndex = middle - 1;
            else
                startIndex = middle + 1;
        }
        return middle;
    }

    public static void main(String[] args) {
        BinarySearchWhile search = new BinarySearchWhile();

        int[] nums = {15, 28, 65, 67, 88, 92, 100, 150};
        int target = 28;
        int index = search.search(nums, target);

        if (index > 0) {
            System.out.println(target + "은 " + index + "번째 있습니다.");
        } else {
            System.out.println(target + "은 없습니다.");
        }
    }
}

実行結果:

5은 2번째 있습니다.

再帰関数を利用した方法

package com.devkuma.algorithum.programming.search.binary;

public class BinarySearchRecursion {

    int search(int arr[], int target, int startIndex, int endIndex) {
        if (startIndex > endIndex)
            return -1;

        int middle = (startIndex + endIndex) / 2;
        if (arr[middle] == target)
            return middle;
        else if (arr[middle] > target)
            return search(arr, target, startIndex, middle - 1);
        else
            return search(arr, target, middle + 1, endIndex);
    }

    public static void main(String[] args) {
        BinarySearchRecursion search = new BinarySearchRecursion();

        int[] nums = {15, 28, 65, 67, 88, 92, 100, 150};
        int target = 28;
        int startIndex = 0;
        int endIndex = nums.length - 1;

        int index = search.search(nums, target, startIndex, endIndex);

        if (index > 0) {
            System.out.println(target + "은 " + index + "번째 있습니다.");
        } else {
            System.out.println(target + "은 없습니다.");
        }
    }
}

実行結果:

28은 2번째 있습니다.

二分探索アルゴリズムの例の説明

上記の例で使った配列から28を探す二分探索を展開すると以下のようになる。

{ 15, 28, 65, 67, 88, 92, 100, 150 }
- 中央値: 88 -> 小さい -> { 15, 28, 65, 67 }
- 中央値: 43 -> 小さい -> { 15, 28 }
- 中央値: 28 -> 終了