バイナリーオプション攻略

フィボナッチ数列の計算量について

フィボナッチ数列の計算量について
フィボナッチ第5項を求める際の関数の呼び出され方

Pythonではじめるアルゴリズム入門 伝統的なアルゴリズムで学ぶ定石と計算量

時代が変わっても 変わらないアルゴリズムから考え方を学ぼう 本書は、初心者にも扱いやすいプログラミング言語「Python」を使用して、 アルゴリズムの基礎・考え.

フィボナッチ数列の計算量について
対応デバイス コンテンツタイプ ファイルサイズ
ブラウザ EPUB
iOS EPUB 40.7MB
Android EPUB 40.7MB
Win EPUB 40.7MB
Mac EPUB 40.7MB
対応デバイス コンテンツタイプ 閲覧期限
ブラウザ EPUB 無制限
iOS EPUB 無制限
Android EPUB 無制限
Win EPUB 無制限
Mac EPUB 無制限
  • ※ 商品は販売開始日にダウンロード可能となります。
  • ※ 価格と販売開始日は変更となる可能性があります。
  • ※ ポイント・クーポンはご利用いただけません。
  • ※ 間違えて予約購入しても、予約一覧から簡単にキャンセルができます。
  • ※ honto会員とクレジットカードの登録が必要です。未登録でも、ボタンを押せばスムーズにご案内します。
    フィボナッチ数列の計算量について
  • ① とにかくすぐ読みたい
  • ② 購入までの手間を省きたい
  • ※ ポイント・クーポンはご利用いただけません。
  • ※ 間違えて購入しても、完了ページもしくは購入履歴詳細から簡単にキャンセルができます。
  • ※ 初めてのご利用でボタンを押すと会員登録(無料)をご案内します。購入する場合はクレジットカード登録までご案内します。

あわせて読みたい本

このセットに含まれる商品

本書は、初心者にも扱いやすいプログラミング言語「Python」を使用して、
アルゴリズムの基礎・考え方を学ぶ入門書です。Pythonがはじめてという方の
ために、第1章ではPythonの基本とデータ構造について解説しています。

本書では、プログラミング入門者が最低限知っておきたいアルゴリズムの
基礎と考え方に加えて、アルゴリズムの定石とその計算量について、具体的
なサンプルコードと動作イメージを交えて丁寧に解説していきます。

【こんな方におすすめ】
・アルゴリズムをゼロから学びたい
・Pythonでプログラミングを学んでいるけれど何から手をつけていいのかわからない フィボナッチ数列の計算量について フィボナッチ数列の計算量について
・過去にアルゴリズムを学ぼうと思ったけれどPythonの資料が少なかった
・基本情報技術者試験でPythonが取り入れられるので勉強したい

【本書の特徴】
・Pythonの基本とアルゴリズムの基礎を一冊で学べる
・具体的なサンプルコードと動作イメージ(フローチャート)を交えて解説
・自分で書いて実行して動作を試しながら学習できる
・アルゴリズムの使い方や考え方だけでなく、アルゴリズムの計算量について
の理解も深まる

【扱うアルゴリズム】
FizzBuzz|フィボナッチ数列|線形探索|二分探索|幅優先探索|
深さ優先探索|番兵|8クイーン問題|n-クイーン問題|ハノイの塔|
ミニマックス法|選択ソート|挿入ソート|バブルソート|ヒープソート|
マージソート|クイックソート|最短経路問題|ベルマン・フォード法|
ダイクストラ法|A*アルゴリズム|文字列探索の力任せ法|Boyer-Moore法|
逆ポーランド記法|ユークリッドの互除法

【章構成】
■第1章 Pythonの基本とデータ構造を知る
■第2章 基本的なプログラムを作ってみる
■第3章 計算量について学ぶ
■第4章 いろいろな探索方法を学ぶ
■第5章 データの並べ替えにかかる時間を比べる
■第6章 実務に役立つアルゴリズムを知る
■Appendix Pythonのインストール

