【英雄算法六月集训】Day08

981. 基于时间的键值存储

设计一个基于时间的键值数据结构，该结构可以在不同时间戳存储对应同一个键的多个值，并针对特定时间戳检索键对应的值。

实现 TimeMap 类：

TimeMap() 初始化数据结构对象
void set(String key, String value, int timestamp) 存储键 key、值 value，以及给定的时间戳 timestamp。
String get(String key, int timestamp)
返回先前调用 set(key, value, timestamp_prev) 所存储的值，其中 timestamp_prev <= timestamp 。
如果有多个这样的值，则返回对应最大的 timestamp_prev 的那个值。
如果没有值，则返回空字符串（“”）。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/time-based-key-value-store
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这里JAVA的话 主要还是调用API 所以练习下API的使用 floorKey TreeMap的一些API

class TimeMap {

    /** Initialize your data structure here. */
    HashMap<String, TreeMap<Integer, String>> map;
    public TimeMap() {
        map = new HashMap();
    }
    
    public void set(String key, String value, int timestamp) {
        map.computeIfAbsent(key, k-> new TreeMap()).put(timestamp, value);
    }
    
    public String get(String key, int timestamp) {
        if(!map.containsKey(key)) {
            return "";
        }
        Integer time = map.get(key).floorKey(timestamp);
        if(time == null) {
            return "";
        }
        return map.get(key).get(time);
    }
}

400. 第 N 位数字

class Solution {
     public int findNthDigit(int n) {
        long ln = n, nine = 9;

        int i;
        for (i = 1; i <= 15; ++i) {
            ln -= nine * i;
            if (ln <= 0) {
                ln += nine * i;
                break;
            }
            nine *= 10;
        }

        long l = nine / 9;
        long r = l * 10 - 1;
        long ans = -1;
        while (l <= r) {
            long mid = (l + r) >> 1;
            long cnt = (mid - nine / 9 + 1) * i;
            if (cnt >= ln) {
                r = mid - 1;
                ans = mid;
            } else {
                l = mid + 1;
            }
        }
        Stack<Long> stack = new Stack<Long>();
        while (ans >= 1) {
            stack.push(ans % 10);
            ans /= 10;
        }
        Collections.reverse(stack);
        System.out.println(stack);
        Long aLong=new Long(0);
        if (stack.size() != 0) {

            aLong = stack.get((int) ((ln - 1) % i));
        }
        return aLong.intValue();
    }
}

1300. 转变数组后最接近目标值的数组和

class Solution {
    public int findBestValue(int[] arr, int target) {
         Arrays.sort(arr);
         int n =arr.length;
         int i,j;
         int sum=0;
         for(i=0;i<arr.length;++i){
             sum+=arr[i];
         }   
         int value = Math.abs(sum-target);
         int index = arr[n-1];
        

         //扫描线 从数组的后面向前扫描
         j=n-1;
         for(i=arr[n-1];i>=0;--i){
             while(j>=0&&arr[j]>i){
                --j;
             }
             sum-=(n-1-j);
             if(Math.abs(sum-target) <=value){
                 value = Math.abs(sum-target);
                 index = i;
             }
             if(sum<=0)break;
         }
         return index;
    }
}

1713. 得到子序列的最少操作次数

class Solution {
    public int minOperations(int[] target, int[] arr) {
         Map<Integer,Integer> pos = new HashMap<Integer,Integer>();   
         List<Integer> ls = new ArrayList<Integer>();  
         int i;
         for(i=0;i<target.length;++i){
             pos.put(target[i],i);
         }

         for(i=0;i<arr.length;++i){
              if(pos.containsKey(arr[i])){
                  ls.add(pos.get(arr[i]));
              }
         }
         int[] a= new int[100002];
         int asize=0;
         for(i=0;i<ls.size();++i){
             int l=1,r=asize;
             int ans = -1;
             while(l<=r){
                 int mid =(l+r)>>1;
                 if(ls.get(i) <= a[mid]){
                     r=mid-1;
                     ans = mid;
                 }else{
                     l=mid+1;
                 }
             }
             if(ans==-1){
                 a[++asize] = ls.get(i);
             }else{
                 a[ans] = ls.get(i);
             }
         }
         return target.length-asize;
    } 
}