L2-3 菜到家了

暴力解法

首先：
把bool数组都初始化为false
memset(st,0,sizeof st);
就这样吧

0x3f3f3f3f是1061109567
比1e9大一些

这个暴力解法能够拿12分，还不错hhh
但是按道理能拿15分的，不是很清楚为什么测试点三拿不到，但是应该是小问题了。

问题：
1.你明明能直接从set中取得终点，为啥你要遍历一遍再判断是否是在set中呢，这好像就有点蠢了。
2.还有对于路径不存在的情况，你的做法也是过于繁琐，但是无伤大雅，也能过一点就是了。
3.wocao?用1e6+10得7分，用2e5+10得11分？？？？？行吧，就你数组的数据可以尽量开得精准一点。
4.最短路这种东西呢，起点和终点是可以随意替换的，你可以利用这一点去替换成最好的样子。

感悟：
反正学习呢，就是把你所学到的东西用，看你看不看得出来应该怎么样巧妙地用就是了。

#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#include <set>

using namespace std;

typedef pair<int, int> PII;

const int N = 2e5 + 40000;

int n, m,p,q;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];

set<int> ps;
set<int> qs;

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

int dijkstra(int p)
{
    memset(dist, 0x3f, sizeof dist);
    dist[p] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, p});
    
    memset(st,0,sizeof st);

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ver = t.second;

        if (st[ver]) continue;
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[ver] + w[i])
            {
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});
            }
        }
        
    }
    
    int minn=0x3f3f3f3f;
    
    for(auto it=qs.begin();it!=qs.end();it++){
            
            minn=min(minn,dist[*it]);
        
    }

    return minn;
}

int main()
{
    scanf("%d%d%d%d", &n, &m,&p,&q);
    
    int t;
    
    if(p<=q){
        
        while(p--){
        scanf("%d",&t);
        ps.insert(t);
        }
        while(q--){
        scanf("%d",&t);
        qs.insert(t);
        }
        
    }
    
    else{
        
        while(p--){
        scanf("%d",&t);
        qs.insert(t);
        }
        while(q--){
        scanf("%d",&t);
        ps.insert(t);
        }
        
    }
    
    

    
    int res=0x3f3f3f3f;
    memset(h, -1, sizeof h);
    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
        add(b, a, c);
    }
    
    for(auto it=ps.begin();it!=ps.end();it++){
        
        res=min(res,dijkstra(*it));
        
    }
    
    
    if(res!=0x3f3f3f3f)
    
    cout<<res;
    
    else cout<<"-1";
    
    return 0;
}

正解

说实话，看懂之后我感觉这个确实是妙啊，一个非常宏观的做法，直接把多次地跑图变成了一次的跑图，而且就是宏观这两个字，思维确实很开阔。
就像是给它补全了，就像高中时的辅助线。让这个dijkstra算法的用处发挥它的极致。
加一个超级源点汇点把所有的源点和汇点变成一个源点和一个汇点。

复现时遇到的问题;
1.不要忘记了是无向边，加两次
2.数据开得要精准？好像也不一定，自己多试几次。
3.wocao，有一个很吃屎的地方，你的头全部初始化为-1是需要在所有的add操作之前的，要不然你add完了之后再给它赋值为1就很 傻逼啊啊啊，
4.你要调试！你要是干想很难想出来的，浪费时间，所以还是一步一步调试是最好的。

哎上面做得半死，才得到12分，下面简介而优雅，得到满分25分，可见思维思路的重要性啊啊啊！！！

代码：

#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

typedef pair<int, int> PII;

const int N = 1e6 + 10;

int n, m,p,q;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[0] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 0});

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        if (st[ver]) continue;
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[ver] + w[i])
            {
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    if (dist[n+1] == 0x3f3f3f3f) return -1;
    return dist[n+1];
}

int main()
{
	
	memset(h, -1, sizeof h);
	
    scanf("%d%d%d%d", &n, &m,&p,&q);
    
    int u;

    for(int i=0;i<p;i++){
        cin >> u;
        add(u,0,0);
        add(0,u,0);
    }
    
    for(int i=0;i<q;i++){
        cin >> u;
        add(u,n+1,0);
        add(n+1,u,0);
    }
    

    
    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
        add(b, a, c);
    }

    cout << dijkstra() << endl;

    return 0;
}