csp 2022 - 09 压轴题高维亚空间超频物质变压缩技术

Tommyjia0405

已于 2024-04-24 21:34:02 修改

阅读量1.1k

点赞数 2

文章标签：算法

于 2023-01-22 11:51:20 首次发布

本文链接：https://blog.csdn.net/Tommyjia0405/article/details/128748388

版权

文章介绍了如何利用斜率优化方法解决动态规划中的时间限制问题，通过维护递增下凸壳优化算法。当面对序列有效分划的要求时，文章提出了采用分治策略进一步降低复杂度，通过递归处理不同m值的子问题，确保序列严格递增。最终，文章提供了一个100分的解决方案，该方案在处理大规模数据时能有效避免超时。

摘要由CSDN通过智能技术生成

斜率优化 + 分治降维

首先分析这个题目，寻找全局最小值，发现可以存在递推关系。从而用动态规划，列表达式。

用dp[i]表示以i为结尾的所有值的最小值。可得 $dp[i] = min (dp[j] + {(s[i] - s[j] - L)^{2}}) (0 <= j <= i - 1)$

$(m[j] < m[i])$

则可以直接两个for加上m递增的判断操作，完成程序，提交，发现只有部分分。（ACM赛制下就是零分）。显然这个算法是 $O(n^{2})$ 的，而数据范围是 $10^{5}$ 的，必然time limit exceeded，所以需要想方法改进。

我们发现若想改进，i最外围走一遍是无法不做的，所以我们可以考虑状态转移到i的那些点是不是可以有更好的方法。看他的数学本质，通常组合数学里你可以任取i前面两个点j, k 列出来看看有什么优化的方法，不过我们这里直接将表达式的平方项展开，并整理。

得到： $dp[j] + s[j]^{2} + 2Ls[j] = 2s[i]s[j] + (dp[i] + 2Ls[i] - s[i]^{2} - L^{2})$

这其实可以看作f(x) = kx + b的形式，其中横坐标是s[j], 纵坐标是上式左侧，如果i前面的j都处理完了，那这就都是定值，可以看做平面上的点，也就是说我现在要处理dp[i]时，就是给了一个斜率2s[i], 那么就会对应一个b，可以发现dp[i]取最小时，当且仅当b取最小时。

那么我们发现对于最优的模式下，由表达式，知s[i]是递增的，dp[i]是递增的，则f(x)也是递增的，所以只需要维护一个递增的下凸壳即可。比如对于小于i的m , n , l来说，如果mn的斜率大于nl的斜率，通过2s[i]与两个斜率大小的分类讨论，得到n一定不可能转移到i。而转移的点从队首操作即可，如果2s[i] > slope(queue[head], queue[head + 1])则队首弹出，向后移；否则即为对于i来讲，要转移的点j。这样就完成了用双端队列维护递增下凸壳。负责度是 $O(n)$ 的，如果2s[i]不是递增的，你可以二分单调双端队列，复杂度是 $O(nlogn)$ 的。

之后这个题还有个致命的问题，就是还要求序列有效分划下，最后一个的m值是要严格递增的。如果还通过上述方式，就会发现很多根本转移不了，这个题就白瞎了。

可以通过分治来把这层偏序划掉，我们对所有m的值域来递归（有点像Lebesgue积分的感觉哈哈），这样每一层里，m大的就可以对所有m小的来转移，操作方法还是如上述所说斜率优化，不过每一层里还要先对坐标id排序，实现起来是有点复杂和难想的，而且还要处理比如一侧为空这种细节。最后假如最大的m值是M, 那么整体复杂度就是 $O(nlognlogM)$ ,这显然是可行的。证毕

以下是100分代码，我看网上还没有，那感觉还不错。（这种我得钻研两三天的题，考试的时候还是争取拿个部分分吧，现阶段老实的模拟题满分对我提分效果大）

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
const int maxn = 100005;
typedef long long ll;
int v[maxn];
int m[maxn];
ll s[maxn];
ll dp[maxn];
const ll inf = 9223372036854775807;
int queue[maxn];
int head, tail;
int n , L; int R0, L0;
typedef double db;
struct node{
    int id;
    int m;
};
struct node aa[maxn];
struct node bb[maxn];
struct node cc[maxn];

