hdu2066 dij

  //去重边   1 #include<stdio.h>
  2 #include<string.h>
  3 #include<queue>
  4 #define maxint 999999999
  5 using namespace std;
  6 int min(int x,int y)
  7 {
  8     return x<y?x:y;
  9 }
 10 struct node
 11 {
 12     int v;
 13     int w;
 14     int next;
 15 }edge[100000];
 16 int vis[2000],head[2000],st[2000];
 17 int n,m,index,d,a[2000],set,dis[2000];
 18 struct Node
 19 {
 20     int point;
 21     int dist;
 22     bool operator<(const Node x) const
 23     {
 24         return x.dist<dist;
 25     }
 26 };
 27 void add(int x,int y,int z)
 28 {
 29     int i,j;
 30     edge[index].v=y;
 31     edge[index].w=z;
 32     edge[index].next=head[x];
 33     head[x]=index++;
 34 }
 35
 36 void dij(int s)
 37 {
 38     priority_queue<Node> q;
 39     int i,j;
 40     for(i=1;i<=set;i++)
 41     {
 42         dis[i]=maxint;
 43     }
 44     dis[s]=0;
 45     Node cur;
 46     cur.point=s;
 47     cur.dist=0;
 48     q.push(cur);
 49     while(!q.empty())
 50     {
 51         Node tmp;
 52         tmp=q.top();
 53         q.pop();
 54         int u=tmp.point;
 55         if(vis[u])
 56             continue;
 57         vis[u]=1;
 58         for(j=head[u];j!=-1;j=edge[j].next)
 59         {
 60             if(!vis[edge[j].v]&&dis[edge[j].v]>dis[u]+edge[j].w)
 61             {
 62                 dis[edge[j].v]=dis[u]+edge[j].w;
 63                 cur.dist=dis[edge[j].v];
 64                 cur.point=edge[j].v;
 65                 q.push(cur);
 66             }
 67         }
 68     }
 69 }
 70 int main()
 71 {
 72     int i,j;
 73     while(scanf("%d%d%d",&n,&m,&d)!=EOF)
 74     {
 75         set=0;
 76         int flag;
 77         memset(head,-1,sizeof(head));
 78         for(i=1;i<=n;i++)
 79         {
 80             int x,y,z;
 81             scanf("%d%d%d",&x,&y,&z);
 82             for(flag=0,j=head[x];j!=-1;j=edge[j].next)
 83             {
 84                 if(y == edge[j].v)
 85                 {
 86                     if(z < edge[j].w)
 87                         edge[j].w=z;
 88                     flag = 1;
 89                     break;
 90                 }
 91              }
 92             if(set<x)
 93                 set=x;
 94             if(set<y)
 95                 set=y;
 96             if(flag)continue;
 97             add(x,y,z);
 98             add(y,x,z);
 99         }
100         for(i=1;i<=m;i++)
101         {
102             scanf("%d",&st[i]);
103         }
104         for(i=1;i<=d;i++)
105             scanf("%d",&a[i]);
106         int ans=maxint;
107         for(i=1;i<=m;i++)
108         {
109             memset(vis,0,sizeof(vis));
110              dij(st[i]);
111              for(j=1;j<=d;j++)
112              {
113
114                  ans=min(ans,dis[a[j]]);
115              }
116         }
117         printf("%d\n",ans);
118     }
119 }
时间: 2024-12-20 17:05:19

hdu2066 dij的相关文章

poj1122 FDNY to the Rescue!(dij+反向建图+输出路径)

题目链接:poj1122 FDNY to the Rescue! 题意:给出矩阵,矩阵中每个元素tij表示从第i个交叉路口到第j个交叉路口所需时间,若tij为-1则表示两交叉路口之间没有直接路径,再给出火警位置所在的交叉路口 和 一个或多个消防站所处的交叉路口位置.输出要求按消防站到火警位置所需时间从小到大排列,输出信息包括消防站位置(初始位置),火警位置(目标位置),所需时间,最短路径上每个交叉路口. 题解:反向建图,从火警位置求一次最短路,求最短路时记录路径,按时间从小到大输出. 1 #in

