BellmanFord\dijkstra\堆优化\FloydWarshall\prime\kruskal算法的简单实现
//图的表示
const int maxv = 1e5;
//struct Edge{ int to, cost; };
//vector<Edge> G[maxv];
vector<int> G[maxv];
int main()
{
int v, e;
scanf("%d%d", &v, &e);
//Edge temp;
for(int i = 0; i < e; i++){
int s, t;
scanf("%d%d", &s, &t);
G[s].push_back(t);
G[t].push_back(s);
}
return 0;
}
//图的遍历、 二分图染色判定问题
const int maxv = 1e5;
vector<int> G[maxv];
int color[maxv];
int V;
//顶点染成1或-1
bool dfs(int v, int c){
color[v] = c;//顶点c染成颜色c
for(int i = 0; i < G[v].size(); i++){
if(color[G[v][i]] == c) return false;//相邻顶点同色
//如果相邻顶点还没被染色,则染成-c
if(color[G[v][i]] == 0 && !dfs(G[v][i], -c)) return false;
}
//如果所有顶点都染过色了,则返回true;
return true;
}
void slove(){
for(int i = 0; i < V; i++){
if(color[i] == 0){//如果顶点没有被染色,染1;
if(!dfs(i, 1)){
printf("No\n");
return;
}
}
}
printf("Yes\n");
}
//单源最短路:BellmanFord算法
const int inf = 1e9;
const int maxv = 1e5;
struct edge{ int from, to, cost; };
edge es[maxv];
int d[maxv];
int pre[maxv];
int V, E;
//单源最短路:BellmanFord算法
void BellmanFord(int s){
for(int i = 0; i < V; i++) d[i] = inf;
d[s] = 0;
pre[s] = -1;
while(true){
bool update = false;
for(int i = 0; i < E; i++){
edge e = es[i];
if(d[e.from] != inf && d[e.to] > d[e.from] + e.cost){
d[e.to] = d[e.from] + e.cost;
pre[e.to] = e.from;
update = true;
}
}
if(!update) break;
}
}
//路径还原
void getPath(int v){
if(pre[v] == -1){
printf("%d ", v);
return;
}
getPath(pre[v]);
printf("%d ", v);
}
//检查是否存在负圈
bool findNegativeLoop(){
memset(d, 0, sizeof(d));
for(int i = 0; i < V; i++){
for(int j = 0; j < E; j++){
edge e = es[j];
if(d[e.to] > d[e.from] + e.cost){
d[e.to] = d[e.from] + e.cost;
//如果第n次仍更新了,则存在负圈
if(i == V - 1) return false;
}
}
}
return true;
}
int main()
{
scanf("%d%d", &V, &E);
E *= 2;
for(int i = 0; i < E; i+= 2){
scanf("%d%d%d", &es[i].from, &es[i].to, &es[i].cost);
es[i+1].from = es[i].to; es[i+1].to = es[i].from;
es[i+1].cost = es[i].cost;
}
BellmanFord(0);
cout << d[6] << endl;
getPath(6);cout << endl;
string str = findNegativeLoop() ? "No negative loop" : "Exist negative loop";
cout << str << endl;
return 0;
}
/*
input:
7 10
0 1 2
0 2 5
1 2 4
1 3 6
1 4 10
2 3 2
3 5 1
4 5 3
4 6 5
5 6 9
output:
16
0 2 3 5 4 6
No negative loop
*/
const int inf = 1e8;
const int maxv = 1e3;
int cost[maxv][maxv];//初始化inf
int d[maxv];
bool used[maxv];
int pre[maxv];
int V, E;
//单源最短路:Dijkstra算法 O(V^2)
void Dijkstra(int s){
for(int i = 0; i < V; i++){
d[i] = inf;
used[i] = false;
}
d[s] = 0;
pre[s] = -1;
while(true){
int v = -1;
for(int i = 0; i < V; i++){
if(!used[i] && (v == -1 || d[i] < d[v])){
v = i;
}
}
if(v == -1) break;
used[v] = true;
for(int i = 0; i < V; i++){
if(d[i] > d[v] + cost[v][i]){
d[i] = d[v] + cost[v][i];
pre[i] = v;
}
}
}
}
//路径还原
void getPath(int v){
if(pre[v] == -1){
printf("%d ", v);
return;
}
getPath(pre[v]);
printf("%d ", v);
}
int main()
{
scanf("%d%d", &V, &E);
int u, v, val;
for(int i = 0; i < V; i++){
for(int j = 0; j < V; j++){
cost[i][j] = inf;
}
}
for(int i = 0; i < E; i++){
scanf("%d%d%d", &u, &v, &val);
cost[u][v] = cost[v][u] = val;
}
Dijkstra(0);
cout << d[6] << endl;
getPath(6);cout << endl;
return 0;
}
/*
input:
7 10
0 1 2
0 2 5
1 2 4
1 3 6
1 4 10
2 3 2
3 5 1
4 5 3
4 6 5
5 6 9
output:
16
0 2 3 5 4 6
*/
//单源最短路:Dijkstra算法 堆优化O(E*logV)
const int inf = 1e8;
const int maxv = 1e3;
struct edge{int to, cost;};
struct Node{
int dis, v;//最短距离及对应的顶点
friend bool operator < (Node n1, Node n2){
return n1.dis > n2.dis;
}
};
vector<edge> G[maxv];
int pre[maxv];
int d[maxv];
int V, E;
//单源最短路:Dijkstra算法 堆优化O(E*logV)
void Dijkstra(int s){
fill(d, d + V, inf);
d[s] = 0;
pre[s] = -1;
priority_queue<Node> que;
Node temp; temp.dis = 0; temp.v = s;
que.push(temp);
while(!que.empty()){
Node node = que.top(); que.pop();
int v = node.v;
if(d[v] < node.dis) continue;
for(int i = 0; i < G[v].size(); i++){
edge e = G[v][i];
if(d[e.to] > d[v] + e.cost){
d[e.to] = d[v] + e.cost;
temp.dis = d[e.to]; temp.v = e.to;
que.push(temp);
pre[e.to] = v;
}
}
}
}
//路径还原
void getPath(int v){
if(pre[v] == -1){
printf("%d ", v);
return;
}
getPath(pre[v]);
printf("%d ", v);
}
int main()
{
scanf("%d%d", &V, &E);
int u, v, val;
edge temp;
for(int i = 0; i < E; i++){
scanf("%d%d%d", &u, &v, &val);
temp.cost = val;
temp.to = v; G[u].push_back(temp);
temp.to = u; G[v].push_back(temp);
}
Dijkstra(0);
cout << d[6] << endl;
getPath(6);cout << endl;
return 0;
}
/*
input:
7 10
0 1 2
0 2 5
1 2 4
1 3 6
1 4 10
2 3 2
3 5 1
4 5 3
4 6 5
5 6 9
output:
16
0 2 3 5 4 6
*/
const int inf = 1e8;
const int maxv = 1e3;
int d[maxv][maxv];
int V, E;
//任意两点间最短距离 Floyd-Warshall算法 O(V^3)
void FloydWarshall(){
for(int k = 0; k < V; k++){
for(int i = 0; i < V; i++){
for(int j = 0; j < V; j++)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
int main()
{
scanf("%d%d", &V, &E);
for(int i = 0; i < V; i++){
for(int j = 0; j < V; j++){
if(i == j){
d[i][j] = 0;
}else
d[i][j] = inf;
}
}
int u, v, val;
for(int i = 0; i < E; i++){
scanf("%d%d%d", &u, &v, &val);
d[u][v] = d[v][u] = val;
}
FloydWarshall();
cout << d[0][6] << endl;
return 0;
}
/*
input:
7 10
0 1 2
0 2 5
1 2 4
1 3 6
1 4 10
2 3 2
3 5 1
4 5 3
4 6 5
5 6 9
output:
16
*/
//最小生成树、prime算法,同dijkstra算法类似
const int inf = 1e8;
const int maxv = 1e3;
int cost[maxv][maxv];
int mincost[maxv]; //从集合x出发的到每个顶点的最小权值
bool used[maxv]; //顶点是否包含在集合x中(集合x为MST的子集)
int V, E;
//最小生成树: prime算法
int Prime(){
for(int i = 0; i < V; i++){
mincost[i] = inf;
used[i] = false;
}
mincost[0] = 0;
int res = 0;
while(true){
int v = -1;
for(int i = 0; i < V; i++){
if(!used[i] && (v == -1 || mincost[i] < mincost[v])){
v = i;
}
}
if(v == -1) break;
used[v] = true;
res += mincost[v];
for(int i = 0; i < V; i++){
mincost[i] = min(mincost[i], cost[v][i]);
}
}
return res;
}
int main()
{
scanf("%d%d", &V, &E);
for(int i = 0; i < V; i++){
for(int j = 0; j < V; j++){
cost[i][j] = inf;
}
}
int u, v, val;
for(int i = 0; i < E; i++){
scanf("%d%d%d", &u, &v, &val);
cost[u][v] = cost[v][u] = val;
}
cout << "MST: " << Prime() << endl;
return 0;
}
/*
input:
7 10
0 1 2
0 2 5
1 2 4
1 3 6
1 4 10
2 3 2
3 5 1
4 5 3
4 6 5
5 6 9
output:
MST: 17
*/
//最小生成树: kruskal算法
#include<stdio.h>
#include<iostream>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<set>
#include<iterator>
#include<map>
#include<stack>
using namespace std;
const int inf = 1e8;
const int maxv = 1e3;
struct edge{int u, v, cost; };
bool cmp(edge e1, edge e2){
return e1.cost < e2.cost;
}
edge es[maxv];
int root[maxv];
int rank[maxv];
int V, E;
void init(int v){
for(int i = 0; i < V; i++){
root[i] = i;
rank[i] = 0;
}
}
int find(int x){
if(root[x] == x) return x;
return root[x] = find(root[x]);
}
bool same(int x, int y){
return find(x) == find(y);
}
void unit(int x, int y){
x = find(x);
y = find(y);
if(x == y) return;
if(rank[x] < rank[y]){
root[x] = y;
}else{
root[y] = x;
if(rank[x] == rank[y]) rank[x]++;
}
}
//最小生成树: kruskal算法
int Kruskal(){
sort(es, es + E, cmp);
init(V);//并查集初始化
int res = 0;
for(int i = 0; i < E; i++){
if(!same(es[i].u, es[i].v)){
unit(es[i].u, es[i].v);
res += es[i].cost;
}
}
return res;
}
int main()
{
scanf("%d%d", &V, &E);
int u, v, val;
for(int i = 0; i < E; i++){
scanf("%d%d%d", &es[i].u, &es[i].v, &es[i].cost);
}
cout << "MST: " << Kruskal() << endl;
return 0;
}
/*
input:
7 10
0 1 2
0 2 5
1 2 4
1 3 6
1 4 10
2 3 2
3 5 1
4 5 3
4 6 5
5 6 9
output:
MST: 17
*/