leetcode 7

dp压缩的方法

    public static int minCost3(String s1,String s2){
        if(s1.length() == 0 || s2.length() == 0){
            return s2.length();
        }
        char[] str2 = s2.toCharArray();
        char[] str1 = s1.toCharArray();
        int M = str2.length;
        int N  = str1.length;
        int[][] dp = new int[M][N];
        int ans = M;//把str2全删除就是M
        for(int start = 0;start < N;start++){//从0列开始
            dp[0][start] = str2[0]==str1[start]?0:M;
            for(int row = 1;row < M;row++){
                //如果row与start相等，等于当前行数，因为下标从0开始的，删除前面的行就可以了
                //如果直线发现start了，设置为row
                dp[row][start] = (str2[row] == str1[start]
                || dp[row-1][start] != M)?row:M;
            }

            ans = Math.min(ans,dp[M-1][start]);
            for(int end = start+1;end < N && end -start <M;end++){
                int first = end -start;
                dp[first][end] = (str2[first] == str1[end] && dp[first-1][end-1] == 0)?0:M;
                //如果左上角值为0且当前行列对应的元素相等

                for(int row = first + 1;row < M;row++){
                    dp[row][end] = M;
                    if(dp[row-1][end] != M){
                        dp[row][end] = dp[row-1][end] + 1;
                    }
                    if(dp[row-1][end-1] != M && str2[row] == str1[end]){
                        dp[row][end] = Math.min(dp[row][end],dp[row-1][end-1]);
                    }
                }
                ans = Math.min(ans,dp[M-1][end]);
            }
        }
        return ans;
    }

LRU

import java.lang.reflect.Array;
import java.util.*;

public class WordMinPaths {
    public static List<List<String>> findMinPaths(
            String start,
            String end,
            List<String> list
    ){
        list.add(start);
        //一个字符串的邻居，这个邻居是在list里有的
        HashMap<String, ArrayList<String>> nexts = getNexts(list);
        //所有的字符串到start的距离
        HashMap<String,Integer> distances = getDistances(start,nexts);
        //上述过程已经知道 所有字符串到start的距离了，但是这个中间的过程具体经过哪些
        //字符串还不知道，
        LinkedList<String> pathList = new LinkedList<>();
        List<List<String>> res = new ArrayList<>();
        getShortestPaths(start,end,nexts,distances,pathList,res);
        return res;
    }

    /**
     *
     * @param cur 现在来到的位置
     * @param to 目的
     * @param nexts 邻居表
     * @param distances 最短距离表
     * @param path 沿途走过的路径
     * @param res 答案往res里放
     */
    public static void getShortestPaths(
            String cur,String to,
            HashMap<String,ArrayList<String>> nexts,
            HashMap<String,Integer> distances,LinkedList<String> path,
            List<List<String>> res
    ){
        path.add(cur);
        if(to.equals(cur)){
            res.add(new LinkedList<String>(path));
        }else{
            for(String next:nexts.get(cur)){
                if(distances.get(next) == distances.get(cur)+1){//严格加1
                    getShortestPaths(next,to,nexts,distances,path,res);
                }
            }
        }
        //* Retrieves and removes the last element of this list,
        //擦除轨迹
        path.pollLast();

    }

    public static HashMap<String,ArrayList<String>> getNexts(List<String> words){
        Set<String> dict = new HashSet<>(words);//list集合转换为set

        HashMap<String,ArrayList<String>> nexts = new HashMap<>();

        for (int i = 0; i < words.size(); i++) {
            nexts.put(words.get(i),getNext(words.get(i),dict));
        }

        return nexts;
    }

    public static ArrayList<String> getNext(String word,Set<String> dict){
        ArrayList<String> res = new ArrayList<String>();
        char[] chs = word.toCharArray();
        //从所有的可能性判断邻居是否在题目给定的列表中出现过
        for(char cur='a';cur<='z';cur++){
            for (int i = 0; i < chs.length; i++) {
                if(chs[i] != cur){
                    char tmp = chs[i];
                    chs[i] = cur;
                    if(dict.contains(String.valueOf(chs))){
                        res.add(String.valueOf(chs));
                    }
                    chs[i] = tmp;
                }
            }
        }
        return res;
    }

    //宽度优先遍历
    public static HashMap<String,Integer> getDistances(String start,
                                                       HashMap<String,ArrayList<String>> nexts){
        HashMap<String,Integer> distances = new HashMap<>();
        distances.put(start,0);
        Queue<String> queue = new LinkedList<>();
        queue.add(start);
        HashSet<String> set = new HashSet<>();
        set.add(start);
        while(!queue.isEmpty()){
            String cur = queue.poll();
            for(String next:nexts.get(cur)){
                if(!set.contains(next)){
                    set.add(next);
                    queue.add(next);
                    distances.put(next,distances.get(cur)+1);
                }
            }
        }
        return distances;
    }
}