第十一届蓝桥杯java b组省赛-简单理解 试题I:BST插入节点问题

问题描述

时间限制: 1.0s 内存限制: 512.0MB 本题总分：25 分
【问题描述】

给定一棵包含 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。

【样例输入】

4 3

0 10

1 0

1 20

3 30

【样例输出】

9

【评测用例规模与约定】

对于 60% 的评测用例，1 ≤ K ≤ N ≤ 100，0 ≤ W_{i} ≤ 200，且 W_{i} 各不相同。

对于所有评测用例，1 ≤ K ≤ N ≤ 10000，0 ≤ W_{i} ≤ 100000000，且 W_{i} 各不相同。

原文链接

解题思路

准备工作:

把节点抽象成一个类
属性包含:
id:节点的编号
parentId:父亲节点的编号
weight:权值
minValue:能改存的最大值
maxValue:能存的最小值

实现代码

import java.util.Scanner;

public class I {
     

	//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;
    }
}