UVa:10308 Roads in the North

这个题真的是胡乱想了个算法，然后WA了好多次，最后我找到了一组没过的数据，改了之后就AC了。。

图是一个无向无环图，其实就是一棵树。

百度到的题解用了dfs，递归每棵子树，答案可能是某两棵子树的和，最后返回一棵最长的子树。

我的思路类似于拓扑排序或者关键路径，其实原理都是一样的。从度为1的节点开始拓展，不断拓展出更长的路径。

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
#include <vector>
#include <map>
#include <stack>
#include <algorithm>
#define MAXN 10005
#define MOD 1000000007
#define INF 10000000
#define ll long long
using namespace std;
struct Edge
{
    int a,b,w;
    Edge(int x=0,int y=0,int z=0) :a(x),b(y),w(z) {}
};
int main()
{
    char str[100];
    while(gets(str))
    {
        vector<Edge> gl[MAXN];
        int from[MAXN]= {0},in[MAXN]= {0};
        int x=0,y=0,z=0,n=0;
        int dis[MAXN]= {0};
        int ans=0;
        if(strlen(str))
        {
            sscanf(str,"%d%d%d",&x,&y,&z);
            in[x]++;
            in[y]++;
            n=max(n,max(x,y));
            gl[x].push_back(Edge(x,y,z));
            gl[y].push_back(Edge(y,x,z));
            while(gets(str)&&strlen(str))
            {
                sscanf(str,"%d%d%d",&x,&y,&z);
                in[x]++;
                in[y]++;
                gl[x].push_back(Edge(x,y,z));
                gl[y].push_back(Edge(y,x,z));
                n=max(n,max(x,y));
            }
            stack<int> sk;
            for(int i=1; i<=n; ++i)
                if(in[i]==1)
                    sk.push(i);

            while(!sk.empty())
            {
                int gettop=sk.top();
                sk.pop();
                for(int i=0; i<gl[gettop].size(); ++i)
                {
                    int ed=gl[gettop][i].b,cost=gl[gettop][i].w;
                    if(from[gettop]==ed) continue;
                    ans=max(ans,dis[gettop]+cost+dis[ed]);//这句非常重要，加上这句才AC了。。
                    if(dis[gettop]+cost>dis[ed])
                    {

                        dis[ed]=dis[gettop]+cost;
                        from[ed]=gettop;
                    }
                    in[ed]--;
                    if(in[ed]==1) sk.push(ed);
                }
            }
        }

        printf("%d\n",ans);
    }
    return 0;
}

 

递归写法

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
#include <vector>
#include <map>
#include <stack>
#include <algorithm>
#define MAXN 10005
#define MOD 1000000007
#define INF 10000000
#define ll long long
using namespace std;
struct Edge
{
    int a,b,w;
    Edge(int x=0,int y=0,int z=0) :a(x),b(y),w(z) {}
};
int ans,n;
int dfs(int node,int father,vector<Edge> gl[])
{
    int maxn=0;
    for(int i=0; i<gl[node].size(); ++i)
    {
        int ed=gl[node][i].b,cost=gl[node][i].w;
        if(ed==father) continue;
        int val=dfs(ed,node,gl)+cost;
        ans=max(ans,maxn+val);
        maxn=max(maxn,val);
    }
    return maxn;
}
int main()
{
    char str[100];
    while(gets(str))
    {
        vector<Edge> gl[MAXN];
        int x=0,y=0,z=0;
        int dis[MAXN]= {0};
        n=ans=0;
        if(strlen(str))
        {
            sscanf(str,"%d%d%d",&x,&y,&z);
            n=max(n,max(x,y));
            gl[x].push_back(Edge(x,y,z));
            gl[y].push_back(Edge(y,x,z));
            while(gets(str)&&strlen(str))
            {
                sscanf(str,"%d%d%d",&x,&y,&z);
                gl[x].push_back(Edge(x,y,z));
                gl[y].push_back(Edge(y,x,z));
                n=max(n,max(x,y));
            }

        }
        dfs(1,-1,gl);
        printf("%d\n",ans);
    }
    return 0;
}