久久婷婷影院,久久国产精品高清,欧美吻胸吃奶大尺度电影

Bellman-Ford && SPFA ��法

MiYu — Sat, 23 Oct 2010 14:09:00 GMT

MiYu原创, 转帖��h��?: 转蝲�?nbsp;______________白白の屋

 B-F 适用条�g&范围
单源最短�\�?从源点s到其它所有顶点v);
有向�?amp;无向�?无向囑֏�以看�?u,v),(v,u)同属于边集E的有向图);
�Ҏ(gu��)��可正可负(如有负权回�\输出错误提示);
差分�U�束�pȝ��;
���法描述�Ҏ(gu��)��条边�q�行|V|-1�ơRelax ( ���是村ּ�操作 )操作;
如果存在(u,v)∈E使得dis[u]+w
For i:=1 to |V|-1 do //v为顶�Ҏ(gu��)��
For 每条�?u,v)∈E do  //�Ҏ(gu��)��条边�q�行遍历
  Relax(u,v,w);
For每条�?u,v)∈E do
  If dis[u]+w时空复杂�?/span>���法旉���复杂度O(VE)。因为算法简单，适用范围又广�Q�虽然复杂度�E�高�Q�仍不失��Z��个很实用的算法�?/p>
 
���法的改�q?--> SPFA 
 
���法����?/span>SPFA(Shortest Path Faster Algorithm)�?a  title="Bellman-Ford���法" style="text-decoration: none; color: rgb(90, 54, 150); background-image: none; background-attachment: initial; background-origin: initial; background-clip: initial; background-color: initial; ">Bellman-Ford���法的一�U?a  title="队列" style="text-decoration: none; color: rgb(0, 43, 184); background-image: none; background-attachment: initial; background-origin: initial; background-clip: initial; background-color: initial; ">队列实现�Q�减���了(ji��n)不必要的冗余计算。也有�h说SPFA本来���是Bellman-Ford���法�Q�现在广为流传的Bellman-Ford���法实际上是山寨版�?/p>
���法���程���法大致���程是用一个队列来�q�行�l�护�?初始时将源加入队列�?每次从队列中取出一个元素，�q�对所有与他相�?c��)���点进�?a  title="村ּ�" style="text-decoration: none; color: rgb(0, 43, 184); background-image: none; background-attachment: initial; background-origin: initial; background-clip: initial; background-color: initial; ">村ּ��Q�若某个盔R��的点村ּ�成功�Q�则���其入队�?直到队列为空时算法结束�?/p>
�q�个���法�Q�简单的说就是队列优化的bellman-ford,利用�?ji��n)每个点不�?x��)更新�ơ数太多的特点发明的此算�?/p>
SPFA——Shortest Path Faster Algorithm�Q�它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短�\径，可以处理负边。SPFA的实现甚��x��Dijkstra或者Bellman_Ford�q�要���单：(x��)
设Dist代表S到I点的当前最短距���，Fa代表S到I的当前最短�\径中I点之前的一个点的编受���开始时Dist全部�?∞�Q�只有Dist[S]=0�Q�Fa全部�?�?/p>
�l�护一个队列，里面存放所有需要进行�P代的炏V��初始时队列中只有一个点S。用一个布?y��u)��(d��ng)数�l�记录每个点是否处在队列中�?/p>
每次�q�代�Q�取出队头的点v�Q�依�ơ枚举从v出发的边v->u�Q�设边的长度为len�Q�判断Dist[v]+len是否���于Dist[u]�Q�若���于则改�q�Dist[u]�Q�将Fa[u]��Cؓ(f��)v�Q��ƈ且由于S到u的最短距���d�����了(ji��n)�Q�有可能u可以改进其它的点�Q�所以若u不在队列中，���将它放入队���。这样一直�P代下�ȝ��到队列变�I�，也就是S到所有的最短距���都���定下来�Q�结束算法。若一个点入队�ơ数���过n�Q�则有负权环�?/p>
SPFA 在�Ş式上和宽度优先搜索非常类��|��不同的是宽度优先搜烦(ch��)中一个点��Z��(ji��n)队列��׃��可能重新�q�入队列�Q�但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进�q�其它的点之后，�q�了(ji��n)一�D�|��间可能本�w�被改进�Q�于是再�ơ用来改�q�其它的点，�q�样反复�q�代下去。设一个点用来作�ؓ(f��)�q�代点对其它点进行改�q�的�q�_���ơ数为k�Q�有办法证明对于通常的情况，k�?左右
���法代码Procedure SPFA;
 