動的計画法(Dynamic Programming)入門

フィボナッチ第5項を求める際の関数の呼び出され方

上の図を見てもらうとわかりますが、fib(5)の計算をする際に、fib(3)の計算を2回行っています。つまり、同じ計算を余分に 1 回行うことになります。

動的計画法を使う場合(メモ化再帰)

このような再帰関数によるトップダウン型の動的計画法の実装方法を、メモ化再帰などと言うことがあります。

動的計画法を使う場合(漸化式)

dp[ i ] := フィボナッチの第 i 項

となるよう、以下のように i が0からn-2の時まで更新してやります。

dp[ i+2 ] = dp[ i+1 ] + dp[ i ]

このような、漸化式を利用したボトムアップ型の動的計画法の実装方法もあります。

ナップサック問題

価値が \(v_i\) 、重さが \(w_i\) で表される荷物が N 個ある。重さ B を超えないようにナップサックに入れる時、選んだ荷物の価値の合計は最大でどれだけか?

ここでは、AtCoder Beginner Contest 032 D – ナップサック問題 のデータセット 2 に対応する部分点を得る解答を考えることとします。(つまり、N≦200 かつ全ての i(1≦i≦N) について 1≦wi≦1000 を満たす)

動的計画法を使わない場合

荷物の選び方は、それぞれの荷物に対して「入れる or 入れない」の2通りがあるので、全体で\(2^N\)通りあります。

これは再帰関数を用いて計算することができます。 i 番目の荷物を選択するかしないかで分岐させてください。

これも、部分問題が構造的に現れています。knapsack(i,b) の計算をする上で、knapsack(i + 1, b – フィボナッチ数列の計算量について w[i]) や knapsack(i + 1, b) といった部分問題を解く必要があります。

動的計画法を使う場合(メモ化再帰)

動的計画法を使う場合(漸化式)

dp[ i ][ b ] := 残りの重さ(容量)が b 以上となる i 番目までの荷物の選び方で、最大となる価値の総和

仮に最適な選び方をしたとして、dp[ i+1 ][ b ] の値を考えてみましょう。

i 番目の荷物を使う時は dp[ i ][ b + フィボナッチ数列の計算量について w[ i ]]+v[ i ] が価値の総和の最大となり、使わない時は dp[ i ][ b ] となるはずです。

(残りの重さを考えていることに注意してください。i 番目の荷物を使う時は、残りが b+W[ i ] からW[ i ] だけ減って b になればよいはずです。)

dp[ i+1 ][ b ] = max(dp[ i ][ b + w[ i ]]+v[ i ], dp[ i ][ b ])

求める答えは、 dp[N][0] になります。

dp[ フィボナッチ数列の計算量について i ][ b ] := i 番目までの荷物について、今までに入れた重さの総和が b 以下となるもので、価値の総和の最大値

フィボナッチ数列の計算量について

「流れ図」って、「フローチャート」のことを言っているのでしょうか? フローチャートは古い書き方なので、再帰呼び出しを *ズバリ* と書く書き方はありません。 あえて書くとしたら、サブルーチン呼び出し(箱の横が二重線になっている)として自分のサブルーチン名を書き、 注釈で「再帰呼び出し」としておくしかありません。

関連するQ&A

問題で フィボナッチ数列のn番目の値を計算する関数 int フィボナッチ数列の計算量について fib(int n) を再帰的に定義し、この関数を利用してフィボナッチ数列の最初の10個を表示するプログラムを書けという問題があるのですが、大まかな流れは想像できるのですが、できないので困っております。 何方か教えてください。

フィボナッチ数列X(n+1)= X(n+1)+X(n) (X(1)=X(2)=1) の1項X(フィボナッチ数列の計算量について 1)からX(30)までの値を表示するプログラムを再帰関数を使って作る方法を教えてください。 再帰関数がよくわかりません。

