Coin Change

    def coinChange(self, coins, amount):
        """
        :type coins: List[int]
        :type amount: int
        :rtype: int
        """
        if amount == 0: return 0
        if not coins: return -1
        dp = [0] + [-1] * amount
        for x in coins:
            for v in range(x, amount+1):
                if dp[v-x] >= 0:
                    dp[v] = min(dp[v], dp[v-x] + 1) if dp[v] > 0 else dp[v-x] + 1
        return dp[amount]

Odd Even Linked List

class Solution(object):
    def oddEvenList(self, head):
        dummy = ListNode(0)
        dummy.next = head
        odd = dummy.next
        if not odd or not odd.next:
            return head
        even = odd.next
        dummy_even = ListNode(0)
        dummy_even.next = even
        while even and odd:
            odd.next = even.next
            odd = odd.next
            if odd:
                even.next = odd.next
                even = even.next
        cur = head
        while cur.next:
            cur = cur.next
        cur.next = dummy_even.next
        return dummy.next

Longest Increasing Path in a Matrix

class Solution(object):
    def longestIncreasingPath(self, M):
        R = len(M)
        if not R: return 0
        C = len(M[0])
        if not C: return 0
        mem = [[0 for _ in range(C)] for _ in range(R)]
        def dfs(i, j):
            tmp = 0
            for (x, y) in [(i, j+1), (i+1, j), (i, j-1), (i-1, j)]:
                if 0 <= x < R and 0 <= y < C:
                    if mem[x][y] == 0 and M[x][y] > M[i][j]:
                        dfs(x, y)
                    if M[x][y] > M[i][j]:
                        tmp = max(tmp, mem[x][y])
            mem[i][j] = tmp + 1
        for i in range(R):
            for j in range(C):
                if mem[i][j] == 0:
                    dfs(i, j)
        result = max([max(row) for row in mem])
        return result