๊ด€๋ฆฌ ๋ฉ”๋‰ด

๋‚˜์˜ ๋ชจ์–‘

026 | Greedy, Brute-Force, Binary Search Algorithm ๋ณธ๋ฌธ

SEB/TIL

026 | Greedy, Brute-Force, Binary Search Algorithm

kexon 2022. 7. 29. 02:33

๐Ÿ’™ Greedy Algorithm

  • ์„ ํƒ์˜ ์ˆœ๊ฐ„๋งˆ๋‹ค ๋‹น์žฅ ๋ˆˆ์•ž์— ๋ณด์ด๋Š” ์ตœ์ ์˜ ์ƒํ™ฉ์œผ๋กœ ์ตœ์ข…์ ์ธ ํ•ด๋‹ต์— ๋„๋‹ฌํ•˜๋Š” ๋ฐฉ๋ฒ•
  1. ์„ ํƒ ์ ˆ์ฐจ(Selection Procedure): ํ˜„์žฌ ์ƒํƒœ์—์„œ์˜ ์ตœ์ ์˜ ํ•ด๋‹ต์„ ์„ ํƒ
  2. ์ ์ ˆ์„ฑ ๊ฒ€์‚ฌ(Feasibility Check): ์„ ํƒ๋œ ํ•ด๊ฐ€ ๋ฌธ์ œ์˜ ์กฐ๊ฑด์„ ๋งŒ์กฑํ•˜๋Š”์ง€ ๊ฒ€์‚ฌ
  3. ํ•ด๋‹ต ๊ฒ€์‚ฌ(Solution Check): ์›๋ž˜์˜ ๋ฌธ์ œ๊ฐ€ ํ•ด๊ฒฐ๋˜์—ˆ๋Š”์ง€ ๊ฒ€์‚ฌํ•˜๊ณ , ํ•ด๊ฒฐ๋˜์ง€ ์•Š์•˜๋‹ค๋ฉด ์„ ํƒ ์ ˆ์ฐจ๋กœ ๋Œ์•„๊ฐ€ ์œ„์˜ ๊ณผ์ • ๋ฐ˜๋ณต

๐Ÿค ํƒ์š• ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์กฐ๊ฑด

  • ํƒ์š•์  ์„ ํƒ ์†์„ฑ(Greedy Choice Property): ์•ž์˜ ์„ ํƒ์ด ์ดํ›„์˜ ์„ ํƒ์— ์˜ํ–ฅ์„ ์ฃผ์ง€ ์•Š์Œ
  • ์ตœ์  ๋ถ€๋ถ„ ๊ตฌ์กฐ(Optimal Substructure): ๋ฌธ์ œ์— ๋Œ€ํ•œ ์ตœ์ข… ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•์€, ๋ถ€๋ถ„ ๋ฌธ์ œ์— ๋Œ€ํ•œ ์ตœ์  ๋ฌธ์ œ ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•์œผ๋กœ ๊ตฌ์„ฑ

⇒ ํ•ญ์ƒ ์ตœ์ ์˜ ๊ฒฐ๊ณผ๋ฅผ ๋„์ถœํ•˜๋Š” ๊ฒƒ์€ ์•„๋‹ˆ์ง€๋งŒ, ์–ด๋Š ์ •๋„ ์ตœ์ ์— ๊ทผ์‚ฌํ•œ ๊ฐ’์„ ๋น ๋ฅด๊ฒŒ ๋„์ถœํ•  ์ˆ˜ ์žˆ๋Š” ์žฅ์  ๋•Œ๋ฌธ์— ํƒ์š• ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ๊ทผ์‚ฌ ์•Œ๊ณ ๋ฆฌ์ฆ˜์œผ๋กœ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Œ

