P3976 [TJOI2015] 旅游

原创 已于 2023-10-25 22:41:22 修改 · 77 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#旅游 #深度优先 #算法

于 2023-10-25 22:39:27 首次发布
文章介绍如何利用树剖和线段树技术解决一个关于路径点权差的问题，涉及节点关系、深度计算、数据结构操作等。

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

洛谷传送门

题目简述：q次询问，求树上俩个点路径上，右边点权减左边点权的最大值。

思路：树剖+线段树

树剖部分，简单树剖即可，无需其他操作
int sum[N], fa[N], dep[N], son[N], top[N];
int pre[N], new_point[N];
int n;

void dfs_1(int father, int cur) {
    sum[cur] = 1;
    for (auto v: f[cur]) {
        if (v == father) continue;
        fa[v] = cur;
        dep[v] = dep[cur] + 1;
        dfs_1(cur, v);
        sum[cur] += sum[v];
        if (sum[v] > sum[son[cur]]) son[cur] = v;
    }
}

int tot;//时间戳

void dfs_2(int fcur, int cur) {
    top[cur] = fcur;
    tot++;
    pre[tot] = cur;//存旧节点编号，方便后面build函数初始化
    new_point[cur] = tot;//存新节点编号，方便后面进行线段树的修改和查询
    if (son[cur]) dfs_2(fcur, son[cur]);
    for (auto v: f[cur]) {
        if (v == fa[cur] || v == son[cur]) continue;
        dfs_2(v, v);
    }
}
线段树部分,首先确定需要维护几个信息：

第一个是左右端点

第二个就是区间最大和区间最小，分别是maxx,minn（用来维护下面第三个和第四个信息）

第三个根据题目定义一个lmax，表示右边节点的点权-左边节点点权的最大值

第四个则相反，定义应该rmax，表示左边节点的点权-右边节点点权的最大值（这俩个标记弱弱我一开始没想到捏，此题第一篇大佬的题解让我幡然醒悟）

然后就要想办法进行分治更新，想一下怎么从左右节点的信息更新我父节点的信息，最大和最小值弱弱我相信各位大佬都会，俺说一下第三信息怎么更新，第四个可以依次类推：

father.lmax=max(max(leftson.lmax,rightson.lmax),rightson.maxx-leftson.minn)

公式如上，俩个儿子没合并之前，父亲的lmax必然会等于左右儿子的lmax中的最大值，考虑合并，合并后可能对父亲lmax产生影响的，即可能可以更新父亲lmax的情况只有右儿子的区间最大值减去左儿子的区间最小值，所以直接对这三者取max即可

第五个是区间加的懒标记，表示这个区间累加的值，这样询问和修改的时候就不用每次访问每一个区间。

最后我们还要再想一下怎么处理题目里给的查询和修改操作

修改，类比树剖求lca，在俩个点跳的同时进行线段树的motify（修改）操作
void cli(int l, int r, int v) {
    while (top[l] != top[r]) {
        if (dep[top[l]] < dep[top[r]]) swap(l, r);
        motify(1, new_point[top[l]], new_point[l], v);
        l = fa[top[l]];
    }
    if (dep[l] > dep[r]) swap(l, r);
    motify(1, new_point[l], new_point[r], v);
}
//l,r为询问给的俩个节点
//new_point数组是前面提到过的存dfs序的数组

//motify操作，涉及懒标记的下传
void pushdown(int u) {
    if (xd[u].lazy) {
        xd[u << 1].maxx += xd[u].lazy;
        xd[u << 1].mmin += xd[u].lazy;
        xd[u << 1].lazy += xd[u].lazy;
        xd[u << 1 | 1].maxx += xd[u].lazy;
        xd[u << 1 | 1].mmin += xd[u].lazy;
        xd[u << 1 | 1].lazy += xd[u].lazy;
        xd[u].lazy = 0;
    }
}

