algorithm@ dijkstra algorithm & prim algorithm

#include<iostream>
#include<cstdio>
#include<cstring>
#include<limits>
#include<vector>
using namespace std;
const int maxn=6;
struct edge{
int to,cost;
edge(int t,int c){
this->to=t; this->cost=c;
}
};
void addEdge(vector<edge> &edgelist, vector<vector<int> > &G,int from,int to,int cost){
edge e = edge(to,cost);
edgelist.push_back(e);
G[from].push_back(edgelist.size()-1);
}
void addDoubleEdge(vector<edge> &edgelist, vector<vector<int> > &G,int from,int to,int cost){
addEdge(edgelist,G,from,to,cost);
addEdge(edgelist,G,to,from,cost);
}
int dijkstra(vector<edge> edgelist,vector<vector<int> > G,int v,int END){
vector<int> d(G.size());
vector<int> vis(G.size());
for(int i=0;i<vis.size();++i) vis[i]=false;
for(int i=0;i<d.size();++i) d[i]=numeric_limits<int>::max();
for(int i=0;i<G[v].size();++i){
edge e = edgelist[G[v][i]];
d[e.to] = e.cost;
}

vis[v]=true;

for(int i=1;i<G.size();++i){
int Min=numeric_limits<int>::max(), k;
for(int j=0;j<G.size();++j){
if(!vis[j] && d[j] < Min){
Min = d[j];
k = j;
}
}
vis[k]=true;

for(int j=0;j<G[k].size();++j){
edge e = edgelist[G[k][j]];
if(!vis[e.to] && d[k] + e.cost < d[e.to]) d[e.to] = d[k] + e.cost;
}
}
return d[END];
}
int prim(vector<edge> edgelist,vector<vector<int> > G,int v){
int overall_cost = 0;
vector<int> lowcost(G.size());
vector<int> closet(G.size());
vector<int> vis(G.size());
for(int i=0;i<vis.size();++i) vis[i]=false;
for(int i=0;i<lowcost.size();++i) lowcost[i]=numeric_limits<int>::max();

for(int i=0;i<G[v].size();++i){
edge e = edgelist[G[v][i]];
lowcost[e.to] = e.cost;
closet[e.to] = v;
}

vis[v]=true;
for(int i=1;i<G.size();++i){
int Min=numeric_limits<int>::max(), k;
for(int j=0;j<G.size();++j){
if(!vis[j] && lowcost[j] < Min){
Min = lowcost[j];
k = j;
}
}
cout<< Min <<endl;
overall_cost += Min;
vis[k] = true;
//closet[k] = v;
for(int j=0;j<G[k].size();++j){
edge e = edgelist[G[k][j]];
if(!vis[e.to] && e.cost < lowcost[e.to]){
lowcost[e.to] = e.cost;
closet[e.to] = k;
}
}
}
return overall_cost;
}
void buildMap(vector<edge> &edgelist, vector<vector<int> > &G){
addDoubleEdge(edgelist, G, 0, 1, 6);
addDoubleEdge(edgelist, G, 0, 2, 1);
addDoubleEdge(edgelist, G, 0, 3, 5);

addDoubleEdge(edgelist, G, 1, 2, 5);
addDoubleEdge(edgelist, G, 2, 3, 5);
addDoubleEdge(edgelist, G, 1, 4, 3);

addDoubleEdge(edgelist, G, 2, 4, 6);
addDoubleEdge(edgelist, G, 2, 5, 4);
addDoubleEdge(edgelist, G, 3, 5, 2);
addDoubleEdge(edgelist, G, 4, 5, 6);

/*
addEdge(edgelist,G,0,2,6);
addEdge(edgelist,G,0,1,4);
addEdge(edgelist,G,0,3,6);

addEdge(edgelist,G,1,2,1);
addEdge(edgelist,G,1,4,7);

addEdge(edgelist,G,2,5,4);
addEdge(edgelist,G,2,4,6);

addEdge(edgelist,G,3,5,5);
addEdge(edgelist,G,3,2,2);

addEdge(edgelist,G,4,6,6);

addEdge(edgelist,G,5,4,1);
addEdge(edgelist,G,5,6,8);
*/
}
int main(){
vector<edge> edgelist;
vector<vector<int> > G(maxn);

buildMap(edgelist, G);

cout<<endl<<dijkstra(edgelist, G, 0, 5)<<endl;

cout<<prim(edgelist, G, 0)<<endl;

return 0;

}