CodeForces 115E Linear Kingdom Races（線段樹 + DP）

Linear Kingdom Races

time limit per test

5 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

You are a car race organizer and would like to arrange some races in Linear Kingdom.

Linear Kingdom has n consecutive roads spanning from left to right. The roads are numbered from 1 to n from left to right, thus the roads follow in the order of their numbers' increasing. There will be several races that may be held on these roads. Each race will use aconsecutive subset of these roads. Also, each race will pay some amount of money to you if this race is held. No races overlap in time, so some roads can be used in several races.

Unfortunately, some of the roads are in a bad condition and they need repair. Each road has repair costs associated with it, you are required to pay this cost to repair the road. A race can only take place if all the roads used in the race are renovated. Your task is to repair such roads (possibly all or none) that will maximize your profit. Your profit is defined as the total money you get from the races that are held minus the total money you spent to repair the roads. Note that you may decide not to repair any road and gain zero profit.

Print the maximum profit you can gain.

Input

The first line contains two single-space separated integers, n and m (1 ≤ n, m ≤ 2·105), denoting the number of roads and the number of races, respectively.

Then n lines follow, each line will contain a single non-negative integer not exceeding 109 denoting the cost to repair a road. The costs are given in order from road 1 to road n.

Finally, m lines follow. Each line is single-space-separated triplets of integers. Each triplet will be given as lb, ub, and p(1 ≤ lb ≤ ub ≤ n, 1 ≤ p ≤ 109), which means that the race these three integers describe will use all the roads from lb to ub, inclusive, and if it's held you get p.

Output

Print a single integer denoting the maximum possible profit you can gain.

Please, do not use the %lld specificator to read or write 64-bit integers in C++. It is recommended to use cin, cout stream (also you may use %I64d specificator).

Sample test(s)

input

7 4
3
2
3
2
1
2
3
1 2 5
2 3 5
3 5 3
7 7 5

output

4

input

2 1
0
3
1 2 5

output

2

input

3 1
10
10
10
1 3 10

output

0

題意：有n條賽道，m場比賽，比賽需要佔用若干條賽道，在舉行比賽之前需要修理賽道，利潤 = 舉辦比賽獲利 - 修理賽道的費用，當然可以選擇不舉辦某幾場比賽，求最大利潤。

先將所有比賽所要佔用的賽道區間按右端從小到大排序，dp[i]表示前i場比賽可得的最大利潤。若第i場比賽的賽道區間爲[l, r]，則影響利潤的一定是l之前的賽道，所以第l - 1條及其之前的賽道都要加上第i場比賽的利潤，若要修理第i條賽道，則第i - 1條及其之前的賽道都要減去修理第i條賽道所需的費用。

聽學長講可以用莫隊算法做，不知道這個是不是跟莫隊算法差不多。。。

#include <cstdio>
#include <iostream>
#include <algorithm>
#define ls node << 1
#define rs node << 1 | 1
#define lson l, mid, ls
#define rson mid + 1, r, rs
#define maxn 200005

using namespace std;

long long cost[maxn], maxx[maxn << 2], add[maxn << 2], dp[maxn];
int n, m;

struct Race{
    int l;
    int r;
    long long v;
}r[maxn];

bool cmp(Race x, Race y)
{
    return x.r < y.r;
}

void pushup(int l, int r, int node)
{
    maxx[node] = max(maxx[ls], maxx[rs]);
}

void pushdown(int node)
{
    if(add[node])
    {
        add[ls] += add[node];
        add[rs] += add[node];
        maxx[ls] += add[node];
        maxx[rs] += add[node];
        add[node] = 0;
    }
}

void build(int l, int r, int node)
{
    if(l == r)
    {
        maxx[node] = 0;
        add[node] = 0;
        return;
    }
    pushdown(node);
    int mid = (l + r) >> 1;
    build(lson);
    build(rson);
    pushup(l, r, node);
}

void update(int x, int y, long long v, int l, int r, int node)
{
    if(l >= x && r <= y)
    {
        add[node] += v;
        maxx[node] += v;
        return;
    }
    pushdown(node);
    int mid = (l + r) >> 1;
    if(x <= mid)
        update(x, y, v, lson);
    if(y > mid)
        update(x, y, v, rson);
    pushup(l, r, node);
}

int main()
{
    int cnt;
    while(scanf("%d%d", &n, &m) != EOF)
    {
        for(int i = 1; i <= n; i++)
            scanf("%d", &cost[i]);
        for(int i = 1; i <= m; i++)
            scanf("%d%d%lld", &r[i].l, &r[i].r, &r[i].v);
        sort(r + 1, r + m + 1, cmp);
        dp[0] = 0;
        build(0, n, 1);
        cnt = 1;
        for(int i = 1; i <= n; i++)
        {
            update(0, i - 1, -cost[i], 0, n, 1);
            while(r[cnt].r == i && cnt <= m)
            {
                update(0, r[cnt].l - 1, r[cnt].v, 0, n, 1);
                cnt++;
            }
            dp[i] = max(dp[i - 1], maxx[1]);
            update(i, i, dp[i], 0, n, 1);
        }
        printf("%lld\n",dp[n]);
    }
}