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