图的存储
- 临接矩阵
- 链式 前向星
#include<iostream>
using namespace std;
struct edge{
int v,w,next;
};
//next 存的是与这个边起点相同的上一条边编号
//head 存储的是以i为起点的最后一条边的编号
edge e[m];
int head[n],idx;
void add(int a,int b, int c)
{
//有向图
e[++idx]={b,c,h[a]};
h[a]=idx;
//无向图
e[++idx]={a,c,h[b]};
h[b]=idx;
}
int main()
{
//遍历以某一个为起点的边
for(int k=head[u];k;k=e[k].next)
{
}
return 0;
}
- 合根植物
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+5;
vector <int> v[maxn];
int ans;
int m,n;
int s=0;
int vis[maxn];
void dfs(int x)
{
if(x<0||x>m*n) return;
if(v[x].empty()) {
return;
}
for(int i=0;i<v[x].size();i++)
{
int nx=v[x][i];
if(vis[nx]==0)
{
vis[nx]=1;
dfs(nx);
}
}
}
int main()
{
cin>>m>>n;
int k;
cin>>k;
for(int i=1;i<=k;i++)
{
int a,b;
cin>>a>>b;
v[a].push_back(b);
v[b].push_back(a);
}
for(int i=1;i<=m*n;i++)
{
if(vis[i]==0)
{
vis[i]=1;
dfs(i);
ans++;
}
}
cout<<ans;
}
欧拉图
-
有向图
- 欧拉回路：入度和出度相等
- 欧拉通路：0/1个顶点的出度-入度/入度-出度为1
-
无向图
- 欧拉回路：顶点度数为偶数
- 欧拉通路：0/2个奇度顶点
-
算法
- 寻找到可能的点
- 在dfs周围的点 并删除相对应的边
- 如果没有可以移动的边，就将该结点加入结果 并返回
-
Enstein学画画
#include<iostream>
using namespace std;
int e[10005];
int main()
{
int n,m;
cin>>n>>m;
for(int i=1;i<=m;i++)
{
int a,b;
cin>>a>>b;
//记录顶点的度
e[a]++;
e[b]++;
}
//相当于寻找欧拉通路
int ans=0;
for(int i=1;i<=n;i++)
{
if(e[i]%2==1)
{
ans++;
}
}
if(ans==0) cout<<"1";
else cout<<ans/2;
return 0;
}
-
最短路的搜索
-
留意初始化：
- 初始化为inf（表示不存在道路）/ 为负值
-
floyd算法【滚动数组的思想&动态规划】
-
f[k] [x] [y]:经过1-k个点 从x到y的最短路
-
转移方程：f[k] [x] [y]= min(f[k-1] [x] [y], f[k-1] [x] [k] + f[k-1] [k] [y]);
-
递归+滚动数组优化:
for(int k=1;k<=n;k++) { for(int i=1;i<=n;i++) { for(int j=1;j<=n;j++) { f[x][y]=min(f[x][y],f[x][k]+f[k][y]); } } }
灾后重建
- 最短路问题：点数较少适用于floyd算法
- 优化：每次会更新点->对应更新以它作为中转点
#include<iostream> using namespace std; int a[205][205]; int main() { int n, m; cin >> n >> m; int t[205]; for (int i = 0; i < n; i++) { cin >> t[i]; } for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (i == j) a[i][j] = 0; else a[i][j] = 0x3f3f3f3f; } } for (int i = 0; i < m; i++) { int u, v, w; cin >> u >> v >> w; a[u][v] = w; a[v][u] = w; } int p; cin >> p; int in = 0; for (int i = 1; i <= p; i++) { int x, y, time; cin >> x >> y >> time; //只有时间小于time的 才能通过 //更新：新增加了几个点 ->k的值的改变 while (t[in] <= time && in < n) { for (int j = 0; j < n; j++) { for (int l = 0; l < n; l++) { a[j][l] = min(a[j][l], a[j][in] + a[in][l]);//从j到x的最短路：经过0-k个点 } } in++; } if (a[x][y] == 0x3f3f3f3f||t[x] > time || t[y] > time) cout << "-1" << endl; else cout << a[x][y] << endl; } } -
-
Dijkstra算法
-
基础： 最短路应该是每一个点都是最短的
-
本质类似于搜索+贪心
-
用一个点集存储最小路的点 ->bool vis 储存是否在点集中
-
从起点开始搜索->注意初始化
-
搜索所有与它相邻的点：加入最小的点【距离该点集最小的点】->int dis[]
更新状态
-
直到没有相邻的点
//未优化的版本[链式前向星] bool vis[maxn]; int dis[maxn]; for(int i=1;i<=n;i++) { dis[i]=inf; } memset(vis,0,sizeof(vis)); dis[a]=0;//起点 vis[a]=1; for(int i=1;i<=n;i++) { //找出最小值 int v=0; for(int j=1;j<=n;j++) { if(vis[j])continue; if(v==0||dis[j]<dis[v]) v=j; } //入点集 vis[v]=1; //更新此时的dis[受影响的只有与v相邻的点] for(int k=head[v];k;k=e[k].next) { if(vis[e[k].v] continue;//已经在点集里面了 dis[e[k].v]=min(dis[e[k].v],dis[v]+e[k].w) } }- 很明显需要最小值->用优先队列优化【自定义排序】：维护的是dis数组的最大值->同时还需要存储如今处在第几个位置
-
-
-
struct node{
int dis,pos;
bool operator <(const node&x) const
{
return x.dis<dis;
}
}
priority_queue<node>q;
dis[a]=0;
q.push({0,a});
//类似bfs
while(!q.empty())
{
node tmp=q.top();
q.pop();
int x=tmp.dis;
int l=tmp.pos;
if(vis[x]) continue;
vis[x]=1;
for(int i=head[x];i;i=e[i].next)
{
int y=e[i].v;
//其他情况意味着有更短路径可以到达该点
if(dis[y]>dis[x]+e[i].w)
{
dis[y]=dis[x]+e[i].w;
if(!vis[y])
q.push({dis[y],y});
}
}
}
-
最小生成树算法
- Prim算法【稠密图】
- 思路：
- 从起点开始搜索
- 贪心往点集中加入最小的点
- 思路：
- Kruskal算法： 归并边【稀疏图】
- 查并集：
- 先进行排序
- 在同一集合->continue
- 不是则连接
奶酪
#include<bits/stdc++.h> using namespace std; struct node{ long long x,y,z; }; //计算两点距离 double dis(node a,node b) { return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)+(a.z-b.z)*(a.z-b.z)); } //是否相交 int jud(node a,node b,int r) { if(dis(a,b)<=2.0*r) return 1; if(dis(a,b)>2*r) return 0; } int fa[10005]; long long get(long long x) { return fa[x]==x ? x:(fa[x]=get(fa[x])); } void add(long long x, long long y) { fa[get(x)]=get(y); } bool an(long long x, long long y) { if(get(x)==get(y)) return 1; return 0; } //寻找是否存在一条路 下表面到上表面->查并集的思想 //单独记录上下表面的点 int main() { int t; cin>>t; vector<long long>u; vector<long long>d; for(int i=1;i<=t;i++) { int n,h,r; cin>>n>>h>>r; node e[10005]; //存图 for(int i=1;i<=n;i++) { cin>>e[i].x>>e[i].y>>e[i].z; } //初始化 for(int i=1;i<=n;i++) { fa[i]=i; if(e[i].z<=r) d.push_back(i); if(e[i].z>=h-r) u.push_back(i); } //搜索：合并 for(int i=1;i<=n;i++) { for(int j=1;j<=n;j++) { if(an(i,j)) continue; if(jud(e[i],e[j],r)) add(i,j); } } //是否存在路 int flag=0; for(int i=0;i<u.size();i++) { for(int j=0;j<d.size();j++) { if(an(u[i],d[j])) { flag=1; goto cmp; } } } cmp: if(flag==1) cout<<"Yes"<<endl; else cout<<"No"<<endl; memset(fa,0,sizeof(fa)); u.clear(); d.clear(); } return 0; }聪明的猴子
-
是否能遍历整个图->相当于是否能够所有的点处于同一个集合内->查并集的思想
-
优化：
对猴子的最大距离进行排序->一个猴子可以遍历，之后的猴子都可以遍历
不可以遍历的时候->重新搜索 更新此时存在多少个同一个点集的点
#include<iostream> #include<cmath> #include<algorithm> using namespace std; struct node{ int x,y; }e[1005]; int fa[1005]; int get(int x) { return fa[x]==x ? x : (fa[x]=get(fa[x])); } int jud(int x,int y) { if(get(x)==get(y)) return 1; return 0; } double dis(node a, node b) { return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); } void add(int a,int b) { fa[get(a)]=get(b); } int main() { int m;cin>>m; int d[505]; for(int i=1;i<=m;i++) { cin>>d[i]; } int n;cin>>n; for(int j=1;j<=n;j++) { cin>>e[j].x>>e[j].y; fa[j]=j; } //！！查并集 是否所有点都在里面 int ans=0; int l=0; sort(d+1,d+1+m); for(int i=1;i<=m;i++) { for(int j=1;j<=n;j++) { for(int k=j+1;k<=n;k++) { if(jud(j,k)) continue; if(dis(e[j],e[k])<=d[i]) { add(j,k); l++;//相当于这两个集合建立了边 } if(l==n-1)//点数与边数相差一的时候成立 { ans=m-i+1; break; } } if(l==n-1) break; } if(l==n-1) break; } cout<<ans<<endl; return 0; } - Prim算法【稠密图】
扫一扫
4217
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
