文章目录
The Fourth Week
不须计较苦劳心，万事原来有命。 ————宋朱敦儒《西江月·世事短如春梦》
一、前言
周日打了robocom决赛，等待ing
二、算法
1.最近公共祖先lca倍增算法
2.Dijkstra算法
单源最短路问题
适用于重边和自环，但不适用于负权边
稀疏图: edge/node ->0 边比点少
稠密图: edge/node ->1 点比边少
- 邻接矩阵
二维数组，时间复杂度o(n*n)，对边的储存，查询，更新操作非常便捷，适合稠密图，但是不能储存重边，容易tle。 - 邻接表
STL的vector数组，时间复杂度o(n+m)，能储存重边，适合规模大的稀疏图，但是会爆数组。 - 链式前向星
静态数组模拟邻接表，时间复杂度o(n+m)，空间效率高，不方便做删除查找操作。
优秀的Dijkstra算法应该是链式前向星存图加上堆优化，给出模版。
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define int long long
typedef pair<int,int> PII;
const int INF = 0x3f;
//比起0x7fffffff，0x3f3f3f3f可以避免正无穷溢出变成负数的情况
//...没看懂，记住吧，就这样
const int N = 2e6+10;
const int M = 2e6+10;
int n,m;
struct ty{
int to,w,next;
}edge[2*M];
int head[2*N],dis[2*N],vis[2*N];
int cnt = 0;
void init() {
memset(vis,0,sizeof vis);
memset(dis,INF,sizeof dis);
//这个INF很有趣，0x3f，0x3f3f3f等等都会赋值成一个32位最大值
//记住吧，暂时没找到解释，好像就是超了之后就不管了
//0x3f的十进制是63，
}
void add_edge(int u,int v,int w) {
cnt++;
edge[cnt].to = v;
edge[cnt].w = w;
edge[cnt].next = head[u];
//让这些点一一相连，互相走走走
head[u] = cnt;
}
void dij(int x) {
priority_queue<PII,vector<PII>,greater<PII>>pq;
//小根堆，升序排序，默认大根堆
pq.push({0,x});
//先把自己放进去
dis[x] = 0;
//自己的距离是0
while (!pq.empty()) {
//直到跑完所有能跑的点为止
x = pq.top().second;
//现在的点
pq.pop();
//要先pop！不然会陷入死循环，特别重要的，错了好久
if(vis[x])continue;
//这个点已经跑过了
vis[x] = 1;
for (int i = head[x]; i != -1; i = edge[i].next) {
//一个个遍历所有它能跑的点
if(!vis[edge[i].to]) {
//已经确定最段路的点不能再跑
if(dis[edge[i].to] > dis[x] + edge[i].w) {
//如果直接跑到下一个点不如在这个点绕一圈来得快
dis[edge[i].to] = dis[x] + edge[i].w;
pq.push({dis[edge[i].to],edge[i].to});
//继续放继续放
}
}
}
}
}
signed main() {
init();
//初始化各数组状态
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a,b,c;
cin >> a >> b >> c;
add_edge(a,b,c);
add_edge(b,a,c);
//双向边的放双向哦
}
dij(1);
//跑一下以1为源头的所有点
return 0;
}
<1>（游戏）
链接: 游戏
题解：
一个n个点m条边的无向图，每条边有一个花费和状态，状态为0表示被锁住，1表示可通过，节点k出有钥匙，问从1到n的最小话费，无法到达输出-1。
先跑一遍Dijkstra，看看从1能不能跑到k，然后从k开始跑一遍Dijkstra跑到n，计算从1直接到n，和从1拿了钥匙再到n的较小值，如果都跑不到，那就输出-1。
代码：
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define int long long
const int N = 2e6+5;
int head[N],dis[N],vis[N];
int n,m,k;
int cnt;
bool st = false;
typedef pair<int,int> PII;
const int INF = 1e11;
struct uth{
int to,w,next,zt;
}edge[N];
void add_edge(int u,int v,int w,int kaka) {
cnt++;
edge[cnt].to = v;
edge[cnt].w = w;
edge[cnt].next = head[u];
edge[cnt].zt = kaka;
head[u] = cnt;
}
void dij(int x) {
priority_queue<PII,vector<PII>,greater<PII>>pq;
pq.push(make_pair(0,x));
dis[x] = 0;
// fa[x] = -1;
while(!pq.empty()) {
x = pq.top().second;
vis[x] = 1;
pq.pop();
for (int i = head[x];i!= -1; i=edge[i].next) {
if(!vis[edge[i].to]) {
int v = edge[i].to;
int weight = edge[i].w;
// cout << dis[x] <<' ' << weight << endl;
// cout << v << '.' << dis[v] << endl;
if(dis[v] > dis[x] + weight) {
if(edge[i].zt == 0)continue;
dis[v] = dis[x]+weight;
pq.push(make_pair(dis[v],v));
if(v == k)st = true;
}
}
}
}
}
void dij1(int x) {
priority_queue<PII,vector<PII>,greater<PII>>pq;
pq.push(make_pair(0,x));
dis[x] = 0;
while(!pq.empty()) {
x = pq.top().second;
vis[x] = 1;
pq.pop();
for (int i = head[x];i!= -1; i=edge[i].next) {
if(!vis[edge[i].to]) {
int v = edge[i].to;
int weight = edge[i].w;
// cout << dis[x] <<' ' << weight << endl;
// cout << v << '.' << dis[v] << endl;
if(dis[v] > dis[x] + weight) {
dis[v] = dis[x]+weight;
pq.push(make_pair(dis[v],v));
}
}
}
}
}
signed main() {
memset(head,-1,sizeof head);
memset(vis, 0, sizeof(vis));
for (int i = 0; i <= N; i++) dis[i] = 1e11;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int a,b,c,d;
cin >> a >> b >> c >> d;
add_edge(a,b,c,d);
add_edge(b,a,c,d);
}
dij(1);
int ans1 = 0;//1k
int ans2 = 0;//1n
int ans3 = 0;//kn
if(dis[n] == 1e11 && !st)cout << "-1";
else {
ans1 = dis[k];
ans2 = dis[n];
memset(vis, 0, sizeof(vis));
for (int i = 0; i <= N; i++) dis[i] = 1e11;
dij1(k);
ans3 = dis[n];
int res = min(ans2,ans1+ans3);
cout << res;
}
return 0;
}
3.拓扑排序
用来处理AOE网中，有先后关系的任务，最后输出任务的一种完成顺序。
判断一个有向图中是否有环，无环的图所有点都能进行拓扑排序。（反例：1指向2指向3指向1）
- 初始状态，1，6的入度都是0，所以拓扑排序不止一种，1，6都入栈，减去其中一个入度为0的点。
- 先去除节点6，找到别的入度为0的点1，去除1和它对应的俩条线，此时入度为0的点有2和3，把这俩个点入栈。
- 去掉了3，5入栈，再去掉5，最后只剩下一个点4入度为0。所以最后的输出顺序会是6，1，2，3，5，4。
int n,m; //n个点m条线
struct ty {
int t,next;
}edge[100010];
int head[100010];
int cnt = 0;
void addedge(int x,int y) {
edge[++cnt].t = y;
edge[cnt].next = head[x];
head[x] = cnt;
}//链式前向星存图
int inc[1010];//每个点的入度
queue<int>q;
void tuopo() {
for (int i = 1; i <= n; i++) {
if(inc[i] == 0) {
q.push(i);
}
}
int tot = 0;
while(!q.empty()) {
int x = q.front();
cout << x << ' ' << endl;
q.pop();
tot++;
//看看多少人进栈
for (int i = head[x]; i != -1; i = edge[i].next) {
inc[edge[i].t]--;
if(!inc[edge[i].t])q.push(edge[i].t);
//这个点入度也是0，进栈
}
}
if(tot != n) cout << -1;
//这个写法会有问题，如果是无法实现的拓扑序，会先输出前面几个再输出-1。
//所以其实应该存表再判断是否输出
}//复杂度O(n+m)
signed main() {
cin >> n >> m;
memset(head,-1,sizeof head);
for (int i = 1; i <= m; i++) {
int a,b;
cin >> a >> b;
addedge(a,b);
//无向边要注意还得有addedeg(y,x);
inc[b]++;
}
tuopo();
return 0;
}
3. Bellman-Ford算法
单源最短路问题
用于处理负权边和负权环的情况，时间复杂度为O（n*m）
const int N = 1e6;
const int M = 2e7;
int dist[N],last[N];
const int INF = 0x3f3f3f3f;
int n,m,k;
//点数，边数，和限制边数
struct ty{
int u,v,w;
}edge[M];
void bellman_ford(int x) {
memset(dist,INF,sizeof dist);
dist[x] = 0;
for (int i = 0; i < k; i++) {
//k次
memcpy(last,dist,sizeof dist);
//复制上一轮的最后情况
for (int j = 0; j < m; j++) {
每条边根据一条边松弛一次
dist[edge[j].v] = min(dist[edge[j].v],last[edge[j].u]+edge[j].w);
}
}
if(dist[n] > 0x3f3f3f3f/2)cout << "impossible" << endl;
else cout << dist[n] << endl;
}//有限制边数的最短路
4. SPFA算法
单源最短路问题
用于处理带负权边的图
int spfa(int s,int t) {
memset(dis,INF,sizeof dis);
memset(vis,0,sizeof vis);
dis[s] = 0;
vis[s] = 1;
while(!q.empty()) {
int x = q.front();
q.pop();
vis[x] = 0;
for (int i = head[x]; i !=-1; i = edge[i].next) {
int to = edge[i].to;
if(dis[to] < dis[x] + edge[i].w) {
dis[to] = dis[x] + edge[i].w;
if(!vis[to]) {
q.push(to);
vis[to] = 1;
}
}
}
}
if(dis[t] >= 0x3f3f3f3f) return -1;
return dis[t];
}
三、总结
结构体内嵌比较函数bool operator ＜ (const node &x) const {}
memset(a,0x3f3f3f3f,sizeof a);//赋值为最大整数且不超变负数
102
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
