[模板]Dijkstra

本文提供了一个用于C++编程竞赛的基础代码模板,包含了常用的库文件引入、宏定义、输入输出加速等技巧,并实现了如快速读取、求幂模、最大公约数等功能。

决定开坑模板。

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<math.h>
#include<vector>
#include<map>
#include<queue>
#include<time.h>
#include<fstream>
#include<string>
#include<set>
#include<list>
#include<stdlib.h>
#define fr(i,a,b) for(int i=a,_end_=b;i<=_end_;i++)
#define fd(i,a,b) for(int i=a,_end_=b;i>=_end_;i--)
#define frei(s) freopen(s,"r",stdin)
#define freo(s) freopen(s,"w",stdout)
#define ll long long
#define uns unsigned
using namespace std;
#define rt return
#define gc getchar()
#define ln putchar('\n')
ll lowbit(ll x)
{
    rt x&(-x);
}
int read()
{
    int s=0,k=1;
    char c=getchar();
    while((c<'0'||c>'9')&&c!='-')c=gc;
    if(c=='-'){
        k=-1;
        c=gc;
    }
    while(c>=48&&c<='9'){
        s=(s<<3)+(s<<1)+(c^48);
        c=gc;
    }
    rt s*k;
}
ll readmod(ll p)
{
    ll s=0;
    int k=1;
    char c=getchar();
    while((c<'0'||c>'9')&&c!='-')c=gc;
    if(c=='-'){
        k=-1;
        c=gc;
    }
    while(c>=48&&c<='9'){
        s=(s<<3)+(s<<1)+(c^48);
        s%=p;
        c=gc;
    }
    rt s*k;
}
int exgcd(int a,int b,int &x,int &y)  
{  
    if(b==0)  
    {  
        x=1;
        y=0;  
        return a;  
    }  
    int d=exgcd(b,a%b,x,y);  
    int temp=x;  
    x=y;  
    y=temp-a/b*y;  
    return d;  
}  
double log(double x,double y)
{
    rt log10(x)/log10(y);
}
ll gcd(ll x,ll y)
{
    rt y?gcd(y,x%y):x;
}
ll P(ll x,ll y)//x>=y
{
    ll r=1;
    fr(i,1,y)
        r*=(x-i+1);
    rt r;
}
ll P(ll x,ll y,ll modnum)//x>=y
{
    ll r=1;
    fr(i,1,y)
        r=r*(x-i+1)%modnum;
    rt r;
}
ll power(ll x,ll y,ll p)//x^y%p
{
    x%=p;
    y%=p;
    ll r=1;
    while(y)
    {
        if(y&1)r=r*x%p;
        y>>=1;
        x=x*x%p;
    }
    rt r;
}
int n,m,s,g[10010],p[10010],k,minn;
vector<int>t[10010];
vector<int>w[10010];
int main(){
#ifndef ONLINE_JUDGE
    freopen("","r",stdin);
    freopen("","w",stdout);
#endif
#define inf 0x7fffffff
    n=read();
    m=read();
    s=read();
    fr(i,1,m)
    {
        int u=read(),v=read(),ww=read();
        t[u].push_back(v);
        w[u].push_back(ww);
    }
    fr(i,1,n)
        g[i]=inf;
    g[s]=0;
    k=s;
    fr(accepted,2,n)
    {
        p[k]=1;
        minn=inf;
        fr(i,0,t[k].size()-1)
            g[t[k][i]]=min(g[t[k][i]],g[k]+w[k][i]);
        fr(i,1,n)
            if(!p[i]&&g[i]<minn)
            {
                k=i;
                minn=g[i];
            }
    }
    fr(i,1,n)
        printf("%d%c",g[i],i==n?'\n':' ');
    rt 0;
}

攒人品ing…

