一本久久综合亚洲鲁鲁五月天,999久久久国产精品,久久久久久久久无码精品亚洲日韩

Dijkstra(�q�杰斯特�?��法

luis — Fri, 15 Jun 2012 19:53:00 GMT

　Dijkstra(�q�杰斯特�?��法是典型的单源最短�\径算法，用于计算一个节点到其他所有节点的最短�\径。主要特�Ҏ��以�v始点��Z��心向外层层扩展，直到扩展到终点�ؓ止。Dijkstra��法是很有代表性的最短�\径算法，在很多专业课�E�中都作为基本内�Ҏ��详细的介�l�，如数据结构，图论�Q�运�{�学�{�等。Dijkstra一般的表述通常有两�U�方式，一�U�用�怹�和��时标��h��式，一�U�是用OPEN, CLOSE表的方式�Q�这里均采用�怹�和��时标��L��方式。注意该��法要求图中不存在负权边�?/span>

问题描述

　　在无向图 G=(V,E) 中，假设每条�?E[i] 的长度�ؓ w[i]�Q�找到由��点 V0 到其余各点的最短�\径。（单源最短�\�?/a>�Q?/span>

　�q�杰斯特�?/a>(Dijkstra)��法思想
　　按�\径长度递增�ơ序产生最短�\径算法：

　　把V分成两组�Q?/span>

　　�Q?�Q�S�Q�已求出最短�\径的��点的集�?/span>

　　�Q?�Q�V-S=T�Q�尚未确定最短�\径的��点集合

　　��T中顶�Ҏ��最短�\径递增的次序加入到S中，

　　保证�Q�（1�Q�从源点V0到S中各��点的最短�\径长度都不大�?/span>

　　从V0到T中�Q何顶点的最短�\径长�?/span>

　　�Q?�Q�每个顶点对应一个距��d�?/span>

　　S中顶点：从V0到此��点的最短�\径长�?/span>

　　T中顶点：从V0到此��点的只包括S中顶点作中间

　　��点的最短�\径长�?/span>

　　依据�Q�可以证明V0到T中顶点Vk的最短�\径，或是从V0到Vk�?/span>

　　直接路径的权��|��或是从V0�l�S中顶点到Vk的�\径权��g��?/span>

　　�Q�反证法可证�Q?/span>

　　求最短�\径步�?/em>

　　��法步骤如下�Q?/span>
　　1. 初��时��o S={V0},T={其余��点}�Q�T中顶点对应的距离�?/span>
　　若存�?lt;V0,Vi>�Q�d(V0,Vi)�?lt;V0,Vi>弧上的权�?/span>
　　若不存在�Q�d(V0,Vi)�?#8733;
　　2. 从T中选取一个其距离��gؓ最��的��点W且不在S中，加入S
　　3. 对T中顶点的距离��D��行修改：若加�q�W作中间顶点，从V0到Vi�?/span>
　　距离值比不加W的�\径要短，则修�Ҏ��距离�?/span>
　　重复上述步骤2�?�Q�直到S中包含所有顶点，即S=T为止

代码�Q?源地址�Q?span style="color: #008000; font-size: 13px; background-color: #eeeeee; ">www.cnblogs.com/newwy

/*********************************
*   最短�\�?--Dijkstra��法实现
*   　　　HDU�Q?544
*   BLOG:www.cnblogs.com/newwy
*   AUTHOR:Wang Yong
**********************************/
#include
#define MAX 100
#define INF 1000000000
using namespace std;
int dijkstra (int mat[][MAX],int n, int s,int f)
{
     int dis[MAX];
     int mark[MAX];//记录被选中的结�?nbsp;
     int i,j,k = 0;
     for(i = 0 ; i < n ; i++)//初始化所有结点，每个�l�点都没有被选中
         mark[i] = 0;
    for(i = 0 ; i < n ; i++)//��每个结点到start�l�点weight记录为当前distance
    {
        dis[i] = mat[s][i];
        //path[i] = s;
    }
    mark[s] = 1;//start�l�点被选中
    //path[s] = 0;
    dis[s] = 0;//��start�l�点的的距离讄��?
    int min ;//讄��最短的距离�?nbsp;
    for(i = 1 ; i < n; i++)
    {
        min = INF;
        for(j = 0 ; j < n;j++)
        {
            if(mark[j] == 0  && dis[j] < min)//未被选中的结点中�Q�距��L��短的被选中
            {
                min = dis[j] ;
                k = j;
            }
        }
        mark[k] = 1;//标记��选中
        for(j = 0 ; j < n ; j++)
        {
            if( mark[j] == 0  && (dis[j] > (dis[k] + mat[k][j])))//修改剩余�l�点的最短距��?nbsp;
            {
                dis[j] = dis[k] + mat[k][j];
            }
        }
    }
    return dis[f];
}
int mat[MAX][MAX];
int main()
{
    int n,m;
    while(scanf("%d %d",&n,&m))
    {
        int a,b,dis;
        if(n == 0 || m == 0)
            break;
        int i,j;
        for(i = 0 ; i < n;i++)
            for(j = 0 ; j < n; j++)
                mat[i][j] = INF;
        for(i = 0 ; i < m ;i++)
        {
            scanf("%d %d %d",&a,&b,&dis);
            --a,--b;
            if(dis < mat[a][b] || dis < mat[b][a])
            mat[a][b] = mat[b][a] = dis;
        }
        int ans = dijkstra(mat,n,0,n-1);
        printf("%d\n",ans);
    }

}

可用优先队列优化

其他解释�Q?br />http://blog.csdn.net/jiahui524/article/details/6636913

luis 2012-06-16 03:53 发表评论

dijkstra��法最��堆优化 <不用stl>转帖

luis — Sun, 09 Aug 2009 13:28:00 GMT
以后慢慢�?br>------------
模板是HDOJ 2544
我写的是记录每个点在堆中的位�|�IncreaseKey�Q�也可以Relax后直接往里插�Q�用个bool数组记录一�?br>
-----
优化之处在于旉��复杂度由n^2变�ؓnlgn
-----
#include
#include

int n,m;
int map[101][101],d[101];

class Heap
{
    public:
        int handle[101];
        void Build(int n)
        {
            for(int i=1;i<=n;i++) a[i]=handle[i]=i;
            size=n;
        }
        void Percup(int p)
        {
            int temp=a[p];
            for(;d[temp]>1]];p>>=1)
            {
                a[p]=a[p>>1];
                handle[a[p]]=p;
            }
            a[p]=temp;
            handle[a[p]]=p;
        }
        int DeleteMin()
        {
            int val=a[1];
            a[1]=a[size--];
            Percdown(1);
            handle[val]=0;
            return val;
        }
        bool Empty() {return size==0;}
    private:
        int a[101],size;
        void Percdown(int p)
        {
            int temp=a[p],child;
            for(;(p<<1)<=size;p=child)
            {
                child=p<<1;
                if(child+1<=size && d[a[child+1]]                if(d[temp]                a[p]=a[child];
                handle[a[p]]=p;
            }
            a[p]=temp;
            handle[a[p]]=p;
        }
}h;

void init()
{
    int i,j,c;
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=n;j++) map[i][j]=0x7fffffff;
        d[i]=0x7fffffff;
    }
    d[1]=0;
    while(m--)
    {
        scanf("%d%d%d",&i,&j,&c);
        map[i][j]=map[j][i]=c;
    }
}

void Relax(int num)
{
    for(int i=1;i<=n;i++)
        if(h.handle[i] && map[num][i]!=0x7fffffff && d[i]>d[num]+map[num][i])
        {
            d[i]=d[num]+map[num][i];
            h.Percup(h.handle[i]);
        }
}

void dijk()
{
    h.Build(n);
    while(!h.Empty()) Relax(h.DeleteMin());
}

int main()
{
    while(scanf("%d%d",&n,&m) && n+m)
    {
        init();
        dijk();
        printf("%d\n",d[n]);
    }
    system("pause");
    return 0;
}
---------------------
另一个版�?br>
#include const int SIZE= 30005, MAXX=2000000000; int n,m,tail, dist[SIZE]; bool mark[SIZE]; struct Node { int id, val; Node* next; }node[SIZE]; struct Heap{ int id, val; }heap[2*SIZE]; void insert(int a, int b, int val) { Node* p = new Node; p->id = a; p->val = val; p->next = node[b].next; node[b].next = p; } void heappush(int id, int val) { heap[++tail].id = id; heap[tail].val = val; int child, parent, temp; child = tail; while((parent = child/2)>=1) { if(heap[child].val < heap[parent].val) // child's val < parent's val ; swap ,filter { temp = heap[child].id; heap[child].id = heap[parent].id; heap[parent].id = temp; temp = heap[child].val; heap[child].val = heap[parent].val; heap[parent].val = temp; child = parent; } else break; } } int heappop() { int child, parent, temp,ret; ret = heap[1].id; heap[1].id = heap[tail].id;

// swap the tail to the root heap[1].val = heap[tail--].val; parent = 1; while((child=2*parent)<=tail) { if(child+1<=tail && heap[child+1].val < heap[child].val) child++; if(heap[child].valid] = p->val; heappush(p->id, p->val); p = p->next; } mark[s] = true; dist[s] = 0; for(i=1; i
if(!mark[p->id]&&

(dist[p->id]==MAXX || dist[pop]+p->val< dist[p->id])) { dist[p->id] = dist[pop] + p->val; heappush(p->id, dist[p->id]); } p = p->next; } } return dist[t]; } int main() { int i,a,b,c; scanf("%d%d", &n, &m); for(i=1; i<=m; i++) { scanf("%d%d%d", &a, &b, &c); insert(a, b, c); } printf("%d\n", dijkstra(n,1)); return 0; }