dij+堆优化

写这个dij+堆优化的原因是有些地方卡SPFA,只能搞这个: 香甜的奶油: 1 #include<iostream> 2 #include<cstdio> 3 #include<cstring> 4 #include<string> 5 #include<cstdlib> 6 #include<ctime> 7 #include<vector> 8 #include<algorithm> 9 #include&

hdu1245+dij,堆优化

有一片100*100的湖泊,中心坐标(0,0),即湖泊右上角的坐标是(50,50),湖泊中间有一片以(0,0)为圆心,15为直径的圆形陆地.现有一个人在陆地,湖泊中散布着一些点可以踩,这个人要利用这些点跳到岸上,求最短路径和最短路径下的最短步数. spfa莫名其妙的超时,dij+堆优化反而能过...可能spfa更适合有向图吧. 使用vector<vector<node> > g这种双重结构时,最好先g.resize(N)设置一下容量,否则直接插入会出错. 1 #include<

POJ 2387 Til the Cows Come Home(dij+邻接矩阵)

( ̄▽ ̄)" //dijkstra算法: //这题建邻接矩阵的时候有坑(先读入边后读入点),还有重边: #include<iostream> #include<cstdio> using namespace std; const int INF=10e7; const int MAXN=2010; int k,minn; int cost[MAXN][MAXN]; int lowcost[MAXN]; bool vis[MAXN]; void dij(int n,int

POJ 1062 昂贵的聘礼(dij+邻接矩阵)

( ̄▽ ̄)" #include<iostream> #include<cstdio> #include<cstring> #include<cstdlib> using namespace std; const int INF=10e8; const int MAXN=110; int k,minn; int c[MAXN][MAXN],lc[MAXN],level[MAXN],X[MAXN]; bool vis[MAXN]; int dij(in

POJ 3268 Silver Cow Party(dij+邻接矩阵)

( ̄▽ ̄)" #include<iostream> #include<cstdio> #include<algorithm> #include<cstring> #include<queue> using namespace std; const int INF=10e8; const int MAXN=1010; int k,minn; int cost[MAXN][MAXN],lowcost[MAXN],lc[MAXN]; bool

HDU 1548 A strange lift(dij+邻接矩阵)

( ̄▽ ̄)" //dijkstra算法, //只是有效边(即能从i楼到j楼)的边权都为1(代表次数1): //关于能否到达目标楼层b,只需判断最终lowtime[b]是否等于INF即可. #include<iostream> #include<cstdio> using namespace std; const int INF=10e7; const int MAXN=210; int k,minn; int K[MAXN]; int cost[MAXN][MAXN];

poj 3013 Big Christmas Tree (dij+优先级队列优化 求最短)

模板 意甲冠军:给你一个图,1始终根,每一方都有单价值,每个点都有权重新. 每个边缘的价格值 = sum(后继结点重)*单价方值. 最低价格要求树值,它构成了一棵树n-1条边的最小价值. 算法: 1.由于每一个边的价值都要乘以后来訪问的节点的权重.而走到后来訪问的点必经过这条边. 实际上总价值就是  到每一个点的最短路径*这个点的权重. 2.可是这个题 数据量真的太大了.50000个点,50000条边. 写普通的dij算法tle. 必须加优先队列优化- - 据说spfa也能过.可是spfa算法不

UVA 12661(动态权值+最短路,dij)

题意:赛车背景,给你n个节点,m条边的图以及起点和终点:其中每条边的信息包括u(起点),v(终点),a(开启的时间),b(关闭的时间),d(通过这条道路的时间):求最短通过的时间,其中车在进的时候,保证时间足够能走出去:否则需要等一些分钟: 思路:dij真是万能的,把固定权值改成动态的即可: 其中改变权值的语句很关键,并且推出的规律有个前提就是保证道路打开的时间一定大于等于通过该条道路的时间,否则相当于道路不通,被我忽略了,WA了3遍,可惜: 1 #include <iostream> 2 #