菜鸟系列——划分树

最新推荐文章于 2017-11-17 17:33:35 发布
最新推荐文章于 2017-11-17 17:33:35 发布
阅读量360 收藏
点赞数
分类专栏： 菜鸟系列 文章标签： acm poj HEU hdu 划分树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kopyh/article/details/46540847
版权
做回菜鸟，老老实实重新学起：

划分树

数据结构；

求k大值及左右和模版：

#define N 123456
int sorted[N]={0};   //对原集合中元素排序后的值
int val[20][N]={0};  //val记录第k层当前位置的值
int num[20][N]={0}; //记录元素所在区间当前位置前的元素进入到左子树的个数
int lnum, rnum;         //询问区间里面k-th数左侧和右侧的数的个数
long long sum[20][N]={0};    //记录比当前元素小的元素的和
long long lsum, rsum;   //询问区间里面k-th数左侧数之和与右侧数之和


void build(int l, int r, int d)
{
    if (l == r) return ;
    int mid = (l + r) >> 1;
    int same = mid - l + 1;
    for (int i=l; i<=r; i++)
        if (val[d][i] > sorted[mid])
            same--;
    int lp = l, rp = mid+1;
    for (int i=l; i<=r; i++) {
        if (i == l) {
            num[d][i] = 0;
            sum[d][i] = 0;
        } else {
            num[d][i] = num[d][i-1];
            sum[d][i] = sum[d][i-1];
        }

        if (val[d][i] > sorted[mid]) {
            num[d][i]++;
            sum[d][i] += val[d][i];
            val[d+1][lp++] = val[d][i];
        } else if (val[d][i] < sorted[mid])
            val[d+1][rp++] = val[d][i];
        else {
            if (same) {
                same--;
                num[d][i]++;
                sum[d][i] += val[d][i];
                val[d+1][lp++] = val[d][i];
            } else val[d+1][rp++] = val[d][i];
        }
    }
    build(l, mid, d+1);
    build(mid+1, r, d+1);
}
int query(int a, int b, int k, int l, int r, int d)
{
    if (a == b) 
        return val[d][a];

    int mid = (l + r) >> 1;
    int s, ss;
    long long sss;
    if (a == l) 
    {
        s = num[d][b];
        ss = 0;
        sss = sum[d][b];
    } 
    else 
    {
        s = num[d][b] - num[d][a-1];
        ss = num[d][a-1];
        sss = sum[d][b] - sum[d][a-1];
    }
    if (s >= k) 
    {
        a = l + ss;
        b = l + ss + s - 1;
        return query(a, b, k, l, mid, d+1);
    } 
    else 
    {
        lnum += s;
        lsum += sss;
        a = mid+1 + a - l - ss;
        b = mid+1 + b - l - num[d][b];
        return query(a, b, k-s, mid+1, r, d+1);
    }
}
bool cmp(int a,int b)
{   return a>b; }
void solve(int n,int m)
{
    long long s[N]={0};
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&sorted[i]);
        val[0][i] = sorted[i];
        s[i] = s[i-1] + sorted[i];
    }
    printf("\n");
    sort(sorted+1,sorted+1+n,cmp);
    build(1,n,0);

    int x,y,k,res;
    while(m--)
    {
        scanf("%d%d%d",&x,&y,&k);
        lsum = lnum = 0;
        res = query(x,y,k,1,n,0);
        printf("%d ",res);  //输出第k大值
        rnum = y-x+1 - lnum;
        rsum = s[y] - s[x-1] - lsum - res;
        printf("%lld %lld\n",lsum,rsum);    //区间内比第k大值小的和大的值的和；
    }
}

eg:

题目参考：http://blog.youkuaiyun.com/yang_7_46/article/details/8613461


POJ 2104 k-th number

http://poj.org/problem?id=2104

题意：

求区间内k小值；

思路：

直接划分树，求第k小值；

code:
#define N 123456
int sorted[N]={0};
int val[20][N]={0};
int num[20][N]={0};
int lnum, rnum;
long long sum[20][N]={0};
long long lsum, rsum;