void motify(int u, int l, int r, int c) {
    if (xd[u].l >= l && xd[u].r <= r) {
        xd[u].maxx += c;
        xd[u].mmin += c;
        xd[u].lazy += c;
    } else {
        pushdown(u);
        int mid = xd[u].l + xd[u].r >> 1;
        if (l <= mid) motify(u << 1, l, r, c);
        if (r > mid) motify(u << 1 | 1, l, r, c);
        pushup(u);
    }
}
查询，类比修改操作，这里边查询边更新答案
int cli2(int l, int r) {
    xds l_1, r_1;//俩个答案线段
    xds temp;
    l_1.lmax = l_1.rmax = 0;
    l_1.maxx = -1e18;
    l_1.mmin = 1e18;
    r_1 = l_1;
    while (top[l] != top[r]) {


        if (dep[top[l]] >= dep[top[r]]) {
            temp = query(1, new_point[top[l]], new_point[l]);
            l = fa[top[l]];

            l_1.lmax = max(max(temp.lmax, l_1.lmax), l_1.maxx - temp.mmin);
            l_1.rmax = max(max(temp.rmax, l_1.rmax), temp.maxx - l_1.mmin);
            l_1.maxx = max(l_1.maxx, temp.maxx);
            l_1.mmin = min(l_1.mmin, temp.mmin);
        } else {
            temp = query(1, new_point[top[r]], new_point[r]);
            r = fa[top[r]];

            r_1.rmax = max(max(temp.rmax, r_1.rmax), temp.maxx - r_1.mmin);
            r_1.lmax = max(max(temp.lmax, r_1.lmax), r_1.maxx - temp.mmin);
            r_1.maxx = max(r_1.maxx, temp.maxx);
            r_1.mmin = min(r_1.mmin, temp.mmin);
        }
    }
    if (dep[l] < dep[r]) {
        temp = query(1, new_point[l], new_point[r]);
        r_1.rmax = max(max(temp.rmax, r_1.rmax), temp.maxx - r_1.mmin);
        r_1.lmax = max(max(temp.lmax, r_1.lmax), r_1.maxx - temp.mmin);
        r_1.maxx = max(r_1.maxx, temp.maxx);
        r_1.mmin = min(r_1.mmin, temp.mmin);
    } else {
        temp = query(1, new_point[r], new_point[l]);

        l_1.lmax = max(max(temp.lmax, l_1.lmax), l_1.maxx - temp.mmin);
        l_1.rmax = max(max(temp.rmax, l_1.rmax), temp.maxx - l_1.mmin);
        l_1.maxx = max(l_1.maxx, temp.maxx);
        l_1.mmin = min(l_1.mmin, temp.mmin);//注意这里要先更新lmax和rmax再更新maxx和minn
//因为合并之前这俩个线段可能没有交集
    }
    return max(max(l_1.rmax, r_1.lmax), r_1.maxx - l_1.mmin);//最后返回一个最优值
}



//线段树query部分

xds query(int u, int l, int r) {
    if (xd[u].l >= l && xd[u].r <= r) return xd[u];
    else {
        pushdown(u);
        xds res;
        int mid = xd[u].l + xd[u].r >> 1;
        if (r <= mid) res = query(u << 1, l, r);
        else if (l > mid) res = query(u << 1 | 1, l, r);
        else {
            xds l_1, r_1;
            l_1 = query(u << 1, l, r);
            r_1 = query(u << 1 | 1, l, r);
            pushup(res, l_1, r_1);
            // return res;
        }
        return res;
    }
}

//pushup操作，返回最优答案，也就是不断更新父节点的信息操作

void pushup(xds &u, xds &l, xds &r) {
    u.maxx = max(l.maxx, r.maxx);
    u.mmin = min(l.mmin, r.mmin);
    u.lmax = max(max(l.lmax, r.lmax), r.maxx - l.mmin);
    u.rmax = max(max(l.rmax, r.rmax), l.maxx - r.mmin);
}
 总结：弱弱我还得练
ps：完整代码：
#include<bits/stdc++.h>

#define int long long
using namespace std;
const int N = 5e4 + 10;
struct xds {
    int l, r;
    int maxx;
    int mmin;
    int lazy;
    int lmax;
    int rmax;
} xd[4 * N];
vector<int> f[N];
int val[N];
int sum[N], fa[N], dep[N], son[N], top[N];
int pre[N], new_point[N];
int n;

void dfs_1(int father, int cur) {
    sum[cur] = 1;
    for (auto v: f[cur]) {
        if (v == father) continue;
        fa[v] = cur;
        dep[v] = dep[cur] + 1;
        dfs_1(cur, v);
        sum[cur] += sum[v];
        if (sum[v] > sum[son[cur]]) son[cur] = v;
    }
}

