每日算法（2021/9/25）

每日算法时间：

1.Valid Parentheses(有效的括号)简单

java：

class Solution {
    public boolean isValid(String s) {

        if(s.length()<2) return false;

        LinkedList<Character> stack = new LinkedList<Character>() {{ add('?'); }};//这里加一个标识符方便之后的map进行判断
        HashMap<Character,Character> map = new HashMap<Character,Character>(){{
            put('{','}');
            put('[',']');
            put('(',')');
            put('?','?');
        }};//放进数据并且放进标识符，如果产生与标识符配对情况，说明配对失败
        for(Character c:s.toCharArray()){//字符串转数组
            if(map.containsKey(c)) stack.addLast(c);//查看是否存在对，不存在则放入
            else if(map.get(stack.removeLast()) != c) return false;
        }
        return stack.size()==1;
    }
}

这里比较有趣的是用到了map中一对一的特性，用来标识括号。

2.Keyboard Row(键盘行)简单

java:

class Solution {
    public String[] findWords(String[] words) {
        HashMap<Character,Integer> map = new HashMap<Character,Integer>(){{
            put('q',1);
            put('w',1);
            put('e',1);
            put('r',1);
            put('t',1);
            put('y',1);
            put('u',1);
            put('i',1);
            put('o',1);
            put('p',1);
            put('a',2);
            put('s',2);
            put('d',2);
            put('f',2);
            put('g',2);
            put('h',2);
            put('j',2);
            put('k',2);
            put('l',2);
            put('z',4);
            put('x',4);
            put('c',4);
            put('v',4);
            put('b',4);
            put('n',4);
            put('m',4);
        }};
        int x=0;
        List<String> list = new ArrayList<String>();
        for(int i=0;i<words.length;i++){
            for(Character c:words[i].toCharArray()){
                x = x + map.get(Character.toLowerCase(c));
            }
            if(x==(words[i].length()*1)||x==(words[i].length()*2)||x==(words[i].length()*4))
                list.add(words[i]);
        }
        String[] strings = new String[list.size()];
        return list.toArray(strings);
    }
}

3.Merge Two Sorted Lists（合并两个有序链表）简单

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null) {
            return l2;
        }
        if(l2 == null) {
            return l1;
        }

        if(l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

4.Delete Operation for Two Strings（两个字符串的删除操作）中等

这个题目光看不好理解，把原题粘过来。

给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。
给定sea，eat
1.sea->ea
2.eat->ea
则相同

java:

class Solution {
    public int minDistance(String s1, String s2) {
        char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();
        int n = s1.length(), m = s2.length();
        int[][] f = new int[n + 1][m + 1];
        for (int i = 0; i <= n; i++) f[i][0] = i;
        for (int j = 0; j <= m; j++) f[0][j] = j;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                f[i][j] = Math.min(f[i - 1][j] + 1, f[i][j - 1] + 1);
                if (cs1[i - 1] == cs2[j - 1]) f[i][j] = Math.min(f[i][j], f[i - 1][j - 1]);
            }
        }
        return f[n][m];
    }
}

 

5.Longest Common Subsequence（最长公共子序列）中等

java：

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {

        int n = text1.length(), m =  text2.length();

        int[][] f = new int[n + 1][m + 1];

        for (int i = 1; i <= n; ++i) {

            for (int j = 1; j <= m; ++j) {

                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {

                    f[i][j] = f[i - 1][j - 1] + 1;
                    
                } else {
                    f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
                }
            }
        }

        return f[n][m];
    }
}

 

6.Regular Expression Matching（正则匹配）困难

 

class Solution {
    public boolean isMatch(String s, String p) {
        int m = s.length();
        int n = p.length();

        boolean[][] f = new boolean[m + 1][n + 1];
        f[0][0] = true;
        for (int i = 0; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (p.charAt(j - 1) == '*') {
                    f[i][j] = f[i][j - 2];
                    if (matches(s, p, i, j - 1)) {
                        f[i][j] = f[i][j] || f[i - 1][j];
                    }
                } else {
                    if (matches(s, p, i, j)) {
                        f[i][j] = f[i - 1][j - 1];
                    }
                }
            }
        }
        return f[m][n];
    }

    public boolean matches(String s, String p, int i, int j) {
        if (i == 0) {
            return false;
        }
        if (p.charAt(j - 1) == '.') {
            return true;
        }
        return s.charAt(i - 1) == p.charAt(j - 1);
    }
}

写了三道动态规划问题，今天下午就深入学习顺便写一下动态规划的博客吧！（cc在写了在写了orz