ABOUT ME

-

Today
-
Yesterday
-
Total
-
  • Chap1 1.1 Algorithms : problem, solution, algorithm
    ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์„ค๊ณ„ ๋ฐ ์‹ค์Šต 2025. 4. 4. 22:23

    1.1 Algorithms ์š”์•ฝ

    ๐Ÿ“Œ 1. ๋ฌธ์ œ(Problem)

    • ์–ด๋–ค ์งˆ๋ฌธ ๋˜๋Š” ์ž‘์—…(task)์— ๋Œ€ํ•œ ์ผ๋ฐ˜์ ์ธ ๊ธฐ์ˆ 
    • ์˜ˆ์‹œ:
      • ์ •๋ ฌ ๋ฌธ์ œ: n๊ฐœ์˜ ์ˆซ์ž๊ฐ€ ์žˆ๋Š” ๋ฆฌ์ŠคํŠธ S๋ฅผ ๋น„๊ฐ์†Œ ์ˆœ์œผ๋กœ ์ •๋ ฌํ•˜๋ผ
      • ํƒ์ƒ‰ ๋ฌธ์ œ: ๋ฆฌ์ŠคํŠธ S ์•ˆ์— x๋ผ๋Š” ๊ฐ’์ด ์กด์žฌํ•˜๋Š”์ง€ ํŒ๋‹จํ•˜๋ผ

    ๐Ÿ“Œ 2. ์ธ์Šคํ„ด์Šค(Instance)

    • ๋ฌธ์ œ์˜ ํŠน์ •ํ•œ ์ž…๋ ฅ ๊ฐ’ ์ง‘ํ•ฉ
    • ์˜ˆ:
      • ๋ฆฌ์ŠคํŠธ S = [10, 7, 8, 11, 5, 13]์ด๊ณ , n = 6์ธ ๊ฒฝ์šฐ → ์ •๋ ฌ ๋ฌธ์ œ์˜ ์ธ์Šคํ„ด์Šค
      • x = 11์ธ ๊ฒฝ์šฐ → ํƒ์ƒ‰ ๋ฌธ์ œ์˜ ์ธ์Šคํ„ด์Šค

    ๐Ÿ“Œ 3. ํ•ด(Solution)

    • ์ธ์Šคํ„ด์Šค๋ฅผ ํ•ด๊ฒฐํ•œ ๊ฒฐ๊ณผ
    • ์œ„ ์˜ˆ์—์„œ ์ •๋ ฌ์˜ ๊ฒฐ๊ณผ๋Š” [5, 7, 8, 10, 11, 13]
    • ํƒ์ƒ‰ ๊ฒฐ๊ณผ๋Š” “Yes, x is in S”

    ๐Ÿ“Œ 4. ์•Œ๊ณ ๋ฆฌ์ฆ˜(Algorithm)

    • ๋ฌธ์ œ์˜ ๋ชจ๋“  ์ธ์Šคํ„ด์Šค๋ฅผ ํ’€ ์ˆ˜ ์žˆ๋Š” ์ผ๋ฐ˜์ ์ธ ๋‹จ๊ณ„๋ณ„ ์ ˆ์ฐจ
    • essential ํŠน์„ฑ 5๊ฐ€์ง€:
      1. ์ž…๋ ฅ(Input): 0๊ฐœ ์ด์ƒ
      2. ์ถœ๋ ฅ(Output): ์ ์–ด๋„ ํ•˜๋‚˜ ์ด์ƒ
      3. ๋ช…ํ™•์„ฑ(Definiteness): ๊ฐ ๋‹จ๊ณ„๋Š” ๋ช…ํ™•ํžˆ ์ •์˜๋˜์–ด์•ผ ํ•จ
      4. ์œ ํ•œ์„ฑ(Finiteness): ์œ ํ•œํ•œ ์‹œ๊ฐ„ ๋‚ด์— ์ข…๋ฃŒ๋˜์–ด์•ผ ํ•จ
      5. ์ •ํ™•์„ฑ(correctiness)
    • optional ํŠน์„ฑ
      1. ํšจ๊ณผ์„ฑ(Effectiveness): ๊ฐ ๋‹จ๊ณ„๋Š” ์‹ค์งˆ์ ์œผ๋กœ ์ˆ˜ํ–‰ ๊ฐ€๋Šฅํ•ด์•ผ ํ•จ
      2. generality

    "we must specify a general step-by-step procedure for producing the solution to each instance. This step-by-step procedure is called an algorithm. We say that the algorithm solves the problem."

    ๐Ÿ‘‰ ํ•ด์„:

    ์šฐ๋ฆฌ๋Š” ๊ฐ ๋ฌธ์ œ ์ธ์Šคํ„ด์Šค์— ๋Œ€ํ•œ ํ•ด๋‹ต์„ ๋„์ถœํ•˜๊ธฐ ์œ„ํ•œ ์ผ๋ฐ˜์ ์ธ ๋‹จ๊ณ„๋ณ„ ์ ˆ์ฐจ๋ฅผ ๋ช…ํ™•ํžˆ ํ•ด์•ผ ํ•œ๋‹ค. ์ด๋Ÿฌํ•œ ๋‹จ๊ณ„๋ณ„ ์ ˆ์ฐจ๋ฅผ ์•Œ๊ณ ๋ฆฌ์ฆ˜(algorithm) ์ด๋ผ๊ณ  ๋ถ€๋ฅธ๋‹ค. ์šฐ๋ฆฌ๋Š” ์ด ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด ํ•ด๋‹น ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•œ๋‹ค๊ณ  ๋งํ•œ๋‹ค.

     

    ์ฆ‰, ์–ด๋–ค ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๊ธฐ ์œ„ํ•ด์„  ๋ชจ๋“  ๊ฒฝ์šฐ์— ์ ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ์ฒด๊ณ„์ ์ธ ๋‹จ๊ณ„๋“ค์ด ํ•„์š”ํ•˜๊ณ , ๊ทธ๊ฒƒ์ด ๋ฐ”๋กœ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด๋ผ๋Š” ๊ฒƒ์ด๋‹ค.


    ๐Ÿ”Ž ์˜ˆ์ œ: Sequential Search

    Algorithm SequentialSearch(S, x)
      for i = 1 to n
        if S[i] == x then
          return i
      return 0  // not found
    • ๋ฆฌ์ŠคํŠธ์—์„œ x๋ฅผ ์ฒ˜์Œ๋ถ€ํ„ฐ ๋๊นŒ์ง€ ๋น„๊ต
    • ๋‹จ์ˆœํ•˜์ง€๋งŒ ๋น„ํšจ์œจ์  (ํŠนํžˆ ๋ฆฌ์ŠคํŠธ๊ฐ€ ํด ๊ฒฝ์šฐ)

     


    ๐Ÿง  pseudocode(์˜์‚ฌ์ฝ”๋“œ)๋ž€?

    ๐Ÿ“Œ ์ •์˜

    pseudocode๋Š” ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด์™€ ์ž์—ฐ์–ด์˜ ์ค‘๊ฐ„ ํ˜•ํƒœ๋กœ ์ž‘์„ฑ๋œ ์ฝ”๋“œ์ž…๋‹ˆ๋‹ค.
    ์ฆ‰, ์‚ฌ๋žŒ์ด ์ดํ•ดํ•˜๊ธฐ ์‰ฝ๊ฒŒ ์“ด ์ฝ”๋“œ ํ˜•ํƒœ์˜ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์„ค๋ช…์ด์—์š”.

    • ์‹ค์ œ๋กœ ์‹คํ–‰๋˜๋Š” ์ฝ”๋“œ๋Š” ์•„๋‹ˆ์ง€๋งŒ
    • ์ปดํ“จํ„ฐ ํ”„๋กœ๊ทธ๋ž˜๋จธ๊ฐ€ ์‰ฝ๊ฒŒ ์ฝ”๋“œ๋ฅผ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ๋„๋ก
    • ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ๋…ผ๋ฆฌ์ ์ธ ํ๋ฆ„๋งŒ์„ ํ‘œํ˜„ํ•ฉ๋‹ˆ๋‹ค.

    ๐Ÿ“ pseudocode์˜ ํŠน์ง•

    ํŠน์ง• ์„ค๋ช…
    ์–ธ์–ด ์ค‘๋ฆฝ์  ํŠน์ • ์–ธ์–ด(C++, Java, Python ๋“ฑ)์— ์ข…์†๋˜์ง€ ์•Š์Œ
    ๊ฐ„๊ฒฐํ•จ ๋ถˆํ•„์š”ํ•œ ๋ฌธ๋ฒ•์„ ์ œ์™ธํ•˜๊ณ  ํ•ต์‹ฌ ๋กœ์ง๋งŒ ํ‘œํ˜„
    ๋ช…ํ™•์„ฑ ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ํ•ต์‹ฌ ๊ตฌ์กฐ์™€ ํ๋ฆ„์ด ์ž˜ ๋“œ๋Ÿฌ๋‚จ
    ์‚ฌ๋žŒ ์ค‘์‹ฌ ์ปดํ“จํ„ฐ๋ณด๋‹ค ์‚ฌ๋žŒ์ด ์ดํ•ดํ•˜๊ธฐ ์‰ฌ์›€

    ๐Ÿงพ ์˜ˆ์‹œ ๋น„๊ต

    ๐Ÿ’ป ์‹ค์ œ C++ ์ฝ”๋“œ

    int sequentialSearch(int S[], int n, int x) {
        for (int i = 0; i < n; i++) {
            if (S[i] == x)
                return i;
        }
        return -1;
    }

    ๐Ÿ“„ pseudocode ๋ฒ„์ „

    Algorithm SequentialSearch(S, x)
      for i = 1 to n
        if S[i] == x then
          return i
      return 0

    → ๋ฐฐ์—ด ์ธ๋ฑ์Šค๋„ 1๋ถ€ํ„ฐ ์‹œ์ž‘ํ•  ์ˆ˜ ์žˆ๊ณ , ํƒ€์ž… ์„ ์–ธ๋„ ์—†๊ณ , ;๋‚˜ {} ๊ฐ™์€ ๋ฌธ๋ฒ•๋„ ์—†์Šต๋‹ˆ๋‹ค.
     ๋…ผ๋ฆฌ๋งŒ ๋‚จ๊ธฐ๊ณ  ๋ฌธ๋ฒ•์„ ๋บ€ ๊ฒƒ์ด ๋ฐ”๋กœ pseudocode์ž…๋‹ˆ๋‹ค.


    โœจ ์™œ pseudocode๋ฅผ ์“ฐ๋Š” ๊ฑธ๊นŒ?

    1. ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์„ค๋ช…์— ์ง‘์ค‘ํ•˜๊ธฐ ์œ„ํ•ด (ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด ๋ฌธ๋ฒ•์€ ์ƒ๋žต)
    2. ๋‹ค์–‘ํ•œ ์–ธ์–ด ์‚ฌ์šฉ์ž์—๊ฒŒ ๊ณตํ†ต๋œ ํ‘œํ˜„ ์ œ๊ณต
    3. ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๊ต์žฌ, ๋…ผ๋ฌธ, ์‹œํ—˜ ๋“ฑ์—์„œ ํ‘œ์ค€์ ์œผ๋กœ ์‚ฌ์šฉ

    ๐Ÿ“– Pseudocode ๊ด€๋ จ ์ •๋ฆฌ (26ํŽ˜์ด์ง€ ๊ธฐ์ค€)


    ๋ฐฐ์—ด ์ธ๋ฑ์Šค๋Š” 1๋ถ€ํ„ฐ ์‚ฌ์šฉ

    • C++์—์„œ๋Š” ๋ฐฐ์—ด ์ธ๋ฑ์Šค๋ฅผ 0๋ถ€ํ„ฐ ์‹œ์ž‘ํ•˜์ง€๋งŒ
    • Pseudocode์—์„œ๋Š” ๋ณดํ†ต 1๋ถ€ํ„ฐ ์‹œ์ž‘
      → ์‚ฌ๋žŒ์ด ๋ฆฌ์ŠคํŠธ๋ฅผ ์„ธ๋Š” ๋ฐฉ์‹๊ณผ ์ž์—ฐ์Šค๋Ÿฝ๊ฒŒ ๋งž์ถฐ ์„ค๋ช…์ด ์‰ฌ์›Œ์ง

    ๐Ÿ“Œ ์˜ˆ์‹œ:

    Inputs: positive integer n, array of numbers S indexed from 1 to n

    Pseudocode ๋ฌธ๋ฒ• ํŠน์ง• ์ •๋ฆฌ

     

    ํ•ญ๋ชฉ Pseudocodeํ‘œํ˜„ C++ํ‘œํ˜„
    ๋ฐฐ์—ด ์ธ๋ฑ์Šค 1๋ถ€ํ„ฐ 0๋ถ€ํ„ฐ
    ์กฐ๊ฑด์‹ if (low ≤ x ≤ high) if (low <= x && x <= high)
    ๊ฐ’ ๊ตํ™˜ exchange x and y temp = x; x = y; y = temp;

    ๐Ÿ”Ž Pseudocode๋Š” ์ˆ˜ํ•™์  ํ‘œํ˜„์„ ๊ทธ๋Œ€๋กœ ์‚ฌ์šฉํ•˜์—ฌ ๊ฐ„๊ฒฐํ•จ๊ณผ ๋ช…ํ™•์„ฑ์„ ์ถ”๊ตฌํ•จ.


    ๋ฐฐ์—ด ์„ ์–ธ๊ณผ ์‚ฌ์šฉ

    • ์ธ๋ฑ์Šค ๋ฒ”์œ„๋ฅผ ๋ช…ํ™•ํžˆ ํ‘œํ˜„: S[2..n] ← 2๋ถ€ํ„ฐ n๊นŒ์ง€ ์ธ๋ฑ์‹ฑ๋จ
    • 2์ฐจ์› ๋ฐฐ์—ด๋„ ์ž์œ ๋กญ๊ฒŒ ์ธ๋ฑ์Šค ๋ฒ”์œ„ ์ง€์ • ๊ฐ€๋Šฅ
    • S[2..n] ํ‘œํ˜„์€ C++์—๋Š” ์—†๊ณ  pseudocode ์ „์šฉ ํ‘œ๊ธฐ์ž„

    ๋ฐ์ดํ„ฐ ํƒ€์ž… ํ‘œํ˜„ (์ถ”์ƒ์  ํ‘œํ˜„)

    Pseudocode์—์„œ๋Š” C++์ฒ˜๋Ÿผ ๊ตฌ์ฒด์  ํƒ€์ž…๋ณด๋‹ค ์—ญํ•  ์ค‘์‹ฌ์˜ ํƒ€์ž… ๋ช…์‹œ ์‚ฌ์šฉ

    ํƒ€์ž… ์ด๋ฆ„์„ค๋ช…
    ํƒ€์ž… ์ด๋ฆ„ ์„ค๋ช…
    keytype ์ •๋ ฌ/ํƒ์ƒ‰ ๋Œ€์ƒ์ด ๋˜๋Š” ํ‚ค ๊ฐ’ ํƒ€์ž…
    index ๋ฐฐ์—ด์„ ์ธ๋ฑ์‹ฑํ•˜๋Š” ์ •์ˆ˜ํ˜• ๋ณ€์ˆ˜
    number ์ •์ˆ˜ ๋˜๋Š” ์‹ค์ˆ˜ ๋ชจ๋‘ ํฌํ•จ ๊ฐ€๋Šฅํ•œ ์ˆซ์ž
    bool true / false ๊ฐ’์„ ๊ฐ€์ง€๋Š” ๋…ผ๋ฆฌํ˜•

    ๋ฐ˜๋ณต๋ฌธ ํ‘œํ˜„

    repeat n times
      ...
     
    • C++์—์„œ๋Š” for๋ฌธ์„ ์จ์•ผ ํ•˜์ง€๋งŒ pseudocode๋Š” ์˜๋ฏธ ์ค‘์‹ฌ์œผ๋กœ ๊ฐ„๋‹จํžˆ ํ‘œํ˜„
    • ๋ฐ˜๋ณต ํšŸ์ˆ˜๋งŒ ์ค‘์š”ํ•  ๋•Œ ๋ฐ˜๋ณต ์ œ์–ด ๋ณ€์ˆ˜ ์ƒ๋žต ๊ฐ€๋Šฅ

    ํ•จ์ˆ˜ vs ํ”„๋กœ์‹œ์ € ๊ตฌ๋ถ„

    ๊ตฌ๋ถ„ ์„ค๋ช… ์˜ˆ์‹œ
    Function ๊ฐ’์„ ๋ฐ˜ํ™˜(return) function Sum(S): number
    Procedure ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•˜์ง€ ์•Š์Œ (void) procedure Sort(S)
    • ๋ฐฐ์—ด ๋“ฑ์€ ์ž๋™์œผ๋กœ ์ฐธ์กฐ๋กœ ์ „๋‹ฌ๋˜๋ฏ€๋กœ & ์•ˆ ๋ถ™์ž„
    • const๋Š” ๋ฐฐ์—ด์ด ์ฝ๊ธฐ ์ „์šฉ์ž„์„ ์˜๋ฏธ

    ๐Ÿ“ ํ•ต์‹ฌ ์š”์•ฝ

    • pseudocode๋Š” ์–ธ์–ด์— ๊ตฌ์• ๋ฐ›์ง€ ์•Š๊ณ  ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋…ผ๋ฆฌ๋ฅผ ์‰ฝ๊ฒŒ ํ‘œํ˜„ํ•˜๊ธฐ ์œ„ํ•œ ๋„๊ตฌ
    • ์ง๊ด€์  ํ‘œํ˜„ + ๊ฐ„๊ฒฐํ•จ์„ ์ค‘์‹œ
    • ์ˆ˜ํ•™์  ํ‘œํ˜„ ํ—ˆ์šฉ (์˜ˆ: ≤, exchange, repeat ๋“ฑ)
    • ๊ตฌํ˜„๋ณด๋‹ค๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์ดํ•ด์— ์ง‘์ค‘ํ•ด์•ผ ํ•  ๋•Œ ์‚ฌ์šฉ

    ๐Ÿ’ก ์˜ˆ์ œ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์ •๋ฆฌ


    ๐Ÿ”น Algorithm 1.1: Sequential Search

    ๋ฌธ์ œ: ๋ฐฐ์—ด S ์•ˆ์— key x๊ฐ€ ์žˆ๋Š”์ง€ ์ฐพ์•„๋ผ
    ์ž…๋ ฅ: ์ •์ˆ˜ n, ๋ฐฐ์—ด S[1..n], key x
    ์ถœ๋ ฅ: x๊ฐ€ ์žˆ์œผ๋ฉด ์ธ๋ฑ์Šค, ์—†์œผ๋ฉด 0

    procedure SequentialSearch(S[1..n], x)
      for i = 1 to n
        if S[i] == x then
          return i
      return 0

    ๐Ÿ“Œ ํŠน์ง•

    • ๋ฐฐ์—ด ์ˆœ์„œ๋Œ€๋กœ x๋ฅผ ๋น„๊ตํ•จ
    • ์ •๋ ฌ๋˜์–ด ์žˆ์ง€ ์•Š์•„๋„ ์‚ฌ์šฉ ๊ฐ€๋Šฅ
    • ์‹œ๊ฐ„๋ณต์žก๋„:
      • ์ตœ์•…: O(n)
      • ์ตœ์„ : O(1)

    ๐Ÿ”น Algorithm 1.2: Add Array Members

    ๋ฌธ์ œ: ๋ฐฐ์—ด S์˜ ๋ชจ๋“  ์›์†Œ์˜ ํ•ฉ์„ ๊ตฌํ•˜๋ผ
    ์ž…๋ ฅ: ์ •์ˆ˜ n, ๋ฐฐ์—ด S[1..n]
    ์ถœ๋ ฅ: ํ•ฉ๊ณ„ sum

    function AddArrayMembers(S[1..n]): number  // ํ•จ์ˆ˜๊ฐ€ ๋ฐ˜ํ™˜ํ•˜๋Š” ๊ฐ’(return value)์˜ ํƒ€์ž…
      sum ← 0
      for i = 1 to n
        sum ← sum + S[i]
      return sum

    ๐Ÿ“Œ ํŠน์ง•

    • ํ•ฉ๊ณ„๋ฅผ ๋ˆ„์ ํ•˜๋Š” ๋‹จ์ˆœ ๋ฐ˜๋ณต
    • ํ•ญ์ƒ n๋ฒˆ ๋ฐ˜๋ณต → ์‹œ๊ฐ„๋ณต์žก๋„ O(n)

    ๐Ÿ”น Algorithm 1.3: Exchange Sort

    ๋ฌธ์ œ: ๋ฐฐ์—ด S๋ฅผ ๋น„๊ฐ์†Œ ์ˆœ(์˜ค๋ฆ„์ฐจ์ˆœ)์œผ๋กœ ์ •๋ ฌ
    ์ž…๋ ฅ: ์ •์ˆ˜ n, ๋ฐฐ์—ด S[1..n]
    ์ถœ๋ ฅ: ์ •๋ ฌ๋œ ๋ฐฐ์—ด S

    procedure ExchangeSort(S[1..n])
      for i = 1 to n-1
        for j = i+1 to n
          if S[j] < S[i] then
            exchange S[i] and S[j]

    ๐Ÿ“Œ ํŠน์ง•

    • ๋งค์šฐ ๊ธฐ์ดˆ์ ์ธ ์ •๋ ฌ ๋ฐฉ์‹
    • ๋ชจ๋“  ์Œ์„ ๋น„๊ตํ•˜์—ฌ ์ •๋ ฌ
    • ์‹œ๊ฐ„๋ณต์žก๋„: O(n²)

    ๐Ÿ”น Algorithm 1.4: Matrix Multiplication

    ๋ฌธ์ œ: ๋‘ ์ •๋ฐฉ ํ–‰๋ ฌ A, B๋ฅผ ๊ณฑํ•˜์—ฌ C๋ฅผ ๊ตฌํ•˜๋ผ
    ์ž…๋ ฅ: ์ •์ˆ˜ n, A[n×n], B[n×n]
    ์ถœ๋ ฅ: C[n×n] = A × B

    procedure MatrixMultiplication(A[1..n,1..n], B[1..n,1..n], C[1..n,1..n])
      for i = 1 to n
        for j = 1 to n
          C[i,j] ← 0
          for k = 1 to n
            C[i,j] ← C[i,j] + A[i,k] × B[k,j]

     

    ๐ŸŽฏ ๋ชฉ์ 

    ๋‘ ์ •๋ฐฉ ํ–‰๋ ฌ A[n×n]๊ณผ B[n×n]๋ฅผ ๊ณฑํ•˜์—ฌ ๊ฒฐ๊ณผ ํ–‰๋ ฌ C[n×n]์„ ๊ตฌํ•˜๋ผ.


    ๐Ÿ”Ž ํ–‰๋ ฌ ๊ณฑ์…ˆ ์ •์˜ ๋ณต์Šต

    ๋‘ ํ–‰๋ ฌ์˜ ๊ณฑ C = A × B์—์„œ
    C[i][j]์˜ ๊ฐ’์€ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๊ณ„์‚ฐ๋จ:

    C[i][j]=A[i][1]⋅B[1][j]+A[i][2]⋅B[2][j]+โ‹ฏ+A[i][n]⋅B[n][j]

    ์ฆ‰,

    • A์˜ i๋ฒˆ์งธ ํ–‰๊ณผ B์˜ j๋ฒˆ์งธ ์—ด์„ ๊ณฑํ•ด์„œ ๋”ํ•œ ๊ฐ’

    pseudocode ๋ถ„์„

    procedure MatrixMultiplication(A[1..n,1..n], B[1..n,1..n], C[1..n,1..n])
      for i = 1 to n                โŸถ C์˜ ํ–‰ ์ธ๋ฑ์Šค
        for j = 1 to n              โŸถ C์˜ ์—ด ์ธ๋ฑ์Šค
          C[i,j] ← 0                โŸถ C[i][j] ๊ฐ’ ์ดˆ๊ธฐํ™”
          for k = 1 to n            โŸถ A์™€ B์˜ ๊ณฑ์…ˆ์— ํ•„์š”ํ•œ ์ธ๋ฑ์Šค
            C[i,j] ← C[i,j] + A[i,k] × B[k,j]

    ๐Ÿ” ๋ฐ˜๋ณต ๊ตฌ์กฐ ์š”์•ฝ

    ๋ฐ˜๋ณต๋ฌธ ์˜๋ฏธ
    i ๋ฐ˜๋ณต A์˜ ํ–‰ (C์˜ ํ–‰)
    j ๋ฐ˜๋ณต B์˜ ์—ด (C์˜ ์—ด)
    k ๋ฐ˜๋ณต A์˜ ํ–‰ x B์˜ ์—ด ์„ฑ๋ถ„ ํ•˜๋‚˜์”ฉ ๊ณฑํ•˜๋ฉด์„œ ๋ˆ„์ ํ•ฉ ๊ณ„์‚ฐ

    ๐Ÿ“Œ ์˜ˆ์ œ (2×2 ํ–‰๋ ฌ ๊ณฑ์…ˆ)

    โฑ ์‹œ๊ฐ„ ๋ณต์žก๋„

    • 3์ค‘ ๋ฐ˜๋ณต๋ฌธ → n × n × n = O(n³)
    • ํ–‰๋ ฌ ํฌ๊ธฐ๊ฐ€ ์ปค์งˆ์ˆ˜๋ก ๊ณ„์‚ฐ๋Ÿ‰ ๊ธ‰๊ฒฉํžˆ ์ฆ๊ฐ€

    ๐Ÿ“˜ ์š”์•ฝ

     

    ํ•ญ๋ชฉ ๋‚ด์šฉ
    ํ•ต์‹ฌ ์•„์ด๋””์–ด A์˜ ํ–‰๊ณผ B์˜ ์—ด์„ ๊ณฑํ•ด์„œ ๋ˆ„์ 
    ์ธ๋ฑ์Šค ์—ญํ•  i: ํ–‰ / j: ์—ด / k: ๋ˆ„์  ์ธ๋ฑ์Šค
    ๋ณต์žก๋„ O(n³)
    ์ฃผ์˜ํ•  ์  C[i][j]๋Š” ๊ผญ 0์œผ๋กœ ์ดˆ๊ธฐํ™”ํ•ด์•ผ ํ•จ

    pseudocode ์‚ฌ์šฉ ๋ฐฉ์‹ ๋ณด์ถฉ ์„ค๋ช…

    • exchange x and y ๊ฐ™์ด ์ง๊ด€์ ์œผ๋กœ ์“ฐ๋Š” ํ‘œํ˜„ ์‚ฌ์šฉ
    • ๋ฐ˜๋ณต๋ฌธ๋„ repeat n times ๊ฐ™์ด ์‹ฌํ”Œํ•œ ํ‘œํ˜„ ํ—ˆ์šฉ
    • ๋ฐฐ์—ด ์ธ๋ฑ์Šค๋Š” 1๋ถ€ํ„ฐ ์‹œ์ž‘ํ•˜๋ฉฐ, ๋ฒ”์œ„ ๋ช…์‹œ (ex: S[2..n])
    • ๋ฐฐ์—ด์€ ์ž๋™ ์ฐธ์กฐ ์ „๋‹ฌ(call by address)
      → ๋ณ„๋„๋กœ & ๋ถ™์ด์ง€ ์•Š์Œ
    • const๋Š” ๋ฐฐ์—ด์ด ์ฝ๊ธฐ ์ „์šฉ์ž„์„ ํ‘œ์‹œ

    ๐Ÿง  ์‹œํ—˜ ๋Œ€๋น„ ์ฒดํฌํฌ์ธํŠธ

    ์ฒดํฌ๋‚ด์šฉ

     

    ์ฒดํฌ ๋‚ด์šฉ
    โœ… pseudocode๋Š” C++๋ณด๋‹ค ๊ฐ„๋‹จํ•˜๊ณ  ์ˆ˜ํ•™์  ํ‘œํ˜„ ํ—ˆ์šฉ
    โœ… ๋ฐฐ์—ด ์ธ๋ฑ์Šค๋Š” ๊ธฐ๋ณธ์ ์œผ๋กœ 1๋ถ€ํ„ฐ ์‚ฌ์šฉ
    โœ… ๊ฐ ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ์ž…๋ ฅ/์ถœ๋ ฅ/๊ธฐ๋ณธ ๋™์ž‘ ํŒŒ์•…
    โœ… ์‹œ๊ฐ„๋ณต์žก๋„๋Š” ๋ฐ˜๋“œ์‹œ ๊ธฐ์–ตํ•  ๊ฒƒ (ํŠนํžˆ O(n), O(n²), O(n³) ๊ตฌ๋ถ„)

    ๋Œ“๊ธ€

Designed by Tistory.