int tot;

void dfs_2(int fcur, int cur) {
    top[cur] = fcur;
    tot++;
    pre[tot] = cur;
    new_point[cur] = tot;
    if (son[cur]) dfs_2(fcur, son[cur]);
    for (auto v: f[cur]) {
        if (v == fa[cur] || v == son[cur]) continue;
        dfs_2(v, v);
    }
}

void pushup(int u) {
    xd[u].maxx = max(xd[u << 1].maxx, xd[u << 1 | 1].maxx);
    xd[u].mmin = min(xd[u << 1].mmin, xd[u << 1 | 1].mmin);
    xd[u].lmax = max(max(xd[u << 1].lmax, xd[u << 1 | 1].lmax), xd[u << 1 | 1].maxx - xd[u << 1].mmin);
    xd[u].rmax = max(max(xd[u << 1].rmax, xd[u << 1 | 1].rmax), xd[u << 1].maxx - xd[u << 1 | 1].mmin);
}

void build(int u, int l, int r) {
    if (l == r) xd[u] = {l, r, val[pre[l]], val[pre[l]], 0, 0, 0};
    else {
        xd[u] = {l, r, 0, 0, 0, 0, 0};
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void pushdown(int u) {
    if (xd[u].lazy) {
        xd[u << 1].maxx += xd[u].lazy;
        xd[u << 1].mmin += xd[u].lazy;
        xd[u << 1].lazy += xd[u].lazy;
        xd[u << 1 | 1].maxx += xd[u].lazy;
        xd[u << 1 | 1].mmin += xd[u].lazy;
        xd[u << 1 | 1].lazy += xd[u].lazy;
        xd[u].lazy = 0;
    }
}

void motify(int u, int l, int r, int c) {
    if (xd[u].l >= l && xd[u].r <= r) {
        xd[u].maxx += c;
        xd[u].mmin += c;
        xd[u].lazy += c;
    } else {
        pushdown(u);
        int mid = xd[u].l + xd[u].r >> 1;
        if (l <= mid) motify(u << 1, l, r, c);
        if (r > mid) motify(u << 1 | 1, l, r, c);
        pushup(u);
    }
}

void pushup(xds &u, xds &l, xds &r) {
    u.maxx = max(l.maxx, r.maxx);
    u.mmin = min(l.mmin, r.mmin);
    u.lmax = max(max(l.lmax, r.lmax), r.maxx - l.mmin);
    u.rmax = max(max(l.rmax, r.rmax), l.maxx - r.mmin);
}

xds query(int u, int l, int r) {
    if (xd[u].l >= l && xd[u].r <= r) return xd[u];
    else {
        pushdown(u);
        xds res;
        int mid = xd[u].l + xd[u].r >> 1;
        if (r <= mid) res = query(u << 1, l, r);
        else if (l > mid) res = query(u << 1 | 1, l, r);
        else {
            xds l_1, r_1;
            l_1 = query(u << 1, l, r);
            r_1 = query(u << 1 | 1, l, r);
            pushup(res, l_1, r_1);
            // return res;
        }
        return res;
    }
}

void cli(int l, int r, int v) {
    while (top[l] != top[r]) {
        if (dep[top[l]] < dep[top[r]]) swap(l, r);
        motify(1, new_point[top[l]], new_point[l], v);
        l = fa[top[l]];
    }
    if (dep[l] > dep[r]) swap(l, r);
    motify(1, new_point[l], new_point[r], v);
}

int cli2(int l, int r) {
    xds l_1, r_1;
    xds temp;
    l_1.lmax = l_1.rmax = 0;
    l_1.maxx = -1e18;
    l_1.mmin = 1e18;
    r_1 = l_1;
    while (top[l] != top[r]) {


        if (dep[top[l]] >= dep[top[r]]) {
            temp = query(1, new_point[top[l]], new_point[l]);
            l = fa[top[l]];

            l_1.lmax = max(max(temp.lmax, l_1.lmax), l_1.maxx - temp.mmin);
            l_1.rmax = max(max(temp.rmax, l_1.rmax), temp.maxx - l_1.mmin);
            l_1.maxx = max(l_1.maxx, temp.maxx);
            l_1.mmin = min(l_1.mmin, temp.mmin);
        } else {
            temp = query(1, new_point[top[r]], new_point[r]);
            r = fa[top[r]];

            r_1.rmax = max(max(temp.rmax, r_1.rmax), temp.maxx - r_1.mmin);
            r_1.lmax = max(max(temp.lmax, r_1.lmax), r_1.maxx - temp.mmin);
            r_1.maxx = max(r_1.maxx, temp.maxx);
            r_1.mmin = min(r_1.mmin, temp.mmin);
        }
    }
    if (dep[l] < dep[r]) {
        temp = query(1, new_point[l], new_point[r]);
        r_1.rmax = max(max(temp.rmax, r_1.rmax), temp.maxx - r_1.mmin);
        r_1.lmax = max(max(temp.lmax, r_1.lmax), r_1.maxx - temp.mmin);
        r_1.maxx = max(r_1.maxx, temp.maxx);
        r_1.mmin = min(r_1.mmin, temp.mmin);
    } else {
        temp = query(1, new_point[r], new_point[l]);

        l_1.lmax = max(max(temp.lmax, l_1.lmax), l_1.maxx - temp.mmin);
        l_1.rmax = max(max(temp.rmax, l_1.rmax), temp.maxx - l_1.mmin);
        l_1.maxx = max(l_1.maxx, temp.maxx);
        l_1.mmin = min(l_1.mmin, temp.mmin);
    }
    return max(max(l_1.rmax, r_1.lmax), r_1.maxx - l_1.mmin);
}

void solve() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> val[i];
    for (int i = 1; i <= n - 1; i++) {
        int u, v;
        cin >> u >> v;
        f[u].push_back(v);
        f[v].push_back(u);
    }
    dfs_1(0, 1);
    dfs_2(1, 1);
    build(1, 1, n);
    int q;
    cin >> q;
    while (q--) {
        int a, b, v;
        cin >> a >> b >> v;
        cli(a, b, v);
        int ans = cli2(a, b);
        if (ans > 0) cout << ans << '\n';
        else cout << 0 << '\n';

    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    int T = 1;
    // cin >> T;
    while (T--) { solve(); }
    return 0;
}

hey_sml
关注
洛谷3976 【TJOI2015】旅游（树链剖分）
Michael_GLF的博客
01-20 229
传送门 【题目分析】 考试3h30min，40min打完T2，就对着这道和T3发懵。。。。。。 讲道理昨天我看见这道题就丢了。。。。。 首先题意简直令人想打出题人，语文水平果然很重要。。。。 其实只能在这条路径上买一次宝石、卖一次宝石，所以就是求最大差值。 但这道题要考虑路径是有向的，所以将路径拆为u-&gt;lca和lca-&gt;v，query的时候直接传结构体就行了。。。 然后...
《P3976 [TJOI2015] 旅游》
Jasmine_llq的博客
07-11 563
摘要：本文描述了一个基于树形结构的宝石买卖问题。给定n个城市组成的树结构，每个城市有初始宝石价格。每次查询给出路径起点a、终点b和涨价v，要求计算从a到b路径上的最大买卖利润（买入后卖出），并更新路径上所有城市宝石价格。算法使用DFS寻找路径，遍历路径计算最大利润（类似股票买卖问题），最后更新路径价格。时间复杂度为O(q*n)，适用于n,q≤5×10^4的数据规模。
P3976 [TJOI2015]旅游（未完成）
dianzhiliu5834的博客
08-07 138
#include<iostream> #include<cstdlib> #include<cstring> #include<cstdio> #include<cmath> using namespace std; const int maxn=1e6+10; const int inf=1<<3...
洛谷 P3976 [TJOI2015]旅游 树链剖分
liangzihao1的博客
10-05 239
题目描述 为了提高智商,ZJY准备去往一个新世界去旅游。这个世界的城市布局像一棵树。每两座城市之间只有一条路径可以互达。每座城市都有一种宝石,有一定的价格。ZJY为了赚取最高利益,她会选择从A城市买入再转手卖到B城市。由于ZJY买宝石时经常卖萌,因而凡是ZJY路过的城市,这座城市的宝石价格会上涨。让我们来算算ZJY旅游完之后能够赚取的最大利润。(如a城市宝石价格为v,则ZJY出售价格也为v) 输入...
[TJOI2015]旅游,洛谷P3976,LCT维护路径信息
Deep_Kevin的娱乐空间
09-01 158
正题 这题主要是用来练手的,只要维护一个mmin,mmax.再维护一个正着来的ans和一个倒着来的ans就可以了. 至于维护倒着的ans的原因就是当makeroot的时候要翻转整个区间,这时候直接翻转两个ans就可以了. #include<bits/stdc++.h> using namespace std; const int N=50010; struct node{ int son[2],fa,mmin,mmax,ans1,ans2,val,tag; ...
洛谷P3976 [TJOI2015] 旅游【树链剖分综合】题解
MorningLa的博客
02-04 364
对于维护信息复杂的线段树，查询时只返回一个值往往得不到正确答案，没有覆盖全部情况，应当直接返回结点，再使用merge函数对信息进行合并，得出最终解。
TJOI2015 旅游
weixin_30877181的博客
02-11 79
题目链接：戳我 树上有向信息合并。 用树链剖分把其转化为序列上的问题——求区间中最大数-最小数的差，限制为最小数必须在最大数前面选取。 有两种选择方法，一种是先选择全局最大数，在它前面区间中选择最小数。一种是选择全局最小数，然后在它后面的区间种选择最大的。（证明只有这两种情况——加入我们选择了一个全局次大，只有当最小数小于它前面区间最小数才有可能最优，最佳情况下会选到全局最小。但是由于它...
[TJOI2015]旅游
zsyzClb的博客
02-23 164
很容易想到要用动态树来维护。 不过这一道题我被恶心了一下，主要是翻转操作会影响结果，所以应该同时维护从左到右和从右到左的结果。 #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> #include<cmath> using namespace std; template<typename T>inline void qr(T &x){
【TJOI2015】旅游
StrideTG的博客
03-19 517
时间限制 : 1000 MS 空间限制 : 256 MB 问题描述 为了提高智商，ZJY准备去往一个新世界去旅游。这个世界的城市布局像一棵树。每两座城市之间只有一条路径可以互达。每座城市都有一种宝石，有一定的价格。ZJY为了赚取最高利益，她会选择从A城市买入再转手卖到B城市。由于ZJY买宝石时经常卖萌，因而凡是ZJY路过的城市，这座城市的宝石价格会上涨。让我们来算算ZJY...
2019.4.summary
LMB_001的博客
07-04 1320
2019.4.1 BZOJ1061: [Noi2008]志愿者招募 真心有点难QAQ https://www.byvoid.com/zhs/blog/noi-2008-employee 看void爷的博客看了三遍才懂。这种网络流建模看不出来啊 首先可以列出一些数相加减的式子 然后可以考虑差分，得到一些式子和为0的情况 这不就很像每一个点流量平衡对吧 正的是流进来的，负的是流出去的 常数是关于s，t...
Java项目：基于SSM框架实现的济南旅游网站管理系统【ssm+B/S架构+源码+数据库+毕业论文+远程部署】
最新发布
weixin_43860634的博客
07-30 940
Java项目：基于SSM框架实现的济南旅游网站管理系统【ssm+B/S架构+源码+数据库+毕业论文+远程部署】
基于cooragent的旅游多智能体的MCP组件安装与其开发
m0_56997192的博客
07-26 941
本文介绍了使用Cooragent构建多智能体旅游规划服务的具体配置步骤。首先需要配置AMAP API密钥，然后安装并配置Excel、Filesystem、Word和Image Downloader等MCP服务模块，包括Python依赖安装和服务器设置。完成环境搭建后，通过cli.py创建四个专用智能体：交通规划、行程设计、费用计算和结果整合智能体。最后通过协同工作流程，输入旅游需求（如2025年上海至北京五日游），系统将自动生成包含交通、住宿、景点推荐及预算的完整规划，并输出Word文档保存至本地。
AI聊天：旅游达人的角色提示词
Dwen512的博客
07-29 730
），并说明自身分析的局限性（“基于你提供的信息，我的看法是…”），引导用户深入思考和表达。“你好，我是小智，你的AI爱情专家伙伴。我在这里倾听你的故事，运用心理学知识和分析工具，为你提供关于情感、关系的见解和建议。：通过旅行史、兴趣标签（美食/摄影/历史/极限运动）、体力值、预算区间、旅行同伴（情侣/家庭/独行）等生成专属旅行基因图谱。努力结合用户的具体描述（人物、事件、感受、背景）提供定制化的分析和建议，避免通用模板回复。在用户情绪剧烈波动时，能提供稳定、理性的视角，帮助用户冷静分析，避免冲动决策。
历史数据分析——中证旅游
人大博士的交易之路
07-26 457
中证旅游板块月线级别显示2015年以来长期下跌后底部放量震荡，周线级别呈现波浪式下跌后MACD金叉，日线级别经过调整后再次形成上涨波段。技术指标显示板块长期下跌基本结束，近期底部信号明显，后续大概率开启持续上涨走势。
AgeTravel | 银发文娱旅游一周新鲜事
AgeClub的博客
07-28 535
近日，乐添云医与湖北鼎途旅游文化有限责任公司（简称“鼎途文旅”）达成合作，双方将围绕“智慧中医”与“康养旅游”展开合作，共同探索“医疗+文旅”的创新模式。据悉，乐添云医是乐添集团旗下中医医疗智慧服务平台，其AI问诊系统可以通过“舌诊、面诊、脉诊、问诊”等流程，为用户提供健康检测与调理方案。（QuestMobile）近日，新加坡旅游局启动面向全国旅游业界的活动“乐龄银发族旅游产品设计大赛”，旨在激发业界创意，开发更多优质的乐龄旅游产品，为银发族群打造独特的旅游体验，构建新加坡“乐龄友好”的旅行生态。
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5332
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
今日十题：56. 合并区间
qq_59259601的博客
07-30 118
解法：先排序（贪心）思想;首先给intervals的所有区间按照区间起点进行排序以第一个区间的左顶点和右顶点为起点和终点{start,end}然后从第二个区间开始遍历，如果有重叠就更新end否则将区间放入结果集，并且更新起点和终点遍历完所有数组，将最后一个区间放入结果集时间复杂度O(nlogn)
求两数之和
silent702366的博客
07-28 162
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
算法【1】
weixin_47868976的博客
07-29 1023
有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；如果 x!= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后，最多只会剩下一块 石头。返回此石头 最小的可能重量。如果没有石头剩下，就返回 0。
P3853 [TJOI2007] 路标设置
07-16
题目描述 在一条公路上，有 $n$ 个路标，第 $i$ 个路标的位置为 $x_i$，每个路标上都有一个数字 $a_i$。现在需要在这条公路上设置 $m$ 个路障，每个路障的位置为 $y_i$，每个路障会覆盖一段长度为 $l_i$ 的区间 $[y_i-l_i,y_i+l_i]$，其中 $l_i$ 是正整数。 对于每个路障，它会覆盖的区间内的路标的数字 $a_i$ 的和为 $s_i$，即 $s_i=\sum_{j=1}^n[a_j\in[y_i-l_i,y_i+l_i]]a_j$。 现在需要在不超过 $k$ 个路障的前提下，最大化所有路障覆盖的数字和的最小值。 输入格式 第一行包含三个整数 $n,m,k$。 接下来 $n$ 行，每行包含两个整数 $x_i,a_i$。 接下来 $m$ 行，每行包含两个整数 $y_i,l_i$。 输出格式 输出一个实数，表示最大化所有路障覆盖的数字和的最小值，保留 $2$ 位小数。 数据范围 $1\leq n,m\leq 200$, $1\leq k\leq 10$, $\leq x_i,y_i\leq 10^9$, $1\leq a_i,l_i\leq 10^6$ 输入样例1 5 2 1 1 2 2 3 3 4 4 5 5 6 3 1 7 1 输出样例1 3.50 输入样例2 5 2 2 1 2 2 3 3 4 4 5 5 6 3 1 7 1 输出样例2 2.50 算法1 (二分答案+贪心) $O(m^2\log w)$ 二分答案+贪心 时间复杂度 参考文献 python3 代码 C++ 代码 算法2 (暴力枚举) $O(n^2m^2)$ blablabla 时间复杂度 参考文献 C++ 代码
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值