Begin
  initialize-single-source(G,s);
  initialize-queue(Q);
  enqueue(Q,s);
  while not empty(Q) do 
    begin
      u:=dequeue(Q);
      for each v∈adj[u] do 
        begin
          tmp:=d[v];
          relax(u,v);
          if (tmp<>d[v]) and (not v in Q) then
            enqueue(Q,v);
        end;
    end;
End;
procedure spfa;
begin
  fillchar(q,sizeof(q),0); h:=0; t:=0;//队列
  fillchar(v,sizeof(v),false);//v[i]判断i是否在队列中
  for i:=1 to n do 
    dist[i]:=maxint;//初始化最����?/span>
 
  inc(t);
  q[t]:=1;
  v[1]:=true;
  dist[1]:=0;//�q�里�?作�ؓ(f��)源点
 
  while h<>t do
    begin
      h:=(h mod n)+1;
      x:=q[h];
      v[x]:=false;
      for i:=1 to n do
        if (cost[x,i]>0) and (dist[x]+cost[x,i][i]) then
          begin
            dist[i]:=dist[x]+cost[x,i];
            if not(v[i]) then
              begin
                t:=(t mod n)+1;
                q[t]:=i;
                v[i]:=true;
              end;
          end;
    end;
end;void SPFA(void)//好久以前写的……今天丢上�?#8230;…话说我都不记得SPFA怎么写了(ji��n)……�?#8230;…ms存图是矩�?#8230;…嗯嗯
{
 int i;
 queue list;
 list.insert(s);
 for(i=1;i<=n;i++)
  {
   if(s==i)
    continue;
   dist[i]=map[s][i];
   way[i]=s;
   if(dist[i])
   list.insert(i);
  }
 int p;
 while(!list.empty())
 {
  p=list.fire();
  for(i=1;i<=n;i++)
   if(map[p][i]&&(dist[i]>dist[p]+map[p][i]||!dist[i])&&i!=s)
    {
     dist[i]=dist[p]+map[p][i];
     way[i]=p;
     if(!list.in(i))
      list.insert(i);
    }
 }
} 

MiYu 2010-10-23 22:09 发表评论

前向�?SPFA(转蝲)

MiYu — Sat, 23 Oct 2010 14:02:00 GMT

MiYu原创, 转帖��h��?: 转蝲�?nbsp;______________白白の屋

代码前向�?/span>+SPFA
我是在做USACO的sweet butter时偶然发现这个东西的。。�?br>�q�个���法�Q�简单的说就是队列优化的bellman-ford,利用�?ji��n)每个点不�?x��)更新�ơ数太多的特点发明的此算法（仅�ؓ(f��)个�h理解=.=�Q?br>SPFA——Shortest Path Faster Algorithm�Q�它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短�\径，可以处理负边。SPFA的实现甚��x��Dijkstra或者Bellman_Ford�q�要���单：(x��)
设Dist代表S到I点的当前最短距���，Fa代表S到I的当前最短�\径中I点之前的一个点的编受���开始时Dist全部�?/span>+∞�Q�只有Dist[S]=0�Q�Fa全部�?�?br>�l�护一个队列，里面存放所有需要进行�P代的炏V��初始时队列中只有一个点S。用一个布?y��u)��(d��ng)数�l�记录每个点是否处在队列中�?br>每次�q�代�Q�取出队头的点v�Q�依�ơ枚举从v出发的边v->u�Q�设边的长度为len�Q�判断Dist[v]+len是否���于Dist�Q�若���于则改�q�Dist�Q�将Fa��Cؓ(f��)v�Q��ƈ且由于S到u的最短距���d�����了(ji��n)�Q�有可能u可以改进其它的点�Q�所以若u不在队列中，���将它放入队���。这样一直�P代下�ȝ��到队列变�I�，也就是S到所有的最短距���都���定下来�Q�结束算法�?br>SPFA 在�Ş式上和宽度优先搜索非常类��|��不同的是宽度优先搜烦(ch��)中一个点��Z��(ji��n)队列��׃��可能重新�q�入队列�Q�但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进�q�其它的点之后，�q�了(ji��n)一�D�|��间可能本�w�被改进�Q�于是再�ơ用来改�q�其它的点，�q�样反复�q�代下去。设一个点用来作�ؓ(f��)�q�代点对其它点进行改�q�的�q�_���ơ数为k�Q�有办法证明对于通常的情况，k�?左右
前向星优化：(x��)
不要把前向星��x��什么高��p�����的东西……它其实就是一�U�邻接表的紧�~�存储�Ş式�?br>��Z��么叫前向星？因�ؓ(f��)它是���边按照前端�Ҏ(gu��)��序，�q�用一个数�l�k[i]记录端点i�W�一�ơ以左端点出现的位置。这��P��我们���p��用O(E)的空间复杂度存储下一个邻接表�Q�而避免了(ji��n)链表或N^2的庞大空间消耗�?br>当然�Q�实际上我们�q�不需要排序：(x��)因�ؓ(f��)我们只需要知道某一条边应该攑ֈ�什么位�|�即可。因而我们还需要一个数�l�t[i]存储从i出发的边的条数。则需要存储在的位�|�就可以很轻易地求得。（详见代码�Q?br>Butter题目代码如下�Q?br>Program butter(input,output);
Type
   edge=record
            x,y,d:longint;
        end;
