2023.07.10力扣6题

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;
    }
}