【LEETCODE】66、字符串分类，hard级别，题目：32，72，76

package y2019.Algorithm.str.hard;

import java.util.Stack;

/**
 * @ProjectName: cutter-point
 * @Package: y2019.Algorithm.str.hard
 * @ClassName: LongestValidParentheses
 * @Author: xiaof
 * @Description: 32. Longest Valid Parentheses
 *
 * Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.
 *
 * Example 1:
 *
 * Input: "(()"
 * Output: 2
 * Explanation: The longest valid parentheses substring is "()"
 * Example 2:
 *
 * Input: ")()())"
 * Output: 4
 * Explanation: The longest valid parentheses substring is "()()"
 *
 * 求最长有效括号对，那么就是要确保子串是连续
 * @Date: 2019/8/6 9:51
 * @Version: 1.0
 */
public class LongestValidParentheses {

    public int solution(String s) {
        //用来统计最大的括号数，我们只要能匹配成功就行
        Stack<Integer> stack = new Stack();
        char[] ss = s.toCharArray();
        int n = ss.length, res = 0;

        //遍历
        for (int i = 0; i < ss.length; ++i) {
            if (ss[i] == '(') {
                stack.push(i); //用来存放int位置
            } else {
                if (!stack.isEmpty()) {
                    //如果不为空，那么就可以进行匹配
                    if (ss[stack.peek()] == '(') stack.pop();
                    else stack.push(i);
                } else {
                    stack.push(i);
                }
            }
        }
        //我们只需要统计剩下无法匹配的连续的（的数据比较就可以了
        //如果栈为空，那么正好完全匹配
        if (stack.isEmpty()) {
            res = n;
        } else {
            //如果不是完全匹配，那么就要计算连续两个(的间隔
            int r = n, l = 0;
            while (!stack.isEmpty()) {
                //不断获取最后的结束符号位置
                l = stack.pop();
                //取最长的串位置
                res = Math.max(r - l - 1, res);
                r = l; //更新位置
            }
            //最后还要判断从起始位置开始到当前位置消掉的长度
            res = Math.max(r, res);
        }
        return res;
    }
}

package y2019.Algorithm.str.hard;

/**
 * @ProjectName: cutter-point
 * @Package: y2019.Algorithm.str.hard
 * @ClassName: MinDistance
 * @Author: xiaof
 * @Description: 72. Edit Distance
 * Given two words word1 and word2, find the minimum number of operations required to convert word1 to word2.
 *
 * You have the following 3 operations permitted on a word:
 *
 * Insert a character
 * Delete a character
 * Replace a character
 * Example 1:
 *
 * Input: word1 = "horse", word2 = "ros"
 * Output: 3
 * Explanation:
 * horse -> rorse (replace 'h' with 'r')
 * rorse -> rose (remove 'r')
 * rose -> ros (remove 'e')
 * Example 2:
 *
 * Input: word1 = "intention", word2 = "execution"
 * Output: 5
 * Explanation:
 * intention -> inention (remove 't')
 * inention -> enention (replace 'i' with 'e')
 * enention -> exention (replace 'n' with 'x')
 * exention -> exection (replace 'n' with 'c')
 * exection -> execution (insert 'u')
 * @Date: 2019/8/7 11:42
 * @Version: 1.0
 */
public class MinDistance {

