HDU 1142 SPFA + DFS记忆搜索 学习了！！

走AB这条路的前提是: B到home的最短路比A到home的最短路要短，求满足这个要求的office到home的路有多少条

SPFA：参考http://sgeteternal.iteye.com/blog/1148891

spfa比dijkstra极大程度减少不必要的松弛操作。故而比dij快。

#include <iostream>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <memory.h>
using namespace std;
#define MAXI 1011
#define INFI 0x7fffffff
#define LLD long long

struct V
{
	int v, w;	//v, w[u, v]
};
vector<V> g[MAXI]; //邻接表
int n, dis[MAXI];	//|V|, d[]
bool inQ[MAXI];	//入队标记

void SPFA(int u)		//源点
{
	int i, v, w;
	queue<int> Q;		//队列
	for (i = 0; i < n; i++)	//初始化
	{
		dis[i] = INFI;
		inQ[i] = false;
	}
	Q.push(u);		//压入源点
	inQ[u] = true;
	dis[u] = 0;
	while (!Q.empty())	//队列不为空
	{
		u = Q.front();
		Q.pop();
		inQ[u] = false;
		for (i = 0; i < g[u].size(); i++)
		{
			v = g[u][i].v;
			w = g[u][i].w;
			if (dis[v] - w > dis[u])	//符合三角不等式2
			{
				dis[v] = w + dis[u];	//松弛操作
				if (inQ[v] == false)	//判断v系唔系队列
				{
					Q.push(v);	//唔系就入队列
					inQ[v] = true;
				}
			}
		}
	}
}

所以SPFA其实就是大家熟悉的 bfs + 松弛操作

松弛操作：应该就是判断更新。

负回路版本只需要加上一个数组记录每个点入队次数就得。

 记忆化搜索：算法上依然是搜索的流程，但是搜索到的一些解用动态规划的那种思想和模式作一些保存。
一般说来，动态规划总要遍历所有的状态，而搜索可以排除一些无效状态。
更重要的是搜索还可以剪枝，可能剪去大量不必要的状态，因此在空间开销上往往比动态规划要低很多。
记忆化算法在求解的时候还是按着自顶向下的顺序，但是每求解一个状态，就将它的解保存下来，
以后再次遇到这个状态的时候，就不必重新求解了。
这种方法综合了搜索和动态规划两方面的优点，因而还是很有实用价值的。

可以归纳为：记忆化搜索=搜索的形式+动态规划的思想

dfs记忆搜索

#include <iostream>
#include <fstream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <stack>
#include <list>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
//#include <ctime>
#include <ctype.h>
using namespace std;
#define L long long
#define inf 0x3fffffff
#define M 1005

struct road{
	int v, w;
};

int n, dist[M], dp[M];
vector<road> g[M]; //保存每个顶点有多少条路径与其它顶点相连
bool inq[M];

void spfa (int u)    //spfa求home到各个点的最短路
{
	int i, v, w;
	for (i = 1; i <= n; i++)
	{
		dist[i] = inf;
		inq[i] = false;
	}
	queue<int> q;
	q.push (u);
	dist[u] = 0;
	inq[u] = true;
	while (!q.empty())
	{
		u = q.front();
		q.pop();
		inq[u] = false;
		for (i = 0; i < g[u].size(); i++)
		{
			v = g[u][i].v;
			w = g[u][i].w;
			if (dist[u] + w < dist[v])    //判断是否可以构造出到v的最短路
			{
				dist[v] = dist[u] + w;   //所谓的松弛
				if (!inq[v])
				{
					q.push (v);
					inq[v] = true;
				}
			}
		}
	}
}

int dfs (int u)    //记忆化搜索
{
	if (u == 2)
		return 1;
	if (dp[u] > 0)    //核心
		return dp[u];
	for (int i = 0; i < g[u].size(); i++)
	{
		int v = g[u][i].v;
		if (dist[v] < dist[u])    //满足题意【v相当于B，u相当于A】
			dp[u] += dfs (v);
	}
	return dp[u];
}

int main()
{
	int m, u, v, w, i;
	road x;
	while (scanf ("%d", &n), n)
	{
		for (i = 1; i <= n; i++)
			g[i].clear();
		scanf ("%d", &m);
		while (m--)
		{
			scanf ("%d%d%d", &u, &v, &w);
			x.v = v, x.w = w;
			g[u].push_back (x);
			x.v = u;
			g[v].push_back (x);
		}
		spfa (2);    //逆向思维，把终点当成起点
		memset (dp, 0, sizeof(dp));
		printf ("%d\n", dfs (1));
	}
	return 0;
}