void build(int l, int r, int d)
{
    if (l == r) return ;
    int mid = (l + r) >> 1;
    int same = mid - l + 1;
    for (int i=l; i<=r; i++)
        if (val[d][i] < sorted[mid])
            same--;
    int lp = l, rp = mid+1;
    for (int i=l; i<=r; i++) {
        if (i == l) {
            num[d][i] = 0;
            sum[d][i] = 0;
        } else {
            num[d][i] = num[d][i-1];
            sum[d][i] = sum[d][i-1];
        }

        if (val[d][i] < sorted[mid]) {
            num[d][i]++;
            sum[d][i] += val[d][i];
            val[d+1][lp++] = val[d][i];
        } else if (val[d][i] > sorted[mid])
            val[d+1][rp++] = val[d][i];
        else {
            if (same) {
                same--;
                num[d][i]++;
                sum[d][i] += val[d][i];
                val[d+1][lp++] = val[d][i];
            } else val[d+1][rp++] = val[d][i];
        }
    }
    build(l, mid, d+1);
    build(mid+1, r, d+1);
}
int query(int a, int b, int k, int l, int r, int d) {
    if (a == b) return val[d][a];

    int mid = (l + r) >> 1;
    int s, ss;
    long long sss;
    if (a == l) {
        s = num[d][b];
        ss = 0;
        sss = sum[d][b];
    } else {
        s = num[d][b] - num[d][a-1];
        ss = num[d][a-1];
        sss = sum[d][b] - sum[d][a-1];
    }

    if (s >= k) {
        a = l + ss;
        b = l + ss + s - 1;
        return query(a, b, k, l, mid, d+1);
    } else {
        lnum += s;
        lsum += sss;
        a = mid+1 + a - l - ss;
        b = mid+1 + b - l - num[d][b];
        return query(a, b, k-s, mid+1, r, d+1);
    }
}
bool cmp(int a,int b)
{   return a<b; }
void solve(int n,int m)
{
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&sorted[i]);
        val[0][i] = sorted[i];
    }
    sort(sorted+1,sorted+1+n,cmp);
    build(1,n,0);
    int x,y,k,res;
    while(m--)
    {
        scanf("%d%d%d",&x,&y,&k);
        res = query(x,y,k,1,n,0);
        printf("%d\n",res);
    }
}
int main() {
    int n, m;
    #ifndef ONLINE_JUDGE
        freopen("test.txt","r",stdin);
    #endif
    scanf("%d%d",&n,&m);
    solve(n,m);
    return 0;
}


HDU 3473 Minimum Sum

http://acm.hdu.edu.cn/showproblem.php?pid=3473

题意：

求区间内sum(x-xi)的最小值；x属于该区间；

思路：

找到区间内中位数即可，求区间内中位数，记录区间内大于和小于中位数的数的和，差值加减多余的中位数的值就是答案了；

code:
#define N 123456
int sorted[N]={0};
int val[20][N]={0};
int num[20][N]={0};
int lnum, rnum;
long long sum[20][N]={0};
long long lsum, rsum;

