2021/4/9算法题打卡-BSF插入节点问题

BFS插入节点问题

题目

给定一棵包含 N 个节点的二叉树，节点编号是 1 ∼ N。其中 i 号节点具有权值 W_{i}，并且这些节点的权值恰好形成了一棵排序二叉树 (BST)。

现在给定一个节点编号 K，小明想知道，在这 N 个权值以外，有多少个整数 X (即 X 不等于任何 W_{i} ) 满足：给编号为 K 的节点增加一个权值为 X 的子节点，仍可以得到一棵 BST。

例如在下图中，括号外的数字表示编号、括号内的数字表示权值。即编号 1 ∼ 4 的节点权值依次是 0、10、20、30。

如果 K = 1，那么答案为 0。因为 1 号节点已经有左右子节点，不能再增加子节点了。

如果 K = 2，那么答案为无穷多。因为任何一个负数都可以作为 2 的左子节点。

如果 K = 3，那么答案为 9。因为 X = 11, 12, · · · , 19 都可以作为 3 的左子节点。

【输入格式】

第一行包含 2 个整数 N 和 K。

以下 N 行每行包含 2 个整数，其中第 i 行是编号为 i 的节点的父节点编号 Pi 和权值 W_{i} 。注意 Pi = 0 表示 i 是根节点。

输入保证是一棵 BST。

【输出格式】
一个整数代表答案。如果答案是无穷多，输出 −1。
/
/
我们可以在创建这颗树的时候就将他的可添加范围找好

分析

通过内部类来装节点数据，我们可以在创建节点的时候就直接分析出节点能插入的范围

代码

package com.blueBrageCup.B2020;

import java.util.Scanner;

/**
 * @auther thk
 * @date 2021/4/9 - 16:11
 */

public class T9BST插入节点问题 {

    //MAX表示无穷大
    static int  MAX=Integer.MAX_VALUE;
    //MAX表示无穷小
    static int MIN=Integer.MIN_VALUE;
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int N=input.nextInt();
        int K=input.nextInt();
        INode[]nodes=new INode[N];

        for (int i = 0; i <N ; i++) {
            int parentId=input.nextInt();
            int weight=input.nextInt();
//第一个节点比较特殊,它的父节点是不存在的,并且它的左右节点都能填到无穷
            if(i==0){
                nodes[0]=new INode(1,parentId,weight,MIN,MAX);
            }else{//其他节点的操作
                int min=0;
                int max=0;
                INode parent=nodes[parentId-1];
                //新的节点会成为改父亲节点的右节点
                //更新新节点的max和min值
                if(weight>parent.weight){
                    //该节点能保存的最小值应该,比父亲节点的权值大1
                    min=parent.weight+1;
                    //该节点能保存的最小值继承父亲节点能保存的最大值
                    max=parent.maxValue;
                    //将父亲节点能保存的最大值变成它的权值,表示不能再加东西了
                    parent.maxValue=parent.weight;
                }else{//添加左子节点
                    //类似上边更新max和min的步骤
                    max=parent.weight-1;
                    min=parent.minValue;
                    parent.minValue=parent.weight;
                }
                nodes[i]=new INode(i+1,parentId,weight,min,max);
            }
        }

        //如果有一个值为MIN或MAX就说明该节点可以添加无穷多的数
        if(nodes[K-1].minValue==MIN||nodes[K-1].maxValue==MAX){
            System.out.println(-1);
        }else{
            System.out.println(nodes[K-1].maxValue-nodes[K-1].minValue);
        }

    }
}

class INode{
    int id;
    int parentId;
    int weight;
    int minValue;
    int maxValue;

    public INode(int id,int parentId, int weight, int minValue, int maxValue) {
        this.id=id;
        this.parentId = parentId;
        this.weight = weight;
        this.minValue = minValue;
        this.maxValue = maxValue;
    }

}