luis 2009-08-09 21:28 发表评论

求最��支撑数 prim��法实现

luis — Sun, 09 Aug 2009 11:52:00 GMT
#include
#define MAX 0xfffffff
#define MaxVertex 21
//prim求最��支持树�Q�多用于求边�E�密�|�的最��支持树旉��复杂度O(n*n)n为顶�Ҏ��;
#define vertextype int
int n;
bool s[MaxVertex];//该点是否被访�?
vertextype cost[MaxVertex];
vertextype dist[MaxVertex][MaxVertex];
void Init()
{
int i,j,a,b,c;
scanf("%d",&n);//先输入点个数
    for(i=1;i<=n;i++)
     for(j=1;j<=n;j++)
      dist[i][j]=MAX;
    while(scanf("%d%d%d",&a,&b,&c),a||b||c)//0 0 0表示边输入结�?
     dist[a][b]=dist[b][a]=c;
    s[1]=true;//该点已经被访�?br>    for(i=2;i<=n;i++)
    {
     cost[i]=dist[1][i];
     s[i]=false;//初始化�ؓfalse
    }
}
int main()
{
freopen("s.txt","r",stdin);
freopen("key.txt","w",stdout);
int i,j,k,m,a,b,c,best,min;
    best=0;
Init();
for(i=1;i{
min=MAX;
j=1;
for(k=2;k<=n;k++)
  if(cost[k]  {
   min=cost[k];
   j=k;
  }
  s[j]=true;
  best+=min;
  for(k=2;k<=n;k++)
  {
   if(dist[j][k]  //dist[j][j]   cost[k]=dist[j][k];
  }
}
printf("%d\n",best);
return 0;
}
学以致用 joj 1170

luis 2009-08-09 19:52 发表评论

dijkstra的邻接表实现

luis — Sun, 09 Aug 2009 03:19:00 GMT
#include
using namespace std;
//求单源最��\径，不妨设源点�ؓ1�Q�算法思想�?
//从未讉K��的顶点中选择dv最��的点（d��Z��该点到源�?的距��）令arcs[v][v]=1
//考虑v的所有邻接顶点w�Q�不断尝试若dv+weight(v,w)//�q�里选择dv最��的很关键，因�ؓ最��，所以肯定是最短�\径，其他的d会不断更新�?
#define MaxVertx 100//最多边长度
#define MAX 1e+8
typedef char vertextype;
typedef float adjtype;
typedef struct{
  int n;//��点个数
  vertextype vertex[MaxVertx];
  adjtype arcs[MaxVertx][MaxVertx];//��L��矩阵形式
}Graph;
typedef struct{
  vertextype vertex;//��点信息
  adjtype length;//最��长�?nbsp;
  int prev;//最短�\径上前驱�l�点�~�号
}Path;
Path dist[MaxVertx];
Graph graph;
void init(Graph *pgraph,Path dist[])
{
  int i;
  dist[0].length=0;
  dist[0].prev=0;
  dist[0].vertex=pgraph->vertex[0];//�W�一个顶点的名称/�~�号
  pgraph->arcs[0][0]=1; /* 表示��点v0在集合U�?*/

   for(i = 1; i < pgraph->n; i++)              /* 初始化集合V-U中顶点的距离�?*/
    {
    dist[i].length=pgraph->arcs[0][i];
    dist[i].vertex=pgraph->vertex[i];
    if(dist[i].length!=MAX)
         dist[i].prev=0;
    else
         dist[i].prev=-1;
    }
}
void dijkstra(Graph graph,Path dist[])
{
  int i,j,minvex;
  adjtype min;
  init(&graph,dist); /* 初始化，此时集合U中只有顶点v0*/
  for(i=1;i  {
   min=MAX;
   minvex=0;
   for(j=1;j   if(graph.arcs[j][j]==0&&dist[j].length   {
    min=dist[j].length;
    minvex=j;
   }
   if(minvex==0)break;/* 从v0没有路径可以通往集合VU中的��点 */
   graph.arcs[minvex][minvex]=1;//表示已经讉K��q�了�Q�不属于VU集合
   for(j=1;j   {
    if(graph.arcs[j][j]==1)continue;
    if(dist[j].length > dist[minvex].length + graph.arcs[minvex][j])//如果不相邻，则arcs[minvex][minvex]=+无穷
    {
                dist[j].length = dist[minvex].length + graph.arcs[minvex][j];
                dist[j].prev = minvex;
        }
   }
  }
}
void initgraph()//初始化矩�?
{
int i,j;
    graph.n=6;
    for (i = 0; i < graph.n; i++)
        for (j = 0; j < graph.n; j++)
            graph.arcs[i][j] = (i == j ? 0 : MAX);
    graph.arcs[0][1] = 50;
    graph.arcs[0][2] = 10;
    graph.arcs[1][2] = 15;
    graph.arcs[1][4] = 5;
    graph.arcs[2][0] = 20;
    graph.arcs[2][3] = 15;
    graph.arcs[3][1] = 20;
    graph.arcs[3][4] = 35;
    graph.arcs[4][3] = 30;
    graph.arcs[5][3] = 3;
    graph.arcs[0][4] = 45;
}
int main()
{
//freopen("s.txt","r",stdin);
//freopen("key.txt","w",stdout);
   int i;
    initgraph();
    dijkstra(graph, dist);
    for (i = 0; i < graph.n; i++)
        printf("(%.0f %d)", dist[i].length,dist[i].prev);
    getchar();
return 0;
}

luis 2009-08-09 11:19 发表评论

joj 2035 Leaf Nodes

luis — Tue, 14 Jul 2009 14:14:00 GMT
Leaf Nodes

Status In/Out TIME Limit MEMORY Limit Submit Times Solved Users JUDGE TYPE

stdin/stdout 1s 10240K 222 102 Standard

Kate is learning about binary tree. She think she know everything you know about binary trees. Wait, you don't know binary tree? Find a book about data structures, and it will just take you about three minutes. Now here is a binary tree:

3 / \ / \ 2 4 / \ \ / \ \ 0 1 6 / / 5

Kate think she also know something that you may not notice. First, for some type of binary trees, only the leaf nodes have the meaning (leaf node is the node which has no sub trees, for the tree above, the leaf nodes are 0 1 5), an example is the Huffman Tree. Second, she guess that if you know the preorder traversal and the postorder traversal of a binary tree, you can ensure the leaf node of the tree, and their order.

For the tree above, the preorder travesal is 3 2 0 1 4 6 5 and the postorder travesal is 0 1 2 5 6 4 3, the leaf nodes in order(from left to right) are 0 1 5.

But now the problem is she just guess it, if you can find a way to print a tree's leaf nodes in order using its preorder traversal and postorder traversal, you can say "she is right!"

Input Specification

The input file will contain one or more test cases. In each test case there is a integer n (0<=n <= 10000), indicating the tree have n nodes, then followed two lists of integers, either contains n integers in the range of 0 and n-1 (both included), the first list is the preorder traversal, and the other is the postorder traversal.

Input is terminated by an interger -1;

Output Specification

For each test case, print the tree's leaf nodes in order, each in a line.

Sample Input

7 3 2 0 1 4 6 5 0 1 2 5 6 4 3 -1

Sample Output

0 1 5
�Ҏ��一个重要结论，无论是先根还是后栚w��历，左子树的�l�点��L��出现在右子树�l�点的前�?br>
                                 G
                                /   \
                              F        B
                            /        /   \
                          K         C      H
                        /   \             /
                      D       E         J
                        \
                          A
                        /
                      I

不论先根后根�Q�左子树的结�Ҏ��L��出现在右子树�l�点的前面�?nbsp;
G为根树，先根�ơ序时G后跟F�Q�后�Ҏ��序时F前有DIAEKF�Q�故DIAEKF为G的左子树的结点，
CJHB为G的右子树的结炏V��且左右子树的先根序为：FKDIAE�Q�BCHJ�?br> 递归处理两子树即可搞�?br>
void find(int preb,int pree,int postb,int poste)
   {
   int i=s(pre,post[poste-1]);
  int j=s(post,pre[preb+1]);
//��d��处理的代�?br> //判断是否有左/��x��

    find(preb+1,i-1,postb,j);
  find(i,pree,j+1,poste-1);
   }
但是上面的思�\�?strong>错误的！�Q�！�Q�！�Q�！�Q�！�Q�！�Q�！�Q?/span>
只知道先序和后序不能能推出树�?

只有中序和先序或者中序和后序才可�?

不然只知道根节点,但是哪些是左子树哪些是右子树��׃��知道�?br>比如先序�?234
后序�?321的二叉树�?�U�比如：
1 1
\ /
2 2
/ /
3 3
\ /
4 4

正确思�\�Q�先遍历后根�ơ序�Q�第一个一定�ؓ叶子�Q�设为当前结点，然后依次��，如果该点在先根序列中位于当前节点的后面，则�ؓ叶子节点�Q�同时更新当前结炏V�?/div>

luis 2009-07-14 22:14 发表评论

一本久久综合亚洲鲁鲁五月天,999久久久国产精品,久久久久久久久无码精品亚洲日韩

Dijkstra(�q�杰斯特�?���法

问题描述

dijkstra���法 最���堆优化 <不用stl>转帖

求最���支撑数 prim���法 实现

dijkstra的邻接表实现

joj 2035 Leaf Nodes

Input Specification

Output Specification

Sample Input

Sample Output

Dijkstra(�q�杰斯特�?��法

dijkstra��法最��堆优化 <不用stl>转帖

求最��支撑数 prim��法实现