leetcode 15

import java.net.Inet4Address;
import java.util.HashMap;

public class LongestSumEqualK {
    public static class  Node{
        int value;
        public Node left;
        public Node right;

        public Node(int v){
            value = v;
        }
    }

    public static int ans = 0;//收集累加和为K的 ，最长路径有多少个节点

    public static int longest(Node head,int K){
        ans = 0;
        HashMap<Integer,Integer> sumMap = new HashMap<>();
        sumMap.put(0,-1);
        process(head,0,0,K,sumMap);
        return ans;
    }

    public static void process(Node X, int level, int preSum, int K, HashMap<Integer, Integer> sumMap){
        if(X!=null){

            //从头结点出发 到当前X节点 总的前缀和是多少
            int allSum = preSum + X.value;
            if(sumMap.containsKey(allSum - K)){//
                ans = Math.max(ans,level-sumMap.get(allSum-K));//当前的累加和 减去前缀和 的最长路径
            }

            if(!sumMap.containsKey(allSum-K)){//记录最早出现的问题，下次还出现不用管，因为要求最长路径
                sumMap.put(allSum,level);
            }

            process(X.left,level+1,allSum,K,sumMap);
            process(X.right,level+1,allSum,K,sumMap);
            //保证 不只对这一条路径遍历
            if(sumMap.get(allSum) == level){//第二次来到这里，自己这个位置带来的
                sumMap.remove(sumMap);
            }
        }
    }
}

public class KTimesOneTime {
    public static int onceNum(int[] arr,int k){
        int[] e0 = new int[32];
        for (int i = 0; i != arr.length; i++) {
            setExlusiveOr(e0,arr[i],k);
        }
        int res = getNumFromSysNum(e0,k);//还原10进制
        return res;
    }

    public static void setExlusiveOr(int[] e0,int value,int k){
        int[] curKSysNum = getSysNumFromNum(value,k);
        for (int i = 0; i != e0.length; i++) {
            e0[i] = (e0[i] + curKSysNum[i]) % k;//防止溢出 每一个摸
        }
    }
    //把e0组成的数字转换成k进制
    public static int[] getSysNumFromNum(int value,int k){
        int[] res = new int[32];
        int index = 0;

        while(value != 0) {
            res[index++] = value%k;
            value = value /k;
        }
        return res;
    }


    public static int getNumFromSysNum(int[] e0,int k){
        int res = 0;
        for(int i = 0;i != e0.length;i++){
            res = res * k * e0[i];
        }
        return res;
    }
}

如果有大于一半的数，依次删除两个不同的数，没有数可以删除，剩下的数就是
如果没有大于一半的话依次删除两个不同的数，没有数可以删除，剩下的不一定是
如果依次删除两个数，如果最后没有剩下数，说明没有答案
如果剩下数，需要再遍历一遍 判断
候选值 肯定是最后的cand 但不一定保证超过一半，所以要验证

public class FindMajority {
    public static void printHalfMajor(int[] arr){
        int cand = 0;//候选的数字
        int HP=  0;
        for (int i = 0; i < arr.length; i++) {
            if(HP == 0){//没有候选的血量
                cand = arr[i];
                HP = 1;
            }else if (arr[i] == cand) {//如果有候选的情况，分两种，遇到和候选的相同HP++不同--
                HP++;
            }else{
                HP--;
            }
        }

        HP = 0;//复用变量
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == cand){
                HP++;
            }
        }
        if(HP > arr.length / 2){
            System.out.println(cand);
        }else{
            System.out.println("no such number");
        }
    }
}

    public static void printKMajor(int[] arr,int K){
        if(K < 2){
            System.out.println("the value of K is invalid");
            return;
        }
        HashMap<Integer,Integer> cands = new HashMap<>();
        for (int i = 0; i < arr.length; i++) {
            if(cands.containsKey(arr[i])){
                cands.put(arr[i],cands.get(arr[i]+1));
            }else{
                if(cands.size() == K-1){//判断候选的hashmap是否满了
                    allCandsMinusOne(cnads);//所有候选的个数都减去1
                }else{
                    cands.put(arr[i],1);
                }
            }
        }

        HashMap<Integer,Integer> reals = new HashMap<>();
        boolean hasPrint = false;
        for(Map.Entry<Integer,Integer> set : cands.keySet()){
            Integer key = set.getKey();
            for(reals.get(key) > arr.length / K){
                hasPrint = true;
                System.out.println(key + " ");
            }
        }
        System.out.println(hasPrint? "":"no such number.");
    }

    public static void allCandsMinusOne(HashMap<Integer,Integer> map){
        
    }

import java.util.Comparator;
import java.util.PriorityQueue;

public class Coffee {
    public static class CoffeeMathine{
        public int start;
        public int work;

        public CoffeeMathine(int s,int w){
            start = s;
            work = w;
        }
    }

    public static class CoffeeMathineComparator implements Comparator<CoffeeMathine>{

        @Override
        public int compare(CoffeeMathine o1, CoffeeMathine o2) {
            return o1.start + o1.work - o1.start - o1.work;
        }
    }

    public static int[] bestChoices(int[] arr,int M){
        int[] ans = new int[M];
        PriorityQueue<CoffeeMathine> heap = new PriorityQueue<>();
        for(int coffeeWork : arr){
            heap.add(new CoffeeMathine(0,coffeeWork));
        }
        for (int i = 0; i < M; i++) {
            CoffeeMathine cur = heap.poll();
            ans[i] = cur.start + cur.work;
            cur.start = ans[i];
            heap.add(cur);
        }
        return ans;
    }