poj 1724

这是一题简单的搜索问题 ， 可我就是w+t了10多次 。

一开始用的是vector来存储图（因为有重边） ， 结果一直超时还加了优化 ， 用邻接表之后 ， 不加优化还过来 ， 诶 ， 直接代码
， 以后凡是图都用邻接表存储吧 。

优化：  可以求出终点到其他点的最短距离 和 最少花费 ， 这个可以把图反过来求 。

优化之后只要 98ms ， 好像有个astar算法 ， 可以0ms过 ， 不知道是什么原理 。

代码：

#include

#include

#include

#include

#include

using namespace std;

const int MAXN = 110;

const int INF = 0x3f3f3f3f;

struct node

{

    int u , d ,
c , pre;

}edge[10010];

struct node2

{

    int u , d ,
c , pre;

}grap[10010];

int pre[MAXN] , c[MAXN] , d[MAXN] , xy[MAXN];

int n , m , k , vis[MAXN];

int minsum , cost , sum ;

void init()

{

    memset(pre ,
-1,  sizeof(pre));

    memset(vis ,
0 , sizeof(vis));

    memset(xy ,
-1, sizeof(xy));

    cost = sum =
0;

    minsum =
INF;

}

void dfs(int u)

{

    if(sum >=
minsum || cost > k)  return ;

    if(u ==
n)

    {

   
    minsum =
sum;

   
    return
;

    }

    for(int i =
pre[u] ; i != -1 ; i = edge[i].pre)

    {

   
   
if(!vis[edge[i].u])

   
    {

   
   
   
vis[edge[i].u] = 1;

   
   
    sum +=
edge[i].d ;

   
   
    cost +=
edge[i].c;

   
   
   
dfs(edge[i].u);

   
   
    sum -=
edge[i].d;

   
   
    cost -=
edge[i].c;

   
   
   
vis[edge[i].u] = 0;

   
    }

    }

}

void ford1()

{

   
queueq;

    memset(vis ,
0 , sizeof(vis));

    int i;

    for(i = 1; i
<= n; i++)  d[i] = INF;

    d
=
0;

   
q.push(n);

   
while(!q.empty())

    {

   
    int u =
q.front(); q.pop();

   
    vis[u] =
0;

   
    for(i =
xy[u] ; i != -1 ; i = grap[i].pre)

   
    {

   
   
   
if(d[grap[i].u] > d[u] + grap[i].d)

   
   
    {

   
   
   
    d[grap[i].u]
= d[u] + grap[i].d ;

   
   
   
   
if(!vis[grap[i].u])  {q.push(grap[i].u) ;
vis[grap[i].u] = 1;}

   
   
    }

   
    }

    }

}

void ford2()

{

   
queueq;