bzoj 4009 分类: bzoj temp...


参考题解: http://www.cnblogs.com/mjy0724/p/4447813.html

  我们先把所有的盘子按照权值排序 然后考虑二分

  如果能覆盖一个水果的1~mid的所有盘子数>=该水果询问的k值

  说明答案在[1,mid]当中,否则在[mid+1,r]中

  但是为了减少计算量 我们可以每次只计算L~mid中的盘子

  需要改变的就是划分到[mid+1,r]时减去[L,mid]中累积的答案


真是一道好题,扫描线+线段树+整体二分。

复杂度:O(N∗log2N+Q∗log2Q∗log2N+P∗log2P∗log2N)≈O(N∗(log2N)2)

第一次写整体二分QAQ,真的改了好久。。。


代码写了 6k+,我是大蒟蒻!


线段树:

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>

const int MAXN = 4e4+5, logN = 16, MAXP = MAXN, MAXQ = MAXP;
struct Btype{int l, r, val;}; struct Query{int id, k, gain;};
struct Node {int x, y; Node(int x = 0,int y = 0):x(x),y(y){}};
struct Edge {int v, next; Edge(int v = 0,int next = 0):v(v),next(next){}};
struct Squ  {int xl, xr, yl, yr; Squ(int xl = 0,int xr = 0,int yl = 0,int yr = 0):xl(xl),xr(xr),yl(yl),yr(yr){}};   
struct Issue{int x, yl, yr, val; Issue(int x = 0,int yl = 0,int yr = 0,int val = 0):x(x),yl(yl),yr(yr),val(val){}};

int n, P, Q; 
Btype bowl[MAXP]; Query qu[MAXQ];
Squ ss[MAXP<<1]; int sl; Node node[MAXQ];

int read()
{
    int x = 0; char c = getchar();
    while(!(c >= '0' && c <= '9')) c = getchar();
    while(c >= '0' && c <= '9')
        x = (x<<1)+(x<<3)+(c-'0'), c = getchar();
    return  x;  
}
void write(int x)
{
    static char s[12];int sl = 0;
    while(x) s[++sl] = x%10 + '0',x /= 10;
    if(!sl) {putchar('0');return;}
    while(sl) putchar(s[sl--]);
}

namespace TreeSolve
{
    int dfn[MAXN], fc[MAXN], end[MAXN], dl;
    Edge edge[MAXN<<1];int el, head[MAXN];
    int fa[MAXN][logN], dep[MAXN];

