PAT1015 Reversible Primes 23 测试点问题

代码

// An highlighted block
#include<iostream>
#include<vector>
#include<set>
#include<algorithm>
using namespace std;
bool tree[10004][10004];
int num_tree[10004];
int dp[10004][10004];
int n;
int findDp(int i,int j){
    if(dp[i][j]!=0){
        return dp[i][j];
    }
    int max_num=0;
    for (size_t k = 1; k <=n; k++)
    {
        if(tree[j][k]==true&&k!=i){
            max_num=max(findDp(j,k)+1,max_num);
        }
    }
    dp[i][j]=max_num;
    return dp[i][j];
}
void dfs(int begin,bool* mark){
    mark[begin]=true;
    for(int j=1;j<=n;j++){
        if (tree[begin][j]==true&&mark[j]==false)
        {
            dfs(j,mark);
        }
    }
    return ;
}
void dfsDp(int begin,bool* mark){
    mark[begin]=true;
    for(int j=1;j<=n;j++){
        if (tree[begin][j]==true&&mark[j]==false)
        {
            // 遍历到每一条边
            // 所以可以计算dp
            findDp(begin,j);
            dp[begin][0]=max(dp[begin][0],dp[begin][j]);
            findDp(j,begin);
            dp[j][0]=max(dp[j][0],dp[j][begin]);
            dfsDp(j,mark);
        }
    }
    return ;
}
void init(){
    for (size_t i = 1; i <= n; i++)
    {
        for(int j=1;j<=n;j++){
            if(tree[i][j]==true&&num_tree[j]==1){
                dp[i][j]=1;
            }
        }
    }
}

int main(){

    cin>>n;
    int a,b;
    for (size_t i = 0; i < n-1; i++)
    {
        cin>>a>>b;
        tree[a][b]=tree[b][a]=true;
        num_tree[a]++;
        num_tree[b]++;
    }


    bool mark[10004]={false};
    int num=0;
    for (size_t i = 1; i <= n; i++)
    {
        if(mark[i]==false){
            num++;
            dfs(i,mark);
        }
    }
    if(num!=1){
        printf("Error: %d components",num);
        return 0;
    }
    init();
    fill(mark,mark+10004,false);
    dfsDp(1,mark);
    int max_deepth=0;
    vector<int> indexs;
    for (size_t i = 1; i <=n; i++)
    {
        if(dp[i][0]==max_deepth){
            indexs.push_back(i);
        }
        if(dp[i][0]>max_deepth){
            max_deepth=dp[i][0];
            indexs.clear();
            indexs.push_back(i);
        }
        
    }
    for (size_t i = 0; i < indexs.size(); i++)
    {
        cout<<indexs[i]<<endl;
    }
    
    return 0;
}

思路

使用动态规划的方法，内存，时间都没超，但是第三个测试点报错内存超限，应该是出现了一个循环跳不出来，最后23分