[POJ2761]Feed the dogs

转载 于 2017-10-09 23:41:00 发布 · 98 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/WizardCowboy/p/7643572.html

本文介绍了一种解决区间第k大元素查询问题的有效算法。通过区间左右端点排序及Treap树数据结构，实现O(nlogn)的时间复杂度。提供两种Treap树实现方式：非旋转Treap和旋转Treap。

Problem

查询区间第k大，但保证区间不互相包含（可以相交）

Solution

只需要对每个区间左端点进行排序，那它们的右端点必定单调递增，不然会出现区间包含的情况。
所以我们暴力对下一个区间加上这个区间没有的点，删去下个区间没有的点。
因为每个点最多被加入，删除1次，所以时间复杂度为O（nlogn）

Notice

当相邻两段区间不相交时，那么我们要先加入点，在删去点。

Code

非旋转Treap

#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define sqz main
#define ll long long
#define reg register int
#define rep(i, a, b) for (reg i = a; i <= b; i++)
#define per(i, a, b) for (reg i = a; i >= b; i--)
#define travel(i, u) for (reg i = head[u]; i; i = edge[i].next)
const int INF = 1e9, N = 100000, M = 50000;
const double eps = 1e-6, phi = acos(-1.0);
ll mod(ll a, ll b) {if (a >= b || a < 0) a %= b; if (a < 0) a += b; return a;}
ll read(){ ll x = 0; int zf = 1; char ch; while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') zf = -1, ch = getchar(); while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar(); return x * zf;}
void write(ll y) { if (y < 0) putchar('-'), y = -y; if (y > 9) write(y / 10); putchar(y % 10 + '0');}
int point = 0, T[N + 5], root, ans[M + 5];
struct Node
{
    int left, right, ask, id;
}Q[M + 5];
struct node
{
    int Size[N + 5], Val[N + 5], Level[N + 5], Son[2][N + 5];
    inline void up(int u)
    {
        Size[u] = Size[Son[0][u]] + Size[Son[1][u]] + 1;
    }
    int Newnode(int v)
    {
        int u = ++point;
        Val[u] = v, Level[u] = rand();
        Size[u] = 1, Son[0][u] = Son[1][u] = 0;
        return u;
    }
    int Merge(int X, int Y)
    {
        if (X * Y == 0) return X + Y;
        if (Level[X] < Level[Y])
        {
            Son[1][X] = Merge(Son[1][X], Y);
            up(X); return X;
        }
        else
        {
            Son[0][Y] = Merge(X, Son[0][Y]);
            up(Y); return Y;
        }
    }
    void Split(int u, int t, int &x, int &y)
    {
        if (!u)
        {
            x = y = 0;
            return;
        }
        if (Val[u] <= t) x = u, Split(Son[1][u], t, Son[1][u], y);
        else y = u, Split(Son[0][u], t, x, Son[0][u]);
        up(u);
    }
    void Build(int l, int r)
    {
        int last, s[N + 5], top = 0;
        rep(i, l, r)
        {
            int u = Newnode(T[i]);
            last = 0;
            while (top && Level[s[top]] > Level[u])
            {
                up(s[top]);
                last = s[top--];
            }
            if (top) Son[1][s[top]] = u;
            Son[0][u] = last;
            s[++top] = u;
        }
        while (top) up(s[top--]);
        root = s[1];
    }

    int Find_num(int u, int t)
    {
        if (t <= Size[Son[0][u]]) return Find_num(Son[0][u], t);
        else if (t <= Size[Son[0][u]] + 1) return u;
        else return Find_num(Son[1][u], t - Size[Son[0][u]] - 1);
    }
    void Insert(int v)
    {
        int t = Newnode(v), x, y;
        Split(root, v, x, y);
        root = Merge(Merge(x, t), y);
    }
    void Delete(int v)
    {
        int x, y, z;
        Split(root, v, x, z), Split(x, v - 1, x, y);
        root = Merge(Merge(x, Merge(Son[0][y], Son[1][y])), z);
    }
}Treap;
int cmp(Node X, Node Y)
{
    return X.left < Y.left || (X.left == Y.left && X.right < Y.right);
}
int sqz()
{
    int n = read(), m = read();
    rep(i, 1, n) T[i] = read();
    rep(i, 1, m) Q[i].left = read(), Q[i].right = read(), Q[i].ask = read(), Q[i].id = i;
    sort(Q + 1, Q + m + 1, cmp);
    rep(i, Q[1].left, Q[1].right) Treap.Insert(T[i]);
    ans[Q[1].id] = Treap.Val[Treap.Find_num(root, Q[1].ask)];
    rep(i, 2, m)
    {
        rep(j, Q[i - 1].right + 1, Q[i].right) Treap.Insert(T[j]);
        rep(j, Q[i - 1].left, Q[i].left - 1) Treap.Delete(T[j]);
        ans[Q[i].id] = Treap.Val[Treap.Find_num(root, Q[i].ask)];
    }
    rep(i, 1, m) printf("%d\n", ans[i]);
    return 0;
}

旋转Treap

#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define sqz main
#define ll long long
#define reg register int
#define rep(i, a, b) for (reg i = a; i <= b; i++)
#define per(i, a, b) for (reg i = a; i >= b; i--)
#define travel(i, u) for (reg i = head[u]; i; i = edge[i].next)
const int INF = 1e9, N = 100000, M = 50000;
const double eps = 1e-6, phi = acos(-1.0);
ll mod(ll a, ll b) {if (a >= b || a < 0) a %= b; if (a < 0) a += b; return a;}
ll read(){ ll x = 0; int zf = 1; char ch; while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') zf = -1, ch = getchar(); while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar(); return x * zf;}
void write(ll y) { if (y < 0) putchar('-'), y = -y; if (y > 9) write(y / 10); putchar(y % 10 + '0');}
int point = 0, T[N + 5], root, ans[M + 5];
struct node
{
    int left, right, ask, id;
}Q[M + 5];
int cmp(node X, node Y)
{
    return X.left < Y.left || (X.left == Y.left && X.right < Y.right);
}
struct Node
{
    int Val[N + 5], Son[2][N + 5], Level[N + 5], Size[N + 5], Num[N + 5];
    inline void up(int u)
    {
        Size[u] = Size[Son[0][u]] + Size[Son[1][u]] + Num[u];
    }
    inline void Lturn(int &x)
    {
        int y = Son[1][x]; Son[1][x] = Son[0][y]; Son[0][y] = x;
        up(x), up(y); x = y;
    }
    inline void Rturn(int &x)
    {
        int y = Son[0][x]; Son[0][x] = Son[1][y]; Son[1][y] = x;
        up(x), up(y); x = y;
    }
    inline void Newnode(int &u, int v)
    {
        u = ++point;
        Level[u] = rand(), Val[u] = v;
        Num[u] = Size[u] = 1, Son[0][u] = Son[1][u] = 0;
    }

    void Insert(int &u, int t)
    {
        if (!u)
        {
            Newnode(u, t);
            return;
        }
        Size[u]++;
        if (t == Val[u]) Num[u]++;
        else if (t < Val[u])
        {
            Insert(Son[0][u], t);
            if (Level[Son[0][u]] < Level[u]) Rturn(u);
        }
        else
        {
            Insert(Son[1][u], t);
            if (Level[Son[1][u]] < Level[u]) Lturn(u);
        }
    }
    void Delete(int &u, int t)
    {
        if (!u) return;
        if (Val[u] == t)
        {
            if (Num[u] > 1)
            {
                Size[u]--, Num[u]--;
                return;
            }
            if (Son[0][u] * Son[1][u] == 0) u = Son[0][u] + Son[1][u];
            else if (Level[Son[0][u]] < Level[Son[1][u]]) Rturn(u), Delete(u, t);
            else Lturn(u), Delete(u, t);
        }
        else if (t < Val[u]) Size[u]--, Delete(Son[0][u], t);
        else Size[u]--, Delete(Son[1][u], t);
    }

    int Find_num(int u, int t)
    {
        if (!u) return 0;
        if (t <= Size[Son[0][u]]) return Find_num(Son[0][u], t);
        else if (t <= Size[Son[0][u]] + Num[u]) return u;
        else return Find_num(Son[1][u], t - Size[Son[0][u]] - Num[u]);
    }
}Treap;
int sqz()
{
    int n = read(), m = read();
    rep(i, 1, n) T[i] = read();
    rep(i, 1, m) Q[i].left = read(), Q[i].right = read(), Q[i].ask = read(), Q[i].id = i;
    sort(Q + 1, Q + m + 1, cmp);
    rep(i, Q[1].left, Q[1].right) Treap.Insert(root, T[i]);
    ans[Q[1].id] = Treap.Val[Treap.Find_num(root, Q[1].ask)];
    rep(i, 2, m)
    {
        if (Q[i].left <= Q[i - 1].right)
        {
            rep(j, Q[i - 1].left, Q[i].left - 1) Treap.Delete(root, T[j]);
            rep(j, Q[i - 1].right + 1, Q[i].right) Treap.Insert(root, T[j]);
        }
        else
        {
            rep(j, Q[i - 1].left, Q[i - 1].right) Treap.Delete(root, T[j]);
            rep(j, Q[i].left, Q[i].right) Treap.Insert(root, T[j]);
        }
        ans[Q[i].id] = Treap.Val[Treap.Find_num(root, Q[i].ask)];
    }
    rep(i, 1, m) printf("%d\n", ans[i]);
    return 0;
}

转载于:https://www.cnblogs.com/WizardCowboy/p/7643572.html

[统计] poj 2761 Feed the dogs
Mr.CJ
08-13 631
/** [统计] poj 2761 Feed the dogs 题意: n个数,m个查询,每次查询[l,r]区间里第k小的数。(需要离散化) 题目保证了区间不会相互包含,可以按L排个序。 然后对于每个区间加入新节点，删去旧结点，就成了裸的查第k小。 这里用 树状数组+二分 实现，O(NlogNlogN) */ #include #include #include using namespac
POJ(2761)Feed the dogs (树状数组+离散化+贪心)
weixin_30491641的博客
07-07 139
#include <iostream> #include <algorithm> #include <stdio.h> #include <string> #include <string.h> #include <stdlib.h> #include <math.h> #include <...
poj2761 Feed the dogs【解法一】
YHaX的博客
08-16 620
离散化+树状数组+二分
poj2761 Feed the dogs
AaronPolaris
11-21 1758
Treap模板题
Feed the dogs（划分树，据说各种树可做）
每一次AC都是一种感动
02-21 717
Feed the dogs Time Limit:6000MS    Memory Limit:65536KB    64bit IO Format:%I64d & %I64u Description Wind loves pretty dogs very much, and she has n pet dogs. So Jiajia has to feed the do
POJ2635-The Embarrassed Cryptographer 测试数据
06-23
《POJ2635-The Embarrassed Cryptographer：测试数据解析与算法探讨》 POJ2635，这是一个源自NCPC（全国大学生程序设计竞赛）2005年问题D的编程挑战，名为“尴尬的密码学家”。在本文中，我们将深入探讨这个问题的...
POJ1426-Find The Multiple【BFS+同余模】
07-31
【标题】"POJ1426-Find The Multiple【BFS+同余模】"是一道来源于北京大学在线编程平台POJ的算法题目，主要涉及到了广度优先搜索（BFS）与同余模运算的知识点。这道题目要求解决的是寻找一个整数的倍数问题，可能...
POJ1027-The Same Game
07-31
【标题】"POJ1027 - The Same Game"是一个经典的编程竞赛题目，源自北京大学的在线编程平台POJ（Problem Online Judge）。该题目主要考察的是动态规划和矩阵链乘法的知识，要求参赛者编写程序解决一个具有策略性的...
poj2761Feed the dogs【主席树|划分树】
MissZhou要努力
04-04 528
Description Wind loves pretty dogs very much, and she has n pet dogs. So Jiajia has to feed the dogs every day for Wind. Jiajia loves Wind, but not the dogs, so Jiajia use a special way to feed the d
POJ 2761 Feed the dogs(Treap名次树+离线处理)
code
04-24 2407
POJ 2761 Feed the dogs(Treap名次树+离线处理) http://poj.org/problem?id=2761 题意:给你N个数,然后要你对下面M个查询回答:L,R,K.回答第L个数到第R个数之间的第K小数的值是多少. 分析:        注意:题目说明中说了没有任何两个区间存在包含关系.这句话告诉我们如果将所有查询区间按L从小到大排序的话,相邻两个区间有这样的
POJ2761[Feed the dogs ] 不带修改主席树
Venishel的博客
08-05 364
POJ2761 主席树
POJ 2761-Feed the dogs（划分树）求区间内第k小的数
Some.
05-06 1067
Feed the dogs Time Limit: 6000MS   Memory Limit: 65536K Total Submissions: 17679   Accepted: 5561 Description Wind loves pretty dogs very much, and she has n pet dogs. So
EI复现考虑网络动态重构的分布式电源选址定容优化方法（Matlab代码实现）
最新发布
11-08
内容概要：本文介绍了基于Matlab代码实现的【EI复现】考虑网络动态重构的分布式电源选址定容优化方法，重点研究在电力系统中结合网络动态重构技术进行分布式电源（如光伏、风电等）的最佳位置选择与容量配置的双层优化模型。该方法综合考虑配电网结构变化与电源布局之间的相互影响，通过优化算法实现系统损耗最小、电压稳定性提升及可再生能源消纳能力增强等多重目标。文中提供了完整的Matlab仿真代码与案例验证，便于复现实验结果并拓展应用于微网、储能配置与配电系统重构等相关领域。; 适合人群：电力系统、电气工程及其自动化等相关专业的研究生、科研人员及从事新能源规划与电网优化工作的工程师；具备一定Matlab编程基础和优化理论背景者更佳。; 使用场景及目标：①用于科研论文复现，特别是EI/SCI级别关于分布式能源优化配置的研究；②支【EI复现】考虑网络动态重构的分布式电源选址定容优化方法（Matlab代码实现）撑毕业设计、课题项目中的电源选址定容建模与仿真；③辅助实际电网规划中对分布式发电接入方案的评估与决策； 阅读建议：建议结合提供的网盘资源下载完整代码与工具包（如YALMIP），按照文档目录顺序逐步学习，注重模型构建思路与代码实现细节的对应关系，并尝试在不同测试系统上调试与扩展功能。
Agda中的函数式编程与验证
11-08
本书深入浅出地介绍如何使用Agda进行函数式编程与程序正确性证明。基于类型理论和Curry-Howard同构，将程序视为证明，实现内外兼修的可信软件构建。内容涵盖布尔逻辑、列表操作、语法解析、类型级计算及直觉主义逻辑的Kripke语义，适合具备基础编程与离散数学知识的读者。通过爱荷华Agda库（IAL）实践，帮助读者掌握从基础数据类型到定理证明的全过程，是进入形式化方法与可信计算领域的理想入门指南。
PSO-LSTM基于PSO优化LSTM网络的电力负荷预测（Python代码实现）
11-08
【PSO-LSTM】基于PSO优化LSTM网络的电力负荷预测（Python代码实现）
基于SpringBoot与Vue的电影院票务管理系统源码及数据库（Java毕业设计项目）
11-08
本系统采用SpringBoot与Vue技术架构，实现了完整的影院票务管理解决方案，包含后台数据库及全套可执行代码。该系统在高等院校计算机专业毕业设计评审中获得优异评价，特别适用于正在进行毕业课题研究的学生群体，以及需要提升项目实践能力的开发者。同时也可作为课程结业作业或学期综合训练项目使用。 系统提供完整的技术文档和经过全面测试的源代码，所有功能模块均通过多轮调试验证，保证系统稳定性和可执行性。该解决方案可直接应用于毕业设计答辩环节，其技术架构符合现代企业级开发规范，采用前后端分离模式，后端基于SpringBoot框架实现业务逻辑和数据处理，前端通过Vue.js构建用户交互界面。 系统核心功能涵盖影院管理、影片排期、座位预定、票务销售、用户管理等模块，实现了从影片上架到票务核销的完整业务流程。数据库设计遵循第三范式原则，确保数据一致性和完整性。代码结构采用分层架构设计，包含控制器层、服务层、数据访问层等标准组件，便于后续功能扩展和维护。 该项目不仅提供了可直接部署运行的完整程序，还包含详细的技术实现文档，帮助开发者深入理解系统架构设计理念和具体实现细节。对于计算机专业学生而言，通过研究该项目可以掌握企业级应用开发的全流程，包括需求分析、技术选型、系统设计和测试部署等关键环节。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
基于MATLAB的水下图像增强与融合算法课程设计实现方案
11-08
基于MATLAB的水下视觉质量优化与多算法集成研究 本研究聚焦于水下光学成像的质量提升问题，通过构建多算法融合框架解决水下图像存在的色偏、模糊及低对比度等典型退化现象。项目采用模块化设计思路，将色彩校正、对比度增强与噪声抑制等核心功能进行系统性整合。 在技术实现层面，首先建立水下光学衰减模型，分析不同波长光波在水体中的传播特性。针对蓝绿波段主导的水下成像环境，开发自适应白平衡算法以恢复物体真实色彩。随后引入多尺度Retinex理论，通过高斯差分滤波器分离光照分量与反射分量，有效提升图像局部对比度。为抑制增强过程中产生的噪声放大现象，特别设计基于小波阈值的去噪模块，在保持边缘细节的同时消除高频噪声。 研究过程中重点考察各算法参数的协同优化策略，通过对比度熵、色彩一致性指数等量化指标评估增强效果。实验数据表明，该融合方案在保持自然度的前提下，显著提升水下图像的视觉可辨识度，为海洋资源勘察、水下工程检测等应用场景提供可靠的技术支持。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
POJ1163-The Triangle 解题思路与代码实现
标题中提到的 "POJ1163-The Triangle" 指的是北京大学在线评测系统（PKU JudgeOnline，通常称为POJ）中的一道经典算法题目。该题目是关于动态规划（Dynamic Programming）算法的实践。动态规划是解决具有重叠子问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值