862. 和至少为 K 的最短子数组

本文介绍了一种算法,用于寻找数组中能满足指定条件的最短连续子数组。该算法通过对数组进行遍历并利用贪心策略来实现,能够有效地找到和至少为K的最短连续子数组。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

返回 A 的最短的非空连续子数组的长度,该子数组的和至少为 K 。

如果没有和至少为 K 的非空子数组,返回 -1 。

 

示例 1:

输入:A = [1], K = 1
输出:1

示例 2:

输入:A = [1,2], K = 4
输出:-1

示例 3:

输入:A = [2,-1,2], K = 3
输出:3

 

提示:

  1. 1 <= A.length <= 50000
  2. -10 ^ 5 <= A[i] <= 10 ^ 5
  3. 1 <= K <= 10 ^ 9

Review : 

这道题真的是写了三遍....

为啥写了三遍... 第一次读错题了...我居然写成了最长的子数组..

然后我在最长子数组代码基础上改成了最短子数组...

由于逻辑不同超时...然后整理了下逻辑

得到了最优O(n) 最差O(n2)的答案

具体流程是遍历数组,累积前n项和,如果sum<=0,则起始指针前移;

当sum大于K时,反向贪心,起始指针能前移多少就前移多少,得到符合的值更新result


Code : 

买一赠二: 赠超时版和最长子数组版

正版:

class Solution {
    public int shortestSubarray(final int[] A, int K) {
        int len = A.length;
        int sum = 0, begin = 0, res = -1;
        for (int i = 0; i < len; i++) {
            if (A[i] >= K) return 1;
            sum += A[i];
            if (sum < 1) {
                sum = 0;
                begin = i + 1;
                continue;
            }
            for (int j = i - 1; A[j + 1] < 0; j--) {
                A[j] = A[j + 1] + A[j];
                A[j + 1] = 0;
            }
            if (sum >= K) {
                while (sum - A[begin] >= K || A[begin] <= 0) 
                    sum -= A[begin++];
                int length = i - begin + 1;
                if (res < 0 || res > length) 
                    res = length;
            }
        }
        return res;
    }
}

 

超时版:

    public int shortestSubarray(int[] A, int K) {
        int len = A.length;
        int[] sum = new int[len + 1];
        sum[1] = A[0];
        for (int i = 1; i < len; i++)
            sum[i + 1] = sum[i] + A[i];
        int minLen = Integer.MAX_VALUE;
        for (int i = 0; i < len; i++) {
            if (i != 0 && A[i] >= K) 
                return 1;
            for (int j = i + 1; j < len + 1; j++) {
                if (sum[j] - sum[i] >= K) {
                    minLen = Math.min(minLen, j - i);
                    break;
                }
            }
        }
        return minLen == Integer.MAX_VALUE ? -1 : minLen;
    }

 

看错题版(最长子数列):

    //妈的做成最长的了
    public int longestSubarray(int[] A, int K) {
        int len = A.length;
        int[] sum = new int[len + 1];
        sum[1] = A[0];
        for (int i = 1; i < len; i++) 
            sum[i + 1] = sum[i] + A[i];
        int maxLen = -1;
        for (int i = 0; i < len; i++) {
            if (len - i < maxLen) 
                return maxLen;
            for (int j = len - 1; j > i + maxLen - 1; j--) 
                if (sum[j] - sum[i] >= K) 
                    maxLen = j - i + 1;
        }
        return maxLen;
    }

 

