POJ 1985

我原本的思路是两次BFS

第一次：从任意点出发，到最远点，几位A

第二次：从A出发，到最远点

提交跑了1900ms+，，，，忽然看到蛋神141ms过的。。。

然后想估计是算法的问题

先贴我的代码

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
#define MAXV 50000
#define MAXE 100000

typedef struct{
	int end, weight, next;
}Edge;
Edge edges[MAXE];

int n, m;
int enumber, head[MAXV], record[MAXV];

int bfs(int s, int flag)
{
	int temp = 0, tempi = s;
	queue<int> q;
	memset(record, -1, sizeof(record));
	record[s] = 0;
	q.push(s);

	while(!q.empty()){
		int v = q.front(); q.pop();
		for(int i = head[v]; i != -1; i = edges[i].next){
			int to = edges[i].end;
			if(record[to] == -1){
				record[to] = record[v] + edges[i].weight;
				if(record[to] > temp){
					temp = record[to];
					tempi = to;
				}
				q.push(to);
			}
		}
	}
	return flag ? tempi : temp;
}

void addedge(int start, int end, int weight)
{
	edges[enumber].end = end;
	edges[enumber].weight = weight;
	edges[enumber].next = head[start];
	head[start] = enumber++;
}

int main()
{
	memset(head, -1, sizeof(head));

	int temps, tempe, templ;
	char d;
	cin >> n >> m;
	for(int i = 1; i <= m; i++){
		cin >> temps >> tempe >> templ >> d;
		addedge(temps, tempe, templ);
		addedge(tempe, temps, templ);
	}

	int a = bfs(1, 1);
	cout << bfs(a, 0) << endl;
}

然后是蛋神的：

树DP， DFS

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
#include <ctime>
using namespace std;
#define maxe 110000
#define maxn 50050
struct edge
{
	int v,nxt,l;
};edge e[maxe<<1];
int n,m,cnt,first[maxn],dp[maxn],ans;
void addedge(int u,int v,int l)
{
	e[cnt].v = v;	e[cnt].l = l;
	e[cnt].nxt = first[u];	first[u] = cnt++;
}
void input()
{
	int i,u,v,l;
	char ch;
	memset(first,-1,sizeof(first));
	cnt = 0;
	for ( i=1 ; i<=m ; i++ )
	{
		scanf("%d %d %d %c",&u,&v,&l,&ch);
		addedge(u,v,l);
		addedge(v,u,l);
	}
}
void dfs(int cur,int fa)
{
	int i,v;
	for ( i=first[cur] ; i!=-1 ; i=e[i].nxt )
	if (e[i].v != fa)
	{
		v = e[i].v;
		dfs(v,cur);
		ans = max(ans,dp[cur] + dp[v] + e[i].l);
		dp[cur] = max(dp[cur],dp[v]+e[i].l);
	}
}
int main()
{
	while (scanf("%d%d",&n,&m)!=EOF)
	{
		input();
		ans = 0;
		dfs(1,0);
		printf("%d\n",ans);
	}
	return 0;
}

既然看到了神级代码，我当然要敲一遍，顺便改成我更熟悉的C++

可提交后发现时间仍是近2000ms，，，，，

于是意识到时语言本身的问题。。。

先贴改后代码：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
#define MAXE 110000
#define MAXN 50050

typedef struct{
	int v, next, l;
}edge;
edge edges[MAXE<<1];

int n, m, cnt;
int ans;
int first[MAXN], dp[MAXN];

void addedge(int u, int v, int l)
{
	edges[cnt].v = v;
	edges[cnt].l = l;
	edges[cnt].next = first[u];
	first[u] = cnt++;
}

void input()
{
	int i, u, v, l;
	char c;
	memset(first, -1, sizeof(first));
	cnt = 0;

	for(int i = 1; i <= m; i++){
		cin >> u >> v >> l >> c;
		addedge(u, v, l);
		addedge(v, u, l);
	}
}

void dfs(int cur, int fa)
{
	int i, v;
	for(i = first[cur]; i != -1; i = edges[i].next)
		if(edges[i].v != fa){//no back
			v = edges[i].v;
			dfs(v, cur);
			ans = max(ans, dp[cur] + dp[v] + edges[i].l);
			dp[cur] = max(dp[cur], dp[v] + edges[i].l);
		}
}

int main()
{
	while(cin >> n >> m){
		input();
		ans = 0;
		dfs(1, 0);
		cout << ans << endl;
	} 
	
	return 0;
}

应该可以看到，，不同的仅仅是读入和输出。

估计就是那里的问题。

然后我又把我最开始的两次BFS的代码的 iostream  改成C语言的。

果然，，，151ms过。。。

更好的封装，意味着更方便的编写，也意味着效率的降低。

以前也知道C++没C语言效率，可没想到竟然如此明显。

仅仅改一个读入输出就可以从近2000ms降到150ms。。。。