六月集训第一天打卡-数组

前言

作为每日打卡的记录，方便自己后续回顾以及补充未掌握好的知识

题目

1. 1588.所有奇数长度子数组的和
2. 1848.到目标元素的最小距离
3. 1652.拆炸弹
4. 1640.能否连接形成数组

解题思路

1. 本题可采用前缀和差分进行求解
   1. 使用一个数组sums存储前缀和
   2. 读取区间[l, r]
   3. 求解区间上的和：ret = sums[r]-sums[l-1]

int sumOddLengthSubarrays(vector<int>& arr) {
        int len = arr.size();
        int ret = 0;
        vector<int> sums(len, 0);  // 记录前缀和的数组
        
        for (int i = 0; i < len; ++i) {
            sums[i] = arr[i];
            if (i)
                sums[i] += sums[i-1];
        }  // 填充前缀和数组
        
        // 构造区间[l, r]
        for (int l = 0; l < len; ++l)
            for (int r = l; r < len; r+=2)
                ret += (sums[r] - (l == 0 ? 0 : sums[l-1]));  // 求差分并进行累加

        return ret;
    }

2. 本题进行简单的一次遍历即可

int getMinDistance(vector<int>& nums, int target, int start) {
        int ret = 1000;
        int tmp;
        for (int i = 0; i < nums.size(); ++i) {
            if (nums[i] == target) {
                tmp = abs(i - start);
                ret = ret < tmp ? ret : tmp;
                if (ret == 0)  // 0就是符合的最小值，如果中途以及为0，无需继续查找
                    return 0;
            }
        }

        return ret;
    }

3. 本题采用双循环
   1. 根据 k值计算局部区间的和
   2. index 为局部区间中的下标，需要注意取模
      1. 当下标为正时直接取模
      2. 下标为负时，需要加上len再取模

vector<int> decrypt(vector<int>& code, int k) {
    int len = code.size();
    vector<int> ret(len, 0);

    if (k == 0) return ret;

    int flag = k < 0 ? -1 : 1;

    for (int i = 0; i < len; ++i) {
        for (int j = 1; j <= abs(k); ++j) {
            int index = ((i + flag * j) < 0 ? (i + flag * j + len) : (i + flag * j)) % len;
            ret[i] += code[index];
        }
    }
    return ret;
}

4. 利用数组map存储数组arr中的下标，通过数组pieces中的所有元素在map中的情况判断是否能连接成数组
   1. pieces中的单元素数组只用判断元素是否在arr中出现过
   2. pieces中的多元素数组，需要判断数组元素中的下标是否是从左到右连续的。

bool canFormArray(vector<int> &arr, vector<vector<int>> &pieces)
{
    vector<int> map(101, -1);
    for (int i = 0; i < arr.size(); ++i)
    {
        map[arr[i]] = i; //记录arr[i]的下标
    }
    for (int j = 0; j < pieces.size(); ++j)
    {
        if (pieces[j].size() == 1)
        {
            if (map[pieces[j][0]] == -1)
                return false;
        }

        else
        {
            for (int k = 1; k < pieces[j].size(); ++k)
                if (map[pieces[j][k]] - map[pieces[j][k - 1]] != 1)
                    return false;
        }
    }
    return true;
}