SMU Summer 2024 div2 4th

文章目录

The Fourth Week
一、前言
二、算法
- 1.最近公共祖先lca倍增算法
- 2.Dijkstra算法
- - <1>（游戏）
- 3.拓扑排序
- 3. Bellman-Ford算法
- 4. SPFA算法
三、总结

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];
}