void build(int l, int r, int d)
{
    if (l == r) return ;
    int mid = (l + r) >> 1;
    int same = mid - l + 1;
    for (int i=l; i<=r; i++)
        if (val[d][i] < sorted[mid])
            same--;
    int lp = l, rp = mid+1;
    for (int i=l; i<=r; i++) {
        if (i == l) {
            num[d][i] = 0;
            sum[d][i] = 0;
        } else {
            num[d][i] = num[d][i-1];
            sum[d][i] = sum[d][i-1];
        }

        if (val[d][i] < sorted[mid]) {
            num[d][i]++;
            sum[d][i] += val[d][i];
            val[d+1][lp++] = val[d][i];
        } else if (val[d][i] > sorted[mid])
            val[d+1][rp++] = val[d][i];
        else {
            if (same) {
                same--;
                num[d][i]++;
                sum[d][i] += val[d][i];
                val[d+1][lp++] = val[d][i];
            } else val[d+1][rp++] = val[d][i];
        }
    }
    build(l, mid, d+1);
    build(mid+1, r, d+1);
}
int query(int a, int b, int k, int l, int r, int d) 
{
    if (a == b) 
        return val[d][a];

    int mid = (l + r) >> 1;
    int s, ss;
    long long sss;
    if (a == l) 
    {
        s = num[d][b];
        ss = 0;
        sss = sum[d][b];
    } 
    else 
    {
        s = num[d][b] - num[d][a-1];
        ss = num[d][a-1];
        sss = sum[d][b] - sum[d][a-1];
    }

    if (s >= k) 
    {
        a = l + ss;
        b = l + ss + s - 1;
        return query(a, b, k, l, mid, d+1);
    } 
    else 
    {
        lnum += s;
        lsum += sss;
        a = mid+1 + a - l - ss;
        b = mid+1 + b - l - num[d][b];
        return query(a, b, k-s, mid+1, r, d+1);
    }
}
bool cmp(int a,int b)
{   return a<b; }
void solve(int n,int m)
{
    long long s[N]={0};
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&sorted[i]);
        val[0][i] = sorted[i];
        s[i] = s[i-1] + sorted[i];
    }
    scanf("%d",&m);
    sort(sorted+1,sorted+1+n,cmp);
    build(1,n,0);

    int x,y,k,res;
    while(m--)
    {
        scanf("%d%d",&x,&y);
        x++,y++;
        k = (y-x+2)>>1;
        lsum = lnum = 0;
        res = query(x,y,k,1,n,0);
        rnum = y-x+1 - lnum;
        rsum = s[y] - s[x-1] - lsum;
        printf("%lld\n",(long long)(rsum-lsum+(lnum-rnum)*res));    //区间内比第k大值小的和大的值的和；
    }
    printf("\n");
}
int main()
{
    int k,kk,n,m;
    #ifndef ONLINE_JUDGE
        freopen("test.txt","r",stdin);
    #endif
    scanf("%d",&k);
    kk=0;
    while(k--)
    {
        printf("Case #%d:\n",++kk);
        scanf("%d",&n);
        solve(n,0);
    }
    return 0;
}


