hdu 6181

最新推荐文章于 2019-01-22 13:39:25 发布

herbertpotter

最新推荐文章于 2019-01-22 13:39:25 发布

阅读量223

点赞数

分类专栏： HDU

HDU 专栏收录该内容

68 篇文章 0 订阅

订阅专栏

题意

就是要你求第二短路，可以说是一个裸题。

题解

这题可以说类似poj2499。解题思路和它是一样的，不过这题是无向图，而且不包含起点就是终点的情况。
poj2499

对于A*算法，都知道f(n)=g(n)+h(n)，这里h(n)为启发式函数。我们令这里的g(n)为从源点s到n所经过的路径，h(n)为把所有边反向后从终点t到n的最短路径dist[n]。即估值=源点到当前点的距离+当前点到终点的最短距离。这时我们建一个优先队列，每次弹出估值f()最小的点，如果弹出的点是t就计算t出队的次数，如果次数等于k，那么到当前点的距离g()即为答案，否者就拓展与当前点相连的边。

比赛的时候写Dijkstra那个地方错了导致一直MLE，好蠢。
不过我这里写了两种，一种用前向星保存边信息，一种用vector保存边信息。看看代码。我觉得怎么都是vector的那个应该用的空间少一些啊，不知道为什么反而前向星用的少。如果有大神知道，请指点一下，不胜感激。

vector代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const ll INF = 1e18;
const int maxn = 1e5+5;
int n,m,k;
ll dist[maxn],ans;
typedef pair<ll,int> P;

vector<P> edge[maxn];

struct A_Node{
    int p;
    ll g;
    bool operator < (A_Node tmp) const
    {
        return tmp.g+dist[tmp.p] < g+dist[p];
    }
};

void init()
{
    for(int i=1;i<=n;i++)
    {
        edge[i].clear();
        dist[i] = INF;
    }
}

void add_edge(int from,int to,ll w)
{
    edge[from].push_back(P(w,to));
    edge[to].push_back(P(w,from));
}

void Dijkstra()
{
    priority_queue<P,vector<P>,greater<P> >pq;
    P p;
    dist[n] = 0;
    pq.push(P(dist[n],n));
    while(!pq.empty())
    {
        p = pq.top(),pq.pop();
        int u = p.second;
        for(int i=0;i<edge[u].size();i++)
        {
            if(dist[edge[u][i].second] > dist[u] + edge[u][i].first)
            {
                dist[edge[u][i].second] = dist[u]+edge[u][i].first;
                pq.push(P(dist[edge[u][i].second],edge[u][i].second));
            }
        }
    }
}

void A_stra()
{
    A_Node cur,next;
    int num=0;
    priority_queue<A_Node>pq;
    cur.p = 1;
    cur.g = 0ll;
    pq.push(cur);
    while(!pq.empty())
    {
        cur = pq.top(),pq.pop();
        if(cur.p==n) num++;
        if(num==2)
        {
            ans = cur.g;
            return;
        }
        for(int i=0;i<edge[cur.p].size();i++)
        {
            next.p = edge[cur.p][i].second;
            next.g = cur.g+edge[cur.p][i].first;
            pq.push(next);
        }
    }
    ans = -1;
    return;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        init();
        int u,v;
        ll w;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%lld",&u,&v,&w);
            add_edge(u,v,w);
        }
        Dijkstra();
        A_stra();
        printf("%lld\n",ans);
    }
    return 0;
}

  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

前向星代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const ll INF = 1e18;
const int maxn = 1e5+5;
int n,m,k;
int head1[maxn],head2[maxn],cnt;
ll dist[maxn],ans;
typedef pair<ll,int> P;

struct Edge{
    int u,v,next1,next2;
    ll w;
    Edge(int _u=0,int _v=0,ll _w=0)
    {
        u = _u;
        v = _v;
        w = _w;
    }
}edge[maxn<<1];

struct A_Node{
    int p;
    ll g;
    bool operator < (A_Node tmp) const
    {
        return tmp.g+dist[tmp.p] < g+dist[p];
    }
};

void init()
{
    for(int i=1;i<=n;i++)
        dist[i] = INF;
    memset(head1,-1,sizeof(head1));
    memset(head2,-1,sizeof(head2));
    cnt=0;
}

void add_edge(int from,int to,ll w)
{
    edge[cnt] = Edge(from,to,w);
    edge[cnt].next1=head1[to],head1[to]=cnt;
    edge[cnt].next2=head2[from],head2[from]=cnt++;
    edge[cnt] = Edge(to,from,w);
    edge[cnt].next1=head1[from],head1[from]=cnt;
    edge[cnt].next2=head2[to],head2[to]=cnt++;
}

void Dijkstra()
{
    priority_queue<P,vector<P>,greater<P> >pq;
    P p;
    dist[n] = 0;
    pq.push(P(dist[n],n));
    while(!pq.empty())
    {
        p = pq.top(),pq.pop();
        int u = p.second;
        for(int i=head1[u];i!=-1;i=edge[i].next1)
        {
            if(dist[edge[i].u] > dist[u] + edge[i].w)
            {
                dist[edge[i].u] = dist[u]+edge[i].w;
                pq.push(P(dist[edge[i].u],edge[i].u));
            }
        }
    }
}

void A_stra()
{
    A_Node cur,next;
    int num=0;
    priority_queue<A_Node>pq;
    cur.p = 1;
    cur.g = 0ll;
    pq.push(cur);
    while(!pq.empty())
    {
        cur = pq.top(),pq.pop();
        if(cur.p==n) num++;
        if(num==2)
        {
            ans = cur.g;
            return;
        }
        for(int i=head2[cur.p];i!=-1;i=edge[i].next2)
        {
            next.p = edge[i].v;
            next.g = cur.g+edge[i].w;
            pq.push(next);
        }
    }
    ans = -1;
    return;
}

int main()
{
    //freopen("1011.in","r",stdin);
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        init();
        int u,v;
        ll w;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%lld",&u,&v,&w);
            add_edge(u,v,w);
        }
        Dijkstra();
        A_stra();
        printf("%lld\n",ans);
    }
    return 0;
}

  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122