ural(Timus) 1463. Happiness to People!

树DP

题意：输入n和m，表示n个城市，m条无向边，下面一行n个数字，表示每个城市的权值，下面m行是每条边的信息，u，v，w，顶点和边权。问你从一个城市出发，走出一条路线，使得权值和最大，权值和包括这条路线上城市的权值和边的权值和。

题中有一句话出卖了它是个树DP：It turned out that if Petrovich can fly (using one or several flights) from town i to town j, then there is exactly one way to do this.

从一个顶点去另一个顶点如果连通的话只有一条路径，说明这个无向图其实是个无根树，所以又变成了经典问题，在无根树中找两点使它们的路径最长，不过这里要加上点的权值而已，是一样的，另外一个点是要记录路径的，输出路径中经过了多少个点，并且沿路径输出每一个点，如果有多条路径任意一条即可

DP思路不说了，可以找前面的题解里面有详细的讲解，说说输出路径。我是分两部分来输出路径的，根到叶子的最大值为一个部分，到叶子的次大值是另一个部分，根据路径输出的要求，前面部分要递归输出，或者可以用一个栈保存，比较懒就用了stl的stack来保存路径，后面的部分不用递归，直接迭代下去，但是为了统计点的个数所以先保存，用了stl的queue来保存路径

整个题目其实不难，注意细节即可

#include <cstdio>
#include <cstring>
#include <utility>
#include <vector>
#include <stack>
#include <queue>
#include <algorithm>
using namespace std;
#define N 50010

typedef long long ll;
typedef pair<ll,ll> pll;
bool vis[N];
vector<pll>a[N];
stack<int>s;
queue<int>q;
ll val[N];
ll dp[N][2];
ll ans;
int n,m,root;
int p[N][2];

void input()
{
    for(int i=0; i<=n; i++) 
        a[i].clear();
    for(int i=1; i<=n; i++) 
        scanf("%lld",&val[i]);
    for(int i=0; i<m; i++)
    {
        int u,v,w;
        pll tmp;
        scanf("%d%d%d",&u,&v,&w);
        tmp.first=v; tmp.second=w; a[u].push_back(tmp);
        tmp.first=u; tmp.second=w; a[v].push_back(tmp);
    }
}

void dfs(int rt)
{
    vis[rt]=true;
    dp[rt][1]=dp[rt][0]=0; 
    p[rt][1]=p[rt][0]=-1;

    int size=a[rt].size();
    for(int i=0; i<size; i++)
    {
        pll tmp = a[rt][i];
        int v = tmp.first;
        int w = tmp.second;
        if(!vis[v])
        {
            dfs(v);
            if(dp[v][1] + w >= dp[rt][1])
            {
                dp[rt][0] = dp[rt][1];
                p[rt][0] = p[rt][1];
                dp[rt][1] = dp[v][1]+w;
                p[rt][1] = v;
            }
            else if(dp[v][1] + w > dp[rt][0])
            {
                dp[rt][0] = dp[v][1] + w;
                p[rt][0] = v;
            }
        }
    }

    dp[rt][1] += val[rt];
    dp[rt][0] += val[rt];
    if( dp[rt][1]+dp[rt][0]-val[rt] > ans)
    {
        root=rt;
        ans = dp[rt][1]+dp[rt][0]-val[rt];
    }
}

int Path1(int rt)
{
    int cc=1;
    int u;
    while(!s.empty()) s.pop();
    s.push(rt);
    for(u=p[rt][1]; u!=-1; u=p[u][1])
    {
        s.push(u);
        cc++;
    }
    return cc;
}

int Path2(int rt)
{
    int cc=0;
    int u;
    while(!q.empty()) q.pop();
    for(u=p[rt][0]; u!=-1; u=p[u][1])
    {
        q.push(u);
        cc++;
    }
    return cc;
}

void solve()
{
    memset(vis,false,sizeof(vis));
    memset(p,-1,sizeof(p));
    ans=-1;   
    /*
    初始化为
    ans=0;
    root=1; //不要初始化为0
    */
    for(int i=1; i<=n; i++)
        if(!vis[i])
            dfs(i);
    printf("%lld\n",ans);

    int c1=Path1(root);
    int c2=Path2(root);
    printf("%d\n",c1+c2);

    while(!s.empty())
    {
        int t=s.top();
        s.pop();
        if(t!=root) printf("%d ",t);
        else        printf("%d",t);
    }
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        printf(" %d",t);
    }
    printf("\n");
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        input();
        solve();
    }
    return 0;
}