【无标题】

最新推荐文章于 2024-10-03 23:25:47 发布

2301_78501372

最新推荐文章于 2024-10-03 23:25:47 发布

阅读量90

点赞数

文章标签：数据结构算法

本文链接：https://blog.csdn.net/2301_78501372/article/details/132009069

版权

/ TopsCoding / 题库 /

对称二叉树

展开

题目描述

一棵有点权的有根树如果满足以下条件，则被轩轩称为 对称二叉树：

二叉树；
将这棵树所有节点的左右子树交换，新树和原树对应位置的结构相同且点权相等。

下图中节点内的数字为权值，节点外的 𝑖𝑑id 表示节点编号。

现在给出一棵二叉树，希望你找出它的一棵子树， 该子树为对称二叉树，且节点数最多。 请输出这棵子树的节点数。

注意：只有树根的树也是对称二叉树。本题中约定，以节点 𝑇T 为子树根的一棵“子树”指的是：节点 𝑇T 和它的全部后代节点构成的二叉树。

输入格式

输入文件名为 tree.in。
第一行一个正整数 𝑛n，表示给定的树的节点的数目，规定节点编号 1∼�1∼n，其中节点 11 是树根。

第二行 𝑛n 个正整数，用一个空格分隔，第 𝑖i 个正整数 𝑣𝑖vi 代表节点 𝑖i 的权值。

接下来 𝑛n 行，每行两个正整数 𝑙𝑖,𝑟𝑖li,ri，分别表示节点 𝑖i 的左右孩子的编号。如果不存在左 / 右孩子，则以 −1−1 表示。两个数之间用一个空格隔开。

输出格式

输出文件名为 tree.out。

输出文件共一行，包含一个整数，表示给定的树的最大对称二叉子树的节点数。

样例

输入数据#1

Copy

输出数据#1

Copy

解释#1

最大的对称二叉子树为以节点 2 为树根的子树，节点数为 1。

输入数据#2

10 
2 2 5 5 5 5 4 4 2 3 
9 10 
-1 -1 
-1 -1 
-1 -1 
-1 -1 
-1 2 
3 4 
5 6 
-1 -1 
7 8

Copy

输出数据#2

Copy

解释#2

最大的对称二叉子树为以节点 7 为树根的子树，节点数为 3。

数据范围

共 2525 个测试点。
𝑣𝑖≤1000vi≤1000。
测试点 1∼3，𝑛≤101∼3，n≤10，保证根结点的左子树的所有节点都没有右孩子，根结点的右子树的所有节点都没有左孩子。
测试点 4∼8，𝑛≤104∼8，n≤10。
测试点 9∼12，𝑛≤1059∼12，n≤105，保证输入是一棵“满二叉树”。
测试点 13∼16，𝑛≤10513∼16，n≤105，保证输入是一棵“完全二叉树”。
测试点 17∼20，𝑛≤10517∼20，n≤105，保证输入的树的点权均为 1。
测试点 21∼25，𝑛≤10621∼25，n≤106。

本题约定：

层次：节点的层次从根开始定义起，根为第一层，根的孩子为第二层。树中任一节点的层次等于其父亲节点的层次加 1。

树的深度：树中节点的最大层次称为树的深度。

满二叉树：设二叉树的深度为 ℎh，且二叉树有 2ℎ−12h−1 个节点，这就是满二叉树。

完全二叉树：设二叉树的深度为 ℎh，除第 ℎh 层外，其它各层的结点数都达到最大个数，第 ℎh 层所有的结点都连续集中在最左边，这就是完全二叉树。

考点：（树的遍历，二叉树，完全树）

题解：

思路:
先输入:

    scanf("%lld",&n);
    for(int i=1;i<=n;i++)
        scanf("%lld",&a[i].d);
    for(int i=1;i<=n;i++)
        scanf("%lld%lld",&a[i].l,&a[i].r);
//没啥好说的，根据题目即可

Copy

先用记忆化搜索跑一遍，记下各子树的总结点数
代码:

const int N=1e6+10;
struct tree
{int l,r,d;bool yz;}a[N];
int dp[N];int n;
inline int dfs(int cur)//求以cur为根节点的子树的节点数
{
    if(cur==-1)return 0;//空节点
    if(dp[cur])return dp[cur];//记忆化
    return dp[cur]=1+dfs(a[cur].l)+dfs(a[cur].r);//一棵树的节点数=1(自身)+左子树节点数+右子树节点数
}

Copy

加一个check函数，用于检查两棵子树是否对称

inline bool check(int cl,int cr)//检查cl和cr是否对称
{
    if(cl==-1&&cr==-1)return 1;//都为空对称
    if(cl==-1||cr==-1)return 0;//一个为空，一个不为空，不对称
    if(a[cl].d!=a[cr].d)return 0;//两点权值不等
    return(check(a[cl].l,a[cr].r)&&check(a[cl].r,a[cr].l));
    //满足前面的条件，且cl的左子树与cr的右子树对称，cl的右子树与cr的左子树对称，则称cl和cr对称
}