ちょうど学校でフィボナッチ数列の話題になったので、思いつきで作ってみました。 そこで、配列を使ったものと再帰呼び出しを使ったものを作りました。 //再帰呼び出し unsigned long Fibonacci(int n) < if(n==1)< return 1;>//初項 else if(n==2) < return 1;>//第2項 return Fibonacci(n-1) + Fibonacci(n-2); > //配列 unsigned long Fibonacci(int n) < unsigned long long f[101]; int i; f[1] = 1; f[2] = 1; for( i=3; ireturn f[n]; > フィボナッチ数列の計算量について この二つを比較すると明らかに配列の方が早いです。 ということは再帰呼び出しはあまり使わない方がよいってことですよね? この場合は配列も似たような感じで見ることができますし。 それとも自分の再帰の書き方が悪いのでしょうか。

「フィボナッチ数を次の手順で求めるプログラムfib2.cを作成。 再帰関数 int fib(int n)を定義し,再帰呼出しによりfib(n)の値を求める。n=30までのフィボナッチ数を求めて表示せよ。 またどのnの値まで求めるか?」という問題です。 で下記のように作りましたが再帰関数をつかわなかったので再提出になってしまいました。 再帰関数はどうやって使うのでしょうか。 今回の場合はどの部分が再帰関数になるのでしょうか? おねがいします。 #include main() < int fib[100], i; fib[0] = 0; fib[1] = 1; printf("F0=0\nF1=1\n"); for(i=2; i>

フィボナッチ数列の性質についてです。 ・左から数えて5番目ごとの数字は5で割り切れる。 ・(初項+第2項+第3項・・・・・+第n項) =第n項×(第n項+1) ・フィボナッチ奇数番目のフィボナッチ数をじゅんにたすと、最後の次の数になる。 ・フィボナッチ偶数番目のフィボナッチ数をじゅんにたすと、最後の次の数から1ひいたものになる。 ・フィボナッチ3つ続いたフィボナッチ数の、外2つをかけたものから中の2乗をひくと、(かわりばんこに)1か-1になる。 上のような性質があるのですが、これを数学的(記号などを使って)に表すとどのように書けますか?

再帰呼び出しを用いた関数の計算量を求める方法がわからないので質問させていただきます. xのn乗を再帰呼び出しを用いて求める関数に関して,計算量を求める問題なのですが,どのような方針で求めればよいのでしょうか? int exponent(int x, int n) < if(n == 0)< return 1; >else < return x * exponent(x, n-1); >> exponentがn回呼ばれるからO(n)というのは間違いでしょうか?

フィボナッチ数列を関数に… フィボナッチ数列の一般項は Fn=(φ^n-(-φ)^n)/√5 (ただし、φは黄金比) で表されますが、それを f(x)フィボナッチ数列の計算量について =(φ^x-(-φ)^x)/√5 と関数で考えます。するとそのグラフは点々のグラフになります。 f(1)=1、f(2)=1、f(3)=2、f(4)=3、f(5)=5… それをどうにかして、連続したグラフにできないでしょうか? 特徴として ・どのx(実数)をとってもx+1に関数が存在する。 ・lim(x→∞)f(x+1)/f(x)=φ があげられると思います。 できるかできないかだけでも良いですので、回答よろしくお願いします。

べき級数の問題 c[0]=c[1]=1.フィボナッチ数列c[n]を係数とするべき級数 f(z)=Σ(n=0~∞) (z∈C) に対して (1) f(z)=1+zf(z)+z^2・f(z)であることを示せ。 (2) (1)を利用してf(z)をべき級数で表せ。 という問題で(1)はできたのですが,(2)ができません。 c[n]がフィボナッチ数列ということで,c[n]の一般項はわかるのですが, (1)を利用しようとするとべき級数で表すことができません・・・。 どなたか解説お願いします。

