leetcode 9

public class TopKSumCrossTwoArrays {
    public static class Node{
        public int index1;
        public int index2;
        public int sum;

        public Node(int i1,int i2,int s){
            index1 = i1;
            index2 = i2;
            sum = s;
        }
    }

    public static  class  MaxHeapComp implements Comparator<Node>{
        @Override
        public int compare(Node o1, Node o2) {
            return o2.sum - o1.sum;
        }
    }

    public static int[] topKSum(int[] arr1,int[] arr2,int topK){
        if(arr1 == null || arr2==null || topK < 1){
            return 0;
        }

        topK = Math.min(topK,arr1.length * arr2.length);

        int[] res=  new int[topK];
        int resIndex = 0;

        PriorityQueue<Node> maxHeap = new PriorityQueue<>(new MaxHeapComp());

        boolean[][] set = new boolean[arr1.length][arr2.length];
        int i1 = arr1.length;
        int i2 = arr2.length;
        maxHeap.add(new Node(i1,i2,arr1[i1]+arr2[i2]));
        set[i1][i2] = true;
        while(resIndex != topK){
            Node curNode = maxHeap.poll();
            res[resIndex++] = curNode.sum;
            i1 = curNode.index1;
            i2 = curNode.index2;
            if(i1 - 1 >= 0 && !set[i1-1][i2]){
                set[i1-1][i2] = true;
                maxHeap.add(new Node(i1-1,i2,arr1[i1-1]+arr2[i2]));
            }

            if(i2-1>=0 && !set[i1][i2-1]){
                set[i1][i2-1] = true;
                maxHeap.add(new Node(i1,i2-1,arr1[i1]+arr2[i2-1]));
            }

        }

    return res;
    }
}

import java.util.HashMap;

public class Split4Parts {
    public static boolean canSplits2(int[] arr){
        if(arr == null || arr.length < 7){
            return false;
        }
        HashMap<Integer,Integer> map = new HashMap<Integer, Integer>();
        int sum = arr[0];
        for(int i = 1;i < arr.length;i++){
            map.put(sum,i);
            sum += arr[i];
        }
        int lsum = arr[0];
        for(int s1 = 1;s1<arr.length-5;s1++){
            int checkSum = lsum * 2 + arr[s1];
            if(map.containsKey(checkSum)){
                int s2 = map.get(checkSum);
                checkSum += lsum + arr[s2];
                if(map.containsKey(checkSum)){
                    int s3 = map.get(checkSum);
                    if(checkSum + arr[s3] + lsum == sum){
                        return true;
                    }
                }
            }
            lsum += arr[s1];
        }
        return true;
    }
}

public class StringCross {
    public static boolean isCross1(String s1,String s2,String ai){
        if(s1 == null || s2 == null || ai == null){
            return false;
        }
        char[] str1 = s1.toCharArray();
        char[] str2 = s2.toCharArray();
        char[] aim = ai.toCharArray();
        if(aim.length != str1.length + str2.length){
            return false;
        }
        //dp[i][j]表示str1 从开头0位置到i-1位置  和 str2 从开头0位置到j-1位置 能否交错组成 aim从0到i+j-1位置
        boolean[][] dp = new boolean[str1.length+1][str2.length+1];
        dp[0][0] =true;
        for (int i = 1; i <= str1.length ; i++) {
            if(str1[i-1] != aim[i-1]){
                break;
            }
            dp[i][0] = true;
        }
        for(int j = 1;j <=str2.length;j++){
            if(str2[j-1] != aim[j-1]){
                break;
            }
            dp[0][j] = true;
        }
        for (int i = 1; i <= str1.length ; i++) {
            for(int j = 1;j <=str2.length;j++){
                if(
                        (str1[i-1] == aim[i+j-1] && dp[i-1][j])
                        ||
                                (str2[j-1] == aim[i+j-1] && dp[i][j-1])
                ){
                    dp[i][j] = true;
                }
            }

        }
        return dp[str1.length][str2.length];
    }
}

public class MinLengthForSort {
    public static int getMinLength(int[] arr){
        if(arr == null || arr.length < 2){
            return 0;
        }
        int min = arr[arr.length -1];
        int noMinIndex = -1;
        for (int i = arr.length-2; i != -1 ; i--) {
            if(arr[i] > min){
                noMinIndex = i;
            }else{
                min = Math.min(min,arr[i]);
            }
        }
        if(noMinIndex == -1){
            return 0;
        }
        int max = arr[0];
        int noMaxIndex = -1;
        for (int i = 1; i != arr.length; i++) {
            if(arr[i] < max){
                noMaxIndex = i;
            }else{
                max = Math.max(max,arr[i]);
            }
        }
        if(noMaxIndex == -1){
            return 0;
        }
        
        return noMaxIndex - noMinIndex + 1;
    }
}

最小不可组成和：两种情况：
1.[min,max] 如果有一个数不能被某个子集得到，求：最小的那个数
arr[3,2,5] sum={2,3,5,5,7，8,10} 少{4,6,9} 返回4
2.[min,max] 如果都有，那么max+1是arr最小不可组成和
1.暴力递归 略dp[i][j]从0到i位置组成数字为j为布尔型

如果数组一定有1，可以用下面解法

import java.util.Arrays;

public class Samllest {
    //已知arr一定有1这个数
    public static int unformedSum3(int[] arr){
        if(arr == null || arr.length == 0){
            return 0;
        }
        Arrays.sort(arr);
        int range = 1;
        for(int i = 1;i != arr.length;i++){
            if(arr[i] > range + 1){
                return range + 1;
            }else{
                range += arr[i];
            }
        }
        return range + 1;
    }
}

import java.util.Arrays;

public class MinPatch {
    //我个人思考了，这个题目 不需要数组必须有1，因为从第一个位置遍历，缺少什么补什么
    //比如第一个位置是5，那么就要补1-4才可以，所以数组不要求必须有1
    public static int minPatches(int[] arr,int aim){
        int patches = 0;//缺多少个数字
        int range = 0;//已经完成了1~range的目标
        Arrays.sort(arr);
        for (int i = 0; i != arr.length; i++) {

            //补充到1~arr[i]-1
            while(arr[i] - 1 > range){
                range += range + 1;
                patches++;
                if(range >= aim){
                    return patches;
                }
            }

            //补充完之后 才可以使用当前位置的数
            range += arr[i];
            if(range >= aim){
                return patches;
            }
        }

        //当上述遍历完之后还没有达到目标，继续补充数
        //我感觉有点问题，好像应该是 aim > range ,
        // 没有问题 等价于aim >= range + 1
        while(aim >= range + 1){
            range += range + 1;
            patches++;
        }
        return patches;
    }
}

dp 第i个位置，受制于两个因素，第一个因素是 该位置前面出现过该位置的元素，第二个因素是最左超不过dp[i-1]的位置
怎么找性价比高的难题
打开leetcode 看赞，点赞越多的