algorithm@ dijkstra algorithm & prim algorithm

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<limits>
 #include<vector>
 using namespace std;
 const int maxn=;
 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()-);
 }
 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=;i<vis.size();++i) vis[i]=false;
     for(int i=;i<d.size();++i) d[i]=numeric_limits<int>::max();
     for(int i=;i<G[v].size();++i){
         edge e = edgelist[G[v][i]];
         d[e.to] = e.cost;
     }

     vis[v]=true;

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

         for(int j=;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 = ;
     vector<int> lowcost(G.size());
     vector<int> closet(G.size());
     vector<int> vis(G.size());
     for(int i=;i<vis.size();++i) vis[i]=false;
     for(int i=;i<lowcost.size();++i) lowcost[i]=numeric_limits<int>::max();

     for(int i=;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=;i<G.size();++i){
         int Min=numeric_limits<int>::max(), k;
         for(int j=;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=;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, , , );
     addDoubleEdge(edgelist, G, , , );
     addDoubleEdge(edgelist, G, , , );

     addDoubleEdge(edgelist, G, , , );
     addDoubleEdge(edgelist, G, , , );
     addDoubleEdge(edgelist, G, , , );

     addDoubleEdge(edgelist, G, , , );
     addDoubleEdge(edgelist, G, , , );
     addDoubleEdge(edgelist, G, , , );
     addDoubleEdge(edgelist, G, , , );

     /*
     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, , )<<endl;

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

         return ;

 }