P3250 最长链

最新推荐文章于 2023-05-07 22:45:05 发布
原创 最新推荐文章于 2023-05-07 22:45:05 发布 · 388 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

【问题描述】 

　　现给出一棵N个结点二叉树，问这棵二叉树中最长链的长度为多少，保证了1号结点为二叉树的根。 

输入格式

　　输入文件chain.in的第1行为包含了一个正整数N，为这棵二叉树的结点数，结点标号由1至N。 
　　接下来N行，这N行中的第i行包含两个正整数l[i], r[i]，表示了结点i的左儿子与右儿子编号。如果l[i]为0，表示结点i没有左儿子，同样地，如果r[i]为0则表示没有右儿子。 

【样例说明】 
　　4-2-1-3-6为这棵二叉树中的一条最长链。 

【数据规模】 
　　对于10%的数据，有N≤10； 
　　对于40%的数据，有N≤100； 
　　对于50%的数据，有N≤1000； 
　　对于60%的数据，有N≤10000； 
　　对于100%的数据，有N≤100000，且保证了树的深度不超过32768。 





定义：过以节点x作为根节点的子树中，节点间的最大距离为Dis(x)。

上图，左图中Dis(根节点)最大，右图中Dis(根节点->left)最大。从上边可以看出每个节点都可能成为最大距离根节点的潜质。

因此可以求出每个Dis(节点)，从中得出最大值即为整个二叉树的根节点最大值。

在求过点x的最大距离时，最大距离的两个点有可能出现在三种情况下

  1. 左子树
  2. 右子树
  3. 过节点x

经分析得出以下特点

  1. 以上三种情况最终必定一叶子结束
  2. 在第三种情况下必然是左子树高度 与 右子树高度 之和（只有这样，才可能取得最大值）

经过以上分析即可得出递推式

