蓝桥杯练习——大臣的旅费

题目如下：

说是说求路费，但是实际上还是求最短路径值，可以使用BFS，这是一个递归算法：

#include<iostream>
#include<string.h>
#define MAXSIZE 1003
using namespace std;

int map[MAXSIZE][MAXSIZE] ;//定义邻阶矩阵
int km, n, sum, maxsum;
char mark[MAXSIZE];//判断该地是否已经经过的散列

//用于计算路费的函数
//km1代表到当前点的路程
//k则是当前点的“下一跳”距离
int money(int km1, int k)
{
	int sum = 0;
	for (int i = km1 + 1; i <= k + km1; i++)
		sum += i + 10;
	return sum;
}

//返回上一点（路费、路程）的函数
//s是当前路费，k是当前路程
void back(int s, int k)
{
	sum -= s;
	km -= k;
}

//s是vertex值，即城市的编号
//bs是路费数，bk是路程数
void dfs(int s, int bs, int bk)
{
	for (int i = 1;i <= n; i++)
	{
		if (map[s][i] && !mark[i])
		{
			mark[i] = 1;
			int j = money(km, map[s][i]);
			sum += j;
			km += map[s][i];
			dfs(i, j, map[s][i]);
		}
	}
	if (sum > maxsum)maxsum = sum;
	back(bs, bk);
}

int main(void)
{
	//初始化基本变量
	int j, k;
	cin >> n;
	memset(map, 0, (n + 1)*MAXSIZE);
	memset(mark, 0, n + 1);

	//初始化邻接表
	for (int i = 1; i < n; i++)
	{
		cin >> j >> k;
		cin >> map[j][k];
		map[k][j] = map[j][k];
	}

	maxsum = 0;

	//主要功能区
	for (int i = 1; i <= n; i++)
	{
		sum = km = 0;
		memset(mark, 0, n + 1);
		mark[i] = 1;
		dfs(i, 0, 0);
	}

	cout << maxsum << endl;
	system("pause");
	return 0;
}

 结果只有75，没能够AC，于是尝试了非递归法，这回成功AC了。估计递归算法复杂度太高了：

#include<iostream>
#include<queue>
#define N 10000
using namespace std;

typedef struct Edge
{
	int v;//点的vertex值
	int info;//边的权值
	struct Edge* next;//连接下个点的next指针
} Edge;

Edge head[N];
int n, sum;
int D[N];
bool visited[N];
queue<int> q;

int bfs_2() 
{
	int _head = 0, _tail = 0;
	q.push(1);
	visited[1] = 1;
	while (!q.empty()) 
	{
		int v = q.front();
		q.pop();
		for (Edge* i = head[v].next; i; i = i->next)
		{
			if (!visited[i->v]) 
			{
				D[i->v] = D[v] + (i->info);
				q.push(i->v);
				visited[i->v] = 1;
			}
		}
	}
	fill(visited, visited + n + 1, 0);
	int max = D[1], index = 1;
	for (int i = 2; i <= n; i++)
		if (max < D[i]) 
		{
			max = D[i];
			index = i;
		}
	fill(D, D + n + 1, 0);//这里+1是因为是从1开始的

	q.push(index);
	visited[index] = 1;
	while (!q.empty())
	{
		int v = q.front();
		q.pop();
		for (Edge* i = head[v].next; i; i = i->next) 
		{
			if (!visited[i->v]) 
			{
				D[i->v] = D[v] + (i->info);
				q.push(i->v);
				visited[i->v] = 1;
			}
		}
	}
	max = D[1], index = 1;
	for (int i = 2; i <= n; i++)
		if (max < D[i]) 
		{
			max = D[i];
			index = i;
		}

	return max * 10 + (1 + max)*max / 2;
}

int main()
{
	cin >> n;
	for (int i = 0; i < n - 1; i++) 
	{
		int x, y, data;
		cin >> x >> y >> data;
		Edge *tp1, *tp2;
		tp1 = new Edge;
		tp2 = new Edge;
		tp1->info = tp2->info = data;
		tp1->v = y;
		tp1->next = head[x].next;
		head[x].next = tp1;
		tp2->v = x;
		tp2->next = head[y].next;
		head[y].next = tp2;
	}
	cout << bfs_2()<<endl;
	system("pause");
	return 0;
}