๐Ÿ’™ Brute-Force Algorithm

  • ๋ชจ๋“  ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ์‹œ์ž‘์ ์œผ๋กœ, ๋ชจ๋“  ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ์‹œ๋„ํ•˜๋Š” ๋งŒํผ ์ง๊ด€์ ์ด๊ณ  ๋ช…ํ™•ํ•˜์ง€๋งŒ, ์ž…๋ ฅ๊ฐ’์ด ํด์ˆ˜๋ก ์˜ค๋ž˜ ๊ฑธ๋ฆผ
  • ์•”ํ˜ธํ•™์—์„œ Brute Force Attack: ํŠน์ •ํ•œ ์•”ํ˜ธ๋ฅผ ํ’€๊ธฐ ์œ„ํ•ด์„œ ๋ชจ๋“  ๊ฐ’์„ ๋Œ€์ž…ํ•˜๋Š” ๋ฐฉ๋ฒ•
    • ์ˆ˜๋งŽ์€ ์‹œํ–‰์ฐฉ์˜ค๋ฅผ ํ†ตํ•ด ๋ฏผ๊ฐํ•œ ๋ฐ์ดํ„ฐ๋ฅผ ํ•ดํ‚นํ•˜๋Š” ๋ฐฉ๋ฒ•์œผ๋กœ, ์˜ฌ๋ฐ”๋ฅธ ์กฐํ•ฉ์„ ์ฐพ์„ ๋•Œ๊นŒ์ง€ ๋‹ค์–‘ํ•œ ์กฐํ•ฉ์„ ์‹œ๋„
    • ๋ฌด์ฐจ๋ณ„ ๋Œ€์ž… ๊ณต๊ฒฉ์ด ๋‹ค๋ฅธ ํ•ดํ‚น ๋ฐฉ๋ฒ•๊ณผ ๋‹ค๋ฅธ ์ ์€ ์ง€๋Šฅํ˜• ์ „๋žต์„ ์‚ฌ์šฉํ•˜์ง€ ์•Š์Œ

๐Ÿค ๋ฌด์ฐจ๋ณ„ ๋Œ€์ž… ๋ฐฉ๋ฒ•

  • ์ปดํ“จํ„ฐ ์„ฑ๋Šฅ์—๋งŒ ์˜์กดํ•˜์—ฌ ๋ชจ๋“  ๊ฐ€๋Šฅ์„ฑ์„ ์‹œ๋„ํ•˜์—ฌ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋Š” ๋ฐฉ๋ฒ•
  • Brute Force๋Š” ๊ณต๊ฐ„๋ณต์žก๋„์™€ ์‹œ๊ฐ„๋ณต์žก๋„์˜ ์š”์†Œ๋ฅผ ๊ณ ๋ คํ•˜์ง€ ์•Š๊ณ  ์ตœ์•…์˜ ์‹œ๋‚˜๋ฆฌ์˜ค๋ฅผ ์ทจํ•˜๋”๋ผ๋„ ์†”๋ฃจ์…˜์„ ์ฐพ์œผ๋ ค๊ณ  ํ•˜๋Š” ๋ฐฉ๋ฒ• ์ด๊ธฐ ๋•Œ๋ฌธ์— ์ตœ์ ์˜ ์†”๋ฃจ์…˜์ด ์•„๋‹˜

๐Ÿค When Using of the Brute-Force Algorithm

  • ํ”„๋กœ์„ธ์Šค ์†๋„๋ฅผ ๋†’์ด๋Š”๋ฐ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๋‹ค๋ฅธ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด ์—†์„ ๋•Œ
  • ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋Š” ์—ฌ๋Ÿฌ ์†”๋ฃจ์…˜์ด ์žˆ๊ณ  ๊ฐ ์†”๋ฃจ์…˜์„ ํ™•์ธํ•ด์•ผ ํ•  ๋•Œ
  • ๋ฌธ์ œ์˜ ๊ทœ๋ชจ๊ฐ€ ํ˜„์žฌ ์ž์›์œผ๋กœ ์ถฉ๋ถ„ํžˆ ์ปค๋ฒ„๊ฐ€ ๊ฐ€๋Šฅํ•  ๋•Œ

⇒ Brute Force Algorithm์€ ๋ฌธ์ œ์— ๋” ์ ์ ˆํ•œ ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•์„ ์ฐพ๊ธฐ ์ „์— ์‹œ๋„ํ•˜๋Š” ๋ฐฉ๋ฒ•์ด์ง€๋งŒ ๋ฐ์ดํ„ฐ์˜ ๋ฒ”์œ„๊ฐ€ ์ปค์งˆ์ˆ˜๋ก ๋น„ํšจ์œจ์  ์ด๋ฏ€๋กœ, ํ”„๋กœ์ ํŠธ์˜ ๊ทœ๋ชจ๊ฐ€ ์ปค์ง„๋‹ค๋ฉด ๋” ํšจ์œจ์ ์ธ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์‚ฌ์šฉํ•ด์•ผ ํ•จ