フィボナッチ数列の計算量について

ループを使って配列を 2 回走査していますが、何も問題になりません。
実行時間は O(N) です。

内側ループのオーダー O(N) が外側のループで N 回繰り返されるので実行時間は O(N^2) です。

またループで生成される i と j の値を使って、配列内にある 2 つの要素の組をすべて表示しています。
そのパターンは O(N^2) あるので、実行時間も O(N^2) …という考え方もできます。

「ループ処理の回数」で考える

全体を 2 倍して「N – 1 と 1, N – 2 と 2, N – 3 と 3 …」 とペアを作るとします。
すると、数字 N を N – 1 ペアつくることができます。

全体を 2 倍したので 1/2 して戻してあげると N(N - 1) / 2 となります。

そして定数を切り捨てると、実行時間は O(N^2) と考えることができます。
この「整数の和の求め方」は以下の記事で詳しく説明しているので参考にしてみてください。

「コードの意味」で考える

ループ生成される j は常に i よりも大きい状態で (i, j) の組を出力します。
N = 8 のとき、(i, j) は以下のように出力されます。

フィボナッチ数列の計算量について
j = 1j = 2j = 3j = フィボナッチ数列の計算量について 4j = 5j = 6j = 7
(0, 1)(0, 2)(0, 3)(0, 4)(0, 5)(0, 6)(0, 7)
(1, 2)(1, 3)(1, 4)(1, 5)(1, 6)(1, 7)
(2, 3)(2, 4)(2, 5)(2, 6)(2, 7)
(3, 4)(3, 5)(3, 6)(3, 7)
(フィボナッチ数列の計算量について 4, 5)(4, 6)(4, 7)
(5, 6)(5, 7)
(6, 7)

これは N * N 行列の半分になっているので N^2 / 2 といえます。
従って実行時間は O(N^2) です。

「ループ処理の回数の平均」で考える

外側のループ処理の回数は N 回です。
内側のループ処理の回数は変動します。

たとえば 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 の平均値は 10/2 フィボナッチ数列の計算量について フィボナッチ数列の計算量について フィボナッチ数列の計算量について フィボナッチ数列の計算量について で 5 です。
なので N だったら、その平均値は N/2 になります。

外側のループ処理の回数が N 回、内側のループ処理の平均回数が N/2 であるなら、
全体のループ処理の回数は N^2/2 なので、実行時間は O(N^2) といえます。

以下は二重ループになっているので O(N^2) とよく勘違いしてしまうのですが、
if 文を考慮すると O(1) になります。

異なるデータをもつ 2 つの配列があって、
それぞれから要素を 1 つずつ引っ張りだして掛け合わすだけの行為は O(N^2) といえません。

配列 A の長さが a で、配列 B の長さが b とするなら、その実行時間は O(ab) となります。
関連性のないデータは a と b のように区別する必要があるのです。

100000 回のループも結局は定数です。例4-2 と同じく O(ab) となります。

配列サイズの半分をループ処理していますが、特にそれは問題にならず O(N) になります。

