POJ2449 Remmarguts' Date

题意：给定一个n(1 <= n <= 1000)个点，m(1 <= m <= 100000)条边的有向图，求S到T的第k短路。

时间限制：4000ms

空间限制：64M

通过时间：219ms

通过空间：9132K

分析：这道题瓶颈不在于时间，而在于空间，朴素算法不外乎BFS，第k次访问到终点的时候，就是答案，容易理解，但是状态量太多，空间只有仅仅的64M，放不下，我们需要寻找一个的更好的搜索方式。

于是我们想到了传说中的启发式搜索A*，网上找到了一篇很好的文章：http://www.cnblogs.com/technology/archive/2011/05/26/2058842.html

根据这篇文章，我们来设计乐观估价函数，不外乎是从终点反向走一遍得出每个点的最短路，作为H，然后已经走过的路程作为G，F = G + H.

这里采用了邻接表建图，需要注意的是，如果hd初始是0，可以选择都赋值成-1，也可以选择边序号从1开始（也就是先进行++cnt）

之后跑SPFA，模板，没啥说的。

然后进行A*搜索过程，用一个结构体A，来存放to结点的F和G.

搜索的时候需要注意以下几个事项：

1.在放第一个结点之前，得先看看是不是能到，不能到直接返回-1.

2.特判S == T的情况，当S == T时，k++.

3.每次取F值最小的元素，所以要用priority_queue小根堆，因为优先队列默认是大根堆，所以重载小于运算符的时候定义成大于符。

以下为扯淡内容：

这道题当时做的时候是几近崩溃的，明明跟题解基本上一模一样，但死活MLE，在进行了一页半（大概30来次）的提交后，终于发现我SPFA的源点用的是n，不是T！！！！瞬间愤怒了，望着8楼的窗外，觉得人生无比美好...

#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;

const int inf = 0x3f3f3f3f, maxn = 1005, maxm = 100005;
bool inq[maxn];
int n, x, y, z, s, t, k, m, cnt, d[maxn], hd[maxn], hd2[maxn];

struct Edge {
	int to, w, nxt;
}edge[maxm], edge2[maxm];

void add(int x, int y, int z) {
    edge[cnt].w = edge2[cnt].w = z;
    edge[cnt].nxt = hd[x];
    edge2[cnt].to = x;
    edge2[cnt].nxt = hd2[y];
    hd[x] = hd2[y] = cnt;
}

void spfa(int s) {
    queue<int> q;
    memset(d, inf, sizeof d);
    d[s] = 0;
    q.push(s);
    while(!q.empty()) {
        int u = q.front(); q.pop();
        inq[u] = 0;
        for(int i = hd[u]; i; i = edge[i].nxt) {
            Edge &e = edge[i];
            if(d[e.to] > d[u] + e.w) {
                d[e.to] = d[u] + e.w;
                if(!inq[e.to]) inq[e.to] = 1, q.push(e.to);
            }
        }
    }
}

struct A {
	int to, g, f;
	bool operator < (const A &rhs) const {
		return f > rhs.f;
	}
};

int Asrch() {
	if(d[s] == inf) return -1;
	if(s == t) k++;
	priority_queue<A> q;
	A e, ne;
	e.to = s, e.g = 0, e.f = d[s];
	q.push(e);
	while(!q.empty()) {
		e = q.top(); q.pop();
		if(e.to == t) k--;
		if(k == 0) return e.g;
		for(int i = hd2[e.to]; i; i = edge2[i].nxt) {
			ne.to = edge2[i].to;
			ne.g = e.g + edge2[i].w;
			ne.f = ne.g + d[ne.to];
			q.push(ne);
		}
	}
	return -1;
}

int main() {
	scanf("%d%d", &n, &m);
	while(m--) scanf("%d%d%d", &x, &y, &z), add(y, x, z);
	scanf("%d%d%d", &s, &t, &k);
	spfa(t);
	printf("%d\n", Asrch());
	return 0;
}