๐Ÿค Limit of the Brute Force Algorithm

Brute Force Algorithm์€ ๋ฌธ์ œ์˜ ๋ณต์žก๋„์— ๋งค์šฐ ๋ฏผ๊ฐํ•œ ๋‹จ์ ์„ ๊ฐ€์ง€๊ณ  ์žˆ์–ด์„œ, ๋ฌธ์ œ๊ฐ€ ๋ณต์žกํ•ด์งˆ์ˆ˜๋ก ๊ธฐํ•˜๊ธ‰์ˆ˜์ ์œผ๋กœ ๋งŽ์€ ์ž์›์„ ํ•„์š”๋กœ ํ•˜๋Š” ๋น„ํšจ์œจ์ ์ธ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด ๋  ์ˆ˜ ์žˆ์Œ (์—ฌ๊ธฐ์„œ ์ž์›์€ ์‹œ๊ฐ„์ด ๋  ์ˆ˜๋„, ์ปดํ“จํŒ… ์ž์›์ด ๋  ์ˆ˜๋„ ์žˆ์Œ). ๋งŒ์•ฝ ์ด๋ฅผ ๋ฒ—์–ด๋‚œ ๊ฒฝ์šฐ๋Š” ์ •ํ™•๋„๋ฅผ ์กฐ๊ธˆ ํฌ์ƒํ•˜๊ณ  ๋” ํšจ์œจ์ ์ธ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์‚ฌ์šฉ

๐Ÿค Where to Use Binary Search Algorithm

๐Ÿ’ซ  ์ˆœ์ฐจ ๊ฒ€์ƒ‰ ์•Œ๊ณ ๋ฆฌ์ฆ˜(Sequential Search)

  • ๋ฐฐ์—ด ์•ˆ์— ํŠน์ • ๊ฐ’์ด ์กด์žฌํ•˜๋Š”์ง€ ๊ฒ€์ƒ‰ํ•  ๋•Œ ์ธ๋ฑ์Šค 0๋ถ€ํ„ฐ ๋งˆ์ง€๋ง‰ ์ธ๋ฑ์Šค๊นŒ์ง€ ์ฐจ๋ก€๋Œ€๋กœ ๊ฒ€์ƒ‰

public boolean SequentialSearch2(int[] arr, int K) {
	int n = arr.length;
	boolean result = false;
	for(int i = 0; i < n; i++) {
		if(arr[i] == K) {
		result = true;
		}
    }
    
	return result;
}
       
// ๋ฐฐ์—ด์„ ์ˆœํšŒํ•˜๋Š” ๋„์ค‘์—, ํ•ด๋‹นํ•˜๋Š” ๊ฐ’์ด ๋ฐœ๊ฒฌ๋˜๋”๋ผ๋„ ๋ฐฐ์—ด์„ ๋ชจ๋‘ ์ˆœํšŒํ•œ ์ดํ›„์— ๊ฒฐ๊ณผ๊ฐ’์„ ๋ฆฌํ„ด

๐Ÿ’ซ  ๋ฌธ์ž์—ด ๋งค์นญ ์•Œ๊ณ ๋ฆฌ์ฆ˜(Brute-Force String Matching)

  • ๊ธธ์ด๊ฐ€ n์ธ ์ „์ฒด ๋ฌธ์ž์—ด๊ณผ ๊ธธ์ด๊ฐ€ m์ธ ๋ฌธ์ž์—ด ํŒจํ„ด์„ ํฌํ•จํ•˜๋Š”์ง€๋ฅผ ๊ฒ€์ƒ‰