    void NewEdge(int u, int v)
    {
        edge[++el] = Edge(v,head[u]), head[u] = el;
    }
    void Init()
    {
        n = read(), P = read(), Q = read();
        for(int i = 1, u, v; i < n; i++)
            u = read(), v = read(), 
            NewEdge(u,v), NewEdge(v,u);
    }
    void PreLca()
    {
        for(int j = 1; j < logN; j++)
            for(int i = 1; i <= n; i++)
                fa[i][j] = fa[fa[i][j-1]][j-1]; 
    }
    int GetLca(int u,int v)
    {
        if(dep[u] > dep[v]) std::swap(u,v);

        for(int i = logN - 1; i >= 0; i--)
            if(dep[fa[v][i]] >= dep[u]) v = fa[v][i];

        if(u == v) return u;

        for(int i = logN - 1; i >= 0; i--)
            if(fa[u][i] != fa[v][i])
                u = fa[u][i], v = fa[v][i]; 

        return fa[u][0];    
    }
    int LinkSon(int u,int v)
    {
        if(dep[u] > dep[v]) std::swap(u,v);

        for(int i = logN - 1; i >= 0; i--)
            if(dep[fa[v][i]] > dep[u]) v = fa[v][i];

        return v;   
    }
    void DFS(int a)
    {
        dfn[++dl] = a, fc[a] = dl;
        dep[a] = dep[fa[a][0]] + 1;

        for(int i = head[a], p; i; i = edge[i].next)
            if((p = edge[i].v) != fa[a][0]) 
                fa[p][0] = a, DFS(p);   

        end[a] = dl;        
    }
    void GetSqu()
    {
        for(int i = 1, u, v, k; i <= P; i++)
        {
            u = read(), v = read(), k = read();
            int t = GetLca(u, v);

            if(t == u || t == v)
            {
                bowl[i].l = sl + 1;

                if(u != t)  std::swap(u,v);

                int w = LinkSon(u,v);

                if(fc[w] > 1)
                    ss[++sl] = Squ(1,fc[w]-1,fc[v],end[v]);
                if(end[w] < n)
                    ss[++sl] = Squ(fc[v],end[v],end[w]+1,n);    

                bowl[i].r = sl;
            }
            else
            {
                bowl[i].l = sl + 1;

                if(fc[u] > fc[v])   std::swap(u,v);
                ss[++sl] = Squ(fc[u],end[u],fc[v],end[v]);

                bowl[i].r = sl;
            }
            bowl[i].val = k;
        }
    }
    void GetNode()
    {
        for(int i = 1, u, v, k; i <= Q; i++)
        {
            u = read(), v = read(), k = read();

            if(fc[u] > fc[v])   std::swap(u,v);
            node[i] = Node(fc[u],fc[v]);
            qu[i].id = i, qu[i].k = k - 1;
        }
    }
    void Main()
    {
        Init(), DFS(1), PreLca(), GetSqu(), GetNode();  
    }
}
namespace SegSolve
{
    #define L(x) ((x)<<1)
    #define R(x) (((x)<<1)|1)
    bool cmpb(const Btype &a, const Btype &b){return a.val < b.val;}
    bool cmpis(const Issue &a, const Issue &b){return a.x < b.x;}
    bool cmpid(const Query &a, const Query &b){return a.id < b.id;}
    bool cmpq(const Query &a, const Query &b){return node[a.id].x < node[b.id].x;}

    int tree[MAXN<<2];

    void PushDown(int x)
    {
        tree[L(x)] += tree[x];
        tree[R(x)] += tree[x];
        tree[x] = 0; 
    }
    void Add(int l,int r,int ll,int rr,int s,int val)
    {
        if(l == ll && r == rr)
            tree[s] += val;
        else
        {
            PushDown(s);

            int mid = (ll + rr)>>1;
            if(r <= mid)
                Add(l,r,ll,mid,L(s),val);
            else if(l > mid)
                Add(l,r,mid+1,rr,R(s),val);
            else
                Add(l,mid,ll,mid,L(s),val),
                Add(mid+1,r,mid+1,rr,R(s),val);     
        }
    }
    int Ask(int k,int ll,int rr,int s)
    {
        if(ll == rr)
            return tree[s];
        else
        {
            PushDown(s);

            int mid = (ll + rr)>>1;
            if(k <= mid)
                return Ask(k,ll,mid,L(s));
            else
                return Ask(k,mid+1,rr,R(s));
        }
    }
    int segroll(int bl,int br,int ql,int qr)
    {
        static Issue hp[MAXP<<2]; int hl = 0;
        static Query tmp[MAXQ]; int tl = 0;

        for(int i = bl; i <= br; i++)
            for(int j = bowl[i].l; j <= bowl[i].r; j++)
            {
                hp[++hl] = Issue(ss[j].xl,ss[j].yl,ss[j].yr,1);
                hp[++hl] = Issue(ss[j].xr+1,ss[j].yl,ss[j].yr,-1);                  
            }
        std::sort(hp+1, hp+hl+1, cmpis);

        int p = ql, ret = ql - 1;

        for(int i = 1; i <= hl; i++)
        {
            while(p <= qr && node[qu[p].id].x < hp[i].x)
                qu[p++].gain = Ask(node[qu[p].id].y,1,n,1);

            Add(hp[i].yl,hp[i].yr,1,n,1,hp[i].val);
        }

        while(p <= qr) qu[p++].gain = 0;

        for(int i = ql; i <= qr; i++)
            if(qu[i].gain <= qu[i].k)
            {
                qu[i].k -= qu[i].gain;
                tmp[++tl] = qu[i];
            }
            else
                qu[++ret] = qu[i];

        for(int i = 1; i <= tl; i++)        
            qu[ret+i] = tmp[i];

        return ret; 
    }
    void Solve(int pl,int pr,int ql,int qr)
    {
        if(pl == pr)
        {
            for(int i = ql; i <= qr; i++)
                qu[i].gain = bowl[pl].val;
            return;
        }
        int mid = (pl + pr)>>1;
        int div = segroll(pl, mid, ql, qr);
        if(ql <= div) Solve(pl, mid, ql, div);
        if(div < qr) Solve(mid+1, pr, div+1, qr);
    }

