C++博客-雪黛依梦-随笔分类-最小生成树

hdu 1548 狄杰斯特拉

雪黛依梦 — Thu, 26 Aug 2010 12:38:00 GMT

开始做这题的时候总是将它和最小生成树算法混淆，最短路径初始的时候是存的从其点到其他各点的距离，没有的设为无穷，每次都是找出最短的路径值（同时标记该顶点，说明已经找到了最短的路径，不需要再修改），并且不断修改起点到其他各点的距离，如此循环，知知道所有顶点都访问；

//思路：本质是找从 A 到 B 的最短路径，如果最短路径存在则一定会用满足题意的按最少次数的按钮
//如果最短路径不存在肯定找不到，输出 -1
//这里将可以到达的点设为 1, 是因为如果可以到达就按了一下按钮，如果不可到达则仍然是MAX
//此题中如果有某一个点找不到到达它的最短路径，说明电梯到达这一层之后不可能再达到其他任何了，所以return返回主函数检查；这是和模板不同的地方

#include <iostream>
#include <string>
using namespace std;

#define MAXN 99999999
int button[201];        //存储每一层按下按钮之后可升降的层数
int map[201][201];

int dist[201];
int visit[201];
int n, a, b;

void dijkstra ()
{
    for (int i = 1; i <= n; i ++)
    {
        dist[i] = map[a][i];                     //初值是起点到每个点的距离！
    }

    dist[a] = 0;

    int k, min;
    for ( int i = 1; i <= n; i ++ )
    {
        min = MAXN;
        for (int j = 1; j <= n; j ++)
        {
            if ( !visit[j] && dist[j] < min )                  //找最短的距离
            {
                 min = dist[j];
                 k = j;
            }
        }

       if ( min == MAXN )   //没有最短路了             // 顺序
           return ;
       visit[k] = 1;


        for (int j = 1; j <= n; j ++)
        {
            if ( !visit[j] && map[k][j] + dist[k] < dist[j] )
            {
                 dist[j] = map[k][j] + dist[k];
            }
        }
    }
}

int main ()
{

    while ( scanf ("%d", &n) != EOF && n )
    {
          scanf ( "%d %d", &a, &b );

          memset ( button, 0, sizeof (button) );
          memset ( dist, 0, sizeof (dist) );
          memset ( visit, 0, sizeof (visit) );

          for ( int i = 1; i <= n; i ++ )
          {
              for ( int j = 1; j <= n; j ++ )
              {
                  map[i][j] = MAXN;
              }
          }

          for ( int i = 1; i <= n; i ++ )
          {
              scanf ("%d", &button[i]);
              if ( i + button[i] <= n )
              {
                   map[i][i + button[i]] = 1;
              }
              if ( i - button[i] >= 1 )    //最大的错误不是else if啊！！！！
              {
                   map[i][i - button[i]] = 1;
              }
          }

          dijkstra ();

          if ( dist[b] < MAXN )               //有路径到达
          printf ("%d\n", dist[b]);
          else
          printf ("%d\n", -1);

    }

     //system ("pause");
     return 0;
}

雪黛依梦 2010-08-26 20:38 发表评论

hdu 1233 kruskal + 并查积

雪黛依梦 — Thu, 26 Aug 2010 08:02:00 GMT

//用并查积和克鲁是卡尔算法实现查找最短边
//利用快排按边递增排列，每次从中选出最短边,同时将最短边的两个顶点并入到集合中
心得：利用并查积和 kruskal算法结合找最短路径可以使查找的效率更高
本题的关键是正确地设定好两个数组，一个是用于存放顶点边值的node1，另一个是用于并查积处理的node2，并且将这两个数组联系好
加入集合中的边都是构成最小生成树的边，所以每家一次sum 都要加上这两个顶点之间的距离

#include <iostream>
#include <string>
using namespace std;

struct node1           //用于存放顶点和边值
{
    int x;
    int y;
    int distance;
};
node1 edge[5010];     // n 个顶点的边无向图最多有  n * (n - 1) / 2 条边

struct node2          //并查积数组
{
    int parent;
    int height;
};
node2 village[100];

bool cmp ( const node1 &a, const node1 &b )
{
     return a.distance < b.distance;
}
//并查积初始化
void set ( int n )
{
     for ( int i = 1; i <= n; i++)
     {
         village[i].parent = i;
     }
}

//找根节点
int findfather (int a)
{
       while ( a != village[a].parent )     //理解while 树状结构：找到最终的跟节点
             a = village[a].parent;
             return a;
}

//合并到同一集合
void merge (int a, int b)      //注意参数：要合并两个节点的根
{
     if ( village[a].height == village[b].height )
     {
          village[b].parent = a;
          village[a].height ++;
     }

     //小树合并到大树
     else if ( village[a].height > village[b].height )
     {
          village[b].parent = a;
     }
     else
     village[a].parent = b;
}

int main ()
{
     int n, k;
     int x, y, d;
     int a, b;
     while ( scanf ("%d", &n ) != EOF && n )
     {
           set ( n );
           memset ( edge, 0, sizeof (edge) );

           //输入处理
           k = n * ( n - 1 ) / 2;
           for ( int i = 0; i < k; i ++ )
           {
               scanf ( "%d %d %d", &x, &y, &d );
               edge[i].x = x;
               edge[i].y = y;
               edge[i].distance = d;
           }
           //排序
           sort ( edge, edge + k, cmp );

           //从已排好的序列中选出最短边同时利用并查积构建图
           int sum = 0;
           for ( int i = 0; i < k; i++ )
           {
               a = findfather ( edge[i].x );
               b = findfather ( edge[i].y );

               if ( a != b )
               {
                    merge ( a, b );
                    sum += edge[i].distance;
               }
           }
           printf ( "%d\n", sum );
     }
     //system ("pause");
     return 0;
}