public boolean BruteForceStringMatch(int[] arr, int[] patternArr) {
    // Brute Force ๋ฌธ์ž์—ด ๋งค์นญ์„ ๊ตฌํ˜„
    int n = arr.length;
    int m = patternArr.length;
    for (int i = 0; i < n - m; i++) {
      // ์ „์ฒด ์š”์†Œ๊ฐœ์ˆ˜์—์„œ ํŒจํ„ด๊ฐœ์ˆ˜๋ฅผ ๋บ€ ๋งŒํผ๋งŒ ๋ฐ˜๋ณต -> ๊ทธ ์ˆ˜๊ฐ€ ๋งˆ์ง€๋ง‰ ๋น„๊ต์š”์†Œ์ด๊ธฐ ๋•Œ๋ฌธ
      // i ๋ฐ˜๋ณต๋ฌธ์€ ํŒจํ„ด๊ณผ ๋น„๊ต์˜ ์œ„์น˜๋ฅผ ์žก์Œ
      int j = 0;
      // j๋Š” ์ „์ฒด์™€ ํŒจํ„ด์˜ ์š”์†Œ ํ•˜๋‚˜ํ•˜๋‚˜๋ฅผ ๋น„๊ต
      
      while (j < m && patternArr[j] == arr[i + j]) {
        // j๊ฐ€ ํŒจํ„ด์˜ ๊ฐœ์ˆ˜๋ณด๋‹ค ์ปค์ง€๋ฉด ์•ˆ๋˜๊ธฐ๋•Œ๋ฌธ์— ๊ฐœ์ˆ˜๋งŒํผ๋งŒ ๋ฐ˜๋ณต
        // ํŒจํ„ด์—์„œ๋Š” j์ธ๋ฑ์Šค์™€ ์ „์ฒด์—์„œ๋Š” i + j ์ธ๋ฑ์Šค์˜ ๊ฐ’์ด ๊ฐ™์€์ง€ ํŒ๋‹จ
        // ๊ฐ™์„๋•Œ j์— +1 
        j = j + 1;
      }
      
      if (j == m) {
        // j์™€ ํŒจํ„ด ์ˆ˜๊ฐ€ ๊ฐ™๋‹ค๋Š” ๊ฒƒ์€ ํŒจํ„ด์˜ ๋ฌธ์ž์—ด๊ณผ ์™„์ „ํžˆ ๊ฐ™์€ ๋ถ€๋ถ„์ด ์กด์žฌ
        // ์ด ๋•Œ์˜ ๋น„๊ตํ–ˆ๋˜ ์œ„์น˜๋ฅผ ๋ฐ˜ํ™˜
        return true;
      }
   }
   
   return false;
 }

๐Ÿ’ซ  ์„ ํƒ ์ •๋ ฌ ์•Œ๊ณ ๋ฆฌ์ฆ˜(Selection Sort)

  • ์ „์ฒด ๋ฐฐ์—ด์„ ๊ฒ€์ƒ‰ํ•˜์—ฌ ํ˜„์žฌ ์š”์†Œ์™€ ๋น„๊ตํ•˜๊ณ  ์ปฌ๋ ‰์…˜์ด ์™„์ „ํžˆ ์ •๋ ฌ๋  ๋•Œ๊นŒ์ง€ ํ˜„์žฌ ์š”์†Œ๋ณด๋‹ค ๋” ์ž‘๊ฑฐ๋‚˜ ํฐ ์š”์†Œ(์˜ค๋ฆ„์ฐจ์ˆœ ๋˜๋Š” ๋‚ด๋ฆผ์ฐจ์ˆœ์— ๋”ฐ๋ผ)๋ฅผ ๊ตํ™˜ํ•˜๋Š” ์ •๋ ฌ ์•Œ๊ณ ๋ฆฌ์ฆ˜