    void Main()
    {
        std::sort(bowl+1,bowl+P+1,cmpb);
        std::sort(qu+1, qu+Q+1, cmpq);

        Solve(1,P,1,Q);

        std::sort(qu+1,qu+Q+1,cmpid);

        for(int i = 1; i <= Q; i++)
            write(qu[i].gain), putchar('\n');
    }
}

int main()
{
#ifndef ONLINE_JUDGE    
    freopen("bzoj4009.in","r",stdin);
    freopen("bzoj4009.out","w",stdout);
#endif  

    TreeSolve::Main();

    SegSolve::Main();

#ifndef ONLIE_JUDGE 
    fclose(stdin);
    fclose(stdout);
#endif  
    return 0;
}

树状数组:

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>

const int MAXN = 4e4+5, logN = 16, MAXP = MAXN, MAXQ = MAXP;
struct Btype{int l, r, val;}; struct Query{int id, k, gain;};
struct Node {int x, y; Node(int x = 0,int y = 0):x(x),y(y){}};
struct Edge {int v, next; Edge(int v = 0,int next = 0):v(v),next(next){}};
struct Squ  {int xl, xr, yl, yr; Squ(int xl = 0,int xr = 0,int yl = 0,int yr = 0):xl(xl),xr(xr),yl(yl),yr(yr){}};   
struct Issue{int x, yl, yr, val; Issue(int x = 0,int yl = 0,int yr = 0,int val = 0):x(x),yl(yl),yr(yr),val(val){}};

int n, P, Q; 
Btype bowl[MAXP]; Query qu[MAXQ];
Squ ss[MAXP<<1]; int sl; Node node[MAXQ];

int read()
{
    int x = 0; char c = getchar();
    while(!(c >= '0' && c <= '9')) c = getchar();
    while(c >= '0' && c <= '9')
        x = (x<<1)+(x<<3)+(c-'0'), c = getchar();
    return  x;  
}
void write(int x)
{
    static char s[12];int sl = 0;
    while(x) s[++sl] = x%10 + '0',x /= 10;
    if(!sl) {putchar('0');return;}
    while(sl) putchar(s[sl--]);
}

namespace TreeSolve
{
    int dfn[MAXN], fc[MAXN], end[MAXN], dl;
    Edge edge[MAXN<<1];int el, head[MAXN];
    int fa[MAXN][logN], dep[MAXN];

