【LeetCode算法题库】Day4：Regular Expression Matching & Container With Most Water & Integer to Roman

【Q10】

Given an input string (s) and a pattern (p), implement regular expression matching with support for '.' and '*'.

'.' Matches any single character.

'*' Matches zero or more of the preceding element.

The matching should cover the entire input string (not partial).

Note:

s could be empty and contains only lowercase letters a-z.
p could be empty and contains only lowercase letters a-z, and characters like . or *.

Example 1:

Input:

s = "aa"

p = "a"

Output: false

Explanation: "a" does not match the entire string "aa".

Example 2:

Input:

s = "aa"

p = "a*"

Output: true

Explanation: '*' means zero or more of the precedeng element, 'a'. Therefore, by repeating 'a' once, it becomes "aa".

Example 3:

Input:

s = "ab"

p = ".*"

Output: true

Explanation: ".*" means "zero or more (*) of any character (.)".

Example 4:

Input:

s = "aab"

p = "c*a*b"

Output: true

Explanation: c can be repeated 0 times, a can be repeated 1 time. Therefore it matches "aab".

Example 5:

Input:

s = "mississippi"

p = "mis*is*p*."

Output: false

Solution： 用正则表达式，解法比较作弊，详细的动态规划解法见链接：
https://leetcode.com/problems/regular-expression-matching/discuss/5723/My-DP-approach-in-Python-with-comments-and-unittest

（1）动态规划

import unittest

class Solution(object):

    def isMatch(self, s, p):

        # The DP table and the string s and p use the same indexes i and j, but

        # table[i][j] means the match status between p[:i] and s[:j], i.e.

        # table[0][0] means the match status of two empty strings, and

        # table[1][1] means the match status of p[0] and s[0]. Therefore, when

        # refering to the i-th and the j-th characters of p and s for updating

        # table[i][j], we use p[i - 1] and s[j - 1].

        # Initialize the table with False. The first row is satisfied.

        table = [[False] * (len(s) + 1) for _ in range(len(p) + 1)]

        # Update the corner case of matching two empty strings.

        table[0][0] = True

        # Update the corner case of when s is an empty string but p is not.

        # Since each '*' can eliminate the charter before it, the table is

        # vertically updated by the one before previous. [test_symbol_0]

        for i in range(2, len(p) + 1):

            table[i][0] = table[i - 2][0] and p[i - 1] == '*'

        for i in range(1, len(p) + 1):

            for j in range(1, len(s) + 1):

                if p[i - 1] != "*":

                    # Update the table by referring the diagonal element.

                    table[i][j] = table[i - 1][j - 1] and \

                                  (p[i - 1] == s[j - 1] or p[i - 1] == '.')

                else:

                    # Eliminations (referring to the vertical element)

                    # Either refer to the one before previous or the previous.

                    # I.e. * eliminate the previous or count the previous.

                    # [test_symbol_1]

                    table[i][j] = table[i - 2][j] or table[i - 1][j]

                    # Propagations (referring to the horizontal element)

                    # If p's previous one is equal to the current s, with

                    # helps of *, the status can be propagated from the left.

                    # [test_symbol_2]

                    if p[i - 2] == s[j - 1] or p[i - 2] == '.':

                        table[i][j] |= table[i][j - 1]

        return table[-1][-1]

（2）正则表达式：

class Solution:

    def isMatch(self, s, p):

        import re

        return re.match('^'+p+'$',s)!=None

【Q11】

Given n non-negative integers a1, a2, ..., an , where each represents a point at coordinate (i, ai). nvertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.

Note: You may not slant the container and n is at least 2.

The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.

Example:

Input: [1,8,6,2,5,4,8,3,7]

Output: 49

解法：从左右两边依次向里递进，声明两个变量area（存储当前水槽容量）和maxArea（存储水槽历史最大容量）。
由于水槽中的水总量总是由左右两柱中较低的那一个决定，所以每次计算完当前水槽总量后，将较低位向里推进，直至到达中心位置处，搜索完毕。
计算量为O（n）

class Solution:

    def maxArea(self, height):

        """

        :type height: List[int]

        :rtype: int

        """

        maxArea = 0

        l = 0

        r = len(height)-1

        while l<r:

            if height[l]<height[r]:

                area = (r-l)*height[l]

                l += 1

            else:

                area = (r-l)*height[r]

                r -= 1

            if area>maxArea:

                maxArea = area

        return maxArea

【Q12】

Symbol       Value

I             1

V             5

X             10

L             50

C             100

D             500

M             1000

For example, two is written as II in Roman numeral, just two one's added together. Twelve is written as, XII, which is simply X + II. The number twenty seven is written as XXVII, which is XX + V + II.

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

I can be placed before V (5) and X (10) to make 4 and 9.
X can be placed before L (50) and C (100) to make 40 and 90.
C can be placed before D (500) and M (1000) to make 400 and 900.

Given an integer, convert it to a roman numeral. Input is guaranteed to be within the range from 1 to 3999.