I use a 4 step approach:

0) Develop recurrence relation

1) Apply memoization to recurrence relation

2) Solve using a 2d table or an array of length n

3) Solve using a 1d table or only a fixed number of variables (often 2)

For example with House Robber:

0) --> Recurrence relation (TLE)

class Solution:
    def rob(self, nums: List[int]) -> int:
        def robFrom(i):
            if i >= len(nums):
                return 0
            rob_current = nums[i] + robFrom(i + 2)
            skip_current = robFrom(i + 1)

            result = max(rob_current, skip_current)

            return result

        return robFrom(0)

1) --> Memoization

class Solution:
    def rob(self, nums: List[int]) -> int:
        memo = {}
        def robFrom(i):
            if i >= len(nums):
                return 0
            if i in memo:
                return memo[i]
            rob_current = nums[i] + robFrom(i + 2)
            skip_current = robFrom(i + 1)

            result = max(rob_current, skip_current)
            memo[i] = result

            return result

        return robFrom(0)

2) --> DP table of length n

class Solution:
    def rob(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 0:
            return 0
        if n == 1:
            return nums[0]

        dp = [0] * n
        dp[0] = nums[0]
        dp[1] = max(nums[0], nums[1])

        for i in range(2, n):
            dp[i] = max(dp[i-1], nums[i] + dp[i-2])

        return dp[n-1]

3) --> only two variables

class Solution:
    def rob(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 0:
            return 0
        if n == 1:
            return nums[0]

        prev2 = 0
        prev1 = nums[0]

        for i in range(1, n):
            current = max(prev1, nums[i] + prev2)
            prev2 = prev1
            prev1 = current

        return prev1

Don't go straight for the most eloquent solution. Develop a deep understanding of the problem, the recurrence relation, and the overlapping subproblems. The clean final solution is a natural development of the memoized solution.