238. 除自身以外数组的乘积
给你一个整数数组 nums,返回 数组 answer ,其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。
题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。
请不要使用除法,且在 O(n) 时间复杂度内完成此题。
示例 1:
输入: nums = [1,2,3,4]
输出: [24,12,8,6]
示例 2:
输入: nums = [-1,1,0,-3,3]
输出: [0,0,9,0,0]
提示:
2 <= nums.length <= 105
-30 <= nums[i] <= 30
保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内
进阶:你可以在 O(1) 的额外空间复杂度内完成这个题目吗?( 出于对空间复杂度分析的目的,输出数组不被视为额外空间。)
时间复杂度:O(n),空间复杂度:O(n)
class Solution {
public int[] productExceptSelf(int[] nums) {
int n=nums.length;
int[] res=new int[n];
int left=1,right=1;
res[0]=1;
res[n-1]=1;
for(int i=1;i<n;i++){
left*=nums[i-1];
res[i]=left;
}
for(int j=n-2;j>=0;j--){
right*=nums[j+1];
res[j]*=right;
}
return res;
}
}
287. 寻找重复数
给定一个包含 n + 1 个整数的数组 nums ,其数字都在 [1, n] 范围内(包括 1 和 n),可知至少存在一个重复的整数。
假设 nums 只有 一个重复的整数 ,返回 这个重复的数
你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。
示例 1:
输入:nums = [1,3,4,2,2]
输出:2
示例 2:
输入:nums = [3,1,3,4,2]
输出:3
提示:
1 <= n <= 105
nums.length == n + 1
1 <= nums[i] <= n
nums 中 只有一个整数 出现 两次或多次 ,其余整数均只出现 一次
1. 简单方法
时间复杂度:O(nlogn),空间复杂度O(1)
class Solution {
public int findDuplicate(int[] nums) {
Arrays.sort(nums);
int res=nums[0],n=nums.length;
for(int i=1;i<n;i++){
if(res==nums[i]) return res;
res=nums[i];
}
return res;
}
}
2. 进阶
如何证明 nums 中至少存在一个重复的数字?
你可以设计一个线性级时间复杂度 O(n) 的解决方案吗?
空间换时间:时间按复杂度O(n),空间复杂度 O(n)
思路和算法
class Solution {
public int findDuplicate(int[] nums) {
//时间复杂度:O(n),空间复杂度O(n)
//寻找第一个count[i]>i的i值就是重复的数据,不管重复数字重复多少次都是满足的
int n=nums.length;
int[] count=new int[n];
for(int i=0;i<n;i++){
count[nums[i]]++;
}
for(int i=1;i<n;i++){
count[i]+=count[i-1];
}
//二分查找寻找第一个count[i]>i的i值就是重复的数据
return binarySearch(count,1,n-1);
}
public int binarySearch(int[] count,int low,int high){
if(low>high) return low;
int mid=(low+high)/2;
if(count[mid]<=mid) return binarySearch(count,mid+1,high);
else return binarySearch(count,low,mid-1);
}
}
239. 滑动窗口最大值
给你一个整数数组 nums,有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回 滑动窗口中的最大值 。
示例 1:
输入:nums = [1,3,-1,-3,5,3,6,7], k = 3
输出:[3,3,5,5,6,7]
解释:
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7
示例 2:
输入:nums = [1], k = 1
输出:[1]
提示:
1 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4
1 <= k <= nums.length
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
//记录窗口内最大值和其位置,每次移动后需要比较窗口内最大值和新值之间的关系
if(k==1) return nums;
int n=nums.length;
int[] res=new int[n-k+1];
//赋初值
Deque<Integer> deque=new ArrayDeque<>();
deque.addFirst(0);
for(int i=1;i<k;i++){
while(!deque.isEmpty()&&nums[deque.getLast()]<nums[i]){
deque.removeLast();
}
deque.addLast(i);
}
res[0]=nums[deque.getFirst()];
for(int i=1;i<n-k+1;i++){
while(!deque.isEmpty()&&(i>deque.getFirst())){
deque.removeFirst();
}
res[i]=Math.max(nums[deque.getFirst()],nums[i+k-1]);
while(!deque.isEmpty()&&(nums[i+k-1]>nums[deque.getLast()])){
deque.removeLast();
}
deque.addLast(i+k-1);
}
//如果i-deque.getFirst()>=3, 队首元素过期, 执行出队操作, deque.removeFirst();
//此时比较队首元素所在数组的值和
//单调递减队列,队列中存储数组下标,如果nums[i]>nums[deque.getLast()]那么deque队列尾部的元素j就要出队deque.removeLast(),因为j<i,并且nums[i]>nums[j],那么往后分析肯定用不到nums[j]。
//deque.addLast();
return res;
}
}
135. AcWing 最大子序和(dp+单调队列优化)
题目描述
输入一个长度为n的整数序列,从中找出一段不超过m的连续子序列,使得整个序列的和最大。
例如 1,-3,5,1,-2,3
当m=4时,S=5+1-2+3=7
当m=2或m=3时,S=5+1=6
输入
第一行两个数n,m(n,m≤300000)(n,m \leq 300000)(n,m≤300000)
第二行有n个数,要求在n个数找到最大子序和
输出
一个数,数出他们的最大子序和
样例输入
6 4
1 -3 5 1 -2 3
样例输出
7
题解:
计算区间和的问题,一般转化为连个前缀和相减的形式进行求解。我们可以先求出S[i]表示序列里前i ii项的和,则连续子序列[L,R]中的和就等于S [ R ] − S [ L − 1 ].所以我们可以非常巧妙地将原问题转化为:找出两个位子h和t,使S [ h ] − S [ t ] 最大并且h − t < = m
首先枚举右端点i,当i固定时,问题就变为:找到一个右端点j,其中j属于[ i − m , i − 1 ]这个集合,并且S [ j ]最小.
如果我们比较一下任意的两个位子j和k,如果k<j<i,并且S[k]>=S[j],那么对于所有大于等于i的右端点,k永远不会成为最佳选择。这是因为不但S[k]不小于S[j],而且j离i更近,长度更不容易超过M,即j的生存能力比k更强。所以当j出现后,k就是个完全无用的位子。
以上比较可以让我们得出结论:可能成为最优选择的策论集合一定是一个"下标位置递增、对应的前缀和S的值也递增"的序列。我们可以用一个队列保存这个序列。随着右端点变从前向后扫描,我们对于每个i可以执行以下步骤:
- 1.判断队头决策与i的距离是否超过M的范围,若超则出队
- 2.此时队头就是右端点i时,左端点j的最优选择
- 3.不断删除队尾决策,直到队尾对应的S值小于S[i]。然后把i作为一个新的决策入队
不用单调队列也可以,直接用数组存储也行,同时记录两个指针指向当前的队首和队尾
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt(),m=sc.nextInt();
sc.nextLine();
int[] nums=new int[n+1];
nums[0]=0;
for(int i=1;i<=n;i++){
nums[i]=sc.nextInt()+nums[i-1];
}
Deque<Integer> deque=new ArrayDeque<>();
deque.addFirst(0);
int ans= Integer.MIN_VALUE;
for(int i=1;i<=n;i++){
while(!deque.isEmpty()&&(i-deque.getFirst())>m) deque.removeFirst();
ans=Math.max(ans,nums[i]-nums[deque.getFirst()]);
while(!deque.isEmpty()&&nums[deque.getLast()]>nums[i]) deque.removeLast();
deque.addLast(i);
}
System.out.println(ans);
}
}
3. 烽火传递
题目描述
原题来自:NOIP 2010 提高组初赛 · 完善程序
烽火台是重要的军事防御设施,一般建在交通要道或险要处。一旦有军情发生,则白天用浓烟,晚上有火光传递军情。 在某两个城市之间有 n座烽火台,每个烽火台发出信号都有一定的代价。为了使情报准确传递,在连续 m 个烽火台中至少要有一个发出信号。现在输入n,m和每个烽火台的代价,请计算总共最少的代价在两城市之间来准确传递情报。
输入
第一行是 n,mn,m,表示 n 个烽火台和连续烽火台数 m;
第二行 nn 个整数表示每个烽火台的代价 ai。
输出
输出仅一个整数,表示最小代价。
样例输入
5 3
1 2 5 6 2
样例输出
4
提示
样例说明
在第 2,52,5 号烽火台上发信号。
题解:
单调队列维护dp
下面主要讲dp思想
设d p [ i ] dp[i]dp[i]表示从i个烽火台开始被点燃的花费最小值
则d p [ i ] = m i n ( d p [ i ] , d p [ j ] + a [ i ] ) ( i − m < = j < = i ) dp[i]=min(dp[i],dp[j]+a[i])(i-m<=j<=i)dp[i]=min(dp[i],dp[j]+a[i])(i−m<=j<=i)根据条件( i − m < = j < = i ) (i - m <= j <= i)(i−m<=j<=i)可知这是一个区间求单调递增队列问题
代码
public class Test {
public int test(int[] fees, int m) {
//fees={0,1,2,5,6,2}, m=3;
//记录窗口内最大值和其位置,每次移动后需要比较窗口内最大值和新值之间的关系
int n=fees.length;
if(m==1){
return Arrays.stream(fees).sum();
}
Deque<Integer> deque=new ArrayDeque<>();
int[] dp=new int[n];
dp[0]=fees[0];
deque.addFirst(0);
for(int i=1;i<n;i++){
while(!deque.isEmpty()&&(i-deque.getFirst()>m)) deque.removeFirst();
dp[i]=dp[deque.getFirst()]+fees[i];
while(!deque.isEmpty()&&deque.getLast()>fees[i]) deque.removeLast();
deque.addLast(i);
}
//两个城市之间有 n 座烽火台,每个烽火台发出信号都有一定的代价,为了使情报准确传递,在连续 m 个烽火台中至少要有一个发出信号。
// f [i] = min( f[j] ) + w[i] (i-m<=j<=i-1) f[i]表示前1-i座均满足要求,最后一座被点燃的是第i座
//用单调递增队列去维护f[j] (i-m<=j<=i-1),每次取队首元素
//维护单调递增队列,首先去除f[j]且j<i-m的数据,然后更新f[i],最后维护单调递增去除队尾元素大于f[i]的,最后将f[i]入队尾
int ans=Integer.MAX_VALUE;
for(int i=n-m;i<n;i++){
ans=Math.min(dp[i],ans);
}
return ans;
}
}
2544. 交替数字和
给你一个正整数 n 。n 中的每一位数字都会按下述规则分配一个符号:
最高有效位 上的数字分配到 正 号。 剩余每位上数字的符号都与其相邻数字相反。 返回所有数字及其对应符号的和。
示例 1:
输入:n = 521
输出:4
解释:(+5) + (-2) + (+1) = 4
示例 2:
输入:n = 111
输出:1
解释:(+1) + (-1) + (+1) = 1
示例 3:
输入:n = 886996
输出:0
解释:(+8) + (-8) + (+6) + (-9) + (+9) + (-6) = 0
提示:
1 <= n <= 109
class Solution {
public int alternateDigitSum(int n) {
int ans=0,flag=1;
while(n!=0){
ans+=(n%10)*flag;
n=n/10;
flag=-flag;
}
return (-flag)*ans;
}
}