华为OD机试c卷（100分）-数组连续和

题目描述

给定一个含有N个正整数的数组, 求出有多少个连续区间（包括单个正整数）, 它们的和大于等于x。

输入描述

第一行两个整数N x（0 < N <= 100000, 0 <= x <= 10000000)
第二行有N个正整数（每个正整数小于等于100)。

输出描述

输出一个整数，表示所求的个数。
注意：此题对效率有要求，暴力解法通过率不高，请考虑高效的实现方式。

用例
输入
3 7
3 4 7
输出 4
说明 第一行的3表示第二行数组输入3个数，第一行的7是比较数，用于判断连续数组是否大于该数；组合为 3 + 4; 3 + 4 + 7; 4 + 7; 7; 都大于等于指定的7；所以共四组。

输入
10 10000
1 2 3 4 5 6 7 8 9 10
输出 0
说明 所有元素的和小于10000，所以返回0。

题目解析

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和大于目标数 target 的 所有不同组合 ，并以列表形式返回。你可以按任意顺序返回这些组合。

回溯三部曲

1、递归函数参数
和leetcode77. 组合一样，依然需要一维数组path来存放符合条件的结果，二维数组result来存放结果集。
这里我依然定义path 和 result为全局变量。length存放每个组合的长度。
至于为什么取名为path？从上面树形结构中，可以看出，结果其实就是一条根节点到叶子节点的路径。
接下来还需要如下参数：
target（int）目标和，也就是题目中的n。
candidates（int*）数组
candidatesSize（int）就是题目中数组的大小。
sum（int）为已经收集的元素的总和，也就是path里元素的总和。
startIndex（int）为下一层for循环搜索的起始位置。

2、递归终止条件
终止条件为 sum > target 和 sum == target。

3、单层搜索的逻辑
单层for循环依然是从startIndex开始，搜索candidates集合。

#include <stdio.h>
#include <stdlib.h>
int *path;
 int pathTop;
 int **ans;
 int ansTop;
 int* length;
void backtracking(int* candidates,int candidatesSize,int target,int sum,int startIdx){
    if(sum>=target){
            int* tmp=(int*)malloc(sizeof(int)*pathTop);
            for(int j=0;j<pathTop;j++)
            tmp[j]=path[j];
            length[ansTop]=pathTop;//存储当前组合的长度
             ans[ansTop++]=tmp;

        return;
    }
    for(int i=startIdx;i<candidatesSize;i++){
        sum+=candidates[i];
        path[pathTop++]=candidates[i];
        backtracking(candidates,candidatesSize,target,sum,i+1);
        sum-=candidates[i];;
        pathTop--;
    }
}
int** combinationSum2(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes){
    path=(int*)malloc(sizeof(int)*50);
    ans=(int**)malloc(sizeof(int*)*100);
     length=(int*)malloc(sizeof(int)*100);
     ansTop=pathTop=0;

     backtracking(candidates,candidatesSize,target,0,0);
     *returnSize=ansTop;
    *returnColumnSizes=(int*)malloc(sizeof(int)*ansTop);
     for(int i=0;i<ansTop;i++)
     (*returnColumnSizes)[i]=length[i];
     return ans;
}
int main()
{
    int n,k;
     scanf("%d",&n);
     scanf("%d",&k);
     int nums[n];
     for(int i=0;i<n;i++)
          scanf("%d",&nums[i]);
     int numsSize = sizeof(nums) / sizeof(nums[0]);
    int returnSize;
    int* returnColumnSizes;
    combinationSum2(nums, numsSize,k,&returnSize, &returnColumnSizes);
     printf("%d",ansTop);

}

改进后代码

#include <stdio.h>
#include <stdlib.h>

int ansTop = 0;


int backtracking(int* candidates, int candidatesSize, int target, int sum, int startIdx) {
    if (sum >= target) {
          ansTop++;
        return;
    }
    for (int i = startIdx; i < candidatesSize; i++) {
        if (i > startIdx && candidates[i] == candidates[i - 1]) // skip duplicates
            continue;
        backtracking(candidates, candidatesSize, target, sum + candidates[i], i + 1);
    }
    return ansTop;
}


int main() {
    int n, k;
    scanf("%d", &n);
    scanf("%d", &k);
    int nums[n];
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    int result = backtracking(nums, n, k, 0, 0);
    printf("%d", result);
    return 0;
}