PAT 甲级 1090 Highest Price in Supply Chain

A supply chain is a network of retailers（零售商）, distributors（经销商）, and suppliers（供应商）-- everyone involved in moving a product from supplier to customer.

Starting from one root supplier, everyone on the chain buys products from one's supplier in a price P and sell or distribute them in a price that is r% higher than P. It is assumed that each member in the supply chain has exactly one supplier except the root supplier, and there is no supply cycle.

Now given a supply chain, you are supposed to tell the highest price we can expect from some retailers.

Input Specification:

Each input file contains one test case. For each case, The first line contains three positive numbers: N (≤105), the total number of the members in the supply chain (and hence they are numbered from 0 to N−1); P, the price given by the root supplier; and r, the percentage rate of price increment for each distributor or retailer. Then the next line contains N numbers, each number Si​ is the index of the supplier for the i-th member. Sroot​ for the root supplier is defined to be −1. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print in one line the highest price we can expect from some retailers, accurate up to 2 decimal places, and the number of retailers that sell at the highest price. There must be one space between the two numbers. It is guaranteed that the price will not exceed 1010.

Sample Input:

9 1.80 1.00
1 5 4 4 -1 4 5 3 6

Sample Output:

1.85 2

题意：

        供应商（根节点）和经销商（非叶子结点的子节点）和零售商（叶子结点），形成一条供应链，这个供应链是一棵树，每经过一个经销商和零售商价格就会上升r%,给出结点个数，原价，和价格上升百分比，下面一行再给出每个结点的经销商或供应商是谁（即父节点），要求出零售商卖出的最大价格是多少，这样的价格有几个？

思路：DFS遍历每一条路径，比对找出最大价格，有一条这样的路径数量就+1。

代码：
 

//这种编号和结点对应的树，用数组静态建树比较方便; 
#include<iostream>
#include<cmath>
#include<vector>
using namespace std;
int n,root,num=0,maxdepth=0,father;
double p,r;
const int maxn=1e5+10;
vector<int > node[maxn];//存放父节点和其子节点的下标;;

void DFS(int index, int depth){
	if(node[index].size()==0){//到达叶子结点，index作为父节点下没有孩子，即叶子结点，完成一条路线的遍历就判断一次; 
		if(depth>maxdepth){
			maxdepth=depth;
			num=1;
		}else if(depth==maxdepth){
			num++;
		}
		return ;
	}
	for(int i=0;i<node[index].size();i++){
		DFS(node[index][i],depth+1);//遍历index结点下的子节点，子节点的深度是父节点的深度+1; 
		//递归式; 
	} 
} 

int main( ){
	scanf("%d%lf%lf",&n,&p,&r);//有n个结点，供应商的价格是p,每经过一个经销商的价格上涨r%;
	r/=100;
	for(int i=0;i<n;i++){//si是下标为i的结点的供应商的编号，即是其父节点的编号； 
		scanf("%d",&father);//结点i的父节点下标;
		if(father!=-1){
			node[father].push_back(i);
		}else {//==-1没有父结点，说明是根节点; 
			root=i; 
		} 
	}
	DFS(root,0);//根节点的深度为0；
	printf("%.2f %d",p*pow(1+r,maxdepth),num);//深度多一层就要涨价百分之r； 
	return 0;
}