雪黛依梦 2010-08-26 16:02 发表评论

hdu 1162 prim算法模板

雪黛依梦 — Mon, 23 Aug 2010 07:35:00 GMT

和 1102 完全一个类型的，只是调用几个数学函数求距离

1
2#include <stdio.h>
3#include <stdlib.h>
4#include <string.h>
5
6int main ()
7{
8    int n, q, a, b;
9    int lowcost[101];               //开始时储存源点到其他各顶点的边值，随后根据加进来的顶点，不断改变所存的边值
10    int edge[101][101];             //存输入的边之间的长度
11    int visit[101];                 //标志顶点是否已经加入
12
13    while ( scanf ("%d", &n)!= EOF )
14    {
15           memset (visit, 0, sizeof (visit));
16           memset (lowcost, 0, sizeof (lowcost));
17
18          //输入处理
19          for (int i = 1; i <= n; i ++)
20          {
21              for (int j = 1; j<= n; j ++)
22              {
23                  scanf ("%d", &edge[i][j]);
24              }
25          }
26          scanf ("%d", &q);
27          if ( q )
28          {
29               for (int i = 0; i < q; i ++)  //本身存在边则该顶点被标记
30               {
31                   scanf ("%d %d", &a, &b);
32                   edge[a][b] = edge[b][a] = 0;
33               }
34          }
35
36          //prime:每次都从剩下的边中选出最短的一条，标记相关的顶点，并且修改相关边的值
37          //对lowcost 进行初始化处理
38          for (int i = 1; i <= n; i ++ )
39          {
40              lowcost[i] = edge[1][i];
41          }
42
43          int sum = 0;
44          int k;
45          for (int i = 1; i <= n; i ++)
46          {
47              int max = 10000;
48
49              for ( int i = 1; i <= n; i ++ )
50              {
51                  if ( lowcost[i] < max && !visit[i] )
52                  {
53                     max = lowcost[i];
54                     k = i;
55                  }
56              }
57
58              if (max == 10000)  //如果没有找到最小的边一下一个顶点作为起点  ，这就是和找最短路径不同的地方
59              break;
60
61              visit[k] = 1;
62              sum += lowcost[k];
63
64              for (int i = 1; i <= n; i ++)
65              {
66                  if ( !visit[i] && lowcost[i] > edge[k][i])  //新引入的顶点到其他顶点的边值  是否小于  原来的边值
67                  {
68                       lowcost[i] = edge[k][i];
69                  }
70              }
71          }
72          printf ("%d\n", sum);
73    }
74   // system ("pause");
75    return 0;
76}
77

雪黛依梦 2010-08-23 15:35 发表评论

hdu 1102

雪黛依梦 — Mon, 23 Aug 2010 06:06:00 GMT

//运用prime 算法解决最小生成树问题 :这里默认从第一个顶点开始
//本题中要求输出最终的最短路径的和，所以将开始就有的路之间的边长设为 0
//奉献了好多次的WA 结果是因为在将已有边存在的地方只设定了 edge[a][b] = 0; 出错
本题的关键运用在于辅助数组 lowcost[ ] 的使用

1
2#include <stdio.h>
3#include <stdlib.h>
4#include <string.h>
5
6int main ()
7{
8    int n, q, a, b;
9    int lowcost[101];               //开始时储存源点到其他各顶点的边值，随后根据加进来的顶点，不断改变所存的边值
10    int edge[101][101];             //存输入的边之间的长度
11    int visit[101];                 //标志顶点是否已经加入
12
13    while ( scanf ("%d", &n)!= EOF )
14    {
15           memset (visit, 0, sizeof (visit));
16           memset (lowcost, 0, sizeof (lowcost));
17
18          //输入处理
19          for (int i = 1; i <= n; i ++)
20          {
21              for (int j = 1; j<= n; j ++)
22              {
23                  scanf ("%d", &edge[i][j]);
24              }
25          }
26          scanf ("%d", &q);
27          if ( q )
28          {
29               for (int i = 0; i < q; i ++)  //本身存在边则该顶点被标记
30               {
31                   scanf ("%d %d", &a, &b);
32                   edge[a][b] = edge[b][a] = 0;
33               }
34          }
35
36          //prime:每次都从剩下的边中选出最短的一条，标记相关的顶点，并且修改相关边的值
37          //对lowcost 进行初始化处理
38          for (int i = 1; i <= n; i ++ )
39          {
40              lowcost[i] = edge[1][i];
41          }
42
43          int sum = 0;
44          int k;
45          for (int i = 1; i <= n; i ++)
46          {
47              int max = 10000;
48
49              for ( int i = 1; i <= n; i ++ )
50              {
51                  if ( lowcost[i] < max && !visit[i] )
52                  {
53                     max = lowcost[i];
54                     k = i;
55                  }
56              }
57
58              if (max == 10000)  //如果没有找到最小的边一下一个顶点作为起点
59              break;
60
61              visit[k] = 1;
62              sum += lowcost[k];
63
64              //修改要加入的顶点到其他未加入顶点之间的距离
                       for (int i = 1; i <= n; i ++)
65              {
66                  if ( !visit[i] && lowcost[i] > edge[k][i])  //新引入的顶点到其他顶点的边值  是否小于  原来的边值
67                  {
68                       lowcost[i] = edge[k][i];
69                  }
70              }
71          }
72          printf ("%d\n", sum);
73    }
74   // system ("pause");
75    return 0;
76}
77

雪黛依梦 2010-08-23 14:06 发表评论