    public int solution(String word1, String word2) {
        int w1 = word1.length(), w2 = word2.length();
        char w1s[] = word1.toCharArray(), w2s[] = word2.toCharArray();
        int[][] dpcost = new int[w1 + 1][w2 + 1];

        //初始化
        for (int i = 0; i <= w1; ++i) {
            dpcost[i][0] = i; //标识要把word1的i个字符化为0个，那就删i次
        }
        for (int j = 0; j <= w2; ++j) {
            dpcost[0][j] = j;
        }
        //这题动态规划了，比较复杂说实话

        //遍历
        for (int i = 1; i < dpcost.length; ++i) {
            for (int j = 1; j < dpcost[i].length; ++j) {
                //我们把动态规划递增的量设置为，word1前i个字符，转换为word2前j个字符需要的最小操作数
                //f(i,j) = f(i-1, j-1) 当word1[i] == word2[j]的时候，相等字符，那么当前字符就不需要花费操作次数
                if (w1s[i - 1] == w2s[j - 1]) {
                    dpcost[i][j] = dpcost[i - 1][j - 1];
                } else {
                    //当word1[i] != word2[j]的时候 分三种情况平衡
                    //1.进行插入操作, 那就是新增一个一样的字符和word2进行匹配，那就是word2的j位就直接新增进去，就不用比较了，我们取没有j号的次数
                    // f(i,j) = f(i, j-1) + 1;
                    int insert = dpcost[i][j - 1];
                    //2.当进行删除操作，那就是把word1当前字符删除掉，当前位置相当于不比较
                    // f(i,j)=f(i-1,j) + 1;
                    int remove = dpcost[i - 1][j];
                    //3.当进行替换操作，那就是把当前字符完全替换，那么就是新增一个操作，其余和之前一样
                    // f(i,j)=f(i-1,j-1) + 1;
                    int replace = dpcost[i - 1][j - 1];

                    dpcost[i][j] = Math.min(insert, Math.min(remove, replace)) + 1;
                }
            }
        }

        return dpcost[w1][w2];

    }
}

package y2019.Algorithm.str.hard;

import java.util.HashMap;
import java.util.Map;

/**
 * @ProjectName: cutter-point
 * @Package: y2019.Algorithm.str.hard
 * @ClassName: MinWindow
 * @Author: xiaof
 * @Description: 76. Minimum Window Substring
 * Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).
 *
 * Example:
 *
 * Input: S = "ADOBECODEBANC", T = "ABC"
 * Output: "BANC"
 * Note:
 *
 * If there is no such window in S that covers all characters in T, return the empty string "".
 * If there is such window, you are guaranteed that there will always be only one unique minimum window in S.
 * @Date: 2019/8/7 15:15
 * @Version: 1.0
 */
public class MinWindow {

    public String solution(String s, String t) {
        if (s == null || t == null || s.length() < t.length() || s.length() == 0 || t.length() == 0) {
            return "";
        }
        //用索引，并且是单次循环
        int l = 0, r = 0, count = t.length(), minle = s.length(), minl = 0, minr = 0;
        Map<Character, Integer> map = new HashMap();
        boolean pipeiok = false;
        //第一次循环，初始化map
        for (int i = 0; i < t.length(); ++i) {
            map.put(t.charAt(i), map.getOrDefault(t.charAt(i), 0) + 1);
        }

        //循环遍历字符串
        while (r < s.length()) {
            //计算是否存在所有字符的子串
            char curc = s.charAt(r);
            if (map.containsKey(curc)) {
                //如果包含
                map.put(curc, map.get(curc) - 1);
                if (map.get(curc) >= 0) {
                    //如果有效匹配
                    --count;
                }
            }

            //如果全部匹配完成,存在单字符匹配
            while (count == 0 && l <= r) {
                pipeiok = true;
                int curlen = r - l + 1;
                if (curlen <= minle) {
                    //存在更小值
                    minl = l;
                    minr = r;
                    minle = curlen;
                }

                //更新最左边索引
                char leftc = s.charAt(l);
                if (map.containsKey(leftc)) {
                    //如果包含，那么就找到了最左边的第一个字符
                    //我们把这个位置的字符剔除掉，然后看是否可以找到更小的子串
                    map.put(leftc, map.get(leftc) + 1);
                    if (map.get(leftc) >= 1) {
                        //加一之后恢复到正常状态
                        count++;
                    }
                }
                //吧最左边右移一次
                l++;
            }
            r++; //往后遍历
        }

        return pipeiok == true ? s.substring(minl, minr + 1) : "";
    }

    public static void main(String[] args) {
        String s[] = {"ADOBECODEBANC", "ABC"};
        String s1[] = {"aa", "aa"};

        MinWindow fuc = new MinWindow();

        fuc.solution(s1[0], s1[1]);

    }
}