Copy

(之前的错误代码(check))52分

bool f[N];
/*
dp[cur]:以cur为根的子树节点个数
f[cur]:保存以cur为根的子树是否对称
*/
inline bool check(int cur)//检查以cur为根节点的子树是否对称
{
    if(cur==-1)return 0;//空节点
    if(a[cur].yz)return 1;//叶子
    if(f[cur])return f[cur];//记忆化
    int l=a[cur].l,r=a[cur].r;
    if(!dp[cur]%2)return 0;//左子树和右子树的和为奇数，两棵树的节点必不相等
    if(l==-1||r==-1)return 0;//只有一个儿子
    if(a[l].d!=a[r].d)return 0;//左儿子和右儿子的权值不相等
    if(dp[l]!=dp[r])return 0;//左子树和右子树的节点数不相等
    return f[cur]=(check(l)&&check(r));//左子树和右子树也对称
}
/*
错误点:
如
    O
   / \
  O   O
 /     \
O       O
这棵树其实是对称的，应比较两边<折叠(对称)>后重合的点是否一致
*/

Copy

然后循环一遍，以i为根的子树对称的话，就与max1比大小(子树的节点数)，更新max1，然后输出即可

    dfs(1);//dfs跑一遍
    int max1=1;//至少是一个节点
    for(int i=1;i<=n;i++)//以i为根节点
        if(dp[i]%2)//若子树的节点数不为奇数，i的左子树和右子树必不相等
        //一个小小的小优化
            if(check(a[i].l,a[i].r))//检查
                max1=max(max1,dp[i]);//求最值
    printf("%lld",max1);

Copy

然后就AC了!!!

总体代码:

/*This is ZJW's Code!!!*/
#include<bits/stdc++.h>
#pragma GCC optimize(2)//O2优化
#define int long long
//using namespace std;
const int N=1e6+10;
struct tree
{int l,r,d;bool yz;}a[N];
int dp[N];int n;
inline int dfs(int cur)//求以cur为根节点的子树的节点数
{
    if(cur==-1)return 0;//空节点
    if(dp[cur])return dp[cur];//记忆化
    return dp[cur]=1+dfs(a[cur].l)+dfs(a[cur].r);//一棵树的节点数=1(自身)+左子树节点数+右子树节点数
}
inline bool check(int cl,int cr)//检查cl和cr是否对称
{
    if(cl==-1&&cr==-1)return 1;//都为空对称
    if(cl==-1||cr==-1)return 0;//一个为空，一个不为空，不对称
    if(a[cl].d!=a[cr].d)return 0;//两点权值不等
    return(check(a[cl].l,a[cr].r)&&check(a[cl].r,a[cr].l));
    //满足前面的条件，且cl的左子树与cr的右子树对称，cl的右子树与cr的左子树对称，则称cl和cr对称
}
inline int max(int a,int b){return a>b?a:b;}//手写max函数
signed main()
{
    scanf("%lld",&n);
    for(int i=1;i<=n;i++)
        scanf("%lld",&a[i].d);
    for(int i=1;i<=n;i++)
        scanf("%lld%lld",&a[i].l,&a[i].r);
    dfs(1);//dfs跑一遍
    int max1=1;//至少是一个节点
    for(int i=1;i<=n;i++)//以i为根节点
        if(dp[i]%2)//若子树的节点数不为奇数，i的左子树和右子树必不相等
        //一个小小的小优化
            if(check(a[i].l,a[i].r))//检查
                max1=max(max1,dp[i]);//求最值
    printf("%lld",max1);
    fclose(stdin);
    fclose(stdout);
    return 0;
}

Copy

(自己先给自己不要脸地点个赞，嘿嘿嘿）

另一种做法：

#include<bits/stdc++.h>
using namespace std;

const int N = 1e6+5;
int n, ans, v[N], l[N], r[N], siz[N], op[N];

int dfs(int k)
{
    siz[k] = 1;
    if(l[k] != -1) siz[k] += dfs(l[k]);
    if(r[k] != -1) siz[k] += dfs(r[k]);
    return siz[k];
}

bool check(int x, int y)
{
    if(x==-1 && y==-1) return true;
    else if(x != -1 && y != -1)
    {
        if(v[x]==v[y])
            return check(l[x], r[y])&&check(r[x], l[y]);
        else
            return false;
    }
    return false;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n;
    for(int i = 1; i <= n; i++)
        cin >> v[i];
    for(int i = 1; i <= n; i++)
        cin >> l[i] >> r[i];
    dfs(1);
    for(int i = 1; i <= n; i++)
    {
        if(check(l[i], r[i]))
            ans = max(ans, siz[i]);
    }
    cout << ans;
    return 0;
}