UPC-9519 New Game 前向星+Dijkstra算法

最短路径算法在复杂场景的应用
本文介绍了一个使用最短路径算法解决复杂场景中点到点距离问题的实例,通过构建图结构并运用Dijkstra算法,实现了在考虑多个圆盘障碍物、不同成本路径及额外节点的情况下,寻找从起点到终点的最优路径。文章详细展示了算法实现过程,包括障碍物处理、成本计算及路径优化等关键步骤。

题目传送门

AC代码:(其实我也看不懂= =)

#include<bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn=1e6+7;
struct Edge{
    int nex,to;
    double w;
}edge[maxn];
int head[maxn];
bool vis[maxn];
int cnt=0;
double dis[maxn];
int  a,b,c1,c2;
int  x[maxn],y[maxn],r[maxn];
int n;
inline void add(int u,int v,double w){
    edge[cnt].to=v;
    edge[cnt].w=w;
    edge[cnt].nex=head[u];
    head[u]=cnt++;
}
inline void read(int&x) {
    int f=1;x=0;char c=getchar();
    while(c>'9'||c<'0') {if(c=='-') f=-1;c=getchar();}
    while(c>='0'&&c<='9') {x=(x<<3)+(x<<1)+c-48,c=getchar();}
    x=x*f;
}
 
typedef pair<double, int> P;
 
void dij(int s){
    priority_queue<P ,vector<P>,greater<P> >q;
    memset(vis,0,sizeof vis);
    for(int i=0;i<n+2;i++)
        dis[i]=(double)1e18;
    dis[s] = 0;
    q.push(P(0,s));
    while (!q.empty()){
        P p = q.top();
        q.pop();
        int u = p.second;
        if(vis[u])continue;
        vis[u] = 1;
        for(int i = head[u];~i;i=edge[i].nex){
            int v = edge[i].to;
            double w = edge[i].w;
            if(dis[v]>dis[u]+w&&!vis[v]){
                dis[v] = dis[u]+w;
                q.push(P(dis[v],v));
            }
        }
    }
 
}
int main()
{
    scanf("%d%d%d%d%d",&n,&a,&b,&c1,&c2);
    for(int i=1;i<=n;i++)
        scanf("%d%d%d",&x[i],&y[i],&r[i]);
    cnt=0;
    memset(head,-1,sizeof head);
    double t=abs(c1-c2)/sqrt(a*a+b*b);
    add(0,n+1,t);
//    mp[0].push_back(make_pair(0,0));
    add(n+1,0,t);
//    mp[n+1].push_back(make_pair(n+1,0));
    for(int i=1;i<=n;i++)
    {
        double t1=abs(a*x[i]+b*y[i]+c1)/sqrt(a*a+b*b)-r[i];
        if(t1<0) t1=0;
        add(i,0,t1);
        add(0,i,t1);
        double t2=abs(a*x[i]+b*y[i]+c2)/sqrt(a*a+b*b)-r[i];
        if(t2<0) t2=0;
        add(n+1,i,t2);
        add(i,n+1,t2);
    }
    for(int i=1;i<=n;i++)
    {
//        mp[i].push_back(make_pair(i,0));
        for(int j=i+1;j<=n;j++)
        {
            double t3=sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]))-r[i]-r[j];
            if(t3<0) t3=0;
            add(i,j,t3);
            add(j,i,t3);
        }
    }
    dij(0);
    printf("%.6f\n",dis[n+1]);
    return 0;
}

 

### Dijkstra算法与链式向星的结合实现 #### 背景介绍 Dijkstra算法是一种经典的单源最短路径算法,适用于带权重的有向图。它通过维护一个距离数组 `dist[]` 来记录从起点到其他各点的当最小距离,并不断更新这些值直到找到全局最优解[^3]。 链式向星则是一种高效的存储图的方式,类似于邻接表但更加节省空间和易于实现。它的核心思想是利用链表的思想来存储每条边的信息,从而减少内存消耗并提高访问效率[^2]。 当两者结合时,可以通过链式向星快速读取图中的边信息,而Dijkstra算法负责计算最短路径。为了进一步提升性能,通常会引入优先队列优化,使得每次都能高效选取当未处理节点中具有最小临时距离的一个节点[^4]。 以下是具体实现方法: --- #### 数据结构设计 1. **边结构定义** 定义一条边的数据结构,包含三个主要成员变量:终点编号 (`to`)、权值 (`weight`) 和下一条边的位置索引 (`next`)。 ```cpp struct Edge { int to; // 边的目标顶点 int weight; // 边的权值 (即长度) int next; // 下一条边在 edges 数组中的位置 }; ``` 2. **辅助数组** - `head[]`: 记录每个节点的第一条边在 `edges` 数组中的起始位置。 - `edges[]`: 存储所有的边信息。 - `cnt`: 当已有的边数量计数器。 --- #### 构建图的过程 初始化阶段需完成如下操作: - 初始化 `head[]` 数组为 `-1` 表示初始状态下没有任何边连接至任何节点; - 对于输入的每一条新边 `(u, v)` 及其对应的权值 `w` ,将其加入数据结构中。 ```cpp // 添加边 u -> v 的函数 void addEdge(int from, int to, int weight) { edges[cnt].to = to; edges[cnt].weight = weight; edges[cnt].next = head[from]; // 将该边链接到头结点之后 head[from] = cnt++; // 更新头指针指向最新添加的这条边 } ``` 上述过程实现了动态增加边的功能,其中每一次调用都会把新增加的一条边挂载到对应出发点所关联的所有边上形成一个新的链条顶端[^5]。 --- #### 主要逻辑流程 基于以上准备好的基础架构之上执行标准版或者堆优化版本的迪杰斯特拉搜索即可得到最终结果。下面给出完整的C++代码样例展示整个过程: ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 7; // 最大可能存在的顶点数目 int dist[MAXN], vis[MAXN]; struct Edge { // 边结构体 int to, weight, next; } edges[2 * MAXN]; int n, m, s, t, cnt, head[MAXN]; // 加入边的方法 void addEdge(int from, int to, int w){ edges[cnt].to=to; edges[cnt].weight=w; edges[cnt].next=head[from]; head[from]=cnt++; } priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> pq;//小根堆 void dijkstra(){ memset(dist,0x3f,sizeof(dist)); memset(vis,0,sizeof(vis)); dist[s]=0;pq.push({0,s}); while(!pq.empty()){ pair<int,int> cur=pq.top();pq.pop(); int d=cur.first,u=cur.second; if(vis[u])continue; vis[u]=true; for(int i=head[u];i!=-1;i=edges[i].next){ int v=edges[i].to,w=edges[i].weight; if(!vis[v] && dist[v]>dist[u]+w){ dist[v]=dist[u]+w; pq.push({dist[v],v}); } } } } int main() { cin>>n>>m>>s>>t; memset(head,-1,sizeof(head));cnt=0; for(int i=0;i<m;i++){ int a,b,c; scanf("%d%d%d",&a,&b,&c); addEdge(a,b,c); } dijkstra(); cout <<(dist[t]==INT_MAX?-1:dist[t]); return 0; } ``` 此程序片段展示了如何运用链式向星配合优先级队列加速后的Dijkstra算法寻找两点间最短路径的实际应用案例。 --- #### 性能分析 相比于传统的矩阵表示方式,这种方法极大地减少了不必要的比较次数;借助二叉堆等高级容器还能让提取下一个最近邻居的操作变得极为迅速,整体时间复杂度降到了 O((V+E)*log(V)) 水平之下。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值