IOI2014 day2 task4 Holiday

最新推荐文章于 2020-03-06 15:47:33 发布

转载最新推荐文章于 2020-03-06 15:47:33 发布 · 90 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/wangck/p/4226806.html

本文介绍了一种算法，用于解决在限定时间内通过访问不同城市的路径选择问题，以达到获得最高得分的目标。通过将问题分解为左右两部分并利用线段树优化计算过程，实现了一个(O(n·log^2n))的时间复杂度解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

题目链接

大意：从左到右有$n$个城市，一开始在城市$start$，每一天有两种选择：

前往相邻的城市。
访问当前城市（每个城市只能访问一次），访问城市$i$可以获得$attraction_i$的分数。

问：在$d$天内最多能获得多少分数。

算法

首先，分成左右两边来做，路线有$4$种：

往右走
往左左
现往右再往左
先往左再往右

将左右分开做，对于往右走，计算出$f(i)$，表示往右走不回头在$i$内最大得分；以及$g(i)$，表示往右走但是要回到原点在$i$天内的最大得分。计算答案时只需要根据上面所说的$4$种情况进行枚举$d$的分布（即枚举$i$天在城市$start$右边转，$d-i$天在左边转）就可以了。

这里讲讲如何计算$f$，那计算$g$是类似的。

那如何计算$f(i)$呢？
枚举最远到达的城市$j$，那么就有$i-j$天的时间去访问城市，那当然访问最大的$i-j$个城市啦。这个用线段树可以实现求城市$start$到城市$j$中，得分最大的前$i-j$的城市的和。这样求一次$f(i)$的复杂度是$O(n \cdot logn)$。

那如何求所有的$f(i)$呢，有一个神奇的东西：
设$f'(i)$为，求$f(i)$时，得到最大得分的枚举的那个城市$j$。那么对于$ i' < i $，有$f'(i') \leqslant f'(i)$。这样子，就可以分治了。

现在求$f(1)$,$f(2),... ,f(d)$（$d$是最大天数），需要枚举的$j$为$start,...,n$，设$m= (1 + d) \text { div } 2$，用上述方法求出$f(m)$。然后递归求$f(1),f(2),...,f(m-1)$，注意，此时枚举的$j$只是$start,start+1,...,f'(m)$，范围缩小了。另外还要递归求$f(m+1),f(m+2),...,f(n)$，此时枚举的$j$只是$sf'(m),f'(m)+1,...,n$。

所以，我们得到一个$O(n\cdot log^2 n)$的算法。

代码

写得不好。

#include"holiday.h"
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <assert.h>
using namespace std;

#ifdef debug
#define ep(...) fprintf(stderr, __VA_ARGS__)
#else
#define ep(...) assert(true)
#endif

typedef long long int i64;

const int MaxN = (int) 1e5 + 3;
const int MaxM = MaxN * 2 + MaxN / 2;
const int MaxT = 262144;

struct Node
{
    i64 sum;
    int cnt;
}T[MaxT];

#define idxl (idx << 1)
#define idxr (idx << 1 ^ 1)

void Modify(int idx, int L, int R, int x, int t, int val)
{
    if (L == R)
    {
        T[idx].cnt = t;
        T[idx].sum = t ? val : 0;
    }
    else
    {
        int M = (L + R) >> 1;
        if (x <= M) Modify(idxl, L, M, x, t, val);
        else Modify(idxr, M + 1, R, x, t, val);
        T[idx].cnt = T[idxl].cnt + T[idxr].cnt;
        T[idx].sum = T[idxl].sum + T[idxr].sum;
    }
}

i64 Query(int idx, int k)
{
    if (k >= T[idx].cnt) return T[idx].sum;
    if (T[idxl].cnt >= k) return Query(idxl, k);
    return T[idxl].sum + Query(idxr, k - T[idxl].cnt);
}

struct OneSide_struct
{
    int n, m;
    int A[MaxN];
    pair<int, i64> f[MaxM], g[MaxM];
    bool goback;

    pair<int, int> tmp[MaxN];
    int rank[MaxN];
    
    void Init()
    {
        for (int i = 0; i < n; i ++) 
            tmp[i] = make_pair(A[i], i);
        sort(tmp, tmp + n);
        for (int i = 0; i < n; i ++)
            rank[tmp[i].second] = n - i - 1;
    }

    pair<int, i64> Compute(int d, int x, int y)
    {
        pair<int, i64> ret = make_pair(-1, -1);
        for (int i = x; i <= y; i ++)
        {
            Modify(1, 0, n - 1, rank[i], 1, A[i]);
            int rest = d - (goback ? i << 1 : i);
            if (rest <= 0) break;
            i64 tmp = Query(1, rest);
            if (tmp > ret.second)
            {
                ret.first = i;
                ret.second = tmp;
            }
        }
        for (int i = x; i <= y; i ++)
            Modify(1, 0, n - 1, rank[i], 0, A[i]);
        assert(ret.second != -1);
        return ret;
    }

    void Solve(int L, int R, int x, int y, pair<int, i64> ans[])
    {
        int M = (L + R) >> 1;
        ans[M] = Compute(M, x, y);
        if (L < M)
            Solve(L, M - 1, x, ans[M].first, ans);
        if (R > M)
        {
            for (int i = x; i < ans[M].first; i ++) Modify(1, 0, n - 1, rank[i], 1, A[i]);
            Solve(M + 1, R, ans[M].first, y, ans);
        }
        for (int i = x; i < y; i ++) Modify(1, 0, n - 1, rank[i], 1, A[i]);
    }
};

long long int findMaxAttraction(int n, int start, int m, int A[])
{
    static OneSide_struct R, L;
    R.n = 0;
    for (int i = start; i < n; i ++)
        R.A[R.n ++] = A[i];
    R.m = m;
    R.Init();

    R.goback = false;
    R.Solve(1, R.m, 0, R.n - 1, R.f);
    R.goback = true;
    memset(T, 0, sizeof(T));
    R.Solve(1, R.m, 0, R.n - 1, R.g);

    L.n = 0;
    for (int i = start - 1; i >= 0; i --)
        L.A[L.n ++] = A[i];
    L.m = m;
    L.Init();

    if (L.n)
    {
        L.goback = false;
        memset(T, 0, sizeof(T));
        L.Solve(1, L.m, 0, L.n - 1, L.f);
        L.goback = true;
        memset(T, 0, sizeof(T));
        L.Solve(1, L.m, 0, L.n - 1, L.g);
    }

#ifdef debug
    for (int i = 0; i < m; i ++)
        ep("R %d %lld %lld\n", i, R.f[i].second, R.g[i].second);
    ep("\n");
    for (int i = 0; i < m; i ++)
        ep("L %d %lld %lld\n", i, L.f[i].second, L.g[i].second);
#endif

    i64 ans = max(R.f[m].second, L.f[m - 1].second);
    for (int i = 0; i < m; i ++)
        ans = max(ans, R.g[i].second + L.f[m - i - 1].second);
    for (int i = 0; i < m - 2; i ++)
        ans = max(ans, L.g[i].second + R.f[m - i - 2].second);

    return ans;
}

转载于:https://www.cnblogs.com/wangck/p/4226806.html