Var
   min,res,n,p,c,x,y,i,j,l,r:longint;
   te,e:array[0..3000] of edge;
   tk,t,k,num,d:array[1..800] of longint;
   q:array[1..100000] of longint;
   use:array[1..800] of boolean;
Procedure swap(var n1,n2:longint);
Var
   tmp:longint;
Begin
   tmp:=n1;n1:=n2;n2:=tmp;
End;
Begin
   assign(input,'butter.in');reset(input);
   readln(n,p,c);
   for i:=1 to n do
   begin
      read(x);
      inc(num[x]);
   end;
   for i:=1 to c do
   begin
      with e[i*2-1] do readln(x,y,d);
      e[i*2]:=e[i*2-1];
      swap(e[i*2].x,e[i*2].y);
   end;
   c:=c*2;
   for i:=1 to c do inc(t[e[i].x]);
   j:=0;k[1]:=1;
   for i:=2 to p do
      k[i]:=k[i-1]+t[i-1];
   tk:=k;te:=e;
   for i:=1 to c do
   begin
      e[tk[te[i].x]]:=te[i];
      inc(tk[te[i].x]);
   end;
   min:=maxlongint;
   for i:=1 to p do
   begin
      fillchar(q,sizeof(q),0);
      fillchar(d,sizeof(d),127);
      fillchar(use,sizeof(use),false);
      q[1]:=i;l:=1;r:=1;d[i]:=0;use[i]:=true;
      repeat
            for j:=k[q[l]] to k[q[l]]+t[q[l]]-1 do
               if d[q[l]]+e[j].d<d[e[j].y] then
               begin
                  d[e[j].y]:=d[q[l]]+e[j].d;
                  if not use[e[j].y] then
                  begin
                     use[e[j].y]:=true;
                     inc(r);
                     q[r]:=e[j].y;
                  end;
               end;
            use[q[l]]:=false;
            inc(l);
      until l>r;
      res:=0;
      for j:=1 to p do
         res:=res+d[j]*num[j];
      if res<min then min:=res;
   end;
   assign(output,'butter.out');rewrite(output);
   writeln(min);close(output);
End.

MiYu 2010-10-23 22:02 发表评论

村ּ�操作

MiYu — Sat, 23 Oct 2010 14:01:00 GMT

MiYu原创, 转帖��h��?: 转蝲�?nbsp;______________白白の屋

(重定向自村ּ�技�?
　　单源最短�\径算法中使用�?ji��n)松弛（relaxation�Q�操作。对于每个顶点v∈V�Q�都讄���一个属性d[v]�Q�用来描�q�C��源点s到v的最短�\径上权值的上界�Q�称为最短�\径估计（shortest-path estimate�Q��?#960;[v]代表S到v的当前最短�\径中v点之前的一个点的编�?我们用下面的Θ(V)旉���的过�E�来�Ҏ(gu��)��短�\径估计和前趋�q�行初始化�?div class="spctrl" style="height: 14px; line-height: 14px; font-size: 12px; overflow-x: hidden; overflow-y: hidden; ">
　　INITIALIZE-SINGLE-SOURCE(G,s)
　　1 for each vertex v∈V[G]
　　2 do d[v]←∞
　　3 π[v]←NIL
　　4 d[s]←0
　　�l�过初始化以后，�Ҏ(gu��)��有v∈V�Q?#960;[v]=NIL�Q�对v∈V-{s}�Q�有d[s]=0以及(qi��ng)d[v]=∞�?div class="spctrl" style="height: 14px; line-height: 14px; font-size: 12px; overflow-x: hidden; overflow-y: hidden; ">

