leetcode刷题总结(6-10题)

六、ZigZag Conversion

本题属于比较简单的，很容易就能总结出规律。

一个zigzag数以2*numRows-2为一个循环，每一个竖行的字母下标为一个cycle，除了第一行和最后一行，中间各行都要加一个j+cycle-2*i ，i为从零开始的行号，j为每个循环里i+cycle*n.

class Solution {
    public String convert(String s, int numRows) {
        int length = s.length();
        if (length == 0||numRows<2)
        {
            return s;
        }
        String res = "";
        int cycle = 2*numRows-2;
        for(int i = 0;i

七、Reverse Integer

这个题看似很简单，但是要考虑很多越界的问题。

class Solution {
    public int reverse(int x) {
       long res = 0;
       long tmp = x;
        if(x==0){
            return 0;
        }
        while(x%10==0){
            x=x/10;
            tmp=x;
        }
        while(tmp!=0){
            res = res*10+tmp%10;
            tmp=tmp/10;
        }  if(res>Integer.MAX_VALUE||res

十、Regular Expression Matching

这个题挺有意思，我做的时候硬是看了半天都没看懂。。。。

不理解最后一个aab和c*a*b为啥也是match的，后来才知道*前面的字母可以是 0个。

public class Solution {
    public boolean isMatch(String s, String p) {
        if(s == null || p == null) {
            return false;
        }
        boolean[][] state = new boolean[s.length() + 1][p.length() + 1];
        state[0][0] = true;
        // no need to initialize state[i][0] as false
        // initialize state[0][j]
        for (int j = 1; j < state[0].length; j++) {
            if (p.charAt(j - 1) == '*') {
                if (state[0][j - 1] || (j > 1 && state[0][j - 2])) {
                    state[0][j] = true;
                }
            } 
        }
        for (int i = 1; i < state.length; i++) {
            for (int j = 1; j < state[0].length; j++) {
                if (s.charAt(i - 1) == p.charAt(j - 1) || p.charAt(j - 1) == '.') {
                    state[i][j] = state[i - 1][j - 1];
                }
                //最简单的情况，两字母相同或者p为.
                if (p.charAt(j - 1) == '*') {     //出现了*
                    if (s.charAt(i - 1) != p.charAt(j - 2) && p.charAt(j - 2) != '.') {     //直接删除*和*之前的
                        state[i][j] = state[i][j - 2];
                    } else {
                        state[i][j] = state[i - 1][j] || state[i][j - 1] || state[i][j - 2];
                    }
                }
            }
        }
        return state[s.length()][p.length()];
    }
}

DP,好难啊。看了一下午，画那个DP的state二维数组画了好久才弄懂，DP这个状态图好像是动态规划的特色，以后注意一下。