以下のうち O(N) と同等になるのはどれでしょうか?

  • O(N + P) ただし P < N/2 とする
  • O(2N)
  • O(N + log N)
  • O(N + M)
  • O(N + P) ただし P < N/2 とする
    • O(N) といえる
      • P は常に N より小さい
      • よって フィボナッチ数列の計算量について フィボナッチ数列の計算量について O(P) を切り捨てることができる
      • O(N) といえる
        • 定数は切り捨てることができる
        • O(N) といえる
          • N と log フィボナッチ数列の計算量について N を比較すると N の方が影響力がある
          • なので log N は切り捨てることができる
          • N と M の関係性が明示されていない…
          • 関係性がわからない以上、いずれも残さないといけない

          O(a * s(log a + log s)): 論理的な名前をつける

          誤った実行時間
          • 各文字列のソート処理は O(N log N)
            • 要素の数だけ処理を行うので O(N フィボナッチ数列の計算量について * N log N) になる
            • 後ろを切り捨てて O(N^2 log N)

            なぜなら N が「文字列の長さ・配列の長さ」で 2 種類の使い方がされており、
            全く区別されていないからです。

            N を使うことで曖昧さが残らないようにしたり、
            N をまったく使わないようにするなど配慮が必要です。

            O(a^2) と O(ab) では意味がまったく違うことを意識しましょう。

            正しい実行時間

            改めて N の代わりに、論理的な名前で文字の定義をします。

            • 最も長い文字列の長さを s とする
            • 配列の長さは a とする
            • 各文字列のソート処理は フィボナッチ数列の計算量について O(s log s)
              • 要素の数だけ処理を行うので O(a * s log s) になる
              • さらにソートには、文字列比較の フィボナッチ数列の計算量について フィボナッチ数列の計算量について O(s) の計算量も伴う
              • O(a log a) * O(s) で O(a * s log フィボナッチ数列の計算量について a) になる
              • これ以上は簡単にできません

              O(N): 平衡二分探索木

              「コードの意味」で考える

              木構造の各ノードに 1 回ずつ訪れているので、計算量は定数時間になります。

              よって実行時間はノードの数に比例します。
              ノードが N 個なら O(N) が実行時間になります。

              「再帰」で考える

              一般的に、複数の枝をもつ再帰関数の実行時間は O(枝の本数^深さ) になります。
              ここでは left / right の 2 本の枝を使っているので O(2^深さ) になります。

              実行時間 O(2^深さ) はパッと見、すごく効率の悪いアルゴリズムに見えてしまうかもしれません。
              これは「指数関数」のアルゴリズムですが、実際はそこまで悪い計算時間じゃありません。

              平衡二分探索木の深さは「log N」なので O(フィボナッチ数列の計算量について 2^log N) になるからです。

              2^P を対数にすると…
              • Q = 2^P
                • log[2]Q = P
                2^log N を対数にすると…
                • P = 2^log フィボナッチ数列の計算量について N
                  • log[2]P = log[2]N
                  • P = N
                  • 2^log N = N

                  ノード数を N とすると、実行時間は O(N) になることがわかります。

                  最悪ケース (for文を最後まで回すケース) は「x が n の平方根に達した場合」となっています。
                  数式にすると x = √n ですね。

                  最悪ケースから判断して、実行時間は O(√n) ということになります。

                  O(N): 階乗

                  引数が n, n – 1, … , 2, 1 と減少しながら再帰実行しています。
                  ただそれだけなので O(n) になります。

                  O(N^2 * N!)

                  「関数は全部で何回呼ばれるか」で考える

                  順序を考えて並べた総数 (置換の総数) はいくつになるか、考えてみましょう。
                  引数に 7 文字を渡した場合だと、順列は 7 * 6 * 5 * 4 * 3 * 2 * 1 通り存在します。

                  1 文字目は 7 通り、2 文字目は 6 通り、3 文字目は 5 通り … の候補になっていくからです。

                  これは 7! の階乗と言い換えることもできるので、n 文字だったら n! 通りになるわけです。
                  よって関数は n! 呼ばれることになります。

                  「関数は途中で何回呼ばれるか」で考える

                  再帰に加えて、for 文のループ処理が加わります。
                  そこで関数は n * n! 回実行されます。

                  「個々の関数の呼び出しはどれくらい時間がかかるか」で考える

                  System.out.prontln(prefix); の実行時間は O(フィボナッチ数列の計算量について n) です。

                  String rem = str.substring(0, i) + str.substring(i + 1); と、
                  permutation(rem, prefix + str.charAt(i)); を合わせた実行時間も O(n) です。

                  rem, prefix, str.charAt(i) の合計は常に n です。
                  よって関数の呼び出し自体の実行時間は O(n) です。

                  「合計の実行時間」で考える

                  permutation 関数は O(n * n!) 回呼び出され、呼び出し毎に O(n) の時間を要します。
                  よって合計時間は O(n^2 * n!) を超えることはありません。

                  O(2^n): フィボナッチ数列

                  フィボナッチ数列とは 1, 1, 2, 3, 5, 8, 13, 21 … のように、
                  2 つ前の値と 1 つ前の値を足すとその数になり、ずっとそれが成立する数列です。

                  再帰なので O(枝の本数^深さ) で OK です。
                  呼び出しごとに 2 つの枝ができるので、深さ N のとき O(2^N) フィボナッチ数列の計算量について になります。

                  fib(n) が O(2^n) であれば、
                  allFib(n) は O(n2^n) になると思うかもしれません。

                  しかし、合計の実行回数 (ノード数) は n によって変化していきます。

                  • fib(0)
                    • ノード数: 2^0 で 1
                    • ノード数: 2^1 で 2
                      • 合計ノード数: 1 + 2 = 3
                      • ノード数: 2^2 で 4
                        • 合計ノード数: 3 + 4 = 7
                        • ノード数: 2^3 フィボナッチ数列の計算量について フィボナッチ数列の計算量について フィボナッチ数列の計算量について で 8
                          • 合計ノード数: 6 + 8 = 15
                          • ノード数: 2^4 で 16
                            • 合計ノード数: 15 + 16 = 31
                            • ノード数: 2^n
                              • 合計ノード数: 2^1 + 2^2 + 2^3 + 2^4 + … + 2^n
                              • 言い換えると、合計の実行回数は 2^n+1 – 1

                              合計の実行回数が 2^n+1 – 1 ということは、
                              fib(n) と同じく allFib(n) も O(2^n) ということになります。

                              O(N): メモ化を使ったフィボナッチ数列

                              以下ソースコードは「メモ化」と呼ばれる方法を使って、
                              指数時間の再帰アルゴリズムを最適化しています。

                              fib(i) が呼ばれるたびに、fib(i – 1) と fib(i – フィボナッチ数列の計算量について フィボナッチ数列の計算量について 2) が呼び出れますが、
                              それらの計算結果はすでにキャッシュされているので、参照して足し算するだけです。

                              • fib(1)
                                • return 1
                                • fib(1)
                                  • return 1
                                  • return 0
                                  • fib(2)
                                    • memo[2] を参照する
                                    • return 1
                                    • return 1
                                    • fib(3)
                                      • memo[3] を参照する
                                      • return 2
                                      • memo[2] フィボナッチ数列の計算量について を参照する
                                      • return 1
                                      • fib(4)
                                        • memo[4] を参照する
                                        • return 3
                                        • memo[3] を参照する
                                        • return 2

                                        キャッシュ保存・参照を利用すれば、定数時間で計算できることになります。
                                        定数時間の処理を N 回おこなうと、実行時間は O(N) になります。

                                        O(log N)

                                        • powersOf2(50)
                                          • powersOf2(25)
                                            • powersOf2(12) フィボナッチ数列の計算量について
                                              • powersOf2(6)
                                                • powersOf2(3)
                                                  • powersOf2(1)
                                                  • print & return 1

                                                  たとえば n = フィボナッチ数列の計算量について フィボナッチ数列の計算量について 50 を渡すと n = 1 になるまで 2 で割り続けます。
                                                  n = 1 になると関数の呼び出しが止まって、そこから結果を返却していきます。

                                                  これは n を 1/2 にしていくので、実行時間は O(log N) になります。

                                                  「コードの意味」で考える

                                                  powersOf2 を呼び出すごとに、1 つの値が出力されて呼び出し元に戻ります。
                                                  6 個の数が出力されたのであれば、powersOf2 が 6 回呼び出されたことを意味します。

                                                  1 から 50 の範囲内の値をもつ 2 のべき乗は フィボナッチ数列の計算量について 2^0 , 2^1 , 2^2 , 2^3 , 2^4 , 2^5 の 6 個です。
                                                  なので powersOf2 は 6 回呼び出されます。

                                                  1 から n の範囲内の値をもつ 2 のべき乗は log n 個です。
                                                  なので powersOf2 は log n 回呼び出されます。

                                                  よって実行時間は O(log N) となります。

                                                  「増加率」で考える

                                                  powersOf2 は「 2 のべき乗の値を返却する関数」なので、
                                                  n が 2^x の値を超えると呼び出し回数が 1 ずつ増えていきます。

                                                  • n = 1
                                                    • n = 2^0
                                                      • x = 0
                                                      • n = 2^1
                                                        • x = 1
                                                        • n = 2^2
                                                          • x = 2
                                                          • n = 2^3
                                                            • x = 3
                                                            • n = 2^4
                                                              • x = 4
                                                                フィボナッチ数列の計算量について
                                                              • n = 2^log n
                                                                • x = log n

                                                                上記 n の値が呼び出し回数が増えるタイミングということです。

                                                                n = 2 から n = フィボナッチ数列の計算量について 3 に変わるだけでは、呼び出し数は変化しませんが、
                                                                n = 2 から n = 4 に変わると、呼び出し数は 1 増えます。

                                                                n = 2^x の x フィボナッチ数列の計算量について は log n です。
                                                                この x の増加率に呼び出し回数は依存しているので、実行時間は O(log n) となります。

                                                                練習の 12 問

                                                                for 文のループを b 回繰り返しているので、実行時間は O(フィボナッチ数列の計算量について フィボナッチ数列の計算量について b) です。

                                                                a の b 乗の計算です。
                                                                再帰的に関数を b 回呼び出すので、実行時間は O(b) となります。

                                                                余り算のアルゴリズムです。実行時間は O(1) つまり定数時間です。

                                                                while 文のループ回数は count で管理しています。
                                                                count は a/b と等しいので、実行時間は O(a/b) です。

                                                                O(log N)

                                                                平方根を求めるために二分探索を行っています。実行時間は O(log n) です。

                                                                O(sqrt(N))

                                                                for 文は guess * guess > n になると終了します。言い換えると guess > sqrt(n) です。
                                                                よって実行時間は O(sqrt(n)) です。

                                                                二分探索木が「平衡ではない」場合、
                                                                ある要素を見つけるには (最悪ケースで) どれくらいの計算時間になるでしょう?

                                                                要素を見つけるのにかかる最大の時間は「木の深さ」で決まります。
                                                                木のノード数を n とすると、深さ n の直線的なリスト状態が考えられます。

                                                                順序の性質が何もないので、すべてのノードを探索しないといけません。
                                                                よって実行時間は O(n) になります。

                                                                copyArray() は繰り返し appendToNew() を呼び出します。
                                                                配列のコピーを行うのにどれくらい時間がかかるでしょう。

                                                                appendToNew() を最初に呼び出すと 1 回のコピーが生じます。
                                                                2 回目の呼び出しでは 2 回のコピーが生じます。
                                                                3 回目の呼び出しでは 3 回のコピーが生じます。

                                                                配列の要素数を n とすると、合計のコピー回数は 1 から n までの和となりますので、
                                                                実行時間は O(n^2) フィボナッチ数列の計算量について となります。

                                                                O(log N)

                                                                d 桁の値であれば、10^d までになります。
                                                                n = 10^d の場合は d = log n となります。

                                                                よって実行時間は O(log n) となります。

                                                                文字列の長さが k で、文字の数を c とすると、
                                                                文字列の生成に O(c^k) の時間を要し、ひとつの文字列のソートチェックに O(k) かかります。

                                                                Pythonではじめるアルゴリズム入門 伝統的なアルゴリズムで学ぶ定石と計算量

                                                                はじめてのお客さまへ

                                                                【扱うアルゴリズム】
                                                                FizzBuzz|フィボナッチ数列|線形探索|二分探索|幅優先探索|
                                                                深さ優先探索|番兵|8クイーン問題|n-クイーン問題|ハノイの塔|
                                                                ミニマックス法|選択ソート|挿入ソート|バブルソート|ヒープソート|
                                                                マージソート|クイックソート|最短経路問題|ベルマン・フォード法|
                                                                ダイクストラ法|A*アルゴリズム|文字列探索の力任せ法|Boyer-Moore法|
                                                                逆ポーランド記法|ユークリッドの互除法

                                                                ※本電子書籍は同名出版物を底本として作成しました。記載内容は印刷出版当時のものです。
                                                                ※印刷出版再現のため電子書籍としては不要な情報を含んでいる場合があります。
                                                                ※印刷出版とは異なる表記・表現の場合があります。予めご了承ください。
                                                                ※プレビューにてお手持ちの電子端末での表示状態をご確認の上、商品をお買い求めください。

                                                                • 増井敏克(著)
                                                                • PCブラウザ
                                                                  ビューア
                                                                • Android
                                                                  (スマホ/タブレット)
                                                                • iPhone / iPad
                                                                • キャンペーンの内容や期間は予告なく変更する場合があります。
                                                                • サイトに記載の日時は日本標準時 (Japan Standard Time) です。

                                                                「Pythonではじめるアルゴリズム入門 伝統的なアルゴリズムで学ぶ定石と計算量(翔泳社)」シリーズ作品一覧(全1冊)

                                                                Pythonではじめるアルゴリズム入門 伝統的なアルゴリズムで学ぶ定石と計算量

                                                                実用 Pythonではじめるアルゴリズム入門 伝統的なアルゴリズムで学ぶ定石と計算量

                                                                本書は、初心者にも扱いやすいプログラミング言語「Python」を使用して、
                                                                アルゴリズムの基礎・考え方を学ぶ入門書です。特にPythonがはじめてという方の
                                                                ために、第1章ではPythonの基本とデータ構造について解説しています。

                                                                本書では、プログラミング入門者が最低限知っておきたいアルゴリズムの
                                                                基礎と考え方に加えて、アルゴリズムの定石とその計算量について、具体的
                                                                なサンプルコードと動作イメージを交えて丁寧に解説していきます。

                                                                【こんな方におすすめ】
                                                                ・アルゴリズムをゼロから学びたい
                                                                ・Pythonでプログラミングを学んでいるけれど何から手をつけていいのかわからない
                                                                ・過去にアルゴリズムを学ぼうと思ったけれどPythonの資料が少なかった
                                                                ・基本情報技術者試験でPythonが取り入れられるので勉強したい

                                                                【扱うアルゴリズム】
                                                                FizzBuzz|フィボナッチ数列|線形探索|二分探索|幅優先探索|
                                                                深さ優先探索|番兵|8クイーン問題|n-クイーン問題|ハノイの塔|
                                                                ミニマックス法|選択ソート|挿入ソート|バブルソート|ヒープソート|
                                                                マージソート|クイックソート|最短経路問題|ベルマン・フォード法|
                                                                ダイクストラ法|A*アルゴリズム|文字列探索の力任せ法|Boyer-Moore法|
                                                                逆ポーランド記法|ユークリッドの互除法

                                                                ※本電子書籍は同名出版物を底本として作成しました。記載内容は印刷出版当時のものです。
                                                                ※印刷出版再現のため電子書籍としては不要な情報を含んでいる場合があります。
                                                                ※印刷出版とは異なる表記・表現の場合があります。予めご了承ください。
                                                                ※プレビューにてお手持ちの電子端末での表示状態をご確認の上、商品をお買い求めください。

                                                                関連記事

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次
閉じる