Answers for "Prim's Algorithm"

2

c program for prims algorithm

#include<stdio.h>
#include<conio.h>
int a,b,u,v,n,i,j,ne=1;
int visited[10]= {	0},min,mincost=0,cost[10][10];
void main() {	
clrscr();	
printf("\n Enter the number of nodes:");	
scanf("%d",&n);	
printf("\n Enter the adjacency matrix:\n");	
for (i=1;i<=n;i++)	  
    for (j=1;j<=n;j++) {		
      scanf("%d",&cost[i][j]);		
      if(cost[i][j]==0)		    
      cost[i][j]=999;	
      }	
    visited[1]=1;	
    printf("\n");	
    while(ne<n) {		
      for (i=1,min=999;i<=n;i++)		  
        for (j=1;j<=n;j++)		    
          if(cost[i][j]<min)		     
          if(visited[i]!=0) {			
          min=cost[i][j];			
          a=u=i;			
          b=v=j;		
          }		
          if(visited[u]==0 || visited[v]==0) 
          {			
            printf("\n Edge %d:(%d %d) cost:%d",ne++,a,b,min);
            mincost+=min;			
            visited[b]=1;		
            }		
          cost[a][b]=cost[b][a]=999;	
          }	
          printf("\n Minimun cost=%d",mincost);
          getch();
}
Posted by: Guest on September-15-2020
4

prim's algorithm python

def empty_graph(n):
    res = []
    for i in range(n):
        res.append([0]*n)
    return res
def convert(graph):
    matrix = []
    for i in range(len(graph)): 
        matrix.append([0]*len(graph))
        for j in graph[i]:
            matrix[i][j] = 1
    return matrix
def prims_algo(graph):
    graph1 = convert(graph)
    n = len(graph1)
    tree = empty_graph(n)
    con =[0]
    while len(con) < n :
        found = False
        for i in con:
            for j in range(n):
                if j not in con and graph1[i][j] == 1:
                    tree[i][j] =1
                    tree[j][i] =1
                    con += [j]
                    found  = True
                    break
            if found :
                break
    return tree
matrix = [[0, 1, 1, 1, 0, 1, 1, 0, 0],
          [1, 0, 0, 1, 0, 0, 1, 1, 0],
          [1, 0, 0, 1, 0, 0, 0, 0, 0],
          [1, 1, 1, 0, 1, 0, 0, 0, 0],
          [0, 0, 0, 1, 0, 1, 0, 0, 1],
          [1, 0, 0, 0, 1, 0, 0, 0, 1],
          [1, 1, 0, 0, 0, 0, 0, 0, 0],
          [0, 1, 0, 0, 0, 0, 0, 0, 0],
          [0, 0, 0, 0, 1, 1, 0, 0, 0]]

lst = [[1,2,3,5,6],[0,3,6,7],[0,3],[0,1,2,4],[3,5,8],[0,4,8],[0,1],[1],[4,5]]
print("From graph to spanning tree:\n")
print(prims_algo(lst))
Posted by: Guest on August-26-2020
1

prims c++

#include <iostream>
#include <vector>
#include <queue>
#include <functional>
#include <utility>

using namespace std;
const int MAX = 1e4 + 5;
typedef pair<long long, int> PII;
bool marked[MAX];
vector <PII> adj[MAX];

long long prim(int x)
{
    priority_queue<PII, vector<PII>, greater<PII> > Q;
    int y;
    long long minimumCost = 0;
    PII p;
    Q.push(make_pair(0, x));
    while(!Q.empty())
    {
        // Select the edge with minimum weight
        p = Q.top();
        Q.pop();
        x = p.second;
        // Checking for cycle
        if(marked[x] == true)
            continue;
        minimumCost += p.first;
        marked[x] = true;
        for(int i = 0;i < adj[x].size();++i)
        {
            y = adj[x][i].second;
            if(marked[y] == false)
                Q.push(adj[x][i]);
        }
    }
    return minimumCost;
}

int main()
{
    int nodes, edges, x, y;
    long long weight, minimumCost;
    cin >> nodes >> edges;
    for(int i = 0;i < edges;++i)
    {
        cin >> x >> y >> weight;
        adj[x].push_back(make_pair(weight, y));
        adj[y].push_back(make_pair(weight, x));
    }
    // Selecting 1 as the starting node
    minimumCost = prim(1);
    cout << minimumCost << endl;
    return 0;
}
Posted by: Guest on July-01-2020
1

Prim's Algorithm

# Prim's Algorithm in Python

