51Nod-1053-最大M子段和 V2

ACM模版

描述

题解

这个题需要用到贪心搞。

首先涉及到一点优化是，连续的正数或者连续的负数，到最后肯定是可以合并在一起的，所以我们首先将序列中的相邻正数或者相邻负数全部合并，将序列压缩，也许这个也谈不上什么优化，因为这个步骤对于整个贪心过程是必须的，在这个过程中，累计下来所有正数的和。

此时，我们可以发现，新的序列是一个一正一负交替的序列，貌似叫做摆动序列吧，那么此时我们可以考虑合并（如果需要的话），合并时我们需要贪心，每次先找最小的（绝对值），如果最小的是负数，我们就加入它，相当于将它前后的数连结在了一起，成为了一个区间，反之，我们就需要删除它，相当于舍去了一个正数区间。这里不难理解，每次我们都需要对最小代价进行修改，因为如果只考虑正数或者负数，那么显然会因为添加了绝对值过大的负数而使结果不能最优，也会存在因为删除了过大的正数而比添加一个小的负数产生的损失更大。

至于这里的合并过程，我们可以用链表优化，自己实现一个仿真的链表，挺简单的，合并的过程中，将左右的值添加到中间，然后删除左右两边即可，另外用 $set$ 或者优先队列维护最小代价应该是不错的，剩下的就没有什么了。

代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <set>

using namespace std;

typedef long long ll;

const int MAXN = 2e6 + 10;

template <class T>
inline bool scan_d(T &ret)
{
    char c;
    int sgn;
    if (c = getchar(), c == EOF)
    {
        return 0;   //  EOF
    }
    while (c != '-' && (c < '0' || c > '9'))
    {
        c = getchar();
    }
    sgn = (c == '-') ? -1 : 1;
    ret = (c == '-') ? 0 : (c - '0');
    while (c = getchar(), c >= '0' && c <= '9')
    {
        ret = ret * 10 + (c - '0');
    }
    ret *= sgn;
    return 1;
}

ll A[MAXN];
int n, m, now;
int pre[MAXN];
int net[MAXN];
set<pair<ll, int> > a;

void _erase(int x)
{
    int l = pre[x], r = net[x];
    if (l)
    {
        net[l] = r;
    }
    if (r)
    {
        pre[r] = l;
    }
}

int main()
{
    scan_d(n), scan_d(m);

    int cnt = 0;
    ll tmp = 0, ans = 0;
    //  将相邻正数和负数分别合并
    for (int i = 1, x; i <= n; ++i)
    {
        scan_d(x);
        if ((tmp < 0 && x > 0) || (tmp > 0 && x < 0))
        {
            now += tmp > 0;
            A[++cnt] = tmp;
            a.insert(make_pair(abs(tmp), cnt));
            tmp = 0;
        }
        tmp += x;
        ans += x > 0 ? x : 0;
    }
    now += tmp > 0;
    A[++cnt] = tmp;
    a.insert(make_pair(abs(tmp), cnt));

    //  构造链表结构
    for (int i = 1; i <= cnt; ++i)
    {
        pre[i] = i - 1;
        net[i] = i + 1;
    }
    net[cnt] = A[0] = 0;

    while (now > m)
    {
        int x = (*a.begin()).second;
        a.erase(a.begin());
        if ((A[x] < 0 && (!pre[x] || !net[x])) || !A[x])
        {
            continue;
        }

        a.erase(make_pair(abs(A[pre[x]]), pre[x]));
        a.erase(make_pair(abs(A[net[x]]), net[x]));

        ans -= abs(A[x]);
        A[x] = A[x] + A[pre[x]] + A[net[x]];

        _erase(pre[x]);
        _erase(net[x]);
        a.insert(make_pair(abs(A[x]), x));
        now--;
    }

    printf("%lld\n", ans);

    return 0;
}