给你一个整数 n 一个在范围 [0, n - 1] 以内的整数 p ,它们表示一个长度为 n 且下标从 0 开始的数组 arr ,数组中除了下标为 p 处是 1 以外,其他所有数都是 0 。 同时给你一个整数数组 banned ,它包含数组中的一些位置。banned 中第 i 个位置表示 arr[banned[i]] = 0 ,题目保证 banned[i] != p 。 你可以对 arr 进行 若干次 操作。一次操作中,你选择大小为 k 的一个 子数组 ,并将它 翻转 。在任何一次翻转操作后,你都需要确保 arr 中唯一的 1 不会到达任何 banned 中的位置。换句话说,arr[banned[i]] 始终 保持 0 。 请你返回一个数组 ans ,对于 [0, n - 1] 之间的任意下标 i ,ans[i] 是将 1 放到位置 i 处的 少 翻转操作次数,如果无法放到位置 i 处,此数为 -1 。 子数组 指的是一个数组里一段连续 非空 的元素序列。 对于所有的 i ,ans[i] 相互之间独立计算。 将一个数组中的元素 翻转 指的是将数组中的值变成 相反顺序 。 嗯,这个问题看起来有点挑战性。让我仔细读题目。题目大意是说,我们有一个长度为n的数组arr,其中只有下标p的位置是1,其他都是0。还有一个banned数组,里面的位置不允许在翻转后出现1。我们的操作是每次选择一个长度为k的子数组进行翻转,翻转后必须保证1不能出现在banned的位置。对于每个位置i,要找出将1移动到i处所需的少翻转次数,如果不可能就返回-1。终要返回一个数组ans,每个位置对应结果。 首先,我需要理解翻转操作对1的位置的影响。假设当前1的位置是pos,翻转一个包含pos的子数组,那么翻转后的1的位置会改变。因为翻转子数组会改变元素的顺序,比如子数组从i到i+k-1,那么原来的位置ii+k-1会被交换,依此类推。假设当前1的位置在子数组中的位置是相对位置m(相对于子数组起始位置),那么翻转后它的新位置会是子数组起始位置 + (k-1 - m)。 举个例子,假设子数组是位置3到5(k=3),当前1在位置4。在子数组中,4的位置是第1位(从0开始的话,3是0,4是1,5是2)。翻转后,这个元素会被放到子数组的起始位置 + (2 -1) =3+1=4的位置?或者是不是位置变成起始位置+ (k-1 -m)。比如子数组起始位置是s,长度k,那么原来的位置s+i翻转后会变成s + (k-1 -i)。所以如果原来的1在位置s+i,翻转后变成s + (k-1 -i)。所以每次翻转操作可以看作是移动1的位置到新的位置,这个新的位置的计算方式需要明确。 比如,当前pos在某个子数组内部,翻转后pos会被移动到新的位置。比如子数组s到s+k-1,原来的pos是s+i,翻转后变为s + (k-1 -i) = s +k-1 -i。例如,子数组长度k=3,起始位置s=2,那么子数组是2,3,4。假设pos是3,即i=1,那么翻转后变成s + (2-1)=2+1=3?或者原数组的3在子数组中的位置是i=1,翻转后的位置是s + (k-1 -i)=2+2-1=3?所以pos的位置不变?这可能吗? 或者应该举具体例子。比如子数组是[0,1,2](k=3,s=0),翻转后变成2,1,0。原来的1在位置0的话,翻转后变成位置2。或者原位置0的元素会移动到位置2,原位置2的元素到位置0。所以,假设当前1的位置在子数组的某个位置,翻转后它会被移动到子数组中对应的对称位置。 所以,假设当前1的位置是pos,被包含在选择的子数组[s, s+k-1]中。那么翻转后,新的位置是 s + (s +k-1 - pos) = 2s +k-1 - pos。这可能吗?比如s=0,k=3,pos=0,那么新位置是0 + (0+2-0) =2?是的,因为子数组翻转后原来的0号位置变成2号。那此时,新的pos是2。 所以,每次操作可以将pos移动到某个新的位置,这取决于选择的子数组的位置。那么,问题转化为,从初始位置p出发,每次移动pos到新的位置,且每次移动后的位置不能在banned的位置,同时终要到达目标i的少步数。这看起来像是一个图的路径问题,其中节点是位置,边是可以通过一次翻转操作到达的位置变化。 那这样的话,每个位置可以看作图中的节点,每个节点可以连接到多个其他节点,连接的条件是存在一个长度为k的子数组,使得翻转后能够从当前pos移动到另一个位置,并且移动后的位置不在banned中。然后我们需要找出从初始节点p到其他所有节点的路径。 接下来需要分析,如何生成每个节点的邻接节点。也就是说,对于当前pos,可以翻转哪些子数组,使得翻转后的新位置不被禁止,并且没有被访问过。 但这里的问题可能比较复杂,因为k的长度可能不同,但题目中给出的k是固定的?或者题目中的k是否是固定的?原问题中的操作是每次选择一个大小为k的子数组进行翻转。这里可能题目中的k是固定的?原问题描述中的参数是否有k?原题的问题描述中的参数中有一个k吗?或者用户的问题是否漏掉了? 仔细看问题描述中的输入参数:用户给出的是整数n,p,banned数组。然后问题描述中说,每次操作选择大小为k的一个子数组。这里的k是否是输入的参数?或者题目中是否有其他参数? 根据用户给出的问题描述:“给你一个整数n一个在范围[0, n-1]的整数p…同时给你一个整数数组banned…你可以进行若干次操作。一次操作中,你选择大小为k的一个子数组…”这里的k应该是固定的,即每次操作必须选择相同长度的k的子数组。但是问题中的参数是否包含k?比如,用户的问题中是否应该包含k作为输入?或者题目是否漏掉了? 这可能是原题中的一个参数。比如,原题的输入应该包括k。可能用户的问题中可能将问题描述中的参数遗漏了。或者可能用户的问题中的输入参数是正确的? 例如,用户的问题中给出的输入参数是:整数n,整数p,数组banned。但根据问题中的操作描述,每次翻转的子数组大小是k。所以k应该是一个输入参数。但用户的问题中没有提到k,这可能是一个错误。例如,可能用户的问题描述中是否有错误? 现在,假设问题中的k是给定的输入参数。例如,用户的问题可能应该有一个k参数,但是可能被遗漏了?或者可能题目中的k是固定的,比如所有操作的子数组长度k是预先确定的? 此时,用户的问题可能存在描述错误,或者我在理解上有问题。需要再次确认问题描述。 根据用户的问题描述:在操作中选择大小为k的子数组,那么k应该是一个输入的参数。否则问题无法解决。所以,可能用户在问题描述中漏掉了参数k。或者可能原题中的k是另一个参数? 例如,正确的题目应该给出参数k,但用户的问题中没有提到,这会影响整个思路。或者可能用户的问题中的k是其他参数? 比如,假设原题的输入是n, p, banned,还有k,那么问题的解答需要考虑k。但在用户的问题中没有提到k,这导致问题描述可能不完整? 或者可能用户的问题中给出的参数是正确的,而k可能作为其他方式给出?比如,可能题目中的k是动态变化的?这似乎不太可能。此时,这可能是一个问题描述的错误,或者我可能误解了问题。 这时候可能需要假设用户的问题中存在参数k,可能用户的问题中的参数列表有遗漏。例如,原题的正确输入应包括n,p,banned,k。否则无法解题。所以,可能用户在问题描述时漏掉了k。例如,正确的参数应该是:整数n,p,整数k,以及数组banned。 基于此,我必须假设k是给定的输入参数之一,否则问题无法解答。因此,可能用户在问题描述中漏掉了k,或者我误解了问题。此时,可能需要假设问题中的每次操作的子数组长度k是给定的。否则,问题将无法处理,因为每次可以选任意长度的子数组,这会使得问题变得非常复杂,甚至可能无法解决。 所以,我需要假设k是作为输入的参数,而用户的问题中可能漏掉了。例如,正确的输入应该包括k,否则问题无法解答。例如,根据原题的描述,用户的问题中的参数可能应该是:整数n,p,以及一个整数k,数组banned。这样才能确定每次 继续生成 给你一个整数 n 一个在范围 [0, n - 1] 以内的整数 p ,它们表示一个长度为 n 且下标从 0 开始的数组 arr ,数组中除了下标为 p 处是 1 以外,其他所有数都是 0 。 同时给你一个整数数组 banned ,它包含数组中的一些位置。banned 中第 i 个位置表示 arr[banned[i]] = 0 ,题目保证 banned[i] != p 。 你可以对 arr 进行 若干次 操作。一次操作中,你选择大小为 k 的一个 子数组 ,并将它 翻转 。在任何一次翻转操作后,你都需要确保 arr 中唯一的 1 不会到达任何 banned 中的位置。换句话说,arr[banned[i]] 始终 保持 0 。 请你返回一个数组 ans ,对于 [0, n - 1] 之间的任意下标 i ,ans[i] 是将 1 放到位置 i 处的 少 翻转操作次数,如果无法放到位置 i 处,此数为 -1 。 子数组 指的是一个数组里一段连续 非空 的元素序列。 对于所有的 i ,ans[i] 相互之间独立计算。 将一个数组中的元素 翻转 指的是将数组中的值变成 相反顺序 。 用C语言解决
03-21
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值