LeetCode 862. 和至少为 K 的最短子数组--前缀和+二分+贪心策略结合动态数组储存数据

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

返回 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 <= A.length <= 50000
-10 ^ 5 <= A[i] <= 10 ^ 5
1 <= K <= 10 ^ 9

题解：

很有趣的一个题目，真的很有趣，一开始很懵，我们不难发现，一般针对这种什么找区间和，大概率和区间相关的，都涉及了前缀和处理，于是我们考虑到，我们用ans[maxn]表示前缀和，那么子区间[x,y]的和可以表示为ans[x]-ans[y-1]，那么我们的目标就是找到这样的x和y，使得ans[x]-ans[y-1]>=K并且x-y尽可能小，好的，于是我们遍历到下标x，把下标[0,x-1]对应的所有前缀和储存到一个容器中，这个容器得有序，这样方便二分查找那个ans[y-1]，那么问题来了，找到这个ans[y-1]，该怎么办，因为ans[x]-ans[y-1]>=K也就是ans[y-1]<=ans[x]-K，这样的y有多个取值，而且下标没有规律，为了找到和x距离最小的那个，我还得需要遍历一遍吗？那绝对超时了，于是我开始陷入自闭，然后反复考虑这个容器中的元素是否存在某种规律或者优化，然后惊讶的发现，我们定义结构体表示。

    struct Node
    {
        int ans;//前缀和
        int pos;//位置
    };

那么我们储存到某个容器中，比如vector，我们开始按从左到右的顺序遍历原始数组，并将对应的前缀和和下标储存到容器中，那么存在的关系只有两种：
1.t[i-1].pos<t[i].pos and t[i-1].ans<=t[i].ans
2.t[i-1].pos<t[i].pos and t[i-1].ans>=t[i].ans
那么有趣的来了，针对第2种情况，直接用t[i]把t[i-1]替代掉，为何可以替代，因为ans越小，后面的ans[x]-ans越可以大于等于K，这个没问题吧，而且t[i]在t[i-1]后面，越靠近x，所以这种情况完全可以替代，而针对第一种情况，则不能替代了，因为t[i]的ans虽然比t[i-1]大，但是也更靠近x，需要保留在后面做判断，于是你会发现，vector容器中储存的元素只有1的情况，那么就是在容器中，位置pos和前缀和ans都是有序的，那么我找到最后一个小于等于ans[x]-K的元素，返回当前的pos，就肯定是最靠近x的位置，没有任何问题。

AC代码

class Solution {
public:
    struct Node
    {
        int ans;//前缀和
        int pos;//位置
    };
    vector<Node>q;
    void add(Node t)
    {
        if(q.empty())q.push_back(t);
        else
        {
            while(q.empty()==false)
            {
                int n=q.size()-1;
                if(q[n].ans>=t.ans)//进行更新
                {
                    q.pop_back();
                }
                else break;
            }
            q.push_back(t);
        }
    }
    int fin(int x)
    {
        int l=0,r=q.size()-1,res=-1;
        while(l<=r)
        {
            int mid=(l+r)/2;
            if(q[mid].ans<=x)
            {
                l=mid+1;
                res=mid;
            }
            else r=mid-1;
        }
        return res==-1?-1:q[res].pos;//返回对应的位置
    }
    int shortestSubarray(vector<int>& A, int K) 
    {
        Node t;
        t.ans=0,t.pos=0;//初始化插入一个元素
        add(t);
        int ans=0,res=1e9;
        for(int i=0;i<A.size();i++)
        {
            ans+=A[i];
            int f=fin(ans-K);
            if(f!=-1)
            {
                res=min(i+1-f,res);//比较最优
            }
            t.ans=ans,t.pos=i+1;
            add(t);
        }
        return res==1e9?-1:res;
    }
};