    void NewEdge(int u, int v)
    {
        edge[++el] = Edge(v,head[u]), head[u] = el;
    }
    void Init()
    {
        n = read(), P = read(), Q = read();
        for(int i = 1, u, v; i < n; i++)
            u = read(), v = read(), 
            NewEdge(u,v), NewEdge(v,u);
    }
    void PreLca()
    {
        for(int j = 1; j < logN; j++)
            for(int i = 1; i <= n; i++)
                fa[i][j] = fa[fa[i][j-1]][j-1]; 
    }
    int GetLca(int u,int v)
    {
        if(dep[u] > dep[v]) std::swap(u,v);

        for(int i = logN - 1; i >= 0; i--)
            if(dep[fa[v][i]] >= dep[u]) v = fa[v][i];

        if(u == v) return u;

        for(int i = logN - 1; i >= 0; i--)
            if(fa[u][i] != fa[v][i])
                u = fa[u][i], v = fa[v][i]; 

        return fa[u][0];    
    }
    int LinkSon(int u,int v)
    {
        if(dep[u] > dep[v]) std::swap(u,v);

        for(int i = logN - 1; i >= 0; i--)
            if(dep[fa[v][i]] > dep[u]) v = fa[v][i];

        return v;   
    }
    void DFS(int a)
    {
        dfn[++dl] = a, fc[a] = dl;
        dep[a] = dep[fa[a][0]] + 1;

        for(int i = head[a], p; i; i = edge[i].next)
            if((p = edge[i].v) != fa[a][0]) 
                fa[p][0] = a, DFS(p);   

        end[a] = dl;        
    }
    void GetSqu()
    {
        for(int i = 1, u, v, k; i <= P; i++)
        {
            u = read(), v = read(), k = read();
            int t = GetLca(u, v);

            if(t == u || t == v)
            {
                bowl[i].l = sl + 1;

                if(u != t)  std::swap(u,v);

                int w = LinkSon(u,v);

                if(fc[w] > 1)
                    ss[++sl] = Squ(1,fc[w]-1,fc[v],end[v]);
                if(end[w] < n)
                    ss[++sl] = Squ(fc[v],end[v],end[w]+1,n);    

                bowl[i].r = sl;
            }
            else
            {
                bowl[i].l = sl + 1;

                if(fc[u] > fc[v])   std::swap(u,v);
                ss[++sl] = Squ(fc[u],end[u],fc[v],end[v]);

                bowl[i].r = sl;
            }
            bowl[i].val = k;
        }
    }
    void GetNode()
    {
        for(int i = 1, u, v, k; i <= Q; i++)
        {
            u = read(), v = read(), k = read();

            if(fc[u] > fc[v])   std::swap(u,v);
            node[i] = Node(fc[u],fc[v]);
            qu[i].id = i, qu[i].k = k - 1;
        }
    }
    void Main()
    {
        Init(), DFS(1), PreLca(), GetSqu(), GetNode();  
    }
}
namespace SegSolve
{
    #define L(x) ((x)<<1)
    #define R(x) (((x)<<1)|1)
    bool cmpb(const Btype &a, const Btype &b){return a.val < b.val;}
    bool cmpis(const Issue &a, const Issue &b){return a.x < b.x;}
    bool cmpid(const Query &a, const Query &b){return a.id < b.id;}
    bool cmpq(const Query &a, const Query &b){return node[a.id].x < node[b.id].x;}

    int tree[MAXN<<2];

    int lowbit(int x)
    {
        return x&-x;
    }
    void Add(int x,int c)
    {   
        while(x <= n)
        {
            tree[x] += c;
            x += lowbit(x);
        }
    }
    void Change(int l, int r, int val)
    {
        Add(l, val), Add(r+1, -val);
    }
    int Ask(int x)
    {
        int ret = 0;
        while(x > 0)
        {
            ret += tree[x];
            x -= lowbit(x);
        }
        return ret;
    }