rp=tan90ο
<think>好的,我现在需要回答用户关于Dijkstra算法在Java中的实现模板的问题。首先,我要确保自己正确理解Dijkstra算法的核心思想。Dijkstra算法用于解决单源最短路径问题,适用于有向和无向图,但边权必须非负。这一点用户提供的引用里也提到了[^1],所以必须注意实现时处理边的权重。 接下来,用户需要一个Java的实现模板。我应该先考虑如何表示图的结构。通常,Java中可以使用邻接表或邻接矩阵。邻接表更节省空间,尤其对于稀疏图来说更高效。所以这里我倾向于使用邻接表,用优先队列(PriorityQueue)来选择当前最短路径的节点,这是Dijkstra算法的典型优化方法,以提升效率。 然后,我需要确定每个节点的数据结构。每个节点需要记录到达它的当前最短距离,以及是否已经确定最短路径。不过,在实现中,通常使用一个距离数组来保存最短距离,并使用优先队列来动态选择下一个要处理的节点。这里需要注意的是,优先队列中的节点可能会存在多个相同的实例,但距离不同,所以在处理时需要检查当前取出的节点是否已经有过更短路径的记录,如果是的话就直接跳过,避免重复处理。 接下来,具体步骤应该是:初始化距离数组,起点的距离设为0,其他节点设为无穷大。将起点加入优先队列。然后循环处理队列中的节点,每次取出距离最小的节点,遍历它的所有邻居,如果通过当前节点到达邻居的路径更短,则更新邻居的距离,并将邻居加入队列。 同时,我需要确保代码的规范性和可读性。比如,使用类的结构来封装边和图的表示。可能定义一个Edge类,包含目标节点和权重。然后图由邻接表组成,每个节点对应的边列表。主算法部分使用优先队列,并按照距离排序。 在编写代码时,要处理可能的异常情况,比如节点不可达的情况。此时,距离数组中的值保持为无穷大,需要在最终结果中进行处理或提示用户。 另外,用户提供的引用中提到Dijkstra算法和A*算法的区别在于启发式函数的使用[^2]。虽然这里不涉及A*算法,但需要确保实现的Dijkstra算法不包含启发式部分,严格按照当前已知的最短路径进行扩展。 最后,测试代码的正确性也是重要的。可以提供一个简单的图示例,比如用户给出的例子中的节点和边,验证输出是否符合预期。例如,起点到各点的最短距离是否正确,不可达节点是否标记为无穷大等。 现在,我需要将这些思路整理成结构化的Java代码,并添加必要的注释,确保用户能够理解每个部分的作用。同时,根据用户的要求,生成相关问题,这些问题应该围绕Dijkstra算法的实现细节、优化方法、应用场景等方面展开。</think>### Dijkstra算法Java实现模板 Dijkstra算法用于解决带非负权重的图结构中的单源最短路径问题。以下是基于优先队列优化的标准实现模板: ```java import java.util.*; // 定义边结构 class Edge { int target; int weight; Edge(int target, int weight) { this.target = target; this.weight = weight; } } public class Dijkstra { private List<List<Edge>> graph; private int[] dist; private int nodes; public Dijkstra(int n) { this.nodes = n; graph = new ArrayList<>(); for (int i = 0; i < n; i++) { graph.add(new ArrayList<>()); } } public void addEdge(int from, int to, int weight) { graph.get(from).add(new Edge(to, weight)); // 如果是无向图需添加反向边 // graph.get(to).add(new Edge(from, weight)); } public void shortestPath(int start) { dist = new int[nodes]; Arrays.fill(dist, Integer.MAX_VALUE); dist[start] = 0; // 优先队列按距离排序 PriorityQueue<int[]> pq = new PriorityQueue<>( (a, b) -> a[1] - b[1] ); pq.offer(new int[]{start, 0}); while (!pq.isEmpty()) { int[] current = pq.poll(); int u = current[0]; int d = current[1]; if (d > dist[u]) continue; // 跳过已处理的旧数据 for (Edge edge : graph.get(u)) { int v = edge.target; int newDist = d + edge.weight; if (newDist < dist[v]) { dist[v] = newDist; pq.offer(new int[]{v, newDist}); } } } } public static void main(String[] args) { Dijkstra dij = new Dijkstra(5); dij.addEdge(0, 1, 4); dij.addEdge(0, 2, 1); dij.addEdge(2, 1, 2); dij.addEdge(2, 3, 5); dij.addEdge(1, 3, 1); dij.addEdge(3, 4, 3); dij.shortestPath(0); System.out.println("节点0到各节点的最短距离:"); for (int i = 0; i < dij.nodes; i++) { System.out.println(i + ": " + (dij.dist[i] == Integer.MAX_VALUE ? "不可达" : dij.dist[i])); } } } ``` #### 关键实现要点: 1. **邻接表存储**:使用`List<List<Edge>>`存储图结构 2. **优先队列优化**:时间复杂度从$O(V^2)$优化到$O(E + V \log V)$ 3. **距离松弛处理**:通过`newDist < dist[v]`判断是否更新路径 4. **旧数据过滤**:`if (d > dist[u]) continue` 跳过无效队列项
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值