leetcode日常学习

int minSubArrayLen(int target, int* nums, int numsSize){
    if (numsSize == 0) {
        return 0;
    }
    int sum = 0;
    int ans = INT_MAX;
    int left = 0;
    int right = 0;

    while (right < numsSize) { //窗口右边界
        sum += nums[right];//右边界zhong'h
        while (sum >= target) {
            ans = fmin(ans, right - left + 1);
            sum -= nums[left];
            left++;
        }
        right++;
    }
    return ans == INT_MAX ? 0 : ans;
}

#define MAX_LENGTH 123

#define MAX_RET 30001

int* findAnagrams(char * s, char * p, int* returnSize){

    int l = 0;

    int r = 0;

    int shash[MAX_LENGTH] = {0};

    int phash[MAX_LENGTH] = {0};

    int slen = strlen(s);

    int plen = strlen(p);

    *returnSize = 0;

    if(slen < plen) {

        return NULL;

    }

    int *ret = calloc(MAX_RET, sizeof(int)); 

    for (int i = 0; i < plen; i++) {

        phash[p[i]]++;

    }

    int diffNum = 0;

    //printf("%d", 'z');

    for (int i = 0; i < MAX_LENGTH; i++) {

        if((phash[i]) > 0) {

            diffNum++;

        };

    }

    int vaild = 0;

    while (r < slen) {

        char sr = s[r];

        r++;

        if (phash[sr] > 0){

            shash[sr]++;

            if (shash[sr] == phash[sr]) {

                vaild++;

            }

        }



        while (r - l >= plen) {

            if(vaild ==  diffNum) {

                ret[(*returnSize)++] = l;

            }

            char sl = s[l];

            l++;

            if (phash[sl] > 0){

                if (shash[sl] == phash[sl]) {

                    vaild--;

                }

                shash[sl]--;

            }

        }

    }

    return ret;

}

#define MAX_NUM 123
#define TRUE 1
#define FALSE 0
bool checkInclusion(char * s1, char * s2){
    int stringLen = strlen(s2);
    int subStringLen = strlen(s1);
    int stringHash[MAX_NUM] = {0};
    int substringHash[MAX_NUM] = {0};
    int right = 0;
    int left = 0;
    int diffNum = 0;
    int vaild = 0;

    for(int i = 0; i < subStringLen; i++) {
        substringHash[s1[i]]++;
    }

    for(int i = 0; i < MAX_NUM; i++) {
        if(substringHash[i] > 0) {
            diffNum++;
        }
    }

    while (right < stringLen) {
        char rightc = s2[right];
        right++;
        if(substringHash[rightc] > 0) {
            stringHash[rightc]++;
            if(stringHash[rightc] == substringHash[rightc]) {
                vaild++;
                printf("%d %d",stringHash[rightc] ,substringHash[rightc]);
            }
        }
        while (right - left >= subStringLen) {
            if(vaild == diffNum) {
                return TRUE;
            }
            char leftc = s2[left];
            left++;
            if(substringHash[leftc] > 0) {
                if(stringHash[leftc] == substringHash[leftc]) {
                    vaild--;
                }
                stringHash[leftc]--;
            }
        }

    }
    return FALSE;

}

#define MAX_LEN 2
int findMaxConsecutiveOnes(int* nums, int numsSize){
    int right = 0;
    int left = 0;
    int numHash[MAX_LEN] = {0};
    int maxlen = 0;
    int maxn = 0;
    while (right < numsSize) {
        if (nums[right] == 1) {
            numHash[nums[right]]++;
        }
        maxn = fmax(maxn, numHash[nums[right]]);
        right++;
        while(right - left > 1 + maxn) {
            numHash[nums[left]]--;
            left++;   
        }
        maxlen = fmax(maxlen, right - left);
    }
    return maxlen;
}

先把所有不生气的求一个和，再加上滑动窗口中最大的窗口

#define MAX_LEN 20001
int maxSatisfied(int* customers, int customersSize, int* grumpy, int grumpySize, int minutes){
    int sum = 0;
    int increase = 0;
    int hash[MAX_LEN] = {0};
    for (int i = 0; i < customersSize; i++) {
        if (grumpy[i] == 0) {
            sum = sum + customers[i];
            hash[i + 1] = hash[i]; 
        } else {
            hash[i + 1] = hash[i] + customers[i]; 
        }
    }

    for (int i = minutes; i < customersSize + 1; i++) {
        increase = fmax(increase, hash[i] - hash[i - minutes]);
    }
    sum =  sum + increase;
    return sum;
}

最佳升级时间窗

#include 
#include "securec.h"

#define ARR_LEN (7 * 24)
void GetBestWindow(int n, int arr[ARR_LEN], int *start, int *end)
{
    int right = 0;
    int left = 0;
    long long sum = 0;
    int maxlen=0;
    *start = -1;
    *end = -1;
    while (right < ARR_LEN) { //窗口右边界
        sum += arr[right];//右边界zhong'h
        while (sum > n) {
            sum -= arr[left++];
        }
        if ((right - left + 1 > maxlen)) {
            *start = left;
            *end = right;
            maxlen = right - left + 1;
        }
        right++;
    }
    return;
}


int main(void)
{
    int n;
    if (scanf_s("%un", &n) != 1) { return -1; }

    static int arr[ARR_LEN];
    for (int i = 0; i < ARR_LEN; i++) {
        if (scanf_s("%u", &arr[i]) != 1) {
            return -1;
        }
    }

    int start, end;
    GetBestWindow(n, arr, &start, &end);
    (void)printf("%d %d", start, end);
    return 0;
}