public int[] SelectionSort(int[] arr) {
    // ์ฃผ์–ด์ง„ ๋ฐฐ์—ด์„ Selection Sort๋กœ ์˜ค๋ฆ„์ฐจ์ˆœ ์ •๋ ฌ
    for (int i = 0; i < arr.length - 1; i++) {
      // ๋ฐฐ์—ด์˜ 0๋ฒˆ์งธ ์ธ๋ฑ์Šค๋ถ€ํ„ฐ ๋งˆ์ง€๋ง‰์ธ๋ฑ์Šค๊นŒ์ง€ ๋ฐ˜๋ณต
      // ํ˜„์žฌ ๊ฐ’ ์œ„์น˜์— ๊ฐ€์žฅ ์ž‘์€ ๊ฐ’์„ ๋„ฃ์Œ
      int min = i;
      // ํ˜„์žฌ ์ธ๋ฑ์Šค๋ฅผ ์ตœ์†Œ๊ฐ’์˜ ์ธ๋ฑ์Šค๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ๋ณ€์ˆ˜์— ํ• ๋‹น
      for (int j = i + 1; j < arr.length; j++) {
        // ํ˜„์žฌ i์— +1์„ j๋กœ ๋ฐ˜๋ณต๋ฌธ์„ ์ดˆ๊ธฐํ™”ํ•˜๊ณ  i ์ดํ›„์˜ ๋ฐฐ์—ด์š”์†Œ๊ณผ ๋น„๊ตํ•˜๋Š” ๋ฐ˜๋ณต๋ฌธ ๊ตฌ์„ฑ
        if (arr[j] < arr[min]) {
          // j์ธ๋ฑ์Šค์˜ ๋ฐฐ์—ด ๊ฐ’์ด ํ˜„์žฌ ์ธ๋ฑ์Šค์˜ ๋ฐฐ์—ด ๊ฐ’๋ณด๋‹ค ์ž‘๋‹ค๋ฉด
          min = j;
          // j ์ธ๋ฑ์Šค๋ฅผ ์ตœ์†Œ๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ์ธ๋ฑ์Šค๋กœ ํ• ๋‹น
        }
      }
      // ๋ฐ˜๋ณต๋ฌธ์ด ๋๋‚ฌ์„ ๋•Œ min์—๋Š” ์ตœ์†Œ๊ฐ’์˜ ์ธ๋ฑ์Šค๊ฐ€ ๋“ค์–ด์žˆ์Œ
      // i๊ฐ’๊ณผ ์ตœ์†Œ๊ฐ’์„ ๋ฐ”๊ฟ” ํ• ๋‹น
      int temp = arr[i];
      arr[i] = arr[min];
      arr[min] = temp;
    }
    
  // ๋ชจ๋“  ๋ฐ˜๋ณต๋ฌธ์ด ๋๋‚˜๋ฉด ์ •๋ ฌ๋œ ๋ฐฐ์—ด ๋ฐ˜ํ™˜
  return arr;
}

๐Ÿ’™ Binary Search Algorithm

  • ๋ฐ์ดํ„ฐ๊ฐ€ ์ •๋ ฌ๋œ ์ƒํƒœ์—์„œ ์ ˆ๋ฐ˜์”ฉ ๋ฒ”์œ„๋ฅผ ๋‚˜๋ˆ  ๋ถ„ํ•  ์ •๋ณต๊ธฐ๋ฒ•์œผ๋กœ ํŠน์ •ํ•œ ๊ฐ’์„ ์ฐพ์•„๋‚ด๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜

๐Ÿค ๋™์ž‘ ๊ณผ์ •

  • Step 1. ์ •๋ ฌ๋œ ๋ฐฐ์—ด์˜ ๊ฐ€์žฅ ์ค‘๊ฐ„ ์ธ๋ฑ์Šค๋ฅผ ์ง€์ •ํ•œ๋‹ค.
  • Step 2. ์ฐพ์œผ๋ ค๊ณ  ํ•˜๋Š” ๊ฐ’์ด ์ง€์ •ํ•œ ์ค‘๊ฐ„ ์ธ๋ฑ์Šค์˜ ๊ฐ’์ด๋ผ๋ฉด ํƒ์ƒ‰์„ ์ข…๋ฃŒํ•˜๊ณ , ์•„๋‹ˆ๋ผ๋ฉด Step 3์œผ๋กœ ๊ฐ„๋‹ค.
  • Step 3. ์ฐพ์œผ๋ ค๊ณ  ํ•˜๋Š” ๊ฐ’์ด ์ค‘๊ฐ„ ์ธ๋ฑ์Šค์˜ ๊ฐ’๋ณด๋‹ค ํฐ ๊ฐ’์ธ์ง€, ์ž‘์€ ๊ฐ’์ธ์ง€ ํ™•์ธํ•œ๋‹ค.
  • Step 4. ๊ฐ’์ด ์žˆ๋Š” ๋ถ€๋ถ„๊ณผ ๊ฐ’์ด ์—†๋Š” ๋ถ€๋ถ„์œผ๋กœ ๋ถ„๋ฆฌํ•œ๋‹ค.
  • Step 5. ๊ฐ’์ด ์žˆ๋Š” ๋ถ€๋ถ„์—์„œ ๋‹ค์‹œ 1๋‹จ๊ณ„๋ถ€ํ„ฐ ๋ฐ˜๋ณตํ•œ๋‹ค.

