poj 2449 K短路问题 邻接表 + dijkstra最短路径 + A*启发式搜索

终于做完了200题中的最后一题大boss 收获颇丰 准备领奖。

//============================================================================
//
// >     File        :    poj2449.cpp
// >     Author      :    flowertree
// >     Time        :    2016年1月21日
// >     Algorithm   :    邻接表 + dijkstra最短路径 + A*启发式搜索
//
//============================================================================

#include <iostream>
#include <string.h>
#include <queue>
#include <algorithm>
#include <stdio.h>
using namespace std;

#define MAX 1005
#define INFINITY 9999999

struct mapnode		//邻接表的节点
{
	int number;
	int w;
	mapnode * next;
}map[MAX * 200];

struct headnode		//邻接表的头结点
{
	int num;		//邻接点的数目
	mapnode * next;
	headnode()
	{
		this -> num = 0;
		this -> next = NULL;
	}
}head[MAX], rehead[MAX];

struct node
{
	int num;
	int g;
	int h;
	bool operator < (node a) const
	{
		return a.g + a.h < g + h;
	}
};

int maph[MAX];
int N, M;
int beginnode, endnode, k;
int mapnodenum = 0;
bool flag[MAX];
priority_queue<node> q;

void dijkstra()
{
	memset(flag, false, sizeof(flag));
	for(int i = 1; i < MAX; i++)
		maph[i] = INFINITY;
	maph[endnode] = 0;
	mapnode * temp;
	int maxnum, mark;
	for(int i = 0; i < N; i++)
	{
		maxnum = INFINITY;
		for(int j = 1; j <= N; j++)
		{
			if(flag[j] == false && maph[j] < maxnum)
			{
				maxnum = maph[j];
				mark = j;
			}
		}
		flag[mark] = true;
		temp = rehead[mark].next;
		for(int j = 0; j < rehead[mark].num; j++)
		{
			if(flag[temp -> number] == false && (maph[mark] + temp -> w) < maph[temp -> number])
				maph[temp -> number] = temp -> w + maph[mark];
			temp = temp -> next;
		}
	}
}

int Astar()		//bfs优化版
{
	while(!q.empty())
		q.pop();
	node n;
	n.g = 0;
	n.h = maph[beginnode];
	n.num = beginnode;
	q.push(n);
	int cnt[MAX];
	memset(cnt, 0, sizeof(cnt));
	while(!q.empty())
	{
		node temp = q.top();
		q.pop();
		cnt[temp.num]++;
		if(cnt[temp.num] > k)
			continue;
		if(cnt[endnode] == k)
			return temp.g;
		mapnode * p;
		p = head[temp.num].next;
		for(int i = 0; i < head[temp.num].num; i++)
		{
			node t;
			t.num = p -> number;
			t.g = p -> w + temp.g;
			t.h = maph[p -> number];
			q.push(t);
			p = p -> next;
		}
	}
	return -1;
}

mapnode * getnode()
{
	return &map[mapnodenum++];
}

int main()
{
	int x, y, w;
	while(scanf("%d%d", &N, &M) != EOF)
	{
		mapnodenum = 0;
		//初始化
		memset(head, 0, sizeof(head));
		memset(rehead, 0, sizeof(rehead));
		for(int i = 0; i < M; i++)
		{
			cin >> x >> y >> w;
			//邻接表存储
			head[x].num++;
			mapnode * temp = getnode();
			temp -> number = y;
			temp -> w = w;
			temp -> next = head[x].next;
			head[x].next = temp;
			//邻接表存储反向表
			rehead[y].num++;
			mapnode * temp1 = getnode();
			temp1 -> number = x;
			temp1 -> w = w;
			temp1 -> next = rehead[y].next;
			rehead[y].next = temp1;
		}		
		cin >> beginnode >> endnode >> k;
		if(beginnode == endnode)
			k++;
		dijkstra();
		cout << Astar() << endl;
	}
	system("pause");
	return 0;
}