1090 Highest Price in Supply Chain 甲级 xp_xht123

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

解题思路：使用dfs，记录最大深度和该深度的节点个数，存数据的时候需要注意，使用vector的二维数组去存储与根相连的每一个节点，如果在dfs的时候遍历完整个数组，也就是将每一个节点又走了一遍，有三个测试点是超时的，因此使用vector去存每一个节点和根的联通情况，可以做到一定的化简。通过样例，我们可以发现最后一层的节点不会在数组中出现，那么就可以使用hasp存储每一个节点的出现次数，只要是0次出现的一定就是最后一层。

超时的dfs

void dfs(int u , int depth)
{
    bool flag = true;
    for(int i = 0;i < n;i ++)
    {
        if(u == a[i])
        {
            flag = false;
            break;
        }
    }
    if(flag)
    {
        if(depth > max_depth) 
        {
            max_depth = depth;
            cnt = 1;
        }
        else if(depth == max_depth) cnt ++;
    }
    
    for(int i = 0;i < n;i ++)
    {
        if(a[i] == u) dfs(i , depth + 1);
    }
}

化简后的dfs

void dfs(int u , int depth)
{
    //或者是v[u].size() == 0;
    //时间复杂度都是O(1)
    if(!hasp[u])
    {
        if(depth > max_depth) 
        {
            max_depth = depth;
            cnt = 1;
        }
        else if(depth == max_depth) cnt ++;
    }
    
    /*
    不能全部遍历一遍
    for(int i = 0;i < n;i ++)
    {
        if(a[i] == u) dfs(i , depth + 1);
    }
    */
    
    for(int i:v[u])
        dfs(i , depth + 1);
}

完整代码：

#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>

using namespace std;
const int N = 1e5 + 10;

int n;
int max_depth = -1;
int cnt = 0;
int a[N];
double p , r;
int hasp[N] = {0};
vector<int>v[N];
/*
//运行超时
void dfs(int u , int depth)
{
    bool flag = true;
    for(int i = 0;i < n;i ++)
    {
        if(u == a[i])
        {
            flag = false;
            break;
        }
    }
    if(flag)
    {
        if(depth > max_depth) 
        {
            max_depth = depth;
            cnt = 1;
        }
        else if(depth == max_depth) cnt ++;
    }
    
    for(int i = 0;i < n;i ++)
    {
        if(a[i] == u) dfs(i , depth + 1);
    }
}
*/
void dfs(int u , int depth)
{
    //或者是v[u].size() == 0;
    //时间复杂度都是O(1)
    if(!hasp[u])
    {
        if(depth > max_depth) 
        {
            max_depth = depth;
            cnt = 1;
        }
        else if(depth == max_depth) cnt ++;
    }
    
    /*
    不能全部遍历一遍
    for(int i = 0;i < n;i ++)
    {
        if(a[i] == u) dfs(i , depth + 1);
    }
    */
    
    for(int i:v[u])
        dfs(i , depth + 1);
}

int main()
{
    cin >> n >> p >> r;
    r /= 100;
    int root = 0;
    for(int i = 0;i < n;i ++) 
    {
        cin >> a[i];
        if(a[i] == -1) root = i;
        if(a[i] != -1) 
        {
            v[a[i]].push_back(i);
            hasp[a[i]] ++;
        }
    }
    
    dfs(root , 0);
    
    printf("%.2lf %d" , p * pow((1 + r) , max_depth) , cnt);
    return 0;
}