一个小菜鸟的——校酷app 产品分析文档
那女孩真拽的博客
05-26 1267
前言   学习产品有一个半月，考虑到之前没有相关的文档经验，写这篇产品分析时也想过是不是用一些规范的文档模式。最后还是决定用自己的逻辑方式来展现我对这款软件的想法和具体实施。我把这次的版本叫做校酷4.0校酷3.2.1版本产品分析产品价值   从最早的国内效仿facebook的各个sns实名社区到现在移动端令人眼花缭乱的社交类app，确实这一领域的用户群体——充满感情诉求，易于接受新鲜事物，重度依赖...
菜鸟日记——k-means聚类实现并绘图
热门推荐
周末饺子配啤酒的博客
11-27 1万+
最近正在做客户细分模型，利用K-means将客户信息划分成多个组并进行特征刻画使得同一簇内的客户相似度较高，不同簇间的相似度比较低。目前只做到了客户信息聚类。 数据准备 原本的数据是一些客户的注册基本信息大部分为离散型数据因此考虑到K-means模型对数值类的数据处理效果要比文本类要好因此将注册信息进行重新编排，用ID类型的数据代替原本的数据，比如注册地点：东莞市<——>01，广州市<——>03
基于Vue和JavaScript的HTML前端开发设计源码——vue菜鸟营地的日常分享
09-29
其中，Vue文件主要负责构建项目的视图层，利用Vue的组件化思想，可以轻松地将界面划分为独立可复用的组件；JavaScript文件则处理了项目的逻辑部分，如交互逻辑、数据处理等，确保网页能够实现预期的功能；JSON文件...
机器学习实战——决策树
Dream_Han的博客
11-17 1100
本文记录的是《机器学习实战》和《统计学习方法》中决策树的原理和实现。1、决策树定义：分类决策树模型是一种描述对实例进行分类的树形结构。决策树由节点（node）和有向边（directed edge）组成。节点有两种类型：内部结点和叶结点，内部结点表示一个特征或者属性，叶结点表示一个类。 用决策树进行分类，从根结点开始，对实例的某一特征进行测试，根据测试结构，将实例分配到其子结点；这时，每一个子结点对
程序员菜鸟必备——作为独立开发者如何系统的学习编程
独立开发者
08-30 3121
接触一个行业，前期最好来一个系统的学习，有完整的框架一点一点的把基础吃透，不能左一耙子，右一锄头，以我的从业经验给大家分享如何系统的学习编程开发，刚入坑的程序员菜鸟注意了，迅速占领高地，迅速收藏了。分享我在开发过程中对基础知识的理解，一个程序员知道这些知识后从事一个软件的开发应该是没有问题了。下面分别来讨论一下这些知识的学习问题。
菜鸟系列——八数码八境界
MyWorld
09-14 6569
菜鸟就要老老实实重新学起： 八数码： 很经典的搜索问题，写这个练练搜索。 八数码问题就是给出一个3*3的矩阵其中有1~8数字和一个空格‘x’，可以移动周围的数字到这个空格上，要求某种排列恢复到{{1,2,3},{4,5,6},{7,8,x}}形式的移动方法。 由大神的八数码八境界想自己实现一下 http://www.cnblogs.com/goodness/archive/20
菜鸟系列——polya计数法
MyWorld
08-12 2105
菜鸟就要老老实实重新学起： Burnside引理，polya计数法： Burnside引理： 1/|G|*(C(π1)+C(π2)+C(π3)+.....+C(πn))； C(π)：指不同置换下的等价类数。例如π=(123)(3)(45)(6)(7)，X={1,2,3,4,5,6,7};那么C(π)={3,6,7}共3个等价类。 Polya定理： 1/|G|*(mC(π1)+m
菜鸟系列——置换群
MyWorld
08-10 1643
菜鸟就要老老实实重新学起： 置换群 简单地说置换群就是按一定规则互相替换的一个集合。简单，主要看例题。 poj3270 给出一列数，求将这列数排成升序的最小花费，这里花费定义为交换两个数的和。 例如给出一排数8 4 5 3 2 7，那么我们最终的状态为2 3 4 5 7 8，这里的轮换有（8 2 7）（4 5 3），这里8应该在第六个位置， 而第6个位置是7,7应该
菜鸟系列——简单搜索
MyWorld
09-22 1431
菜鸟就要老老实实重新学起： 简单搜索： 一些简单搜索题，源自kuangbin大神的题目列表，留下以后出题用。 eg: POJ1321 棋盘问题 http://poj.org/problem?id=1321 题意： 在一个棋盘内放k个棋子，每一行每一列都最多只能有一个棋子，求方法数，‘#’为可放的地方。 思路： 直接暴力深搜枚举所有情况即可，每一行选择一个点向下继续深搜，同
菜鸟系列——双连通分量
MyWorld
09-09 1055
菜鸟就要老老实实重新学起： 双连通分量 就是求图中能够彼此之间有不少于2条路线到达的点集，也就是点集中不存在割点（若无重边）。 求无向图的双联通分量与有向图的强联通分量相同，用Tarjan算法，只是因为是无向图所以注意加边是双向加但是深搜时不能搜回父节点。 模版： #define N 110 vectorg[N]; stackst; // 深度优先搜索访问次序, 能追溯到的最早
菜鸟系列——欧几里德与扩展欧几里
MyWorld
08-19 903
菜鸟就要老老实实重新学起： 欧几里德算法： 就是辗转相除法，小学的东西，gcd(a,b)=gcd(b,a%b), 实现简单，用途广泛，， 模版： long long gcd(long long x,long long y) { return y?gcd(y,x%y):x; } 或者用迭代的写法： long long gcd(long long x,long long y
菜鸟系列——康托展开
MyWorld
09-11 842
菜鸟就要老老实实重新学起： 康托展开/逆康托展开： 主要就是用来求全排列的次序，可用于取某序列的hash值。 ///康托展开 { int fac[] = {1,1,2,6,24,120,720,5040,40320}; //i的阶乘为fac[i] /* 康托展开.{1...n}的全排列由小到大有序，s[]为第几个数 */ int KT(int n, int s[]) {
菜鸟系列——二分图匹配
MyWorld
07-25 689
菜鸟就要老老实实重新学起： 二分图匹配——匈牙利算法（dfs实现） dfs深搜找增广路经求二分图最大匹配。 //二分图匹配：二分图最大配对数 //最小点覆盖：选取最少的点覆盖所有边 //最大独立集：选取最多的点，集合中点之间无连接 //二分图最大匹配==最小点覆盖==总点数-最大独立集 模版： #define N 1234 int n,m,cnt; int f[N]; int v
菜鸟系列——欧拉函数
MyWorld
09-28 657
菜鸟就要老老实实重新学起： 欧拉函数 在数论，对正整数n，欧拉函数是少于或等于n的数中与n互质的数的数目。 欧拉定理 a与p互质，a^x==1(mod p)则x==euler[p]; 模版： //直接求解欧拉函数 long long euler(long long n) { long long res=n,a=n; for(long long i
菜鸟系列——线段树
MyWorld
06-11 597
做回菜鸟，老老实实重新学起： 线段树 基本数据结构； 求和模版： #define N 51234 #define root 1 , n , 1 #define lson l , m , rt << 1 #define rson m + 1 , r , rt << 1 | 1 long long sum[N<<2],add1[N<<2],add2[N<<2]; //
菜鸟系列——容斥原理
MyWorld
09-07 543
菜鸟就要老老实实重新学起： 容斥原理： 容斥原理就是求有重复覆盖区间的总和大小， eg: //大小为n1,n2,n3的三个集合，有多少种组合 //二集合中第i个不能与a[i]个一集合的项组合，不能与b[i]个三集合的项组合 int a[N],b[N]; long long solve(int n2,int n2,int n3) { long long sum=n1*n2*
菜鸟系列——Sparse Table
MyWorld
06-11 537
做回菜鸟，老老实实重新学起： Sparse Table 构造RMQ数组: ST(int n)   O(nlog(n))的算法复杂度 dp[i][j] 表示从i到i+2^j -1中最小的一个值(从i开始持续2^j个数) dp[i][j]=min{dp[i][j-1],dp[i+2^(j-1)][j-1]} 查询RMQ: RMQ(int i,int j) 将i-j 分成两个2
菜鸟系列——最近公共祖先（LCA）
MyWorld
01-12 511
菜鸟就要老老实实重新学起： 最近公共祖先（LCA） 求树上亮点的最近公共祖先，就是求包含这两个点的最小的子树的根节点。 Tarjan（离线算法）： 就是预先储存所有询问，然后深搜便利所有点，后序遍历找到每个询问中的点，对于每个询都是在两个点都找到的那一刻得到最近公共祖先，后序遍历中不断把点加入并查集中，已加入的最上面的点就是当前的根节点。 模版： const int M
菜鸟系列——约瑟夫环
MyWorld
08-20 456
菜鸟就要老老实实重新学起： 约瑟夫环： 就是长度为n的环每数m个就删去，最后留下一个。 一般问题有两种，求某种m情况下最后留下的序号 核心就是循环倒推： for(i=2;i<=n;i++) res=(res+m)%i; 或者求一种m使得某一段序列最后被留下。 核心就是枚举m正向循环，同时取模求当前删去数的序号： res=0;k=1; for(i=0;i<n;i+
菜鸟驿站快递管理系统
最新发布
03-04
为了满足不同用户群体的需求，系统被细分为两大类角色——管理员和普通用户，并围绕这些角色构建了一系列核心业务逻辑： - **用户管理**：支持注册登录、个人信息维护等功能； - **快递类型设置**：定义不同类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值