    int segroll(int bl,int br,int ql,int qr)
    {
        static Issue hp[MAXP<<2]; int hl = 0;
        static Query tmp[MAXQ]; int tl = 0;

        for(int i = bl; i <= br; i++)
            for(int j = bowl[i].l; j <= bowl[i].r; j++)
            {
                hp[++hl] = Issue(ss[j].xl,ss[j].yl,ss[j].yr,1);
                hp[++hl] = Issue(ss[j].xr+1,ss[j].yl,ss[j].yr,-1);                  
            }
        std::sort(hp+1, hp+hl+1, cmpis);

        int p = ql, ret = ql - 1;

        for(int i = 1; i <= hl; i++)
        {
            while(p <= qr && node[qu[p].id].x < hp[i].x)
                qu[p++].gain = Ask(node[qu[p].id].y);

            Change(hp[i].yl,hp[i].yr,hp[i].val);
        }

        while(p <= qr) qu[p++].gain = 0;

        for(int i = ql; i <= qr; i++)
            if(qu[i].gain <= qu[i].k)
            {
                qu[i].k -= qu[i].gain;
                tmp[++tl] = qu[i];
            }
            else
                qu[++ret] = qu[i];

        for(int i = 1; i <= tl; i++)        
            qu[ret+i] = tmp[i];

        return ret; 
    }
    void Solve(int pl,int pr,int ql,int qr)
    {
        if(pl == pr)
        {
            for(int i = ql; i <= qr; i++)
                qu[i].gain = bowl[pl].val;
            return;
        }
        int mid = (pl + pr)>>1;
        int div = segroll(pl, mid, ql, qr);
        if(ql <= div) Solve(pl, mid, ql, div);
        if(div < qr) Solve(mid+1, pr, div+1, qr);
    }

    void Main()
    {
        std::sort(bowl+1,bowl+P+1,cmpb);
        std::sort(qu+1, qu+Q+1, cmpq);

        Solve(1,P,1,Q);

        std::sort(qu+1,qu+Q+1,cmpid);

        for(int i = 1; i <= Q; i++)
            write(qu[i].gain), putchar('\n');
    }
}