๐Ÿค When Using of the Binary Search Algorithm

  • ์ •๋ ฌ๋œ ๋ฐฐ์—ด์—์„œ ์š”์†Ÿ๊ฐ’์„ ๋” ํšจ์œจ์ ์œผ๋กœ ๊ฒ€์ƒ‰ํ•  ๋•Œ
  • ๋ฐ์ดํ„ฐ์˜ ์–‘์ด ๋งŽ์œผ๋ฉด ๋งŽ์„์ˆ˜๋ก ํšจ์œจ์ด ๋†’์•„์„œ ์ •๋ ฌ๋œ ๋ฐ์ดํ„ฐ์˜ ์–‘์ด ๋งŽ์„ ๋•Œ

⇒ ํƒ์ƒ‰์„ ๋ฐ˜๋ณตํ•  ๋•Œ๋งˆ๋‹ค ํƒ์ƒ‰ ๋ฒ”์œ„๊ฐ€ ์ ˆ๋ฐ˜์œผ๋กœ ์ค„์–ด๋“ค๊ฒŒ ๋˜์–ด, ๋ฐ์ดํ„ฐ ์–‘์ด ๋งŽ์„์ˆ˜๋ก ๋” ๋†’์€ ํšจ์œจ์„ ๊ฐ€์ง

๐Ÿค Limit of the Binary Search Algorithm

  • ์ •๋ ฌ๋œ ๋ฐฐ์—ด์—๋งŒ ๊ตฌํ˜„ ๊ฐ€๋Šฅ
    • ๊ทœ๋ชจ๊ฐ€ ์ž‘์€ ๋ฐฐ์—ด์ด๋ผ๋„ ์ •๋ ฌ์ด ๋˜์–ด ์žˆ์ง€ ์•Š๋‹ค๋ฉด ์ •๋ ฌ์„ ํ•œ ํ›„ Binary Search Algorithm์„ ์‚ฌ์šฉํ•ด๋„ ํšจ์œจ์ด ๋‚ฎ์Œ

๐Ÿค Where to Use Binary Search Algorithm

๋Œ€๊ทœ๋ชจ์˜ ๋ฐ์ดํ„ฐ ๊ฒ€์ƒ‰์— ์ฃผ๋กœ ์‚ฌ์šฉ

  • ์‚ฌ์ „ ๊ฒ€์ƒ‰, ๋„์„œ๊ด€ ๋„์„œ ๊ฒ€์ƒ‰, ๋Œ€๊ทœ๋ชจ ์‹œ์Šคํ…œ์— ๋Œ€ํ•œ ๋ฆฌ์†Œ์Šค ์‚ฌํ•ญ ํŒŒ์•…, ๋ฐ˜๋„์ฒด ํ…Œ์ŠคํŠธ ํ”„๋กœ๊ทธ๋žจ์—์„œ ๋””์ง€ํ„ธ, ์•„๋‚ ๋กœ๊ทธ ๋ ˆ๋ฒจ์„ ์ธก์ •

'SEB > TIL' ์นดํ…Œ๊ณ ๋ฆฌ์˜ ๋‹ค๋ฅธ ๊ธ€

029 | ๋„คํŠธ์›Œํฌ - ์›น์„ ๊ตฌ์„ฑํ•˜๋Š” ๊ธฐ์ˆ   (0) 2022.08.02
027 | Permutation & Combination, Greedy Implementation  (0) 2022.07.29
026 | Time Complexity  (0) 2022.07.28
024 | Data Structure - Tree, Graph  (0) 2022.07.26
023 | Data Structure - Stack & Queue  (0) 2022.07.25
Comments