2055. 蜡烛之间的盘子

2055. 蜡烛之间的盘子

输入：s = "**|**|***|", queries = [[2,5],[5,9]]
输出：[2,3]
解释：
- queries[0] 有两个盘子在蜡烛之间。
- queries[1] 有三个盘子在蜡烛之间。
提示：

3 <= s.length <= 105
s 只包含字符 '*' 和 '|' 。
1 <= queries.length <= 10^5
queries[i].length == 2
0 <= lefti <= righti < s.length

题解

注意：本题仅有思路，实现时在leetcode遇到了超时，但思路的其他题解代码可以通过 奇怪:(

时间复杂度：由于1 <= queries.length <= 10``^``5,所以本题的结题复杂度最多到nlogn。

题目求解其实就是查询左边第一个蜡烛与右边第一个蜡烛之间的盘子数量。

特殊情况：

左边和右边 都 至少有一支蜡烛

左右都无蜡烛则为0

二分求解

因为复杂度控制在nlogn，我们知道二分复杂度为logn，那么可以用二分查找的low_bound函数（找大于等于第一个数）和up_bound函数（找大于的第一个数）查找范围内左右第一个蜡烛。

• 首先用一个数组存每个蜡烛的下标，接下来在这个数组中二分查找蜡烛的下标
• 这里通过low_bound找范围内左边第一个蜡烛（包含左边界）
• 通过up_bound找到右边界右侧的第一个蜡烛，此蜡烛左边的蜡烛即是范围内最右侧的蜡烛
• 最后右蜡烛下标-左蜡烛下标 - 两个蜡烛之间蜡烛数量 = 目标盘子数量

这里有自我实现两个二分函数

// 二分解法
class Solution {
public:
    int my_low_bound(vector<int>& nums, int target) {
        // 找到比n大于或等于的第一个元素
        int l = 0, r = nums.size(), mid;
        while (l < r) {
            mid = l + ((r - l) >> 1); // 防止溢出的设计, 移位更快
            if (nums[mid] < target) {
                // 小于的时候向右移动，直到移动到大于等于target就不变了
                l = mid + 1;
            } else {
                // 直至移动到和l相同的地方
                r = mid;
            }
        }
        return l;
    }  


    int my_up_bound(vector<int> index , int n){
        // 找到比n大的第一个元素
        int l = 0,r = index.size(),mid;
        while(l<r){
            mid = l + ((r - l) >> 1); // 防止溢出的设计, 移位更快
            if(index[mid] <= n) l = mid +1; // 小于的时候向右移动，直到移动到大于target就不变了
            else r = mid; // 比n大就一直向左边移动
        }
        return l;
    }

    vector<int> platesBetweenCandles(string s, vector<vector<int>>& queries) {
        vector<int> index;
        for(int i = 0;i<s.length();i++){
            if(s[i] == '|') index.push_back(i);
        }
        int n = index.size();
        vector<int> ans;
        for(int i = 0;i<queries.size();i++){
            int l = queries[i][0], r = queries[i][1];
            if(n == 0){
                ans.push_back(0);
                continue;
            }
            if(r<index[0] or l>index[n-1]){
                ans.push_back(0);
                continue;
            }
            int ll = my_low_bound(index,l);
            int rr = my_up_bound(index,r)-1;
            cout<<ll<<" "<<rr<<endl;
            ans.push_back(max(0,index[rr] - index[ll] -1-(rr-ll-1)));
        }
        return ans;
    }
};

前缀和

这里还可以提升时间复杂度到O(N)

利用前缀和来实现

• 用index_left数组存当前位置左边的最近蜡烛下标（包含自己）
• 用index_right数组当前位置右侧的最近蜡烛下标（包含自己）
• 用sum数组做前缀和，存当前位置前盘子数（包含自己）

以如下为例

i            0  1  2  3  4  5  6  7  8  9
s:           *  *  |  *  *  |  *  *  *  |
index_right: 0  0  2  0  0  2  2  2  2  5
index_left:  0  0  0  2  2  5  5  5  5  9
sum:         1  2  2  3  4  4  5  6  7  7

• 那么可以O(1)时间用index_left可以找到右边界左侧最近的蜡烛
• 那么可以O(1)时间用index_right可以找到右边界左侧最近的蜡烛
• 然后在利用各个位置的前缀和求差得到区间内的盘子数

class Solution {
public:
    vector<int> platesBetweenCandles(string s, vector<vector<int>>& queries) {
        int n = queries.size();
        int m = s.length();
        vector<int> index_left(m,0); // 当前位置左边的最近蜡烛下标（包含自己），初始化为下标-1（最左）
        vector<int> index_right(m,m-1); // 当前位置右侧的最近蜡烛下标（包含自己），初始化为下标n（最右）
        vector<int> sum(m,0); // 盘子数前缀和
        vector<int> ans(n,0); // 结果

        // 特殊情况没有任何字符
        if(m == 0) return ans;

        // 记录左侧蜡烛位置
        if(s[0] == '|') index_left[0] = 0;
        for(int i = 1;i<m;i++){
            if(s[i] == '|') index_left[i] = i; // 记录蜡烛下标
            else index_left[i] = index_left[i-1]; // 最近蜡烛下标与左侧相同
            cout<<index_left[i]<<" ";
        }
        cout<<endl;

        // 记录右侧位置
        if(s[m-1] == '|') index_right[m-1] = m-1;
        for(int i = m-2;i>=0;i--){
            if(s[i] == '|') index_right[i] = i; // 记录蜡烛下标
            else index_right[i] = index_right[i+1]; // 最近蜡烛下标与右侧相同
            cout<<index_right[i]<<" ";
        }
        cout<<endl;

        // 计算前缀和
        if(s[0] == '*') sum[0] = 1;
        for(int i = 1;i<m;i++){
            if(s[i] == '*') sum[i] = sum[i-1] + 1;
            else sum[i] = sum[i-1];
            cout<<sum[i]<<" ";
        }
        cout<<endl;
        
        for(int i = 0;i<queries.size();i++){
            int l = queries[i][0];
            l = l<0?0:l; // 约数下标范围
            l = l>m-1?m-1:l;
            int r = queries[i][1];
            r = r<0?0:r; // 约数下标范围
            r = r>m-1?m-1:r;
            cout<<l<<" "<<r<<endl;
            int ll = index_right[l]; // 右侧包含自己的第一个蜡烛位置
            int rr = index_left[r]; // 左侧包含自己的第一个蜡烛位置
            cout<<l<<" "<<r<<"    ->    "<<ll<<" "<<rr<<endl;
            int temp_ans = sum[rr]-sum[ll];
            ans[i] = (temp_ans>0?temp_ans:0);
        }
        return ans;
    }
};