题意：
一个完全图，有n个点，其中m条边是权值为a的无向边，其它是权值为b的无向边，问从1到n的最短路。
思路：
首先判断1和n被哪种边连通。
如果是被a连通，那么就需要全部走b的边到达n，选择最小的；
被b连通，需要走全部为a的边到达n，选择最小的。
第二种情况，用输入的边跑dijkstra；
但是第一种情况边太多，所以并不能单纯的用最短路。
可以想到的是，对于第二种情况，一个点只会经过一次。
所以用一个set来存还未访问过的点，进行bfs。
每次从队列中取出一个点x，把set中与x以a边相连的点暂时去掉，那么此时set中就是与x以b边相连并且还未访问的点了，这个时候就可以进行松弛了。
之后再对set进行更新，使其为还未访问到的点。
又犯了这个睿智错误，数据还没输入就进行处理了，真是睿智。
自定义的比较宏比algor里面得到快很多啊。
代码：
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <set>
#include <queue>
#define mi(x,y) (x) > (y) ? (y) : (x)
using namespace std;
typedef long long ll;
const int N = 1e5 + ;
struct node
{
int to,cost;
node (int a,int b):to(a),cost(b){};
node(){};
};
struct js
{
int x;
ll d;
js(int a,ll b):x(a),d(b){};
js(){};
bool operator < (const js& y) const
{
return y.d < d;
}
};
vector<node> g[N];
int n,m,a,b;
ll dis[N];
void dij(void)
{
for (int i = ;i <= n;i++) dis[i] = 1e18;
dis[] = ;
priority_queue<js> pq;
pq.push(js(,));
while (!pq.empty())
{
js t = pq.top();pq.pop();
if (t.d > dis[t.x]) continue;
int x = t.x;
for (auto v:g[x])
{
if (dis[v.to] > dis[x] + v.cost)
{
dis[v.to] = dis[x] + v.cost;
pq.push(js(v.to,dis[v.to]));
}
}
}
}
void bfs(void)
{
set<int> s,t;
for (int i = ;i <= n;i++) s.insert(i);
queue<int> q;
q.push();
while (!q.empty())
{
int x = q.front();q.pop();
if (x == n) break;
for (auto v:g[x])
{
if (s.count(v.to) == ) continue;
s.erase(v.to);
t.insert(v.to);
}
for (auto y:s)
{
dis[y] = dis[x] + b;
q.push(y);
}
s.swap(t);
t.clear();
}
}
int main()
{
while (scanf("%d%d%d%d",&n,&m,&a,&b) != EOF)
{
for (int i = ;i <= n;i++)
{
g[i].clear();
}
bool f = ;
for (int i = ;i < m;i++)
{
int x,y;
scanf("%d%d",&x,&y);
if (x > y) swap(x,y);
g[x].push_back(node(y,a));
g[y].push_back(node(x,a));
if (x == && y == n) f = ;
}
ll ans;
if (f)
{
bfs();
ans = mi((ll)a,dis[n]);
}
else
{
dij();
ans = mi((ll)b,dis[n]);
}
printf("%lld\n",ans);
}
return ;
}