【PAT甲级笔记】树的题型以及对应解法

tips:

• 树类的问题，一般需要用到dfs并且，创建（结构体型）节点，

1053. Path of Equal Weight (30)

tip: sort排序的时候，对父节点排序…

#include<cstdio>
#include<algorithm>
#include<vector>

using namespace std;

struct Node
{
    int w;
    vector<int> child;
};

//define
int n,m,target,fat,k,temp;
vector<Node> v;
vector<int> path;

void dfs(int sum, Node d1)
{

    if(sum>target) return;
    if(sum == target)
    {
     if(d1.child.empty()==0)
            return;
     //print
     printf("%d", v[path[0]].w);
     for(int j=1;j<path.size();j++)
        printf(" %d",v[path[j]].w);
     printf("\n");
     return;
    }
    for (int i=0;i<d1.child.size();i++)
        {
            int index = d1.child[i];
            sum+=v[index].w;
            path.push_back(index);
            dfs(sum,v[index]);
            sum-=v[index].w;
            path.pop_back();
        }
    return;
}

int cmp(int d1, int d2)
{

    return v[d1].w > v[d2].w;
}
int main()
{
    scanf("%d%d%d", &n, &m, &target);
    v.resize(n);
    for(int i=0;i<n;i++)
        scanf("%d", &v[i].w);
    for(int i=0;i<m;i++)
    {
        scanf("%d%d", &fat, &k);
        for(int j=0;j<k;j++)
        {
            scanf("%d",&temp);
            v[fat].child.push_back(temp);
        }
        sort(v[fat].child.begin(),v[fat].child.end(),cmp);
    }
    path.push_back(0);
    dfs(v[0].w,v[0]);
    return 0;
}

1079 Total Sales of Supply Chain (25分)

tips:

• 递归调用传入的参数最好为int等，传入结构体会出现段错误，void dfs(Node d1, int depth). 具体原因并不是很清楚，大概是特别占用内存的时候会溢出吧…

---

2/11补充： 使用函数传入参数应该使用传入引用的方式，不然都会超时，不一定非要用索引，可以在void dfs(Node &d1, int depth)，这样也能过，而且鼓励推荐

• 当出现段错误时，可以注释掉一部分代码，如果提交后变成了答案错误，那说明注释代码为出问题的点。（如果提交后仍为段错误，则注释代码并不是错误点）

#include<cstdio>
#include<algorithm>
#include<vector>
#include<cmath>

using namespace std;

struct Node
{
    //int depth;
    vector<int> child;
    bool is_ch;
};

//define
vector<Node> point;
int n,k,index;
double p,r,sum;

void dfs(int d1, int depth)
{
    if(point[d1].is_ch ==0)
    {
        sum+= point[d1].child[0]*pow(r+1,depth)*p;
        return;
    }

    for(int i=0;i<point[d1].child.size();i++)
    {
        int index1 = point[d1].child[i];
        dfs(index1, depth+1);
    }


}



int main()
{
    //init
    scanf("%d%lf%lf", &n, &p, &r);
    r = r/100;
    point.resize(n+10);
    sum = 0.0;

    for(int i=0;i<n;i++)
    {
        scanf("%d", &k);
        if(k==0)
        {
            scanf("%d", &index);
            point[i].is_ch = 0;
            point[i].child.push_back(index);
        }
        else{
            for(int j=0;j<k;j++)
               {
                 scanf("%d", &index);
                 point[i].child.push_back(index);
                 point[i].is_ch=1;
               }
        }
    }
    dfs(0,0);
    printf("%.1f", sum);
    return 0;
}

1090 Highest Price in Supply Chain (25)

tips:

• vector 型的数组a[n]，n给-1，会发生段错误…
• 如果采用保存某个结点的父结点的下标的形式，然后一直遍历到根结点的深度/广度优先，会出现三个超时。因为从叶子结点往上遍历将会把所有路径都走一遍，很多都是重复走的路径，会超时，没有从根结点往下遍历的方式快～～

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

using namespace std;
int n,num,hlen,root;
float p,r,highest;

struct Node
{
    vector<int> pos;
    int depth;
};
vector<Node> tree;


void dfs(int length, int index)
{

    if(tree[index].pos.empty())
    {
        tree[index].depth=length;
        if(length > hlen)
        {
            hlen = length;
            num=1;
        }
        else if(length == hlen)
        {
            num++;
        }
        return;
    }
    for(int j=0;j<tree[index].pos.size();j++)
    {
        dfs(length+1, tree[index].pos[j]);
    }

}

int main()
{
    int temp;
    scanf("%d%f%f", &n, &p, &r);
    r=r/100;
    tree.resize(n);
    for(int i=0;i<n;i++)
       {
           scanf("%d", &temp);
           if(temp==-1) root=i;
           tree[temp].pos.push_back(i);
       }
    hlen = num = 0;
    dfs(0,root);
    highest = pow(1+r,hlen)*p;
    printf("%.2f %d\n",highest,num);
    return 0;
}