๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ

์•Œ๊ณ ๋ฆฌ์ฆ˜/LEETCODE

Search a 2D Matrix II | LeetCode 806 | Python3 ๐Ÿ

๋ฐ˜์‘ํ˜•

 

๐Ÿ“„ ๋ชฉ์ฐจ

     

     

    ๐Ÿค” ๋ฌธ์ œ : Search a 2D Matrix II | LeetCode 806

    ๋ฌธ์ œ: https://leetcode.com/explore/interview/card/top-interview-questions-medium/110/sorting-and-searching/806/

    Matirx์ƒ์—์„œ ํƒ€๊ฒŸ๊ฐ’์ด ์žˆ๋Š”์ง€ ํ™•์ธํ•˜๋Š” ๋ฌธ์ œ์ž…๋‹ˆ๋‹ค.

    ๋‹จ, Matrix๋Š” ๊ฐ ํ–‰, ์—ด์ด ๋ชจ๋‘ ์ •๋ ฌ๋˜์–ด์žˆ์Šต๋‹ˆ๋‹ค. 

    ๐Ÿ’ก ํ’€์ด

    1. ๊ฐ ์—ด์— ๋Œ€ํ•ด BS

    ๋‹น์—ฐํžˆ BS๋กœ ์ ‘๊ทผํ•ด์•ผ ํ•˜๋Š” ๋ฌธ์ œ๋กœ ์ƒ๊ฐํ–ˆ์Šต๋‹ˆ๋‹ค.

    1) ๊ฐ ์—ด์˜ ์ฒซ๋ฒˆ์งธ ํ•ญ์„ ์ˆœํšŒํ•ฉ๋‹ˆ๋‹ค. ์ฒซ ํ–‰์„ ์ˆœํšŒํ•˜๋Š”๊ฒŒ ๋˜๊ฒ ์ฃ .

    2) ์—ด์˜ ์ฒซ๋ฒˆ์žฌ ๊ฐ’์ด ํƒ€๊ฒŸ๊ฐ’๋ณด๋‹ค ์ž‘์œผ๋ฉด, ๊ทธ ์—ด์— ํƒ€๊ฒŸ๊ฐ’์ด ์žˆ์„ ์ˆ˜ ์žˆ๋‹ค๋Š” ๋œป์ด๊ฒ ์ฃ ? ํ•ด๋‹น ์—ด์— ๋Œ€ํ•ด BS๋ฅผ ํ•ฉ๋‹ˆ๋‹ค.

    class Solution:
        def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
            def bs(listIdx, st, ed):
                if st > ed: return False
                md = int((st + ed) /2)
                if matrix[listIdx][md] == target: return True
                if matrix[listIdx][md] < target: return bs(listIdx, md+1, ed)
                return bs(listIdx, st, md-1)
    
            for listIdx in range(len(matrix)): # ๊ฐ ์—ด์— ๋Œ€ํ•ด์„œ 
                if matrix[listIdx][0] == target: return True
                if matrix[listIdx][0] < target: # ์ฒซ๋ฒˆ์งธ ๊ฐ’์ด ํƒ€๊ฒŸ๊ฐ’๋ณด๋‹ค ์ž‘์œผ๋ฉด BS
                    if bs(listIdx, 0, len(matrix[listIdx])-1):
                        return True
            return False

     

    Time Complexity
    ์ตœ์•…์˜ ๊ฒฝ์šฐ ๋งˆ์ง€๋ง‰ ์—ด์— ํƒ€๊ฒŸ๊ฐ’์ด ์žˆ์œผ๋ฉด logN์„ n๋ฒˆ ์ˆ˜ํ–‰ํ•ฉ๋‹ˆ๋‹ค.
    O(NlogN)

     

     

    2. BS๋ฅผ ์“ฐ์ง€ ์•Š๋Š” ํ’€์ด?!

    1๋ฒˆํ’€์ด๊ฐ€ ์ข€.. ๋ง‰๋ฌด๊ฐ€๋‚ด์ธ๊ฐ€(?) ํ•˜๋Š” ์ƒ๊ฐ์ด ๋“ค์–ด ๋‹ค๋ฅธ ํ’€์ด๋“ค์„ ์ฐพ์•„๋ดค๋Š”๋ฐ ์—ญ์‹œ๋‚˜ ํš๊ธฐ์ ์ธ ํ’€์ด๊ฐ€ ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค.

     

    ์™ผ์ชฝ๋งจ ์•„๋ž˜ ๊ฐ’ ๋ถ€ํ„ฐ ํƒ€๊ฒŸ๊ฐ’์„ ์ฐพ์•„๊ฐ€๋Š”๋ฐฉ์‹์ž…๋‹ˆ๋‹ค.

    ํ˜„์žฌ ๋ณด๊ณ ์žˆ๋Š” ๊ฐ’์ด ํƒ€๊ฒŸ๊ฐ’๋ณด๋‹ค ํฌ๋‹ค๋ฉด?

    ์ง€๊ธˆ๋ณด๋‹ค ์˜ค๋ฅธ์ชฝ ์•„๋ž˜์—๋Š” ํƒ€๊ฒŸ๊ฐ’์ด ์žˆ์„ ์ˆ˜ ์—†๊ฒ ์ฃ . ํ˜„์žฌ๊ฐ’์˜ ์˜ค๋ฅธ์ชฝ ์•„๋ž˜์ชฝ์€ ๋‹ค ํ˜„์žฌ๊ฐ’๋ณด๋‹ค ํฌ๋‹ˆ๊น์š”.

    ๊ทธ๋Ÿผ ๋ณด๊ณ  ์žˆ๋Š” ๊ฐ’์„ ์œ„๋กœ ํ•œ ์นธ  ์˜ฎ๊น๋‹ˆ๋‹ค. 

     

    ํ˜„์žฌ ๋ณด๊ณ ์žˆ๋Š” ๊ฐ’์ด ํƒ€๊ฒŸ๊ฐ’๋ณด๋‹ค ์ž‘๋‹ค๋ฉด?

    ์ง€๊ธˆ๋ณด๋‹ค ์™ผ์ชฝ ์œ„์—๋Š” ํƒ€๊ฒŸ๊ฐ’์ด ์žˆ์„ ์ˆ˜ ์—†๊ฒ ์ฃ . ํ˜„์žฌ๊ฐ’์˜ ์™ผ์ชฝ ์œ„๋Š” ๋‹ค ํ˜„์žฌ๊ฐ’๋ณด๋‹ค ํฌ๋‹ˆ๊น์š”.

    ๊ทธ๋Ÿผ ๋ณด๊ณ  ์žˆ๋Š” ๊ฐ’์„ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ํ•œ ์นธ  ์˜ฎ๊น๋‹ˆ๋‹ค. 

    class Solution:
        def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
            m = len(matrix)
            n = len(matrix[0])
            
            def solve(i, j):
                if i < 0: return False
                if j >= n: return False
                
                if matrix[i][j] == target: return True
                if matrix[i][j] < target: return solve(i, j+1)
                if matrix[i][j] > target: return solve(i-1, j)          
            return solve(m-1, 0)

     

    Time complexity
    ํƒ€๊ฒŸ๊ฐ’์ด ํ–‰๋ ฌ์˜ ๊ฐ€์žฅ ์˜ค๋ฅธ์ชฝ ๊ฐ€์žฅ ์œ„์— ์žˆ๋Š” ๊ฒฝ์šฐ๊ฐ€ ์ตœ์•…์˜ ๊ฒฝ์šฐ๊ฐ€ ๋˜๊ณ 
    ์ด ๋•Œ์˜ time complexity๋Š” m:๊ฐ€๋กœ๊ธธ์ด, n:์„ธ๋กœ๊ธธ์ด๋ผ ํ•  ๋•Œ
    O(m+n)

     

    ๋ฐ˜์‘ํ˜•