INF = 9999999
# number of vertices in graph
N = 5
#creating graph by adjacency matrix method
G = [[0, 19, 5, 0, 0],
     [19, 0, 5, 9, 2],
     [5, 5, 0, 1, 6],
     [0, 9, 1, 0, 1],
     [0, 2, 6, 1, 0]]

selected_node = [0, 0, 0, 0, 0]

no_edge = 0

selected_node[0] = True

# printing for edge and weight
print("Edge : Weight\n")
while (no_edge < N - 1):
    
    minimum = INF
    a = 0
    b = 0
    for m in range(N):
        if selected_node[m]:
            for n in range(N):
                if ((not selected_node[n]) and G[m][n]):  
                    # not in selected and there is an edge
                    if minimum > G[m][n]:
                        minimum = G[m][n]
                        a = m
                        b = n
    print(str(a) + "-" + str(b) + ":" + str(G[a][b]))
    selected_node[b] = True
    no_edge += 1
Posted by: Guest on July-23-2021
2

prims minimum spanning tree

import math
def empty_tree (n):
    lst = []
    for i in range(n):
        lst.append([0]*n)
    return lst
def min_extension (con,graph,n):
    min_weight = math.inf
    for i in con:
        for j in range(n):
            if j not in con and 0 < graph[i][j] < min_weight:
                min_weight = graph[i][j]
                v,w = i,j
    return v,w
            
def min_span(graph):
    con = [0]
    n = len(graph)
    tree = empty_tree(n)
    while len(con) < n :
        i ,j  = min_extension(con,graph,n)
        tree[i][j],tree[j][i] = graph[i][j], graph[j][i]
        con += [j]
    return tree

def find_weight_of_edges(graph):
    tree = min_span(graph)
    lst = []
    lst1 = []
    x = 0
    for i in tree:
        lst += i 
    for i in lst:
        if i not in lst1:
            lst1.append(i)
            x += i
    return x

graph = [[0,1,0,0,0,0,0,0,0],
         [1,0,3,4,0,3,0,0,0],
         [0,3,0,0,0,4,0,0,0],
         [0,4,0,0,2,9,1,0,0],
         [0,0,0,2,0,6,0,0,0],
         [0,3,4,9,6,0,0,0,6],
         [0,0,0,1,0,0,0,2,8],
         [0,0,0,0,0,0,2,0,3],
         [0,0,0,0,0,6,8,3,0]]
graph1 = [[0,3,5,0,0,6],
          [3,0,4,1,0,0],
          [5,4,0,4,5,2],
          [0,1,4,0,6,0],
          [0,0,5,6,0,8],
          [6,0,2,0,8,0]]
print(min_span(graph1))
print("Total weight of the tree is: " + str(find_weight_of_edges(graph1)))
Posted by: Guest on December-16-2020
0

prims algorithm

// Minimum spanning tree using Prim's Algorithm Efficient Approach
//     Using Priority Queue
// Watch striver graph series :)
#include<bits/stdc++.h>
using namespace std;
void addedge(vector<pair<int,int>>adj[],int u,int v,int weight)
{
    adj[u].push_back(make_pair(v,weight));
    adj[v].push_back(make_pair(u,weight));
}
int main()
{
    int vertex,edges;
    cout<<"ENTER THE NUMBER OF VERTEX AND EDGES:"<<endl;
    cin>>vertex>>edges;
    vector<pair<int,int>>adj[vertex];
    int a,b,w;
    cout<<"ENTER THE LINKS:"<<endl;
    for(int i=0;i<edges;i++)
    {
        cin>>a>>b>>w;
        addedge(adj,a,b,w);
    }
    int parent[vertex],key[vertex];
    bool mset[vertex];
    for(int i=0;i<vertex;i++)
    {
        parent[i]=-1;
        key[i]=INT_MAX;
        mset[i]=false;
    }
    priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>pq;
    parent[0]=-1;
    key[0]=0;
    pq.push(make_pair(0,0));//storing Key[i] and i
    for(int count=0;count<vertex-1;count++)
    {
        int u=pq.top().second;
        pq.pop();
        mset[u]=true;
        for(auto it:adj[u])
        {
            int v=it.first;
            int weight=it.second;
            if(mset[v]==false&&weight<key[v])
            {
                parent[v]=u;
                pq.push(make_pair(key[v],v));
                key[v]=weight;
            }
        }
    }
    for(int i=1;i<vertex;i++)
    {
        cout<<parent[i]<<"->"<<i<<endl;
    }
    return 0;
}
Posted by: Guest on August-20-2021

Python Answers by Framework

Browse Popular Code Answers by Language