文章目录
The Fourth Week
不须计较苦劳心，万事原来有命。 ————宋朱敦儒《西江月·世事短如春梦》
一、前言
周一IOI赛制个人赛，打得还行？链接: link
周二组队赛，没写题解，打得还行。
周三河南萌新联赛，有一道题不该没做出来的，打得灰常一般。链接: link
周四IOI赛制个人赛，不好评价。链接: link
周六早上暑假友谊赛，当时忘记打了，晚了四十分钟开始，所以有一道题差一点做出来，很可惜，脑子转的不够快。这场以思维题居多。链接: link
周六下午打了去年的robocom国赛，没补题，打得挺一般的中位线，大概看了一下每道题的方法。
周日打了robocom国赛，等待ing。
二、算法
1.最近公共祖先(LCA)倍增算法
- dfs一遍，创建ST表
倍增递推 fa[u][I]=fa[fa[u][I-1][I-1]; - 利用ST表求LCA
（1）将u，v跳到同一层，深度之差为y，将y进行二进制拆分
（2）将u，v一起跳到LCA的下一层，一直尝试到0为止
const int N = 5e5+10;
vector<int>e[N];
int dep[N],fa[N][20];
void dfs(int u,int father) {
dep[u] = dep[father]+1;
//深度是父亲的深度加一
fa[u][0] = father;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i-1]][i-1];
//递推一个点的所有祖先节点
}//2的20次方是50万，所以到19即可
for (int v : e[u]) {
//继续往下找
if (v != father) dfs(v, u);
}
}//时间复杂度O(nlongn)
int lca (int u,int v) {
if(dep[u] < dep[v]) swap(u,v);
//先跳到同一层
for (int i = 19; i >= 0; i--) {
if(dep[fa[u][i]] >= dep[v]) u = fa[u][i];
}
if(u == v) return v;
//v恰好是u的公共祖先
for (int i = 19; i >= 0; i--) {
if(fa[u][i] != fa[v][i]) {
u = fa[u][i],v = fa[v][i];
}//找到第一个不一样的祖先
}return fa[u][0];
}//时间复杂度O(logn)
<1>（尖塔第四强的高手）
河南萌新联赛2024第（四）场：河南理工大学J
思路其实不难，基本就是一道LCA变形题，但我当时真的不太会LCA，当然现在也不是很会谢谢。题意太复杂了上图。
题解：
开始解读，可以发现k的范围非常大到1e9，但是斐波那契数列的增长其实非常快，所以只要k>25，其实就已经超过了n的范围，直接输出0即可。这个点比较关键，脑子要转一下。
LCA倍增算法的复杂度其实比较高，但是这道题给出的q组询问，每个区间的数的最近共同祖先，一个一个分别推导即可，不用n*n的复杂度，所以最大也就到24n，不会超时。
代码：
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 1e5+10;
vector<int>e[N];
int fa[N][20],dep[N];
int f[50];
vector<int>xq;
int n,r,q;
void dfs(int x,int father) {
dep[x] = dep[father]+1;
fa[x][0] = father;
for (int i = 1; i <= 19; i++) {
fa[x][i] = fa[fa[x][i-1]][i-1];
}
for (auto y : e[x]) {
if(y == father) continue;
dfs(y,x);
}
}
int lca(int u,int v) {
if(dep[u] < dep[v]) swap(u,v);
for (int i = 19; i >= 0; i--) {
if(dep[fa[u][i]] >= dep[v]) u = fa[u][i];
}
if(u == v) return u;
for (int i = 19; i >= 0; i--) {
if(fa[u][i] != fa[v][i]) u = fa[u][i],v = fa[v][i];
}
return fa[u][0];
}
signed main() {
cin >> n >> r >> q;
f[1] = 1,f[2] = 2;
for (int i = 3; i <= 40; i++) f[i] = f[i-1]+f[i-2];
for (int i = 1; i < n; i++) {
int a,b;
cin >> a >> b;
e[a].push_back(b);
e[b].push_back(a);
}
dfs(r,0);
for (int i = 1; i <= q; i++) {
int x,k;
cin >> x >> k;
if(k > 25) {
cout << 0 << endl;
continue;
}
int u = x + f[k];
int v = x + f[++k];
if(x + f[k-1] > n) cout << 0 << endl;
else {
while(v <= n) {
u = lca(u,v);
v = x + f[k++]; }
cout << u << endl;
}
}
return 0;
}
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;
}
4. 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;
}//有限制边数的最短路
5. 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];
}
6. Prim算法
最小生成树
无向图中，一个连通图的最小连通子图就是它的生成树，最小生成树指的是它的权值之和最小，可以有多个。特性：删去任何一条边，都不是一个通路，加上任意一条边，都会形成回路。
struct ty{
int t,l,next;
}edge[2*500000+100];
int head[100010];
int cnt = 0;
void addedge(int x,int y,int z) {
cnt++;
edge[cnt].t = y;
edge[cnt].l = z;
edge[cnt].next = head[x];
head[x] = cnt;
}
bool vis[100010];
struct ty2 {
int x,len;
bool operator < (const ty2 & a) const {
return len > a.len;
}
};
priority_queue<ty2>q;
void prim() {
vis[1] = 1;
ty2 tmp;
for (int i = head[1]; i != -1; i = edge[i].next) {
tmp.x = edge[i].t;
tmp.len = edge[i].l;
q.push(tmp);
}
int ans = 0;
while(!q.empty()) {
ty2 tmp = q.top();
q.pop();
if(vis[tmp.x])continue;
vis[tmp.x] = 1;
int x = tmp.x;
ans += tmp.len;
for (int i = head[x]; i != -1; i = edge[i].next) {
if(vis[edge[i].t])continue;
tmp.x = edge[i].t;
tmp.len = edge[i].l;
q.push(tmp);
}
}
cout << ans;
}
signed main() {
cin >> n >> m;
memset(head,-1,sizeof head);
for (int i = 1; i <= m; i++) {
int a,b,v;
cin >> a >> b >> v;
addedge(a,b,v);
addedge(b,a,v);
}
prim();
return 0;
}
7. Kruskal算法
贪心选取最短的边来组成一颗最小的生成树。
//Kruskal算法
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 5e6+10;
int n,m;
int fa[N];
struct ty {
int x,y,z;
}edge[N];
int head[N];
bool cmp(ty a,ty b) {
return a.z < b.z;
}
int find(int x) {
return fa[x] == x ? x:fa[x] = find(fa[x]);
}
signed main() {
cin >> n >> m;
memset(head,-1,sizeof head);
for (int i = 1; i <= m; i++) {
cin >> edge[i].x >> edge[i].y >> edge[i].z;
}
for (int i = 1; i <= n; i++)fa[i] = i;
sort(edge+1,edge+1+m,cmp);
int ans = 0;
for (int i = 1; i <= m; i++) {
int fx = find(edge[i].x);
int fy = find(edge[i].y);
if(fx == fy) continue;
ans += edge[i].z;
fa[fx] = fy;
}
cout << ans;
return 0;
}
三、总结
结构体内嵌比较函数bool operator ＜ (const node &x) const {}
memset(a,0x3f3f3f3f,sizeof a);//赋值为最大整数且不超变负数
好多算法我有点晕…
扫一扫
1228
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
