bzoj 4009 分类： bzoj temp...

最新推荐文章于 2024-08-14 08:53:12 发布
最新推荐文章于 2024-08-14 08:53:12 发布
阅读量89 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/dashgua/p/4723014.html
版权

参考题解: 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

aa288288
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Node.js-ZOJCH是BZOJ题库的离线版
08-09
【标题】"Node.js-ZOJCH是BZOJ题库的离线版"揭示了这个项目的核心功能，即提供一个基于Node.js平台的离线版本的BZOJ（BestCoder Judging System）题库。BZOJ是一个在线编程竞赛平台，而ZOJCH则允许用户在没有网络...
BZOJ第一部分
11-03
1. **基础编程语言**：BZOJ支持C、C++、Java、Python等多种编程语言，理解每种语言的基本语法和特性是必不可少的。 2. **数据结构**：数组、链表、栈、队列、树、图、哈希表等是解决问题的基础工具，熟练运用它们能...
bzoj4009
weixin_30821731的博客
03-19 79
4009: [HNOI2015]接水果 Time Limit:60 SecMemory Limit:512 MBSubmit:633Solved:299[Submit][Status][Discuss] Description 风见幽香非常喜欢玩一个叫做 osu!的游戏，其中她最喜欢玩的模式就是接水果。 由于她已经DT FC 了The big black,...
BZOJ 4009: [HNOI2015]接水果(整体二分套二维偏序)
Freopen的博客
03-20 150
题目 表示这种题好套路啊。 原题如果注意到一条路径包含另一条路径，那么在dfs序上第一条路径的端点与第二条路径的端点是有一个偏序关系的。 然后就变成了二分答案+三维偏序。 因为可以离线， 将二分答案和一维整合起来变成整体二分O(nlog⁡n)O(n\log n)O(nlogn)。 剩下两维就是一个二维偏序，排序后树状数组维护O(log⁡n)O(\log n)O(logn)。 一共O(nlog⁡2n...
【整体二分/点分治/树链剖分 + 数据结构】BZOJ4009 [HNOI2015]接水果
MEET YOU FIRST TIME
02-13 315
【题目】 BZOJ 一棵nnn个节点的树，有PPP条带权值不相同路径，QQQ个询问。每个询问给定一条路径以及一个KKK，查询所有带权路径中是给定路径的子路径的第KKK小权值。n,m,Q≤4×104n,m,Q\leq 4\times 10^4n,m,Q≤4×104。 【解题思路】 首先显然的套路是一条带权路径能贡献到的询问是询问路径的两个端点分别在带权路径的两个子树中或一个在子树中另一个不在子树中。...
bzoj4009: [HNOI2015]接水果【整体二分+扫描线】
cdsszjj的博客
03-12 315
Description 风见幽香非常喜欢玩一个叫做 osu!的游戏，其中她最喜欢玩的模式就是接水果。由于她已经DT FC 了The big black, 她觉得这个游戏太简单了，于是发明了一个更加难的版本。首先有一个地图，是一棵由 n 个顶点、n-1 条边组成的树（例如图 1给出的树包含 8 个顶点、7 条边）。这颗树上有 P 个盘子，每个盘子实际上是一条路径（例如图 1 中顶点 6 到顶点 ...
【BZOJ4009】[HNOI2015]接水果
SunIsMe的博客
04-03 542
题目描述给你一颗有nn个节点的树，给你pp条路径作为盘子，再给你qq条路径作为水果，问被当前水果完全覆盖的第kk大盘子的权值是多少。题目解析之前有道题和这个特别相似，把路径(x,y)(x,y)通过端点的dfndfn转化为点对(dfnx,dfny)(dfn_x,dfn_y)，然后在线段树上进行插入和查询，因为是考试，所以说我一下子就兴奋了，这不就是那道题的翻版吗，把线段树套线段树改成主席树套线段树就行
bzoj 2879 分类： bzoj temp...
aa288288的博客
08-07 77
动态加点KM 这个KM模型已经比较常见了： http://blog.csdn.net/cyxhahaha/article/details/44657619 构图： X 侧点为对菜品的需求，Y 侧点为厨师对菜品的供应 如果让 i 厨师在倒数第 t 次制作菜品 j，花费时间为 cost(i,j)∗t 记 sp=∑p[i]，如果把每个厨师拆成 sp ...
bzoj 2038 分类： bzoj temp...
aa288288的博客
03-26 98
因为考试题太难了改不出，于是就弃疗搞莫队算法去了 造福社会：莫涛2010年集训队论文 hzwer的写法极其简略，长跪不起 具体实现： 1.分块 S=sqrt(n)+ 双关键字排序 2.如下 [来自莫涛论文] ...
bzoj 1030 分类： bzoj temp...
aa288288的博客
08-06 66
AC自动机模板 #include <cstdio> #include <cstdlib> #include <cstring> #include <cmath> #include <ctime> #include <string> #include <map> #includ...
BZOJ泡泡堂题解.doc
09-29
### BZOJ1034 题解分析 #### 题目概述 题目编号为BZOJ1034的问题，通过一种独特的贪心算法进行解答。本题涉及两个队伍之间的对抗，每个队伍都有自己的实力排序。目标是最大化己方得分。 #### 解题思路与核心代码...
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
（自己写的动态点分治巨垃圾，常数是别人的两倍） 用动态开点线段树死活过不去，学了一波大佬用 vector 开树状数组立马就卡过去了 考虑点分树的做法，在点分树上每个点以距离为下标建一棵线段树，每次询问查询子树的...
BZOJ全代码
02-05
【标题】"BZOJ全代码"所指的是一份包含BZOJ（BestCoder Zhijiang Online Judge）平台所有编程题目解决方案的压缩文件。BZOJ是一个在线编程竞赛平台，它提供了大量的算法题目供参赛者练习和提交代码，以检验编程能力...
543 二叉树的直径
Noric! 的博客
08-13 307
说明：如果有多个转折点，那么路径上会产生分支，该路径不为合法路径；若没有转折点，可将末尾节点的另外一个子节点加入路径，该路径不是最长的；每一条最长路径中一定存在一个转折点 + 若干非转折点（见说明），只需要把每一个点看做转折点，然后开始构建最长路径，从这些路径长度中选取最大值，即为树的直径。那么，如何构建最长的路径呢，很简单，可以通过递归来解决，在递归之中每一步，情况一：该节点为非转折点，最长路径经过其。作为非转折点能构建的最长的路径长度。情况二：该节点为转折点，最长路径经过其。为转折点构建的路径长度。
【数据结构与算法】二叉树
qq_74047911的博客
08-10 992
当找到要删除的节点后,如果要删除节点的左边为空,就将姚删除节点的右边节点连接到要删除节点的位置,同理姚删除节点的右边为空的时候,就将要删除节点的左边连接到要删除的节点.我们这里选择找右子树的最小值,先将要删除节点的右孩子找到,然后根据二叉搜索树的性质,我们需要一直找其左子节点,能够找到最小的值.如果要插入的数据小于根节点的数据,就往左边遍历,否则右边遍历,直到tmp为空,那么parent就是要删除节点的父节点.如果当前节点不为空,同时当前节点的数据不是我们要删除的数据,那么我们一直遍历.
【经验分享】数据结构——哈希查找冲突处理方法（开放地址法-线性探测、平方探测、双散列探测、再散列，分离链接法）
VLOKL的博客
08-11 876
【经验分享】数据结构——哈希查找冲突处理方法（开放地址法-线性探测、平方探测、双散列探测、再散列，分离链接法）
python 实现tree sort树排序算法
最新发布
luthane的博客
08-14 379
树排序”（Tree Sort）并不是一个广泛认知或标准算法库中的直接术语，但我们可以从字面意思上理解它可能指的是一种基于树结构的排序算法。在算法和数据结构领域，有多种使用树来辅助排序的算法，但没有一个特定的、广泛接受的“树排序”算法。
集合（1）
supercool7的博客
08-12 775
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
bzoj.org俄罗斯方块
05-06
bzoj.org是一个在线的编程题库，其中包含了很多经典算法问题和实际应用中的编程问题。其中包括了很多有趣的游戏算法问题，比如Puzzle，Tetris等。 而bzoj.org俄罗斯方块就是在该平台上的一个经典的俄罗斯方块游戏。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值