　　在松弛一条边(u,v)的过�E�中�Q�要��试是否可以通过u�Q�对�q�今扑ֈ�的v的最短�\径进行改�q�；如果可以改进的话�Q�则更新d[v]�?#960;[v]。一�ơ松弛操作可以减��最短�\径估计的值d[v]�Q��ƈ更新v的前��域π[v](S到v的当前最短�\径中v点之前的一个点的编�?。下面的伪代码对�?u,v)�q�行�?ji��n)一步松弛操作�?div class="spctrl" style="height: 14px; line-height: 14px; font-size: 12px; overflow-x: hidden; overflow-y: hidden; ">　　RELAX(u, v, w)

　　1 if(d[v]>d[u]+w(u,v))

　　2 then d[v]←d[u]+w(u,v)

　　3 π[v]←u

　　每个单源最短�\径算法中都会(x��)调用INITIALIZE-SINGLE-SOURCE�Q�然后重复对边进行松弛的�q�程。另外，村ּ�是改变最短�\径和前趋的唯一方式。各个单源最短�\径算法间区别在于�Ҏ(gu��)��条边�q�行村ּ�操作的次敎ͼ�以及(qi��ng)对边执行村ּ�操作的次序有所不同。在Dijkstra��法以及(qi��ng)关于有向无回路图的最短�\径算法中�Q�对每条�Ҏ(gu��)��行一�ơ松弛操作。在Bellman-Ford��法中，每条边要执行多次村ּ�操作�?div class="spctrl" style="height: 14px; line-height: 14px; font-size: 12px; overflow-x: hidden; overflow-y: hidden; ">　　procedure relax(u,v,w:integer);//多数情况下不需要单独写成procedure�?div class="spctrl" style="height: 14px; line-height: 14px; font-size: 12px; overflow-x: hidden; overflow-y: hidden; ">　　begin

　　if dis+w　　begin

　　dis[v]:=dis+w;

　　pre[v]:=u;

　　end

　　end;

MiYu 2010-10-23 22:01 发表评论

PKU 1258 POJ 1258Agri-Net ( MST Kruskarl �q�查�?) ACM 1258 IN PKU

MiYu — Sat, 16 Oct 2010 08:30:00 GMT

MiYu原创, 转帖��h��?: 转蝲�?nbsp;______________白白の屋

题目地址:

http://poj.org/problem?id=1258

题目描述:

Agri-Net
Time Limit: 1000MSMemory Limit: 10000K
Total Submissions: 16557Accepted: 6745
Description
Farmer John has been elected mayor of his town! One of his campaign promises was to bring internet connectivity to all farms in the area. He needs your help, of course. 
Farmer John ordered a high speed connection for his farm and is going to share his connectivity with the other farmers. To minimize cost, he wants to lay the minimum amount of optical fiber to connect his farm to all the other farms. 
Given a list of how much fiber it takes to connect each pair of farms, you must find the minimum amount of fiber needed to connect them all together. Each farm must connect to some other farm such that a packet can flow from any one farm to any other farm. 
The distance between any two farms will not exceed 100,000. 
Input
The input includes several cases. For each case, the first line contains the number of farms, N (3 <= N <= 100). The following lines contain the N x N conectivity matrix, where each element shows the distance from on farm to another. Logically, they are N lines of N space-separated integers. Physically, they are limited in length to 80 characters, so some lines continue onto others. Of course, the diagonal will be 0, since the distance from farm i to itself is not interesting for this problem.
Output
For each case, output a single integer length that is the sum of the minimum length of fiber required to connect the entire set of farms.
Sample Input
4
0 4 9 21
4 0 8 17
9 8 0 16
21 17 16 0
Sample Output
28
题目分析 : 	MST 水题, 用KRUSKARL �?PRIM ��L��能过.代码如下 :/*
Mail to   : miyubai@gamil.com
MyBlog    : http://baiyun.me
Link      : http://www.cnblogs.com/MiYu  || http://m.shnenglu.com/MiYu
Author By : MiYu
Test      : 1
Complier  : g++ mingw32-3.4.2
Program   : Agri-Net
Doc Name  : PKU_1258
*/
//#pragma warning( disable:4789 )
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
const int MAX = 105;
int st[105];
int N, x, y, w;
struct vv {
       int x, y, val;
       void set ( int a, int b, int w ) { x=a,y=b,val=w; }

}v[10005];       
bool cmp ( const vv &a, const vv &b ) {
          return a.val < b.val;     
}
void creat () {
     for ( int i = 0; i <= N; ++ i )
          st[i] = i;     
}
int find ( int x ) {
    return x != st[x] ? find ( st[x] ) : x;    
}
void merge ( int x, int y ) {
     x = find ( x );
     y = find ( y );
     if ( x == y ) return;
     st[y] = x;     
}
int main ()
{
    while ( scanf ( "%d", &N )==1) {
           creat ();
           memset ( v, 0, sizeof ( v ) );
           int c = 0;
           for ( int i = 1; i <= N; ++ i ) {
                for ( int j = 1; j <= N; ++ j ) {
                     scanf ( "%d", &w );  
                     v[c++].set ( i,j,w );  
                }    
           }     
           sort ( v, v + c, cmp );
           int sum = 0;
           for ( int i = 0 ; i < c; ++ i ) {
                if ( find ( v[i].x ) != find ( v[i].y ) ) {
                    sum += v[i].val;  
                    merge ( v[i].x, v[i].y );
                }    
           }
           printf ( "%d\n", sum );
    }
    return 0;
}