int main()
{
#ifndef ONLINE_JUDGE    
    freopen("bzoj4009.in","r",stdin);
    freopen("bzoj4009.out","w",stdout);
#endif  

    TreeSolve::Main();

    SegSolve::Main();

#ifndef ONLIE_JUDGE 
    fclose(stdin);
    fclose(stdout);
#endif  
    return 0;
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

转载于:https://www.cnblogs.com/dashgua/p/4723014.html

VTK基础教程(1)- vtkPolyData 介绍 目录 VTK的编译与环境搭建 VTK一般渲染流程 VTK数据类型-vtkPolyData 使用vtk自带的多边形数据 使用自己创建的数据 添加顶点颜色 添加面颜色 VTK的编译与环境搭建 这部分目前已经有了大佬做了成熟的傻瓜式配置,大家可以参考这篇文章:VTK+VS2019(或其他版本均可) 傻瓜式一站式 配置_Nancy_fairy的博客-优快云博客_vs2019 vtk VTK一般渲染流程 这部分的介绍也很多,大家可以参考这篇文章:VTK笔记-了解VTK_黑山老妖的博客. 阅读详情

相关推荐

从零开始用TS开发babylonjs - 本机环境搭建

babylonjs,初始化本地安装,web3d引擎

han3527638的专栏 798

bzoj1289: [CTSC2009]移盘子

不会做了QAQ

OZY的博客 890

STM32按键中断切换红绿蓝灯

通过以上步骤,我们实现了使用STM32的按键中断来切换红绿蓝LED灯的功能。在实际应用中,可能还需要考虑更多的细节,如按键消抖、更精确的延时实现等。但上述代码提供了一个基本的框架和思路,可以根据具体需求进行扩展和优化。希望这篇博客对您有所帮助!

2301_79865940的博客 953

BZOJ 4009: [HNOI2015]接水果(整体二分套二维偏序)

题目 表示这种题好套路啊。 原题如果注意到一条路径包含另一条路径,那么在dfs序上第一条路径的端点与第二条路径的端点是有一个偏序关系的。 然后就变成了二分答案+三维偏序。 因为可以离线, 将二分答案和一维整合起来变成整体二分O(nlog⁡n)O(n\log n)O(nlogn)。 剩下两维就是一个二维偏序,排序后树状数组维护O(log⁡n)O(\log n)O(logn)。 一共O(nlog⁡2n...

Freopen的博客 238

在 FreeStyle SAP UI5 应用里优雅落地 Draft 草稿机制:用 DraftManager 封装 DraftController 的一套实战套路

SAP Fiori应用中,Draft草稿机制是解决业务中断、多人协作和长表单填写等痛点的核心能力。本文提出了一套针对FreeStyle SAP UI5应用的Draft管理方案,通过封装sap.ui.generic.app.transaction.DraftController为DraftManager服务类,将复杂的草稿操作逻辑集中管理。该方案实现了草稿的创建、激活、丢弃等核心功能,使控制器只需调用简单意图式API即可完成操作,同时解决了组件化架构下的上下文切换、统一错误处理等问题。文章还详细介绍了后端Dr

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 2752

SAP 系统里生成 PDF 的几条主干路径:从 Spool 转换到 Adobe 原生渲染,再到 BTP 云服务

本文系统梳理了SAP生态中PDF生成的多种技术方案,包括Spool转换、OTF转换、Smart Forms/Adobe Forms原生生成以及云端服务等不同路径。文章通过实际案例和代码示例,详细分析了各方案的适用场景、技术要点和工程实践建议,特别强调了多语言支持、字体处理、性能优化等关键因素。针对不同业务需求,提供了从简单导出到复杂交互式PDF的完整解决方案框架,为SAP环境下的PDF处理提供了实用指南。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 295

【整体二分/点分治/树链剖分 + 数据结构】BZOJ4009 [HNOI2015]接水果

【题目】 BZOJ 一棵nnn个节点的树,有PPP条带权值不相同路径,QQQ个询问。每个询问给定一条路径以及一个KKK,查询所有带权路径中是给定路径的子路径的第KKK小权值。n,m,Q≤4×104n,m,Q\leq 4\times 10^4n,m,Q≤4×104。 【解题思路】 首先显然的套路是一条带权路径能贡献到的询问是询问路径的两个端点分别在带权路径的两个子树中或一个在子树中另一个不在子树中。...

MEET YOU FIRST TIME 427

【Autosar COM】Marvell 88Q5050 以太网交换机驱动技术解析

本驱动实现了对Marvell 88Q5050交换机的全面控制,通过模块化设计满足AUTOSAR规范要求。增加DMA加速机制提升大数据量处理性能实现TSN(时间敏感网络)特性支持引入异步通知机制替代轮询操作增强安全特性,如MACsec支持该驱动架构为车载以太网交换机控制提供了可靠基础,其设计思想可推广到其他车载网络控制器开发中。随着车载网络技术的演进,驱动需持续迭代以支持新特性与更高通信速率需求。

1451

BZOJ 4009 HNOI2015 接水果 树套树

题目大意:给定一棵树和mm条路径,每条路径有一个权值,Q次询问,每次询问某条路经包含的所有路径中权值的第k小 原来精神污染那个题是这么做的啊QwQ 题解网上都有,我就直接贴代码了 没心情写题解了#include <cstdio> #include <cstring> #include <iostream> #include <algorithm> #define M 40400 using n

世界 2698

HQChart实战教程54:Renko砖形K线图实现详解

Renko图(砖形图)起源于日本,只关注价格变动而忽略时间和成交量因素: 2.2 算法说明 初始化:使用第一根K线的收盘价创建第一个砖块 变动检测:计算当前价格与最后一个砖块的差值 砖块生成: 当价格变动≥砖块大小时,生成新砖块 当价格变动不足时,更新当前砖块的高低价 方向判断:根据价格变动方向确定砖块颜色 三、完整实现代码 四、Renko图的高级应用 4.1 动态砖块大小调整 4.2 Renko交易策略 三砖反转策略:趋势跟踪策略:本文详细介绍了Renko图的实现原理和在HQChart中的应

QQ_778132974的博客 875

Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示

Unity热更有很多方案,各种lua热更,ILRuntime等,这里介绍的是YooAsset+HybridCLR的热更方案,HybridCLR负责更新c#代码,YooAsset负责更新资源。HybridCLR是一种创新的解决方案,专为 Unity 游戏开发中的热更新需求设计。它通过结合解释执行和 Ahead-of-Time (AOT) 编译技术,为跨平台的游戏开发提供了一种高效的热更新机制。原生C#热更新体验,开发工作流与传统Unity C#开发几乎相同,零学习和使用成本。

仙魁XAN 3866

BZOJ4009: [HNOI2015]接水果

BZOJ4009: [HNOI2015]接水果 由于$BZOJ$上经常有人拿这道题卡评测姬,所以变成了权限题。。。 本蒟蒻表示没钱氪金。。。 这里附上洛谷的体面: P3242 [HNOI2015]接水果 题目描述 风见幽香非常喜欢玩一个叫做 osu!的游戏,其中她最喜欢玩的模式就是接水果。由于她已经DT FC 了The big black, 她觉得这个游戏太简单了,于是发明了一个更加难...

weixin_30289831的博客 197

Transformer-LSTM预测 | 基于Transformer-LSTM的多变量单步时间序列预测(Matlab)

Transformer-LSTM预测 | 基于Transformer-LSTM的多变量单步时间序列预测(Matlab)

机器学习之心的博客,关注并私信文章链接,获取对应文章源码和数据。 192

bzoj4009

4009: [HNOI2015]接水果 Time Limit:60 SecMemory Limit:512 MBSubmit:633Solved:299[Submit][Status][Discuss] Description 风见幽香非常喜欢玩一个叫做 osu!的游戏,其中她最喜欢玩的模式就是接水果。 由于她已经DT FC 了The big black,...

weixin_30821731的博客 141

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

【BZOJ4009】[HNOI2015]接水果

题目描述给你一颗有nn个节点的树,给你pp条路径作为盘子,再给你qq条路径作为水果,问被当前水果完全覆盖的第kk大盘子的权值是多少。题目解析之前有道题和这个特别相似,把路径(x,y)(x,y)通过端点的dfndfn转化为点对(dfnx,dfny)(dfn_x,dfn_y),然后在线段树上进行插入和查询,因为是考试,所以说我一下子就兴奋了,这不就是那道题的翻版吗,把线段树套线段树改成主席树套线段树就行

SunIsMe的博客 630

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

bzoj4009: [HNOI2015]接水果

传送门:http://www.lydsy.com/JudgeOnline/problem.php?id=4009 思路:先给定一些路径,每个路径有一个权值。 题目要求的是对于一个路径,它的子路径中权值第k大的是多少 首先我们观察一个盘子(u,v),它能接到哪些水果呢? 分情况:如果u!=lca(u,v) 那么水果的两端点(a,b)就在盘子两端点的子树中 用dfs序来...

weixin_30920091的博客 217

bzoj4009: [HNOI2015]接水果【整体二分+扫描线】

Description 风见幽香非常喜欢玩一个叫做 osu!的游戏,其中她最喜欢玩的模式就是接水果。由于她已经DT FC 了The big black, 她觉得这个游戏太简单了,于是发明了一个更加难的版本。首先有一个地图,是一棵由 n 个顶点、n-1 条边组成的树(例如图 1给出的树包含 8 个顶点、7 条边)。这颗树上有 P 个盘子,每个盘子实际上是一条路径(例如图 1 中顶点 6 到顶点 ...

cdsszjj的博客 398

【算法拾光】队列|在每个树⾏中找最⼤值 + 最后⼀块⽯头的重量

本文总结两道经典算法题:一是通过层序遍历(BFS)逐层找最大值,利用队列分层处理,每层维护最大值;二是用大根堆(优先队列)模拟石头碰撞过程,每次取最大两块石头,差值重新入堆,直至剩余一块或无石。前者适用于树的层次遍历,后者适合动态获取最值场景。核心思想:队列用于分层遍历,堆用于高效取极值。

wuqingyigexiaoba的博客 202

头歌 数据结构-串的表示与实现

本关任务是实现串的定长顺序存储结构。使用静态数组char arr[MaxLen]存储字符串,输入字符串后输出其内容、实际长度(通过strlen计算)和存储长度(sizeof(arr))。代码在Begin-End间补充,完成字符串读取与信息输出。测试用例为输入"aaaaa",预期输出为"aaaaa"、5、20。

一名敲代码的苦13程序员 198

【算法拾光】链表 哈希表|K个一组翻转链表 + 两数之和

K个一组翻转链表需分段反转,借助哑节点与前驱指针维护连接,避免断链;两数之和利用哈希表实现O(1)查找,空间换时间,高效定位目标组合。前者考察链表指针操作,后者聚焦映射关系构建,均为面试高频题。

wuqingyigexiaoba的博客 341

排序算法深度笔记(下):非比较类排序的线性突破与工程边界

排序算法时间复杂度额外空间复杂度稳定性是否基于比较选择排序O(N^2)(O(1))不稳定是冒泡排序O(N^2)(O(1))稳定是插入排序O(N^2)(O(1))稳定是归并排序O(N\log N)(O(N))稳定是快速排序O(N\log N)O(log N)不稳定是堆排序O(N\log N)O(1)不稳定是计数排序(O(N + M))O(M))稳定否基数排序O(N)稳定否桶排序平均O(N) / 最坏O(N^2)

2401_87069538的博客 617

Rust LeetCode443 算法题解

LeetCode 443 字符串压缩:原地行程编码,用 start 标记组起点、next 扫描组边界、i 原地写出;长度 1 不写计数使编码不膨胀,写指针不越过读指针。时间 O(n),额外空间 O(1)。

weixin_43379230的博客 185

优选算法:分治-归并排序

交易逆序对的总数

Wangshijie1015的博客 154

Java 集合容器高频面试题全解:HashMap 树化阈值、1.7 死循环与 ConcurrentHashMap 演进(2026 招聘 JD 真题复盘)

HashMap 树化阈值 8 的泊松分布依据、退化阈值 6 的防抖设计、JDK 1.7 头插成环死循环的排查与修复、1.8 尾插后为何仍线程不安全、ConcurrentHashMap 放弃分段锁的原因与 ForwardingNode 协作扩容、computeIfAbsent 死锁陷阱、大集合找重复的场景题选型,附三层追问链自测。题目来源为 38 期公开招聘 JD 样本与字节、拼多多、建行、美团、快手公开面经。

蒙眼过河 427

栈和队列和数组-优快云博客

一句话理解:栈就像一个羽毛球桶或手枪弹夹——只能从一头放、从一头取,最后放进去的最先拿出来。严格定义:栈是限定仅在某一端进行插入或删除操作的线性表。允许插入和删除的一端叫栈顶(top);另一端叫栈底(bottom);不含任何元素的栈叫空栈;栈中元素遵循后进先出(LIFO,Last In First Out)。两个核心动作插入数据叫入栈 / 进栈(Push);删除数据叫出栈(Pop)。⚠️ 易错点:栈只能在一端操作,不是两端。判断题里说「栈允许在两端操作」一定是错的。一句话理解。

2501_93853322的博客 175

数据结构-栈

数据结构,栈相关

2501_93884468的博客 495

从决策树到随机森林:Python机器学习里的“树形家族“深度实战与原理拆解

文章浏览阅读2.4k次,点赞52次,收藏32次。决策树和随机森林作为机器学习中的经典算法,各有优劣。决策树以其高可解释性和快速训练的特点

2601_96798011的博客 260
上一篇: bzoj2820 分类: bzoj 2015-...
下一篇: sgu 202 分类: sgu 2015-06...
aa288288
博客等级 码龄11年 0粉丝 0原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值