Dis(x) = max(Dis(x->left), Dis(x->right), height(x->left)+height(x->right)






--------------------------------------------------------------------------------------

维护一个数组f，f[i]表示以i节点为“最高点”的最长链的长度，左右子树都不存在时f[i]=0，否则f[i]=max(f[i的左子树],f[i的右子树])+1.

ff[i]表示以i为共同父节点的的链长度。所求为max(ff[i])  i=1~n.

a[k]、b[k]分表表示节点k的左右子树编号。

----------------------------------------------------------------------------------------



import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;

public class Main
{
	private static Reader reader;
	private static int[] a,b,f,ff;
	public static void main(String[] args)
	{
		reader=new InputStreamReader(System.in);
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		int n=getInt();
		a=new int[n+1];
		b=new int[n+1];
		f=new int[n+1];
		ff=new int[n+1];
		for(int i=1;i<=n;i++)
		{
			a[i]=getInt();
			b[i]=getInt();
		}
		
		dfs(1);
		
		int max=0;
		for(int i=1;i<=n;i++)
			{
				if(a[i]>0)
					ff[i]+=f[a[i]]+1;
				if(b[i]>0)
					ff[i]+=f[b[i]]+1;
				if(ff[i]>max)
					max=ff[i];
			}
		
		out.println(max);
		out.flush();
		
	}
	
	
	public static void dfs(int k)
	{
		if(a[k]==0&&b[k]==0)
		{
			f[k]=0;
			return ;
		}
		
		if(a[k]>0)
		{
			dfs(a[k]);
		}
		if(b[k]>0)
		{
			dfs(b[k]);
		}
		
		if(f[a[k]]>f[b[k]])
			f[k]=f[a[k]]+1;
		else 
		{
			f[k]=f[b[k]]+1;
		}
	}
	
	
	public static int getInt() {  
        int read;  
        int res = 0;  
        boolean isNegative = false;
        try {  
            while ((read = reader.read()) != -1) {  
                if ((char) read == '-') {  
                    res = 0;  
                    isNegative = true;  
                    break;  
                } else if (isNumber((char) read)) {  
                    res = read - '0';  
                    break;  
                }  
            }  
            while ((read = reader.read()) != -1) {  
                char ch = (char) read;  
                if (isNumber(ch)) {  
                    res = res * 10 + (read - '0');  
                } else {  
                    break;  
                }  
            }  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
        if (isNegative == true) {  
            res = -1 * res;  
        }  
        return res;  
    }  
	
	
	 public static boolean isNumber(char ch) {  
	        if (ch <= '9' && ch >= '0') {  
	            return true;  
	        }  
	        return false;  
	    }  
}

数据规模较大，dfs较深爆栈，使用手工栈： 


import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.util.Stack;

public class Main
{
	private static Reader reader;
	private static int[] a,b,f,ff;
	private static boolean[] visit;
	public static void main(String[] args)
	{
		reader=new InputStreamReader(System.in);
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		int n=getInt();
		a=new int[n+1];
		b=new int[n+1];
		f=new int[n+1];
		ff=new int[n+1];
		visit=new boolean[n+1];
		for(int i=1;i<=n;i++)
		{
			a[i]=getInt();
			b[i]=getInt();
		}
		
		dfs();
		
		int max=0;
		for(int i=1;i<=n;i++)
			{
				if(a[i]>0)
					ff[i]+=f[a[i]]+1;
				if(b[i]>0)
					ff[i]+=f[b[i]]+1;
				if(ff[i]>max)
					max=ff[i];
			}
		
		out.println(max);
		out.flush();
		
	}
	
	
	public static void dfs()
	{
		Stack<Integer> stack=new Stack<>();
		stack.push(1);
		while(!stack.isEmpty())
		{
			int k=stack.peek();
			visit[k]=true;
			
			if(a[k]==0&&b[k]==0)
			{
				f[k]=0;
				stack.pop();
				continue;
			}
			
			if(a[k]>0&&!visit[a[k]])
			{
				stack.push(a[k]);
			}
			if(b[k]>0&&!visit[b[k]])
			{
				stack.push(b[k]);
			}
			
			if(visit[a[k]]&&visit[b[k]]||(b[k]==0&&visit[a[k]])||(a[k]==0&&visit[b[k]]))
			{
				if(f[a[k]]>f[b[k]])
					f[k]=f[a[k]]+1;
				else 
				{
					f[k]=f[b[k]]+1;
				}
				stack.pop();
			}
		}
	}
	
	
	public static int getInt() {  
        int read;  
        int res = 0;  
        boolean isNegative = false;
        try {  
            while ((read = reader.read()) != -1) {  
                if ((char) read == '-') {  
                    res = 0;  
                    isNegative = true;  
                    break;  
                } else if (isNumber((char) read)) {  
                    res = read - '0';  
                    break;  
                }  
            }  
            while ((read = reader.read()) != -1) {  
                char ch = (char) read;  
                if (isNumber(ch)) {  
                    res = res * 10 + (read - '0');  
                } else {  
                    break;  
                }  
            }  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
        if (isNegative == true) {  
            res = -1 * res;  
        }  
        return res;  
    }  
	
	
	 public static boolean isNumber(char ch) {  
	        if (ch <= '9' && ch >= '0') {  
	            return true;  
	        }  
	        return false;  
	    }  
}



wdlsjdl2
关注
关于(最长链)的模板题
CutieDeng的博客
10-19 1165
题目描述 Description 现给出一棵N个结点二叉树，问这棵二叉树中最长链的长度为多少，保证了1号结点为二叉树的根。 输入描述 Input Description 输入的第1行为包含了一个正整数N，为这棵二叉树的结点数，结点标号由1至N。 接下来N行，这N行中的第i行包含两个正整数l[i], r[i]，表示了结点i的左儿子与右儿子编号。如果l[i]为0，表示结点i没
Java实现 蓝桥杯VIP 算法训练 无权最长链
热门推荐
南 墙
04-23 1万+
试题 算法训练 无权最长链 问题描述 　　给定一个n节点m边的无圈且连通的图，求直径 输入格式 　　第一行两个数字n,m 　　接下来m行每行两个数字x,y,代表x,y之间有一条边 输出格式 　　要求用户的输出满足的格式。 　　例：输出1行，包含一个整数，表示矩阵中所有元素的和。 样例输入 一个满足题目要求的输入范例。 3 2 1 2 2 3 样例输出 与上面的样例输入对应的输出。 例： 2 数据规...
二叉树的最长链长度—DFS buaacoding 树形DP初步-二叉树
12-03 367
首先虽然这道题说的是树形DP的事情，但是其实本质上还是考察DFS的事情，说起深搜，自己的理解还是太浅了，一开始对这道题的理解是，默认题目里说的最长链说的是一定会经过俩个叶节点，但是不一定会经过根节点。但是实质上根节点不一定在最长链的通路上。而我一开始实现的操作还是利用了上学期的数据结构的利用递归实现求树的深度。 这个时候深搜的作用就被大大消减。深度优先搜索实质上是一种算法，一种思想，而...
二叉树中的最长路径_二叉树中最长的链
weixin_26705651的博客
08-22 672
二叉树中的最长路径A binary tree is a special type of graph where each parent node has exactly two child nodes. 二叉树是一种特殊类型的图，其中每个父节点正好有两个子节点。 Today’s puzzle, then, is to traverse the binary tree in order to fi...
最长链
weixin_30328063的博客
09-04 194
【题目描述】 现给出一棵N个结点二叉树，问这棵二叉树中最长链的长度为多少，保证1号结点为二叉树的根。 【输入描述】 输入的第1行包含一个正整数N，为这棵二叉树的结点数，结点标号为1~N； 接下来N行，第i行包含两个正整数L[i]、R[i]，表示了结点i的左儿子与右儿子编号。 如果L[i]=0，表示结点i没有左儿子，如果R[i]=0，则表示没有右儿子。 【输出描述】 ...
20191028 专题：基环树最长链
hongkongreporter
10-28 380
先上模板题 （黑的？？？） 自己 做的第一道 黑题，先祭一波~~~ 做了3h …毕竟我还是太弱了。 T1 P4381 [IOI2008]Island （洛谷P4381） 题目描述 你准备浏览一个公园，该公园由 NN 个岛屿组成，当地管理部门从每个岛屿 ii 出发向另外一个岛屿建了一座长度为LiL_iLi​的桥，不过桥是可以双向行走的。同时，每对岛屿之间都有一艘专用的往来两岛之间的渡船。相对于乘船而...
长链非编码RNA CCAT1通过调控miR-181a-5p促进肺癌细胞增殖和转移的机制.pdf
11-22
综上所述，该研究揭示了长链非编码RNA CCAT1通过直接调控miR-181a-5p的表达，进而影响肺癌细胞的增殖和转移，这一发现对于理解肺癌的发病机制以及寻找新的治疗靶点具有重要意义。未来的研究可能需要进一步探索CCAT1-...
音视频-编解码-p53相关的长链非编码RNA在肝细胞肝癌中的作用和机制研究彭传会.pdf
04-16
长链非编码RNA（Long non-coding RNA, lncRNA）是一种长度超过200个核苷酸的非编码RNA分子，它们并不编码蛋白质，但通过多种机制参与基因表达的调控。在肝细胞肝癌（Hepatocellular Carcinoma, HCC）中，lncRNA与...
最大半连通子图(tarjan缩点+拓扑排序+dp最长链)
qq_53504307的博客
07-14 315
之间可能存在多条边，所以我们需要另建图，使得两顶点之间只有一条边有向边关联，最终方可统计正确的。显然由于连通分量一定是半连通分量，所以我们可以通过。，否则会重复更新，因为两点之间存在多条边。将连通分量缩成一个点，从而将图转化为。个要求是求最大半连通子图的节点数。......
长链非编码RNA HOXA11-AS靶向miR-506-3p调控食管癌细胞增殖和凋亡的机制.pdf
11-23
【长链非编码RNA HOXA11-AS与miR-506-3p的相互作用】 长链非编码RNA（Long Non-Coding RNA, lncRNA）是一类长度超过200个核苷酸的非编码RNA分子，它们在生物体内发挥着多种生物学功能，包括基因表达调控、细胞分化...
HDU - 4607 Park Visit 求一个图中的最长链
扬帆起航
05-03 1512
Claire and her little friend, ykwd, are travelling in Shevchenko's Park! The park is beautiful - but large, indeed. N feature spots in the park are connected by exactly (N-1) undirected paths, and Cla
[BZOJ2404]最长链
UISG103的博客
07-20 1091
题目描述 给定一棵有n个节点的树，求每个节点到其他节点的最大距离 输入 输入第一行是一个自然数n(n≤10000), 接下来 (n−1) 行描述：  第i行包含两个自然数 , 表示编号为i的节点连接到的节点编号和这条网线的长度..距离总长不会超过10^9. 每行中的两个数字用空格隔开. 输出 输出包含n行. 第i行表示对于离编号为i的节点最远的节点与该节点的距离Si(1
Codevs 1814 最长链
weixin_30698297的博客
08-02 184
1814 最长链 时间限制: 1 s 空间限制: 256000 KB 题目等级 : 钻石 Diamond 题目描述 Description 现给出一棵N个结点二叉树，问这棵二叉树中最长链的长度为多少，保证了1号结点为二叉树的根。 输入描述 Input Description 输入的第1行为包含了一个正整数N，为这棵二叉树的结...
【SSL 1528】最长链(深搜)
m0_73647951的博客
05-07 127
现给出一棵N个结点二叉树，问这棵二叉树中最长链的长度为多少，保证了1号结点为二叉树的根。第1行为包含了一个正整数N，为这棵二叉树的结点数，结点标号由1至N。接下来N行，这N行中的第i行包含两个正整数l[i], r[i]，表示了结点i的左儿子与右儿子编号。如果l[i]为0，表示结点i没有左儿子，同样地，如果r[i]为0则表示没有右儿子。1个正整数，为这棵二叉树的最长链长度。
1814 最长链
weixin_33744854的博客
08-05 119
1814 最长链 时间限制: 1 s 空间限制: 256000 KB 题目等级 : 钻石 Diamond 题解 题目描述Description 现给出一棵N个结点二叉树，问这棵二叉树中最长链的长度为多少，保证了1号结点为二叉树的根。 输入描述Input Descr...
LeetCode104. 二叉树的最大深度和N叉树的最大深度
weixin_43553142的博客
09-25 392
给定一个二叉树（N叉树），找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。示例：给定二叉树 [3,9,20,null,null,15,7]，返回它的最大深度 3。来源：力扣（LeetCode）
Codevs P1814 最长链
Starlight
10-26 578
Codevs P1814 最长链题目描述 Description现给出一棵N个结点二叉树，问这棵二叉树中最长链的长度为多少，保证了1号结点为二叉树的根。输入输出 Input&Output输入描述 Input Description输入的第1行为包含了一个正整数N，为这棵二叉树的结点数，结点标号由1至N。 接下来N行，这N行中的第i行包含两个正整数l[i], r[i]，表示了结点i的左儿子与右儿子编
本实验设计用单链表实现两个有序表的合并 本实验要求： （1）：单链表中结点所描述的数据元素的类型为整形，可以随机生成，可以手动输入。 （2）：除了合并操作外，需要提供创建、销毁、输出的其他必须的基本操作。 #include<iostream> using namespace std; #include"lianbiao.h";其中 lianbiao.h如下 template <class DT> struct LNode //链表结点 { DT data; //数据域，存储数据元素值 LNode *next; //指针域，指向下一个结点 }; //算法2.1 template <class DT> bool PriorElem_e(LNode<DT> *L, DT e, DT &pre_e) // 求值为e的元素前驱 { int k; k=LocateElem_e(L,e); // 1.获取e的位序k if(k>1) // 2.位序k大于1 { GetElem_i(L,k-1,pre_e); // 第k-1个元素为e的前驱 return true; } else // 3.元素e无前驱 return false; // 返回false } //【算法2.14】 创建空单链表 template <class DT> bool InitList(LNode<DT> *&L) { L=new LNode<DT>; // 1.创建头结点 if(!L) exit(1); // 2.创建失败，退出 L->next=NULL; // 3.创建成功 return true; // 返回true } //【算法2.15】 尾插法创建n的元素 template <class DT> bool CreateList_1(LNode<DT> *&L,int n) { int i; LNode<DT> *p,*s; p=L; //1.工作指针初始化，指向尾结点 cout<<"依次输入"<<n<<"个数据元素："<<endl; for(i=1; i<=n;i++) // 2.按元素位序正序创建各结点 { s=new LNode<DT>; // 2.1 新建一个结点s if (!s) // 2.2 创建失败，返回false return false; cin>>s->data; // 2.3 输入结点值 s->next=p->next; // 2.4 s 链在表尾 p->next=s; p=s; // 2.5 工作指针指向 s } return true; // 3.创建成功，返回true } //【算法2.16】 头插法创建n个元素 template <class DT> bool CreateList_2(LNode<DT> *(&L),int n) { int i; LNode<DT> *s; cout<<"逆序输入"<<n<<"个数据元素："<<endl; for(i=1; i<=n;i++) // 1.按元素位序逆序创建各结点 { s=new LNode<DT>; // 1.1 新建一个结点 s if (!s) // 1.2 创建失败，返回false return false; cin>>s->data; // 1.3 输入结点值 s->next=L->next; // 1.4 s 在头结点后 L->next=s; } return true; // 1.创建成功，返回true } //【算法2.17】 template <class DT> void DestroyList(LNode<DT> *(&L)) // 释放链表所占空间 { LNode<DT> *p; while(L) // 1. 表非空,从头结点开始，依次释放结点 { p=L; // 1.1 处理表头结点 L=L->next; // 1.2 头指针后移 delete p; // 1.3 释放表头结点所占内存 } L=NULL; // 2.头指针指向空 } //【算法2.18】 获取第i个元素 template<class DT> bool GetElem_i(LNode<DT> *L,int i, DT &e) { LNode<DT> *p; // 1.初始化 p=L->next; // 1.1 设置工作指针，从首结点开始数结点 int j=1; // 1.2 计数器初始化 while(p&&j<i) // 2.定位到第i个元素结点 { p=p->next;j++; } if(!p ||j>i ) // 3 未找到，返回false return false; else // 4. 找到 { e=p->data; // 获取第i个元素值 return true; // 返回true } } //【算法2.19】 查找值为e的元素位序 template<class DT> int LocateElem_e(LNode<DT> *L, DT e) { LNode<DT> *p; // 1.初始化从首元开始查找 p=L->next; // 1.1从首元开始查找 int j=1; // 1.2 计数器初值 while(p && p->data!=e) // 2.顺序查找 { p=p->next; // 2.1未找到指针后移 j++; // 2.2 计数器增1 } if(p==NULL) // 3. 判断是否找到 return 0; // 3.1末找到，返回0 else return j; // 3.2 找到，返回位序 } //【算法2.20】 插入第i个元素 template<class DT> bool InsertElem_i(LNode<DT> *&L,int i, DT e) { int j=0; LNode<DT> *p; // 1.初始化 p=L; // 工作指针初始化 while(p && j<i-1) // 2. 定位到插入点前驱 { p=p->next; j++; } if(!p||j>i-1) // 3.判断定位是否成功： return false; // 3.1 定位失败，不能插入 else // 3.2 定位成功 { LNode<DT> *s; s=new LNode<DT>; // 3.2.1建立新结点 s->data=e; // 3.2.2新结点赋值 s->next=p->next; // 3.2.3结点S链接到p结点之后 p->next=s; return true; // 3.2.4 插入成功，返回true } } //【算法2.21】 删除第i个元素 template<class DT> bool DeleElem_i(LNode<DT> *(&L),int i) { LNode<DT> *p,*q; //1.初始化：设置工作指针 p=L; //查找从头结点开始 int j=0; //计数器初始化 while(p->next && j<i-1) //2.p定位到删除点的前驱 { p=p->next; j++; } if(!p->next||j>i-1) //3.删除位置不合理，不能删除 return false; //返回false else //4.删除操作 { q=p->next; //4.1暂存删除结点位置 p->next=q->next; //4.2从链表中摘除删除结点 delete q; return true; //4.3删除成功，返回true } } //【算法2.22】 修改第i个元素值 template<class DT> bool PutElem_i(LNode<DT> *(&L),int i, DT e) { LNode<DT> *p; // 1.初始化:设置工作指针 p=L->next; // 从首结点开始，数结点 int j=1; // 计数器初始化 while(p&&j<i) // 2.查找第i个元素结点 { p=p->next;j++; } if(!p||j>i) // 3.元素不存在,返回false return false; else // 4.定位成功 { p->data=e; // 修改元素值 return true; // 返回true } } // 释放链表所占空间 template<class DT> void ClearList(LNode<DT> *(&L)) { LNode<DT> *p; while(L->next) // 从首元结点开始，依次释放结点 { p=L->next; L->next=p->next; delete p; } cout<<endl<<"表已清空!"<<endl; } //【算法2.23】 测表长 template<class DT> int ListLength(LNode<DT> *L) { // 1.初始化 int len=0; // 1.1 结点计数器赋初值0 LNode<DT> *p; // 1.2设置工作指针 p=L; // 指向头结点 while(p->next) // 2.数结点个数。有后继结点， { len++;p=p->next; // 结点数增1，指针后移 } return len; // 3.返回表长 } // template<class DT> bool ListEmpty(LNode<DT> *L) //测表空 { if(L->next==NULL) return true; //空表，返回1 else return false; //不空，返回0 } //【算法2.24】 遍历表 template <class DT> void DispList(LNode<DT> *L) // 显示表内容 { LNode<DT> *p; // 1. 设置工作指针 p=L->next; // 从首元结点开始遍历 while(p) // 2.依次输出各结点值 { cout<<p->data<<"\t"; p=p->next; } cout<<endl; }请完善代码
最新发布
05-31
迭代方法更稳定，适合长链表。我需要选择一种并给出示例代码。同时，需要确保合并后的链表依然有序，时间复杂度为O(n+m)。然后，考虑代码的健壮性，比如处理空链表的情况，以及释放内存避免泄漏。用户之前的代码片段...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值