Write a program that will print adjacency matrix of a directed and weighted graph.
Weights are positive real values, and graph is strongly connected.
Then, print values of two vertices which indices are read (values of each vertice are functions: sin(index),cos(index),index^2,sqrt(index)).

How to check if a graph is strongly connected? I found some algorithms for strongly connected components of a graph (Tarjan's algorithm and Kosaraju's algorithm),
but can't figure out how to implement them with using only standard libraries.

How to read two indices of previously read vertices (after creating adjacency matrix)?

Here is the unfinished code:

#include <stdio.h>
#include<stdlib.h>
#include<math.h>
#define MAX 10
#define PI 3.14

typedef struct
{
  int vertices;//number of vertices
  int edges;//number of edges
  int u,v;//index of current and next node
  double w;// positive weights
  double nodes[MAX];//data of one node/vertice are all defined *math. functions
  double w_mat[MAX][MAX];//weight matrix
}GRAPH;

void readGraph(GRAPH *pg);
void printWMatrix(GRAPH *pg);
void FLOYD(GRAPH *pg);//Floyd's algorithm for shortest path
void printPath(GRAPH *pg);

//*math. functions
double temp_sin(int x);
double temp_cos(int x);
double temp_pow(int x);
double temp_sqrt(int x);

void readGraph(GRAPH *pg)
{
    do
    {
        printf("Number of vertices: ");
        scanf("%d",&pg->vertices);
    }
    while(pg->vertices <= 0 || pg->vertices > MAX);
    do
    {
        printf("Number of edges: ");
        scanf("%d",&pg->edges);
    }
    while(pg->edges <= 0);
    int i,j;
    for(i=0; i<pg->vertices; i++)
        for(j=0; j<pg->vertices; j++)
           pg->w_mat[i][j]=0;
    printf("(u,v,w): \n");
    for(i=0; i<pg->edges; i++)
    {
        do
        {
            scanf("%d %d %lf",&pg->u, &pg->v, &pg->w);
            pg->w_mat[pg->u][pg->v]=pg->w;
        }
        while(pg->w <= 0);
    }
}

void printPath(GRAPH *pg)
{
    int i,j;
    for(i=0; i<pg->vertices; i++)
    {
        //for each node, print math. functions
    }
}

void FLOYD(GRAPH *pg)
{
    int i,j,k;
    for(k=0; k<pg->vertices; k++){
       for(i=0; i<pg->vertices; i++){
        for(j=0; j<pg->vertices; j++){
            if(pg->w_mat[i][j] > pg->w_mat[i][k] + pg->w_mat[k][j])
                pg->w_mat[i][j]=pg->w_mat[i][k] + pg->w_mat[k][j];
        }
       }
    }
    printPath(pg);
}

void printWMatrix(GRAPH *pg)
{
  int i,j;
  for(i=0; i<pg->vertices; i++)
  {
      for(j=0; j<pg->vertices; j++)
        printf("%4.2lf ",pg->w_mat[i][j]);
      printf("\n");
  }
  printf("\n");
}

double temp_sin(int x)
{
  double res;
  double t=x*PI/180;
  res=sin(t);
  return res;
}
double temp_cos(int x)
{
  double res;
  double t=x*PI/180;
  res=cos(t);
  return res;
}
double temp_pow(int x)
{
  double res;
  res=pow(x,2);
  return res;
}
double temp_sqrt(int x)
{
  double res;
  res=sqrt(x);
  return res;
}

int main()
{
    GRAPH pg;
    readGraph(&pg);
    printWMatrix(&pg);

    /*printf("Read two indices of existing vertices: \n");
    do
    {
       printf("(u,v): \n");
       scanf("%d %d",&pg.u, &pg.v);
    }
    while(pg.u < 0 || pg.v < 0);*/

    //FLOYD(&pg);
    return 0;
}

I haven't gotten that far into your code yet, but WHY are you writing those silly temp_sqrt(int) and similar functions? That just so unnecessary. If you need to compute the square root or a power of some integers, just cast the numbers to floats/doubles as appropriate and do it directly! In C/C++ programming, the less code the better, and the easier it is to debug!

This article has been dead for over six months. Start a new discussion instead.