leetcode 5

最长公共子序列

public class LCSubsequence {
    public static int lcs(String s1,String s2){
        char[] str1 = s1.toCharArray();
        char[] str2 = s2.toCharArray();
        int N  = str1.length;
        int M = str2.length;
        return process(str1,str2,N-1,M-1);
    }

    public static int process(char[] str1,char[] str2,int i1,int i2){
        if(i1 == 0 && i2 == 0){
            return str1[i1] == str2[i2] ? 1 : 0;
        }
        //i1和i2不同时为0
        if(i1 == 0){
            return ((str1[i1] == str2[i2]) || process(str1,str2,i1,i2-1) == 1) ? 1: 0;
        }
        if(i2 == 0){
            return ((str1[i1] == str2[i2]) || process(str1,str2,i1-1,i2)==1) ? 1 : 0;
        }
        //i1和i2都不是0
        //最长公共子序列结尾，不是以str1[i1]与str2[i2]结尾
        int p1 = process(str1,str2,i1-1,i2-1);
        //以i1结尾，补i2结尾
        int p2 = process(str1,str2,i1,i2-1);

        int p3 = process(str1, str2, i1-1, i2);
       //以i1结尾 以i2结尾
        int p4 = -1;
        if(str1[i1] == str2[i2]){
            p4 = p1 + 1;
        }
    return Math.max(Math.max(p1,p2),Math.max(p3,p4));
    }
    public static int dp(String s1,String s2){
        char[] str1 = s1.toCharArray();
        char[] str2 = s2.toCharArray();
        int N = str1.length;
        int M = str2.length;
        
        int[][] dp = new int[N][M];
        dp[0][0] = str1[0] == str2[0] ? 1 : 0;
        for (int i = 1; i < M; i++) {
            dp[0][i] = str1[0] == str2[i] ? 1 : dp[0][i-1];
        }
        for (int i = 1; i < N; i++) {
            dp[i][0] = str1[i] == str2[0] ? 1 : dp[i-1][0];
        }

        for (int i = 1; i < N; i++) {
           for(int j = 1;j < M;j++){
               //p2和p3的可能性
               dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]);
                //不用可能性1的情况了，上一行已经说明小于左边和上边的值了，所以对于结果肯定小于dp[i-1][j-1]
               if(str1[i] == str2[j]){
                   dp[i][j] = Math.max(dp[i][j],dp[i-1][j-1] + 1);
               }
           }
        }
        return dp[N-1][M-1];
    }
}

import sun.reflect.generics.tree.Tree;

import java.util.TreeMap;

public class GetFolderTree {
    public static class Node{
        public String path;
        public TreeMap<String,Node> nextMap;

        public Node(String p){
            this.path = p;
            nextMap = new TreeMap<>();
        }
    }
    public static void print(String[] folderPaths){
        if(folderPaths == null || folderPaths.length == 0){
            return;
        }
        Node head = generateFolderTree(folderPaths);
        printProcess(head,0);
    }
    public static void printProcess(Node node,int level){
        if(level != 0){
            System.out.println(get4nSpace(level)+node.path);
        }
        for(Node next:node.nextMap.values()){
            printProcess(node,level+1);
        }
    }

    public static String get4nSpace(int n){
        //打印空格
        return "";
    }
    //建立前缀树
    public static Node generateFolderTree(String[] folderPaths){
        Node head = new Node("");
        for(String foldPath:folderPaths){
            String[] paths = foldPath.split("\\\\");
            Node cur = head;
            for (int i = 0; i < paths.length; i++) {
                if(!cur.nextMap.containsKey(paths[i])){
                    cur.nextMap.put(paths[i],new Node(paths[i]));
                }
                cur = cur.nextMap.get(paths[i]);
            }
        }
        return head;
    }
    public static void main(String[] args) {
        String test = "a\\b\\cd";
        String[] arr = test.split("\\\\");
        for (String str :
                arr) {
            System.out.println(str  );
        }
    }
}

public class PreAndInArrayToPosArray {
    public static int[] preInToPos1(int[] pre,int[] in){
        if(pre == null || in == null || pre.length != in.length){
            return null;
        }
        int N = pre.length;
        int[] pos = new int[N];
        process1(pre,0,N-1,in,0,N-1,pos,0,N-1);
        return pos;
    }

    //三个数组必须等长
    public static void process1(
            int[] pre,int L1,int R1,
            int[] in,int L2,int R2,
            int[] pos,int L3,int R3
    ){
        if(L1 > R1){
            return ;
        }
        if (L1 == R1) {
            pos[L3] = pre[L1];
            return;
        }
        pos[R3] = pre[L1];
        int mid = L2;
        for(;mid <= R2;mid++){
            if(in[mid] == pre[L1]){
                break;
            }
        }

        int leftSize = mid - L2;
        process1(pre,L1+1,L1+leftSize,in,L2,mid-1,pos,L3,L3+leftSize-1);
        process1(pre,L1+leftSize+1,R1,in,mid+1,R2,pos,L3+leftSize,R3-1);
    }
}

难记住

public class LIS {
    public static int[] getdp2(int[] arr){
        int[] dp = new int[arr.length];
        int[] ends = new int[arr.length];//满足最长子序列i+1的最小尾数
        ends[0] = arr[0];
        dp[0] = 1;
        int right =0;//0.。。right是有效区
        //下面三个变量是二分用的
        int l = 0;
        int r = 0;
        int m = 0;
        //找到数组arr大于ends的最左位置
        for (int i = 0; i < arr.length; i++) {
            l = 0;
            r = right;
            while(l <= r){
                m = (l+r)/2;
                if(arr[i] > ends[m]){
                    l = m+1;
                }else{
                    r = m-1;
                }
            }
            //结果就是l,如果没有找到 l->right+1
            right = Math.max(right,l);
            ends[l] = arr[i];
            dp[i] = l+1;
        }
        return dp;
    }
}

思路：每个信封都有长宽，长按照从小到大排列，如果长相等，宽从大到小排列，在这些宽组成的数组，最长递增子序列就是答案。
因为在长相等的情况下，宽从大到小，从左往右不能嵌套，