Algo:Array Manipulation

Problem

给你一个长度为N的列表，列表的初始值全是0。对此列表，你要进行M次查询，输出列表中最终N个值的最大值。对每次查询，给你的是3个整数——a,b和k，你要对列表中从位置a到位置b范围内的（包含a和b)的全部元素加上k。

输入格式

第一行包含两个整数 N和 M。
接下来 M行，每行包含3个整数 a, b 和 k。
列表中的数位置编号为从1到 N。

输出格式

单独的一行包含 最终列表里的最大值

约束条件

3 <= N <= 10^7
1 <= M <= 2*10^5
1 <= a <= b <= N
0 <= k <= 10^9

输入样例 #00:

5 3
1 2 100
2 5 100
3 4 100

输出样例 #00:

200

第一次更新后，列表变为 100 100 0 0 0，
第二次更新后，列表变为 100 200 100 100 100。
第三次更新后，列表变为 100 200 200 200 100。
因此要求的答案是200。

程序样例

#include 

using namespace std;

vector split_string(string);

// Complete the arrayManipulation function below.
long arrayManipulation(int n, vector> queries) {
  
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    string nm_temp;
    getline(cin, nm_temp);

    vector nm = split_string(nm_temp);

    int n = stoi(nm[0]);

    int m = stoi(nm[1]);

    vector> queries(m);
    for (int i = 0; i < m; i++) {
        queries[i].resize(3);

        for (int j = 0; j < 3; j++) {
            cin >> queries[i][j];
        }

        cin.ignore(numeric_limits::max(), '\n');
    }

    long result = arrayManipulation(n, queries);

    fout << result << "\n";

    fout.close();

    return 0;
}

vector split_string(string input_string) {
    string::iterator new_end = unique(input_string.begin(), input_string.end(), [] (const char &x, const char &y) {
        return x == y and x == ' ';
    });

    input_string.erase(new_end, input_string.end());

    while (input_string[input_string.length() - 1] == ' ') {
        input_string.pop_back();
    }

    vector splits;
    char delimiter = ' ';

    size_t i = 0;
    size_t pos = input_string.find(delimiter);

    while (pos != string::npos) {
        splits.push_back(input_string.substr(i, pos - i));

        i = pos + 1;
        pos = input_string.find(delimiter, i);
    }

    splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));

    return splits;
}

代码

long arrayManipulation(int n, vector> queries) {
    vector arr(n,0);
    int a,b,k;
    for(int i=0;imax)
        max=arr[i];
    }
    return max;
}

耗时太长

优化

O(n) time complexity and O(1) Auxiliary space
思路：不对arr做具体的操作，而是记录每次操作的边界。关键在于右边界后为什么减去对应的k？这是由于x=x+a[i],如果某次加k，后面实际上没操作的话，可用-k抵消对应的操作。此时x对应的就是所有操作后每个index对应的值。

long arrayManipulation(int n, vector> queries) {
    vector arr(n+1,0);
    int a,b,k;
    long max=0,x=0;
    for(int i=0;i

每次x计算得对应的a[i]：100 200 200 200 100