bool cmp1(struct node a, struct node b){return a.id < b.id;}
bool cmp2(struct node a, struct node b){return a.m < b.m;}
inline db slope(int i, int j){
    return ((dp[i] + s[i] * s[i] + 2 * L * s[i]) - (dp[j] + s[j] * s[j] + 2 * L * s[j])) / (s[i] - s[j]);
}
int findpoint(int x, int l, int r){
    if (aa[r].m <= x)return r;
    if (aa[l].m > x)return l - 1;
    while (l < r){
        int mid = (l + r) >> 1;
        if (aa[mid].m <= x){
            l = mid + 1;
        }
        else r = mid;
    }
    if (aa[l].m > x)return l - 1;
    else return l;
}

void solve(int l, int r, int left, int right){
//    cout << dp[2] << endl;
    if (l >= r )return ;
    if (left == right){
        dp[aa[left].id] = min (dp[aa[left].id], dp[0] + (s[aa[left].id] - s[0] - L) * (s[aa[left].id] - s[0] - L));
        return ;
    }
    
    int mid = (l + r) >> 1;
    int point = findpoint(mid, left, right);             //   cout << point << endl;
    int ll = point - left + 1; int rr = right - point;
    
    if (ll == 0){
        for (int i = left; i <= right; i ++){
          //  cout << aa[i].id << " ";
            dp[aa[i].id] = min (dp[aa[i].id], dp[0] + (s[aa[i].id] - s[0] - L) * (s[aa[i].id] - s[0] - L));
        }
    }else if (ll >= 1){
        solve(l, mid, left, point);
        for (int i = 1; i <= ll; i ++)bb[i] = aa[i + left - 1];
        for (int i = 1; i <= rr; i ++)cc[i] = aa[i + point];

        sort(bb + 1, bb + ll + 1, cmp1); sort(cc + 1, cc + rr + 1, cmp1);
        head = 1; tail = 1;
        queue[1] = 0;
        int i = 1;
        
        if (rr >= 1) while (bb[1].id > cc[i].id && i <= rr){
            dp[cc[i].id] = min(dp[cc[i].id], dp[0] + (s[cc[i].id] - s[0] - L) * (s[cc[i].id] - s[0] - L));
            i ++;
        }
        int t = 1;
        for (int j = i; j <= rr; j ++){
            
            while (t <= ll && bb[t].id < cc[j].id  ){
            
                while (head < tail && slope(queue[tail], queue[tail - 1]) > slope(queue[tail], bb[t].id)) --tail;
                queue[++ tail] = bb[t].id;
            //    while (head < tail && slope(queue[head], queue[head + 1]) < 2 * s[j]) ++ head;
                t++;
            }
            while (head < tail && slope(queue[head], queue[head + 1]) < 2 * s[cc[j].id]) ++ head;
            int ans = queue[head];
            dp[cc[j].id] = min (dp[cc[j].id], dp[ans] + (s[cc[j].id] - s[ans] - L) * (s[cc[j].id] - s[ans] - L));
       //     if (dp[cc[j].id] == inf) dp[cc[j].id] = ((s[cc[j].id] - s[0] - L) * (s[cc[j].id] - s[0] - L));
        }
    }
    if(rr >= 1) solve(mid + 1, r, point + 1, right);
}

int main(void){
    R0 = L0 = 0;
//    memset(dp, 0, sizeof(dp));
    memset(queue, 0, sizeof(queue));
    cin >> n >> L; s[0] = 0;
  
    for (int i = 1; i <= n ; i ++){ cin >> v[i]; s[i] = s[i - 1] + v[i]; }
    for (int i = 1; i <= n ; i ++){
        aa[i].id = i;
        cin >> aa[i].m;
        R0 = max (R0, aa[i].m);
    }
    for (int i = 1; i <= n ; i ++)dp[i] = inf; dp[0] = 0; dp[1] = (s[1] - s[0] - L) * (s[1] - s[0] - L);
    sort(aa + 1, aa + n + 1, cmp2);
    solve(L0, R0, 1, n);
//    for (int i = 1; i <= n ; i ++)cout << dp[i] << " "; cout << endl;
    cout << dp[n] << endl;
    return 0;
}