1
int minSubArrayLen(int tar, vector<int>& nums) {
2
  int n=nums.size();
3
  int ans=1e9,sum=0;
4
  for(int l=0,r=0;r<n;r++){
5
    sum+=nums[r];
6
    while(sum-nums[l]>=tar){
7
      sum-=nums[l++];
8
    }
9
    if(sum>=tar) ans=min(ans,r-l+1);
10
  }
11
  return ans==1e9?0:ans;
12
}

1
int lengthOfLongestSubstring(string s) {
2
  int n=s.size();
3
  unordered_map<char,int> hp;
4
  int ans=0;
5
  for(int l=0,r=0;r<n;r++){
6
    if(hp.find(s[r])!=hp.end()){
7
      l=max(l,hp[s[r]]+1);
8
    }
9
    hp[s[r]]=r;
10
    ans=max(ans,r-l+1);
11
  }
12
  return ans;
13
}

1
string minWindow(string s, string t) {
2
  int n=s.size(),dt=t.size();
3
  unordered_map<char,int> cnts;
4
  for(char c:t){
5
    cnts[c]++;
6
  }
7
  int l=0,r=0,ll=-1,rr=-1;
8
  string res="";
9
  int ans=1e9+1;
10
  for(;r<n;r++){
11
    if(cnts.find(s[r])!=cnts.end()){
12
      cnts[s[r]]--;
13
      if(s[r]>=0) dt--;
14
    }
15
    while(dt<=0){
16
      if(r-l+1<ans){
17
        ans=r-l+1;
18
        ll=l;rr=r;
19
      }
20
      if(cnts.find(s[l])!=cnts.end()){
21
        cnts[s[r]]++;
22
        dt++;
23
      }
24
      l++;
25
    }
26
  }
27
  if(ans!=1e9+1){
28
    for(int i=ll;i<=rr;i++){
29
      res+=s[i];
30
    }
31
  }
32
  return res;
33
}

1
int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
2
  int n=gas.size();
3
  vector<int> rems(n,0);
4
  for(int i=0;i<n;i++){
5
    rems[i]=gas[i]-cost[i];
6
  }
7
  for(int l=0,r=0,sum;l<n;l=r+1,r=l){
8
    sum=0;
9
    while(sum+rems[r%n]>=0){
10
      if(r-l+1==n) return l;
11
      sum+=rems[r%n];
12
      r++;
13
    }
14
  }
15
  return-1;
16
}

1
int hp[128]={0};
2
bool check(){
3
  return hp['Q']>=0&&hp['W']>=0&&hp['E']>=0&&hp['R']>=0;
4
}
5

6
int balancedString(string s) {
7
  int n=s.size();
8
    hp['Q']=hp['W']=hp['E']=hp['R']=n/4;
9
  for(char c:s){
10
    hp[c]--;
11
  }
12
  int ans=1e9+1;
13
  for(int l=0,r=0;r<n;r++){
14
    hp[s[r]]++;
15
    while(l<=r&&check()&&hp[s[l]]>0){
16
      hp[s[l]]--;
17
      l++;
18
    }
19
    if(check()){
20
      ans=min(ans,r-l+1);
21
    }
22
  }
23
  return ans==1e9+1?0:ans;
24
}

1
int subarraysWithKDistinct(vector<int>& nums, int k) {
2
  int n=nums.size();
3
  vector<int> vis(n+1,0);
4
  auto wd = [&](auto&& self,int k,int n)->int{
5
    fill(vis.begin(),vis.end(),0);
6
    int cnt=0,ans=0;
7
    for(int l=0,r=0;r<n;r++){
8
      if(vis[nums[r]]==0) cnt++;
9
      vis[nums[r]]++;
10
      while(l<=r&&cnt>k){
11
        vis[nums[l]]--;
12
        if(vis[nums[l]]==0) cnt--;
13
        l++;
14
      }
15
      ans+=r-l+1;
16
    }
17
    return ans;
18
  };
19
  return wd(wd,k,n)-wd(wd,k-1,n);
20
}

1
int longestSubstring(string s, int k){
2
  int n=s.size();
3
  vector<int> cnts(26);
4
  int ans=0;
5
  auto check = [&](auto&& self)->bool{
6
    for(int i=0;i<26;i++){
7
      if(cnts[i]!=0&&cnts[i]<k){
8
        return false;
9
      }
10
    }
11
    return true;
12
  };
13
  for(int i=1;i<=26;i++){
14
    fill(cnts.begin(),cnts.end(),0);
15
    for(int l=0,r=0,cnt=0;r<n;r++){
16
      if(cnts[s[r]-'a']==0) cnt++;
17
      cnts[s[r]-'a']++;
18
      while(cnt>i){
19
        cnts[s[l]-'a']--;
20
        if(cnts[s[l]-'a']==0) cnt--;
21
        l++;
22
      }
23
      if(cnt==i&&check(check)){
24
        ans=max(ans,r-l+1);
25
      }
26
    }
27
  }
28
  return ans;
29
}

1
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
2
  int n=nums.size();
3
  vector<int> ans;
4
  deque<int> dq;
5
  for(int l=0,r=0;r<n;r++){
6
    while(!dq.empty()&&nums[dq.back()]<nums[r]){
7
      dq.pop_back();
8
    }
9
    dq.push_back(r);
10
    while(r-l+1>k){
11
      if(dq.front()<=l){
12
        dq.pop_front();
13
      }
14
      l++;
15
    }
16
    if(r-l+1==k) ans.push_back(nums[dq.front()]);
17
  }
18
  return ans;
19
}

1
int longestSubarray(vector<int>& nums, int lmt) {
2
  int n=nums.size(),ans=0;
3
  deque<int> ma,mi;
4
  for(int l=0,r=0;r<n;r++){
5
    while(!ma.empty()&&nums[ma.back()]<=nums[r]){
6
      ma.pop_back();
7
    }
8
    ma.push_back(r);
9
    while(!mi.empty()&&nums[mi.back()]>=nums[r]){
10
      mi.pop_back();
11
    }
12
    mi.push_back(r);
13
    while(nums[ma.front()]-nums[mi.front()]>lmt){
14
      if(ma.front()==l) ma.pop_front();
15
      if(mi.front()==l) mi.pop_front();
16
      l++;
17
    }
18
    ans=max(ans,r-l+1);
19
  }
20
  return ans;
21
}