力扣-第十一次双周赛（虚拟竞赛）

5088. 等差数列中缺失的数字  简单
      

用户通过次数 615
用户尝试次数 634
通过次数 623
提交次数 1255
题目难度 Easy
有一个数组，其中的值符合等差数列的数值规律，也就是说：
在 0 <= i < arr.length - 1 的前提下，arr[i+1] - arr[i] 的值都相等。
我们会从该数组中删除一个 既不是第一个 也 不是最后一个的值，得到一个新的数组 arr。
给你这个缺值的数组 arr，请你帮忙找出被删除的那个数。

示例 1：

输入：arr = [5,7,11,13]
输出：9
解释：原来的数组是 [5,7,9,11,13]。
示例 2：

输入：arr = [15,13,12]
输出：14
解释：原来的数组是 [15,14,13,12]。

提示：

3 <= arr.length <= 1000
0 <= arr[i] <= 10^5

public static int missing(int[] arr){
		int[] ca =new  int[arr.length-1];
		for(int i=0;i<arr.length-1;i++){
			ca[i] = arr[i+1]-arr[i];
		}
		int max=0;
		if(arr[0]>arr[1]){
			for(int i=1;i<ca.length;i++){
				if(ca[max]>ca[i]){
					max=i;
				}
			}
		}else{
			for(int i=1;i<ca.length;i++){
				if(ca[max]<ca[i]){
					max=i;
				}
			}
		}
			return arr[max]+ca[max]/2;
	}

网上看到的一种做法，很牛逼，超快

 public int missingNumber(int[] arr) {
        for (int i = 1; i < arr.length - 1; ++i) {
            if (arr[i] - arr[i - 1] != arr[i + 1] - arr[i]) {
                return arr[i - 1] + arr[i + 1] - arr[i];
            }
        }
        return 0;
    }

作者：wowph

5089.  安排会议日程  中等  
      

用户通过次数 338
用户尝试次数 475
通过次数 347
提交次数 1384
题目难度 Medium
你是一名行政助理，手里有两位客户的空闲时间表：slots1 和 slots2，以及会议的预计持续时间 duration，请你为他们安排合适的会议时间。
「会议时间」是两位客户都有空参加，并且持续时间能够满足预计时间 duration 的 最早的时间间隔。
如果没有满足要求的会议时间，就请返回一个 空数组。
「空闲时间」的格式是 [start, end]，由开始时间 start 和结束时间 end 组成，表示从 start 开始，到 end 结束。
题目保证数据有效：同一个人的空闲时间不会出现交叠的情况，也就是说，对于同一个人的两个空闲时间 [start1, end1] 和 [start2, end2]，要么 start1 > end2，要么 start2 > end1。

示例 1：

输入：slots1 = [[10,50],[60,120],[140,210]], slots2 = [[0,15],[60,70]], duration = 8
输出：[60,68]
示例 2：

输入：slots1 = [[10,50],[60,120],[140,210]], slots2 = [[0,15],[60,70]], duration = 12
输出：[]

提示：

1 <= slots1.length, slots2.length <= 10^4
slots1[i].length, slots2[i].length == 2
slots1[i][0] < slots1[i][1]
slots2[i][0] < slots2[i][1]
0 <= slots1[i][j], slots2[i][j] <= 10^9
1 <= duration <= 10^6

list,Integer[],int[]之间的互转(jdk1.8)

public List<Integer> minAvailableDuration(int[][] slots1, int[][] slots2, int duration) {
        List<node> list1=new ArrayList<node>();
        List<node> list2=new ArrayList<node>();
        for(int i=0;i<slots1.length;i++)
        	list1.add(new node(slots1[i][0],slots1[i][1]));
        for(int i=0;i<slots2.length;i++)
        	list2.add(new node(slots2[i][0],slots2[i][1]));
        Collections.sort(list1,new mySort());
        Collections.sort(list2,new mySort());
        for(int i=0;i<list1.size();i++)
        	System.out.printf("%d %d\n",list1.get(i).x,list1.get(i).y);
        List<Integer> ans=new ArrayList<>();
        int i=0,j=0,p=Integer.MAX_VALUE;
        while(i<list1.size() && j<list2.size())
        {
        	int r=Math.min(list1.get(i).y, list2.get(j).y);
        	//System.out.printf("%d %d %d\n",list1.get(i).x,list2.get(j).x,r);
        	if(list1.get(i).x<=list2.get(j).x)
        	{
        		if(r-list2.get(j).x>=duration)
        		{
        			p=list2.get(j).x+duration;
        			break;
        		}
        	}
        	else
        	{
        		if(r-list1.get(i).x>=duration)
        		{
        			p=list1.get(i).x+duration;
        			break;
        		}
        	}
        	if(list1.get(i).y==r) i++;
        	if(list2.get(j).y==r) j++;
        }
        System.out.println(p);
        if(p!=Integer.MAX_VALUE)
        {
        	ans.add(p-duration);
        	ans.add(p);
        }
        return ans;
    }

5090. 抛掷硬币
      用户通过次数 173
      用户尝试次数 302
      通过次数 176
      提交次数 674
      题目难度 Medium
      有一些不规则的硬币。在这些硬币中，prob[i] 表示第 i 枚硬币正面朝上的概率。
      请对每一枚硬币抛掷 一次，然后返回正面朝上的硬币数等于 target 的概率。

示例 1：

输入：prob = [0.4], target = 1
输出：0.40000
示例 2：

输入：prob = [0.5,0.5,0.5,0.5,0.5], target = 0
输出：0.03125
提示：

1 <= prob.length <= 1000
0 <= prob[i] <= 1
0 <= target <= prob.length
如果答案与标准答案的误差在 10^-5 内，则被视为正确答案。

//dp
	public double probabilityOfHeads(double[] prob, int target) {
        double[][] dp=new double[prob.length][target+100];
        if(prob.length==0) return 0;
        dp[0][0]=1.0-prob[0];dp[0][1]=prob[0];
        for(int i=1;i<prob.length;i++)
        	dp[i][0]=dp[i-1][0]*(1.0-prob[i]);
        for(int i=1;i<prob.length;i++)
        	for(int j=1;j<=Math.min(target, i+1);j++)
        		dp[i][j]+=dp[i-1][j]*(1.0-prob[i])+dp[i-1][j-1]*prob[i];
        return dp[prob.length-1][target];
    }