精华内容
下载资源
问答
  • 数据结构课设

    2013-01-03 02:51:25
    4.概要设计:给出每道题采用的数据结构,算法设计思想,算法的时间复杂度; 5.详细设计:给出每道题的源程序,并在必要的代码处给出注释; 6.功能测试:给出每道题的测试数据和结果; 7.完成情况:每道题完成部分和...
  • 1、线性关系如果把这两个变量分别作为点的横坐标与纵坐标,其图象...长度为0的表称为空表,空表不包含任何数据元素。3、数据的逻辑结构从逻辑关系上描述数据,与数据的存储无关,是独立于计算机的。4、数据的存储结...

    1线性关系

    如果把这两个变量分别作为点的横坐标与纵坐标,其图象是平面上的一条直线,则这两个变量之间的关系就是线性关系。从逻辑来讲,线性表的数据元素之间存在一对一的逻辑关系,即为数据关系。

    2、线性表的长度

    n为线性表中包含的数据元素的个数,即为线性表的长度。长度为0的表称为空表,空表不包含任何数据元素。

    3、数据的逻辑结构

    从逻辑关系上描述数据,与数据的存储无关,是独立于计算机的。

    4、数据的存储结构

    是逻辑结构用计算机语言的实现(亦称为映象),它依赖于计算机语言。对机器语言而言,存储结构是具体的。一般,只在高级语言的层次上讨论存储结构。

    5、顺序存储方法

    把逻辑上相邻的结点存储在物理位置上相邻的存储单元里,结点间的逻辑关系由存储单元的邻接关系来体现。由此得到的存储表示称为顺序存储结构(Sequential Storage Structure

    6、链接存储方法

    不要求逻辑上相邻的结点在物理位置上亦相邻,结点间的逻辑关系由附加的指针字段表示。由此得到的存储表示称为链式存储结构(Linked Storage Structure)。

    7线性表的顺序存储

    用一组地址连续的存储单元来依次存储线性表中的数据元素,这种存储结构称为线性表的顺序存储结构。它是用数据元素在机内物理位置上的相邻关系来映射数据元素之间的相邻关系。

    8、顺序表

    采用顺序存储结构的线性表称为顺序表。

    9线性表的链式存储

    用一组地址任意的存储单元(可以是连续的,也可以是不连续的)来依次存储线性表中的各个数据元素。线性表按链式存储时,每个数据元素 (结点)的存储包括数据区和指针区两个部分。数据区存放结点本身的数据,指针区存放其后继元素的地址 (没有后继元素时设置为空字符(Null).。只要知道该线性表的起始地址 (记录在头指针中),表中的各个元素就可通过其间的链接关系逐步找到。

    10、结点

    链表中的每个元素都为一个结点。

    11、数据域

    结点中存储元素本身信息的域称为数据域。

    12、指针域

    存储表中下一个元素的地址域称为指针域。

    13、链

    指针域中存储的信息称做指针或链(各结点之间以指针(指出元素地址)相连的数据结构)。

    14、线性单链表

    分为不带头结点的单链表、带头结点的单链表和空表。

    15、双向链表

    它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点。

    16、环链表

    链表中最后一个链结点的指针域指向链表的第一个链结点,整个链表形成一个环。

    17、线性表

    线性表是 n>=0 个数据元素 a1a2an 的有限序列,表中每个元素,除首元素和尾元素外,有且仅有一个直接前趋和直接后继。表中的元素个数定义为线性表的长度。

    18、开始结点

    开始结点是指链表中的第一个结点,也就是没有直接前趋的那个结点。

    19、头指针

    链表的头指针是一指向链表开始结点的指针(没有头结点时),单链表由头指针唯一确定,因此单链表可以用头指针的名字来命名。

    20、头结点

        头结点是在链表的开始结点之前附加的一个结点。有了头结点之后,头指针指向头结点,不论链表否为空,头指针总是非空。而且头指针的设置使得对链表的第一个位置上的操作与在表其他位置上的操作一致(都是在某一结点之后)。

    image.png

    来源:我是码农,转载请保留出处和链接!

    本文链接:http://www.54manong.com/?id=15

    '); (window.slotbydup = window.slotbydup || []).push({ id: "u3646208", container: s }); })();
    '); (window.slotbydup = window.slotbydup || []).push({ id: "u3646147", container: s }); })();
    展开全文
  • 任何两个圆都不会相交(也不会相切),但是圆与圆之间可能存在包含关系。当我们在一个圆里面的时候,我们必须经过它的边界一次,才能走出这个圆。 对于不同的两个圆A、B,如果可以从A到B且经过超过K次边界,则称A...

    Description

    二维坐标平面内有n个圆,第i个圆圆心在(Xi,Yi),半径为Ri,权值Vi。任何两个圆都不会相交(也不会相切),但是圆与圆之间可能存在包含关系。当我们在一个圆里面的时候,我们必须经过它的边界一次,才能走出这个圆。

    对于不同的两个圆A、B,如果可以从A到B且经过不超过K次边界,则称A、B是连通的。现在的问题是:对于所有的连通的一对圆(A,B),权值差的绝对值最大有多少。即找到max{ |VA – VB|, 其中A B连通}。

    对于100%的数据,T ≤ 10, 2 ≤ n ≤ 50000, 2 ≤ K ≤ 100, 0 < Ri ≤ 200000000, -1000000000 ≤ Xi, Yi, Vi ≤ 1000000000

    Solution

    首先我们把每个圆看做一个点,将包含这个圆的最小圆看做它的父亲,这样构成一棵树,接下来就是树上距离不超过K的点对权值差的最大值,随便DP一下即可。

    我们考虑如何求包含某个圆的最小圆。
    用扫描线从左到右扫,用一个set维护每个圆与扫描线的交点之间的位置关系。

    由于圆与圆之间不会相交,也就意味着交点 之间的相对顺序是不会改变的。
    我们在加入一个圆的两个交点时,考虑比上交点高的第一个点。

    如果这个点是一个上交点,那么新加的圆的父亲就是那一个点对应的圆。
    否则新加的圆的父亲与那一个点对应的圆的父亲相同。

    做到一个圆的最右端时就将两个交点删除。
    这样就在O(T(nlogn+nk))O(T(n\log n+nk))的复杂度做完了。

    显然后面nk的部分可以优化,大可以采用点分治/长链剖分等做法。
    毒瘤的是原题卡空间

    Code

    #include <bits/stdc++.h>
    #define fo(i,a,b) for(int i=a;i<=b;++i)
    #define fod(i,a,b) for(int i=a;i>=b;--i)
    #define N 100005
    #define LL long long
    using namespace std;
    priority_queue<int,vector<int>,greater<int> > hp;
    int t,fs[N],nt[N],dt[N],a[N][4],now,fa[N],m1,n,m,mx[20005][101],mi[20005][101],ans,rt[N],n1,mx1;
    struct node
    {
    	int w,x,p;
    }d[N];
    bool cmp(node x,node y)
    {
    	return x.x<y.x;
    }
    LL sqr(LL x)
    {
    	return x*x;
    }
    struct nd
    {
    	int w,p;
    	friend double wz(nd x)
    	{
    		if(!x.p) return a[x.w][1]-sqrt(sqr(a[x.w][2])-sqr(a[x.w][0]-now));
    		else return a[x.w][1]+sqrt((sqr(a[x.w][2])-sqr(a[x.w][0]-now))); 
    	}
    	friend bool operator<(nd x,nd y)
    	{
    		return (wz(x)<wz(y));	
    	}
    };
    set<nd> h;
    void link(int x,int y)
    {
    	nt[++m1]=fs[x];
    	dt[fs[x]=m1]=y;
    }
    void dfs(int k,int fa)
    {
    	rt[k]=0;
    	for(int i=fs[k];i;i=nt[i])
    	{
    		int p=dt[i];
    		if(p!=fa)
    		{
    			dfs(p,k);
    			if(!rt[k])
    			{
    				rt[k]=rt[p];
    				fod(j,m,1) 
    				{
    					mx[rt[k]][j]=mx[rt[k]][j-1],mi[rt[k]][j]=mi[rt[k]][j-1];
    					if(k) mx[rt[k]][j]=max(mx[rt[k]][j],a[k][3]),mi[rt[k]][j]=min(mi[rt[k]][j],a[k][3]);
    					ans=max(ans,mx[rt[k]][j]-mi[rt[k]][j]);
    				}
    				if(k) mx[rt[k]][0]=mi[rt[k]][0]=a[k][3];
    				else mx[rt[k]][0]=-1e9,mi[rt[k]][0]=1e9;
    			}
    			else
    			{
    				fo(j,0,m) 
    				{
    					if(j!=m) ans=max(ans,max(mx[rt[k]][j]-mi[rt[p]][m-j-1],mx[rt[p]][m-j-1]-mi[rt[k]][j]));
    					if(j) mx[rt[k]][j]=max(mx[rt[k]][j],mx[rt[p]][j-1]),mi[rt[k]][j]=min(mi[rt[k]][j],mi[rt[p]][j-1]); 
    				}
    				hp.push(rt[p]);
    			}
    		}
    	}
    	if(!rt[k]) 
    	{
    		rt[k]=hp.top(),hp.pop();
    		fo(j,0,m) mx[rt[k]][j]=mi[rt[k]][j]=a[k][3];
    	}
    }
    int main()
    {
    	cin>>t;
    	int cnt=0;
    	while(t--)
    	{
    		int l=0;
    		m1=0;
    		while(!hp.empty()) hp.pop();
    		memset(fs,0,sizeof(fs));
    		scanf("%d%d",&n,&m);
    		fo(i,1,n) hp.push(i);
    		a[0][0]=a[0][1]=0,a[0][2]=2e9;
    		fo(i,1,n) 
    		{
    			scanf("%d%d%d%d",&a[i][0],&a[i][1],&a[i][2],&a[i][3]);
    			d[++l]=(node){i,a[i][0]-a[i][2],0},d[++l]=(node){i,a[i][0]+a[i][2],1};
    		}
    		sort(d+1,d+l+1,cmp);
    		h.clear();
    		h.insert((nd){0,0}),h.insert((nd){0,1});
    		ans=0;
    		fo(i,1,l)
    		{
    			now=d[i].x;
    			if(!d[i].p)
    			{
    				set<nd>::iterator it=h.upper_bound((nd){d[i].w,1});
    				nd p1=*it;
    				if(p1.p==0) fa[d[i].w]=fa[p1.w];
    				else fa[d[i].w]=(*it).w;
    				link(fa[d[i].w],d[i].w);
    				now=d[i].x+1;
    				h.insert((nd){d[i].w,0}),h.insert((nd){d[i].w,1});
    				now=d[i].x;
    			}
    			else h.erase((nd){d[i].w,0}),h.erase((nd){d[i].w,1});
    		}
    		dfs(0,0);
    		cnt++;
    		printf("Case %d: %d\n",cnt,ans);
    	}
    }
    
    展开全文
  • 《大数据:互联网大规模数据挖掘与分布式处理》源自作者在斯坦福大学教授多年的“Web挖掘”课程材料,主要关注大数据环境下数据挖掘的实际算法。...(3)对每个频繁项对,在存储计数值的数据结构中相应的计数值上...
  • 《大数据:互联网大规模数据挖掘与分布式处理》源自作者在斯坦福大学教授多年的“Web挖掘”课程材料,主要关注大数据环境下数据挖掘的实际算法。...(3)对每个频繁项对,在存储计数值的数据结构中相应的计数值上...
  •  本书是一本关于oracle database 9i、10g 和11g 数据库体系结构的权威图书,涵盖了所有重要的oracle 体系结构特性,包括文件、内存结构和进程,锁和闩,事务、并发和多版本,表和索引,数据类型,分区和并行,以及...
  •  本书是一本关于Oracle 9i & 10g数据库体系结构的权威图书,涵盖了所有最重要的Oracle体系结构特性,包括文件、内存结构和进程,锁和闩,事务、并发和多版本,表和索引,数据类型,以及分区和并行,并利用具体的...
  • GUI模块是在LCD显示驱动程序上开发,将LCD驱动的画点画线函数封装成不同的控件,在控件上加载相应的数据结构,为界面应用程序提供控件的创建、销毁等操作。 应用层程序是面向用户,通过调用中间服务函数和库函数来...
  • 地理信息系统算法基础

    千次下载 热门讨论 2009-06-20 10:57:53
    12.1.3DEM数据结构的相互转换 12.2基本地形因子分析算法 12.2.1坡面因子提取的算法基础 12.2.2坡度、坡向 12.2.3坡形 12.3地形特征提取算法 12.3.1地形特征点的提取 12.3.2基于规则格网DEM数据提取...
  • 允许将值键入(分配)到数据列表中未包含的Text属性 (样式= csDropDownEh)。 允许将KeyValue和Text保持为互不影响的值。 当KeyField,ListField,ListSource,DataField和DataSource生效 属性为空。 下拉...
  • MAPGIS地质制图工具

    2013-05-06 16:15:30
    3、 执行菜单“1辅助工具\导入导出功能\MapGis<-> Excel\MapGis-> Excel1”,然后鼠标框选输出数据区域即可,自动打开Excel并且点数据输出到Excel,线数据不输出; 备注:a、MapGis-> Excel输出数据时,点线文件...
  • C++ 资源大全中文版 awesome-cpp 就是 fffaraz 发起维护的 C++ 资源列表,内容包括:标准...PGM-index:能够快速查找、前导、范围搜索和更新数以亿计项数组的数据结构,其跟传统索引相比,使用梯度的顺序而不是空间。 ...
  • 4.3.1 数组和链表数据结构描述,各自的时间复杂度。 4.3.2 error和exception的区别,CheckedException,RuntimeException的区别。 4.3.3 请列出5个运行时异常。 4.3.4 在自己的代码中,如果创建一个java.lang....
  • JavaScript王者归来

    2013-01-10 11:30:48
    12.4.2 平面展开--通过文档元素直接创建 12.4.3 回收空间--删除不用的节点 12.5 访问和操纵DOM节点 12.5.1 打开每一个盒子--遍历节点 12.5.2 弄清层级关系--父子与兄弟 12.5.3 如何搜索特定节点 12.5.4 克隆节点--一...
  • 千里马酒店前台管理系统V7使用手册

    热门讨论 2011-06-16 14:09:38
    千里马酒店前台管理系统V7.2采用了面向对象的三层逻辑结构的体系架构,即分为用户界面层、业务逻辑层(或称应用层)和数据处理层。 用户界面层负责人-机交互的操作界面,即接受用户的指令和输入、并将结果显示...
  • 什么是VLAN

    2013-10-23 09:59:12
    而且这种划分的方法也导致了交换机执行效率的降低,因为在每一个交换机的端口都可能存在很多个VLAN组的成员,这样就无法限制广播了。另外,对于使用笔记本电脑的用户来说,他们的网卡可能经常更换,这样,VLAN就...
  • 具体讲述了二叉空间剖分(BSP)、八叉树等图形学中常用的数据结构。新版本增加了图形用户界面、椭圆、图像压缩和线条反走样算法等,还增加了Liang-Barsky裁剪算法和Nicholl-Lee- Nicholl裁剪算法。新版本大大扩充了可...
  • 最后记录RSSI和d的对应关系,这样就得到了70组测量数据(),= 1,2,3,…,100,其中表示距离为时终端接收到的功率值。对所采集的70组测量数据使用线性回归分析,带入以下公式,即可求出p0、n(式中A表示p0): ...
  • 系统,和汇编相比,C 在功能上、结构性、可读性、可维护性上有明显的优 势,因而易学易用。 Keil c51 软件提供丰富的库函数和功能强大的集成开发调试工具,全 Windows 界面。另外重要的一点,只要看一下编译后生成的...
  • 数据结构》严蔚敏 《计算机网络》谢希仁 《计算机组成原理》唐朔飞(或者白中英) 《操作系统》汤子瀛 3. 807软件工程专业综合 2018年807考试大纲 2019年807考试大纲 4. 811概率论 注意: 从2019考研起,北邮...
  • 交通信号灯用于道路平面交叉路口,通过对车辆、行人发出行进或停止的指令,使人与人、车与车之间尽可能减少相互干扰,从而提高路口的通行能力,保障路口畅通和安全。本文介绍了一种城市十字路口交通信号灯控制系统。...
  • 一、题目 点此看题 二、解法 看到这种平面图形向的题...由于只会出现包含关系,那么端点之间的相对位置关系是不会变化的(比如一对端点被夹着,那么以后都会被夹着),可以利用这一点去用数据结构维护。 我选择set\tt

    一、题目

    点此看题

    二、解法

    看到这种平面图形向的题一定要去想:扫描线

    我们以xx坐标做扫描线,我们需要的是找出第一个包含某个圆的圆,做到了这一点的话就可以建出表示包含关系的树然后处理询问了。

    怎么找呢?在一开始加入这个圆的时候,这时候圆还只是一个点xx,去找满足lxrl\leq x\leq r的已经插入的圆即可(表示圆的左右端点),由于只会出现包含关系,那么端点之间的相对位置关系是不会变化的(比如一对端点被夹着,那么以后都会被夹着),可以利用这一点去用数据结构维护。

    我选择set\tt set,可以找到左边最接近的端点和右边最接近的端点,分情况讨论:

    • 如果是一个圆的左右端点,直接设置父亲。
    • 如果是两个圆,且他们父亲不一样,那么他们一定是包含关系,看谁是父亲就可以了。
    • 如果他们父亲一样,那么是并列关系,设置成他们的公共父亲即可。

    时间复杂度O(nlogn)O(n\log n)

    #include<iostream>
    #include<algorithm>
    #include<cstdio>
    #include<cmath>
    #include<vector>
    #include<cstring>
    #include<set>
    
    using namespace std;
    
    const double eps = 1e-6;
    const int maxn = 1e5;
    int nowx;
    
    namespace UnionFindSet {
        int ufs[maxn + 5];
        void init(int n) {
            for (int i = 1; i <= n; ++i)ufs[i] = i;
        }
        int find(int x) {
            return x == ufs[x] ? x : ufs[x] = find(ufs[x]);
        }
        void unite(int x, int y) {
            x = find(x), y = find(y);
            if (x != y)ufs[x] = y;
        }
    }
    
    namespace TreeChainSplitting {
    
        vector<int> g[maxn + 5];
    
        int parent[maxn + 5], son[maxn + 5], sz[maxn + 5], deep[maxn + 5];
        int top[maxn + 5], id[maxn + 5];
        int tot;
    
        void init() {
            memset(son, -1, sizeof(son));
            memset(deep, 0, sizeof(deep));
            tot = 0;
        }
    
        void dfs1(int u, int father) {
            deep[u] = deep[father] + 1, sz[u] = 1, parent[u] = father;
            for (int i = 0; i < g[u].size(); ++i) {
                int v = g[u][i];
                if (v == father)continue;
                dfs1(v, u);
                sz[u] += sz[v];
                if (son[u] == -1 || sz[v] > sz[son[u]])son[u] = v;
            }
        }
    
        void dfs2(int u, int root) {
            top[u] = root, id[u] = ++tot;
            if (son[u] == -1)return;
            dfs2(son[u], root);
            for (int i = 0; i < g[u].size(); ++i) {
                int v = g[u][i];
                if (v != son[u] && v != parent[u])dfs2(v, v);
            }
        }
    
        int lca(int x, int y) {
            while (top[x] != top[y]) {
                if (deep[top[x]] < deep[top[y]])swap(x, y);
                x = parent[top[x]];
            }
            return deep[x] < deep[y] ? x : y;
        }
    }
    
    struct circle {
        circle(int x = 0, int y = 0, int r = 0) :x(x), y(y), r(r) {}
        int x, y, r;
    }c[maxn + 5];
    
    struct event{
        int x, type, id;
        event(int x = 0, int type = 0, int ss = 0) : x(x), type(type), id(ss) {}
    }eve[2 * maxn + 5];
    
    bool operator < (const event&a, const event &b) {
        if (a.x == b.x) {
            if (a.type == b.type)return a.id < b.id;
            else return a.type > b.type;
        }
        else return a.x < b.x;
    }
    struct node {
        node(int ss = 0, int type = 0) :id(ss), type(type) {}
        int id, type;
    };
    
    double get_pos(const node &p) {
        int type = p.type, ss = p.id;
        if (type == 1) return (double)c[ss].y + sqrt((double)c[ss].r * c[ss].r - (double)(c[ss].x - nowx) * (c[ss].x - nowx));
        if (type == -1)return (double)c[ss].y - sqrt((double)c[ss].r * c[ss].r - (double)(c[ss].x - nowx) * (c[ss].x - nowx));
    }
    
    bool operator < (const node &a, const node &b) {
        double A = get_pos(a), B = get_pos(b);
        return  A > B || fabs(A - B) < eps && a.type > b.type;
        //就是在接近的时候会把右端点放在前面 
    }
    
    set<node> s;
    int fa[maxn + 5], n, q, cnt;
    
    int main()
    {
        scanf("%d", &n);
        for (int i = 1; i <= n; ++i) {
            scanf("%d %d %d", &c[i].x, &c[i].y, &c[i].r);
            eve[++cnt] = event(c[i].x - c[i].r, 1, i);
            eve[++cnt] = event(c[i].x + c[i].r, -1, i);
        }
        sort(eve + 1, eve + 1 + cnt);
        for (int i = 1; i <= cnt; ++i) {
            int id = eve[i].id;
            nowx = eve[i].x;
            if (eve[i].type == 1) {
                auto up = s.lower_bound(node(id, 1));
                auto down = s.upper_bound(node(id, 1));
                if (up == s.begin() || down == s.end()) {
                    fa[id] = 0;
                    s.insert(node(id, 1));
                    s.insert(node(id, -1));
                    continue;
                }
                --up;
                if (up->id == down->id)fa[id] = up->id;
                else if (fa[up->id] != fa[down->id]) {
                    if (fa[up->id] == down->id)    fa[id] = down->id;
                    else if (fa[down->id] == up->id)    fa[id] = up->id;
                }
                else fa[id] = fa[up->id];
                s.insert(node(id, 1));
                s.insert(node(id, -1));
            }
            else {
                s.erase(node(id, 1));
                s.erase(node(id, -1));
            }
        }
        UnionFindSet::init(n);
        TreeChainSplitting::init();
        for (int i = 1; i <= n; ++i) {
            if (fa[i] == 0)continue;
            int u = fa[i], v = i;
            TreeChainSplitting::g[u].push_back(v);
            TreeChainSplitting::g[v].push_back(u);
            UnionFindSet::unite(v, u);
        }
        for (int i = 1; i <= n; ++i) {
            if (UnionFindSet::ufs[i] == i) {
                TreeChainSplitting::dfs1(i, i);
                TreeChainSplitting::dfs2(i, i);
            }
        }
        scanf("%d", &q);
        for (int i = 1, u, v; i <= q; ++i) {
            scanf("%d %d", &u, &v);
            int fu = UnionFindSet::find(u), fv = UnionFindSet::find(v);
            if (fu != fv) {
                int d1 = TreeChainSplitting::deep[u], d2 = TreeChainSplitting::deep[v];
                int res = d1 + d2 - 2;
                printf("%d\n", res);
            }
            else {
                int lca = TreeChainSplitting::lca(u, v);
                int du = TreeChainSplitting::deep[u], dv = TreeChainSplitting::deep[v], dlca = TreeChainSplitting::deep[lca];
                int res = du + dv - 2 * dlca - 2;
                if (u == lca || v == lca) res += 1;
                printf("%d\n", res);
            }
        }
        return 0;
    }
    
    展开全文

空空如也

空空如也

1 2
收藏数 23
精华内容 9
关键字:

关系数据结构包不包含平面数据

数据结构 订阅