MiYu 2010-10-16 16:30 发表评论

MiYu — Sat, 25 Sep 2010 12:03:00 GMT

Floyd-Warshall��法�Q�简�U�Floyd��法�Q�用于求解�Q意两炚w��的最短距��，旉��复杂度�ؓ(f��)O(n^3)。我们��^时所见的Floyd��法的一般�Ş式如下：(x��)

1 void Floyd(){
2     int i,j,k;
3     for(k=1;k<=n;k++)
4         for(i=1;i<=n;i++)
5             for(j=1;j<=n;j++)
6                 if(dist[i][k]+dist[k][j]<dist[i][j])
7                     dist[i][j]=dist[i][k]+dist[k][j];
8 }

注意下第6行这个地方，如果dist[i][k]或者dist[k][j]不存在，�E�序中用一个很大的��C��ѝ��最好写成if(dist[i][k]!=INF && dist[k][j]!=INF && dist[i][k]+dist[k][j] 上面�q�个形式的算法其实是Floyd��法的精��版，而真正的Floyd��法是一�U�基于DP(Dynamic Programming)的最短�\径算法�?br> 讑֛�G中n 个顶点的�~�号�?到n。��o(h��)c [i, j, k]表示从i 到j 的最短�\径的长度�Q�其中k 表示该�\径中的最大顶点，也就是说c[i,j,k]�q�条最短�\径所通过的中间顶�Ҏ(gu��)��大不��过k。因此，如果G中包含边�Q�则c[i, j, 0] =�?lt;i, j> 的长度；若i= j �Q�则c[i,j,0]=0�Q�如果G中不包含�?lt;i, j>�Q�则c (i, j, 0)= +∞。c[i, j, n] 则是从i 到j 的最短�\径的长度�?br> 对于��L��的k>0�Q�通过分析可以得到�Q�中间顶点不��过k 的i 到j 的最短�\径有两种可能�Q�该路径含或不含中间��点k。若不含�Q�则该�\径长度应为c[i, j, k-1]�Q�否则长度�ؓ(f��) c[i, k, k-1] +c [k, j, k-1]。c[i, j, k]可取两者中的最��倹{�?br> 状态�{�U�L��E�：(x��)c[i, j, k]=min{c[i, j, k-1], c [i, k, k-1]+c [k, j, k-1]}�Q�k�Q?�?br> �q�样�Q�问题便��h��?ji��n)最优子�l�构性质�Q�可以用动态规划方法来求解�?/p>

��Z��(ji��n)�q�一步理解，观察上面�q�个有向图：(x��)若k=0, 1, 2, 3�Q�则c[1,3,k]= +∞�Q�c[1,3,4]= 28�Q�若k = 5, 6, 7�Q�则c [1,3,k] = 10�Q�若k=8, 9, 10�Q�则c[1,3,k] = 9。因�?�?的最短�\径长度�ؓ(f��)9�?/span>
下面通过�E�序来分析这一DP�q�程�Q�对应上面给出的有向图：(x��)

1 #include <iostream>
2 using namespace std;
3
4 const int INF = 100000;
5 int n=10,map[11][11],dist[11][11][11];
6 void init(){
7     int i,j;
8     for(i=1;i<=n;i++)
9         for(j=1;j<=n;j++)
10             map[i][j]=(i==j)?0:INF;
11     map[1][2]=2,map[1][4]=20,map[2][5]=1;
12     map[3][1]=3,map[4][3]=8,map[4][6]=6;
13     map[4][7]=4,map[5][3]=7,map[5][8]=3;
14     map[6][3]=1,map[7][8]=1,map[8][6]=2;
15     map[8][10]=2,map[9][7]=2,map[10][9]=1;
16 }
17 void floyd_dp(){
18     int i,j,k;
19     for(i=1;i<=n;i++)
20         for(j=1;j<=n;j++)
21             dist[i][j][0]=map[i][j];
22     for(k=1;k<=n;k++)
23         for(i=1;i<=n;i++)
24             for(j=1;j<=n;j++){
25                 dist[i][j][k]=dist[i][j][k-1];
26                 if(dist[i][k][k-1]+dist[k][j][k-1]<dist[i][j][k])
27                     dist[i][j][k]=dist[i][k][k-1]+dist[k][j][k-1];
28             }
29 }
30 int main(){
31     int k,u,v;
32     init();
33     floyd_dp();
34     while(cin>>u>>v,u||v){
35         for(k=0;k<=n;k++){
36             if(dist[u][v][k]==INF) cout<<"+∞"<<endl;
37             else cout<<dist[u][v][k]<<endl;
38         }
39     }
40     return 0;
41 }

输入 1 3
输出 +∞
            +∞
            +∞
            +∞
            28
            10
            10
            10
            9
            9
            9

Floyd-Warshall��法不仅能求��Z�Q�?炚w��的最短�\径，�q�可以保存最短�\径上�l�过的节炏V��下面用�_��版的Floyd��法实现�q�一�q�程�Q�程序中的图依然对应上面的有向图�?br>

1 #include <iostream>
2 using namespace std;
3
4 const int INF = 100000;
5 int n=10,path[11][11],dist[11][11],map[11][11];
6 void init(){
7     int i,j;
8     for(i=1;i<=n;i++)
9         for(j=1;j<=n;j++)
10             map[i][j]=(i==j)?0:INF;
11     map[1][2]=2,map[1][4]=20,map[2][5]=1;
12     map[3][1]=3,map[4][3]=8,map[4][6]=6;
13     map[4][7]=4,map[5][3]=7,map[5][8]=3;
14     map[6][3]=1,map[7][8]=1,map[8][6]=2;
15     map[8][10]=2,map[9][7]=2,map[10][9]=1;
16 }
17 void floyd(){
18     int i,j,k;
19     for(i=1;i<=n;i++)
20         for(j=1;j<=n;j++)
21             dist[i][j]=map[i][j],path[i][j]=0;
22     for(k=1;k<=n;k++)
23         for(i=1;i<=n;i++)
24             for(j=1;j<=n;j++)
25                 if(dist[i][k]+dist[k][j]<dist[i][j])
26                     dist[i][j]=dist[i][k]+dist[k][j],path[i][j]=k;
27 }
28 void output(int i,int j){
29     if(i==j) return;
30     if(path[i][j]==0) cout<<j<<' ';
31     else{
32         output(i,path[i][j]);
33         output(path[i][j],j);
34     }
35 }
36 int main(){
37     int u,v;
38     init();
39     floyd();
40     while(cin>>u>>v,u||v){
41         if(dist[u][v]==INF) cout<<"No path"<<endl;
42         else{
43             cout<<u<<' ';
44             output(u,v);
45             cout<<endl;
46         }
47     }
48     return 0;
49 }

输入 1 3
输出 1 2 5 8 6 3

MiYu 2010-09-25 20:03 发表评论

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 16557		Accepted: 6745

久久婷婷影院,久久国产精品高清,欧美吻胸吃奶大尺度电影

Bellman-Ford && SPFA ��法

B-F

��法描述

时空复杂�?/span>

��法��?/span>

��法��程

��法代码

前向�?SPFA(转蝲)

村ּ�操作

PKU 1258 POJ 1258Agri-Net ( MST Kruskarl �q�查�?) ACM 1258 IN PKU

久久婷婷影院,久久国产精品高清,欧美吻胸吃奶大尺度电影

Bellman-Ford && SPFA ���法

B-F

���法描述

时空复杂�?/span>

���法����?/span>

���法���程

���法代码

前向�?SPFA(转蝲)

村ּ�操作

PKU 1258 POJ 1258Agri-Net ( MST Kruskarl �q�查�?) ACM 1258 IN PKU

Bellman-Ford && SPFA ��法

��法描述

��法��?/span>

��法��程

��法代码