L2-012 关于堆的判断 (25分) java

将一系列给定数字顺序插入一个初始为空的小顶堆H[]。随后判断一系列相关命题是否为真。命题分下列几种：

• x is the root：x是根结点；
• x and y are siblings：x和y是兄弟结点；
• x is the parent of y：x是y的父结点；
• x is a child of y：x是y的一个子结点。

输入格式：

每组测试第1行包含2个正整数N（$\le$ 1000）和M（$\le$ 20），分别是插入元素的个数、以及需要判断的命题数。下一行给出区间$[-10000,10000]$内的N个要被插入一个初始为空的小顶堆的整数。之后M行，每行给出一个命题。题目保证命题中的结点键值都是存在的。

输出格式：

对输入的每个命题，如果其为真，则在一行中输出T，否则输出F。

输入样例：

5 4
46 23 26 24 10
24 is the root
26 and 23 are siblings
46 is the parent of 23
23 is a child of 10

    
    
    
    

      
     
        
      
      
      
     
    
    
    
    
    

输出样例：

F
T
F
T

    
    
    
    

      
     
        
      
      
      
     
    
    
    
    
    

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.regex.Pattern;

import javax.management.monitor.Monitor;


//** Class for buffered reading int and double values *//*
class Reader {
	static BufferedReader reader;
	static StringTokenizer tokenizer;

	// ** call this method to initialize reader for InputStream *//*
	static void init(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	// ** get next word *//*
	static String next() throws IOException {
		while (!tokenizer.hasMoreTokens()) {
			// TODO add ceck for eof if necessary
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}
	static boolean hasNext()throws IOException {
		return tokenizer.hasMoreTokens();
	}
	static String nextLine() throws IOException{
		return reader.readLine();
	}
	static char nextChar() throws IOException{
		return next().charAt(0);
	}
	static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}
	static long nextLong() throws IOException {
		return Long.parseLong(next());
	}
	static float nextFloat() throws IOException {
		return Float.parseFloat(next());
	}
	static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
	static void close() throws IOException {
		reader.close();
	}
}
class Writer{
	static BufferedWriter writer;
	static void init(OutputStream outputStream) {
		writer = new BufferedWriter(new OutputStreamWriter(outputStream));
	}
	static void print(Object object) throws IOException {
		writer.write(object.toString());
	}
	static void println(Object object) throws IOException {
		writer.write(object.toString());
		writer.write("\n");
	}
	static void close() throws IOException {
		// TODO Auto-generated method stub
		writer.close();
	}
}
public class Main {
	
	public static void main(String[] args) throws IOException {
		Reader.init(System.in);
		Writer.init(System.out);
		solve();
		Reader.close();
		Writer.close();
	}
	static int[]heap;
	static int size;
	private static void solve() throws IOException {
		int n = Reader.nextInt();
		int m = Reader.nextInt();
		heap = new int[1005];
		create();
		for (int i = 0; i < n; i++) {
			int x = Reader.nextInt();
			insert(x);
		}
		for (int i = 0; i < m; i++) {
			String s = Reader.nextLine();
			String[]t = s.split(" ");
			if (s.contains("is the root")) {
				if (Integer.parseInt(t[0])==heap[1]) {
					Writer.println("T");
				}else {
					Writer.println("F");
				}
			}else if(s.contains("are siblings")) {
				int x = Integer.parseInt(t[0]);
				int y = Integer.parseInt(t[2]);
				if (search(x)/2 == search(y)/2) {
					Writer.println("T");
				}else {
					Writer.println("F");
				}
			}else if(s.contains("is the parent of")) {
				int x = Integer.parseInt(t[0]);
				int y = Integer.parseInt(t[5]);
				if (search(x)==search(y)/2) {
					Writer.println("T");
				}else {
					Writer.println("F");
				}
			}else if(s.contains("is a child of")) {
				int x = Integer.parseInt(t[0]);
				int y = Integer.parseInt(t[5]);
				int ix = search(x);
				int iy = search(y);
				if (ix == iy*2||ix == iy*2+1) {
					Writer.println("T");
				}else {
					Writer.println("F");
				}
			}
			
		}
	}
	static void create() {
		size = 0;
		heap[0] = -100005;
	}
	private static void insert(int x) {
		int i ;
		for (i = ++size; heap[i/2] > x; i/=2) {
			heap[i] = heap[i/2];
		}
		heap[i] = x;
	}
	static int search(int data) {
		for (int i = 0; i < heap.length; i++) {
			if (heap[i]==data) {
				return i;
			}
		}
		return -1;
	}
}