Leetcode 第28场双周赛题解

贼不稳。

5420. 商品折扣后的最终价格

思路：两层for循环遍历即可。

class Solution {
    public int[] finalPrices(int[] prices) {
    	
    	int n=prices.length;
    	int[] ans=new int[n];
    	
    	for(int i=0;i<n;i++) {
    		ans[i]=prices[i];
    		for(int j=i+1;j<n;j++)
    			if(prices[j]<=prices[i]) {
    				ans[i]=prices[i]-prices[j];
    				break;
    			}
    	}
    	
    	return ans;
    	
    }
}

5422. 子矩形查询

思路：这题是有更优的解法的，只是比赛时为了求速度，我这里用的暴力法。

class SubrectangleQueries {

	int m,n;
	int[][] a;
	
    public SubrectangleQueries(int[][] rectangle) {
    	
    	m=rectangle.length;
    	n=rectangle[0].length;
    	a=rectangle;
    }
    
    public void updateSubrectangle(int row1, int col1, int row2, int col2, int newValue) {
    	
    	for(int i=row1;i<=row2;i++)
    		for(int j=col1;j<=col2;j++)
    			a[i][j]=newValue;
    }
    
    public int getValue(int row, int col) {
    	return a[row][col];
    }
}

5423. 找两个和为目标值且不重叠的子数组

思路：这道题和一个比较经典的求原数组中有多少个子数组的和为target类似，只是这道题让你找出来两个并且长度之和最短，做法仍然是一样的，我们考虑求前缀和，对于当前前缀sum，判断之前是否出现过前缀和为sum-target，如果有的话说明当前子数组的和为target，为了保证最短，我们需要保存前缀和为sum-target的位置之前能满足条件的最短长度子数组，这个很容易做到，具体可以参考代码。

class Solution {
    public int minSumOfLengths(int[] arr, int target) {
    	
    	int n=arr.length;
    	int[] mn=new int[n+1];
    	int[] sum=new int[n+1];
    	Map<Integer,Integer> map=new HashMap<>();
    	
    	int ans=n+1;
    	
    	for(int i=0;i<=n;i++)
    		mn[i]=n+1;
    	
    	for(int i=1;i<=n;i++) {
    		sum[i]=sum[i-1]+arr[i-1];
    		if(sum[i]==target)
    			mn[i]=Math.min(mn[i], i);
    		if(map.containsKey(sum[i]-target)) {
    			int index=map.get(sum[i]-target);
    			if(index>0) ans=Math.min(ans, mn[index]+i-index);
    			mn[i]=Math.min(mn[i-1], i-index);
    		}
    		map.put(sum[i], i);
    		mn[i]=Math.min(mn[i], mn[i-1]);
    	}
    	
    	return ans>n?-1:ans;
    }
}

5421. 安排邮筒

思路：动态规划，我们定义dp[i][j]表示前i个房子分成j组的最小距离和，对于每一组，可以证明将邮筒放在中间的房子位置能够使得该组的距离之和最短。

class Solution {
	
	private int[] a;
	private long[] sum;
	
    public int minDistance(int[] houses, int k) {
    	
    	int n=houses.length;
    	long[][] dp=new long[n+1][k+1];
    	a=new int[n+1];
    	sum=new long[n+1];
    	
    	if(k>=n) return 0;
    	
    	Arrays.parallelSort(houses);
    	
    	for(int i=1;i<=n;i++) {
    		a[i]=houses[i-1];
    		sum[i]=sum[i-1]+houses[i-1];
    	}
    	
    	for(int i=0;i<=n;i++)
    		for(int j=0;j<=k;j++) {
    			if(j>=i) dp[i][j]=0;
    			else dp[i][j]=1000000000;
    		}
    	
    	for(int i=1;i<=n;i++)
    		for(int j=1;j<=k;j++)
    			for(int h=0;h<i;h++)
    				dp[i][j]=Math.min(dp[i][j], dp[h][j-1]+Sum(h+1,i));
    	
    	return (int)dp[n][k];
    }
    
    private long Sum(int l,int r) {
    	
    	if(l==r) return 0;
    	
    	int p=(l+r)/2;
    	
    	long x=a[p]*(p-l+1)-(sum[p]-sum[l-1])+sum[r]-sum[p]-a[p]*(r-p);
    	
    	p=(l+r+1)/2;
    	long y=a[p]*(p-l+1)-(sum[p]-sum[l-1])+sum[r]-sum[p]-a[p]*(r-p);

    	return Math.min(x, y);
    }
}