Исправить ошибку в коде - C (СИ) (78988)

Узнай цену своей работы

Формулировка задачи:

написала программу а она выдает ошибку которая повторяется раз пять не знаю как исправить не понимаю почему именно это ошибка помогите исправить
Листинг программы 
  1. #include <stdio.h>
  2. #define RAZMER 15
  3.  
  4. int main()
  5. {
  6.     int Counter;
  7.     int Adjacency[RAZMER][RAZMER] = {{0}};      
  8.     int Reachability[RAZMER][RAZMER] = {{0}}; 
  9.     int Counter_reachability[RAZMER][RAZMER] = {{0}};   
  10.     int Mutual_reachability[RAZMER][RAZMER] = {{0}};   
  11.     int Strong[RAZMER][RAZMER] = {{0}};    
  12.     int Condens[RAZMER][RAZMER] = {{0}};   
  13.     int Span[RAZMER][RAZMER] = {{0}};   
  14.     int i,j;    
  15.     FILE * inp;
  16.     inp = fopen("ishodnik.txt", "r");    
  17.     for(i = 0; i < RAZMER; i++)
  18.         for (j = 0; j < RAZMER; j++)
  19.             fscanf(inp, "%d", &Adjacency[i][j]);    
  20.  
  21.     printf ("Initial adjacency matrix:\n"); 
  22.     Print_matrix (Adjacency);             
  23.     Reach_matrix (Adjacency,Reachability);    
  24.     printf ("Reachability matrix:\n");     
  25.     Print_matrix (Reachability);      
  26.     Counter_reach_matrix (Reachability, Counter_reachability);
  27.     printf ("Counter reachability matrix:\n");   
  28.     Print_matrix (Counter_reachability);     
  29.     Mutual_reach_matrix(Reachability, Mutual_reachability);
  30.     printf ("Mutual reachability matrix:\n");   
  31.     Print_matrix (Mutual_reachability);      
  32.     Strong_component (Mutual_reachability, Strong);     
  33.     Condensation (Adjacency, Strong, Condens);   
  34.     printf ("Condensation:\n");   
  35.     for(i = 0; i < Counter; i++)
  36. {
  37.         for(j = 0; j < Counter; j++)
  38.             printf("%d ", Condens[i][j]);    
  39.         printf("\n");
  40.     }
  41.     Span_tree (Reachability, Span);  
  42.     printf("\nSpanning Tree:\n");   
  43.     Print_matrix(Span);
  44.     return 0;   
  45. }
  46.  
  47.     void Print_matrix (int *ptr)
  48.     {   
  49.             int i,j;        
  50.         for(i = 0; i < RAZMER; i++)
  51.         {
  52.             for(j = 0; j < RAZMER; j++)
  53.                printf(" %d", ptr[i*RAZMER+j]);   
  54.             printf("\n");
  55.      }
  56.         printf("\nThis matrix is:\n");  
  57.         if (Reflexive(ptr))     
  58.             printf("reflexive\n");
  59.      else
  60.             printf("NOT reflexive\n");
  61.         if (Symmetry(ptr))      
  62.             printf("symmetrical\n");
  63.         else
  64.             printf("NOT symmetrical\n");
  65.         if (Transitive(ptr))  
  66.             printf("transitive\n");
  67.         else
  68.           printf("NOT transitive\n");
  69.         if (Irreflexive(ptr))      
  70.             printf("Irreflexive\n");
  71.      else
  72.             printf("NOT Irreflexive\n");
  73.         if (Asymmetry(ptr))      
  74.             printf("asymmetric\n");
  75.      else
  76.          printf("NOT asymmetric\n");
  77.      if (Antisymmetry(ptr))      
  78.           printf("antisymmetric\n\n");
  79.         else
  80.          printf("NOT antisymmetric\n\n"); 
  81.      }
  82.  
  83. void Assignment (int *ptr1, int *ptr2)
  84. {  
  85.     int i,j;    
  86.     for(i = 0; i < RAZMER; i++)
  87.         for(j = 0; j < RAZMER; j++)
  88.             ptr1[i*RAZMER+j] = ptr2[i*RAZMER+j];
  89. }
  90.  
  91. void Reach_matrix (int *Adjacency_ptr,int *Reachability_ptr){  
  92.     int i,j,k;  
  93.     for (k = 0; k < RAZMER; k++)
  94.         for (i = 0; i < RAZMER; i++)
  95.             for (j = 0; j < RAZMER; j++)
  96.                 Adjacency_ptr[i*RAZMER+j]+=Adjacency_ptr[i*RAZMER+k]*Adjacency_ptr[k*RAZMER+j];      for (i = 0; i < RAZMER; i++)
  97.         for (j = 0; j < RAZMER; j++){
  98.             if(Adjacency_ptr[i*RAZMER+j]>=1)
  99.                 Reachability_ptr[i*RAZMER+j] = 1;
  100.         else
  101.             Reachability_ptr[i*RAZMER+j] = 0;
  102.         Reachability_ptr[i*RAZMER+i] = 1;
  103.         }
  104. }
  105.  
  106. void Counter_reach_matrix (int *Reachability_ptr, int *Counter_reachability_ptr)
  107. {    
  108.     int i,j;    
  109.     for (i = 0; i < RAZMER; i++)
  110.         for (j = 0; j < RAZMER; j++)
  111.             Counter_reachability_ptr[i*RAZMER+j] = Reachability_ptr[j*RAZMER+i];
  112. }
  113.  
  114. void Mutual_reach_matrix (int *Reachability_ptr, int *Mutual_ptr)
  115. {   
  116.     int i,j;        for (i = 0; i < RAZMER; i++)
  117.         for (j = 0; j < RAZMER; j++)
  118. Mutual_ptr[i*RAZMER+j] =Reachability_ptr[i*RAZMER+j]*Reachability_ptr[j*RAZMER+i];
  119. }
  120.  
  121. int Reflexive(int *ptr){   
  122.     int i;    
  123.     for (i = 0; i < RAZMER; i++)
  124.         if (ptr[i*RAZMER+i] == 0)
  125.             return 0;
  126.     return 1;
  127. }
  128.  
  129. int Symmetry(int *ptr ){
  130.     int i, j;    
  131.     for (i = 0; i < RAZMER; i++)
  132.         for (j = 0; j < RAZMER; j++)
  133.             if(ptr[i*RAZMER+j] != ptr[j*RAZMER+i])
  134.                 return 0;
  135.     return 1;
  136. }
  137.  
  138. int Transitive(int *ptr){     
  139.     int k, i, j;    
  140.     for (i = 0; i < RAZMER; i++)
  141.         for (j = 0; j < RAZMER; j++)
  142.             for (k = 0; k < RAZMER; k++)
  143.                 if(ptr[i*RAZMER+j] == 1 && ptr[j*RAZMER+k] == 1 && ptr[i*RAZMER+k] != 1)
  144.                     return 0;
  145.     return 1;
  146. }
  147.  
  148. int Irreflexive(int *ptr){
  149.     int i;    
  150.     for (i = 0; i < RAZMER; i++)
  151.         if (ptr[i*RAZMER+i] != 0)
  152.             return 0;
  153.     return 1;
  154. }
  155.  
  156. int Asymmetry(int *ptr) {   
  157.     int i, j;    
  158.     for (i = 0; i < RAZMER; i++)
  159.         for (j = 0; j < RAZMER; j++)
  160.             if((ptr[i*RAZMER+j]!=0) && (ptr[i*RAZMER+j] == ptr[j*RAZMER+i]))
  161.                 return 0;
  162.     return 1;
  163. }
  164.  
  165. int Antisymmetry (int *ptr){   
  166.     int i, j;    
  167.         for (i = 0; i < RAZMER; i++)
  168.             for (j = 0; j < RAZMER; j++)
  169.                 if (ptr[i*RAZMER+j] == 1 && ptr[j*RAZMER+i] == 1 && i!=j)
  170.                     return 0;
  171.     return 1;
  172. }
  173.  
  174. void Strong_component (int *Mutual_ptr, int *Strongly_ptr)
  175. {    
  176.     int i, j, k, Counter;    
  177.     int Mutual_counter[RAZMER][RAZMER] = {{0}};   
  178.     int Strong_counter[RAZMER][RAZMER] = {{0}}; 
  179.     Assignment  (Mutual_counter, Mutual_ptr); 
  180.     for (j = 0; j < RAZMER; j++)
  181.     {
  182.         for (i = 0; i < RAZMER; i++)
  183.             for (k = 0; k < RAZMER; k++)
  184.      if ((Mutual_counter[k][j] == Mutual_counter[i][j]) && (Mutual_counter[k][j] == 1) && (k > i))
  185.                     for (Counter = 0; Counter < RAZMER; Counter++) 
  186.                         Mutual_counter[k][Counter] = 0; 
  187.         Counter = 0       
  188.      for (i = 0; i < RAZMER; i++)
  189.             Counter+= Mutual_counter[j][i];
  190.         if (Counter >= 1)
  191.             for (i = 0; i < RAZMER; i++)
  192.                 Strong_counter[j][i] = Mutual_counter[j][i];
  193.         }
  194.     for (k = 0; k < RAZMER; k++)
  195. {
  196.         for (i = 0; i < RAZMER-1; i++)
  197. {
  198.             Counter = 0;
  199.             for (j = 0; j < RAZMER; j++)
  200.                 Counter+= Strong_counter[i][j];
  201.             if (Counter == 0){
  202.                 for (j = 0; j < RAZMER; j++)
  203. {
  204.                     Strong_counter[i][j] = Strong_counter[i+1][j];
  205.                     Strong_counter[i+1][j] = 0;
  206.                 }
  207.             }
  208.         }
  209.         for (j = 0; j < RAZMER; j++)
  210.             if (Strong_counter[k][j] !=0)     
  211.                 Strong_counter[k][j] = j+1;    
  212.     }
  213.     for (i = 0; i < RAZMER; i++)
  214. {
  215.         for (j = 0; j < RAZMER; j++)
  216.             if (Strong_counter[i][j] !=0)
  217. {
  218.                 Strongly_ptr[i*RAZMER+Counter] = Strong_counter[i][j];  
  219.                 Counter++;
  220.             }
  221.         Counter = 0;   
  222.     }
  223.     Counter = 0;   
  224.     for (i = 0; i < RAZMER; i++)
  225.         for (j = 0; j < RAZMER; j++)
  226.             if (Strong_counter[i][j] !=0)
  227. {
  228.                 Counter++;  
  229.                 break;
  230.             }
  231.     printf ("Strongly connected components:\n\n");   
  232.     for (i = 0; i < Counter; i++)
  233. {
  234.         printf("Component #%d:\n{", i+1);
  235.         for(j = 0; j < RAZMER; j++)
  236.             printf("%d,", Strongly_ptr[i*RAZMER+j]);   
  237.         printf("}\n\n");
  238.     }
  239. }
  240.  
  241. void Condensation (int *Adjacency_ptr, int *Strongly_ptr, int *Condensation_ptr){  
  242.     int i,j,k,l;    
  243.     for (i = 0; i < RAZMER; i++)
  244.         for (j = 0; j < RAZMER; j++)
  245.             if (Strongly_ptr[i*RAZMER+j] != 0)
  246.                 for (k = 0; k < RAZMER; k++)
  247.                     for (l = 0; l < RAZMER; l++)
  248.                         if ((k != i) && (Strongly_ptr[k*RAZMER+l] != 0) && (Adjacency_ptr[Strongly_ptr[i*RAZMER+j]*RAZMER+Strongly_ptr[k*RAZMER+l]] == 1))
  249.                             Condensation_ptr[i*RAZMER+k] = 1;
  250. }
  251.  
  252. void Span_tree (int *Adjacency_ptr, int *Span_ptr){ 
  253.     int i,j,k,l,m, Stack[RAZMER] = {0}, Stack_number = 0;
  254.     Stack[0] = 6;       for (i = 0; i < RAZMER; i++)
  255.         Span_ptr[i*RAZMER+Stack[0]] = 0;   
  256.     while(Stack_number <= RAZMER-1){
  257.         for (i = 0; i < RAZMER; i++)
  258.             if (Span_ptr[Stack[Stack_number]*RAZMER+i] == 1)
  259.                 for (j = 0; j < RAZMER; j++)
  260.                     if ((Span_ptr[j*RAZMER+i] == 1) && (j != Stack[Stack_number]))
  261.                         Span_ptr[j*RAZMER+i] = 0;
  262.         ++Stack_number;
  263.         Stack[Stack_number] = Stack_number;
  264.     }
  265. }
компилятор выдает
Листинг программы 
  1.  error: conflicting types for 'Print_matrix'
  2.  error: previous implicit declaration of 'Print_matrix' was here
  3.  error: conflicting types for 'Reach_matrix'
  4.  error: previous implicit declaration of 'Reach_matrix' was here
  5. : error: conflicting types for 'Counter_reach_matrix'
  6.  error: previous implicit declaration of 'Counter_reach_matrix' was
  7.  
  8. : error: conflicting types for 'Mutual_reach_matrix'
  9.  error: previous implicit declaration of 'Mutual_reach_matrix' was
  10.  
  11. : error: conflicting types for 'Strong_component'
  12.  error: previous implicit declaration of 'Strong_component' was her
  13.  
  14.  function `Strong_component':
  15. : warning: passing arg 1 of `Assignment' from incompatible pointer
  16.  
  17. : error: syntax error before "for"
  18. : error: syntax error before ')' token
  19.  top level:
  20. : error: conflicting types for 'Condensation'
  21.  error: previous implicit declaration of 'Condensation' was here
  22. : error: conflicting types for 'Span_tree'
  23.  error: previous implicit declaration of 'Span_tree' was here

Решение задачи: «Исправить ошибку в коде»

textual
Листинг программы 
  1. printf ("Initial adjacency matrix:\n"); 
  2.  Print_matrix ((int*)Adjacency); 
  3.  Reach_matrix ((int*)Adjacency, (int*)Reachability); 
  4.  printf ("Reachability matrix:\n"); 
  5.  Print_matrix ((int*)Reachability); 
  6.  Counter_reach_matrix ((int*)Reachability, (int*)Counter_reachability);
  7.  printf ("Counter reachability matrix:\n"); 
  8.  Print_matrix ((int*)Counter_reachability); 
  9.  Mutual_reach_matrix((int*)Reachability, (int*)Mutual_reachability);
  10.  printf ("Mutual reachability matrix:\n"); 
  11.  Print_matrix ((int*)Mutual_reachability); 
  12.  Strong_component ((int*)Mutual_reachability, (int*)Strong); 
  13.  Condensation ((int*)Adjacency, (int*)Strong, Condens); 
  14.  printf ("Condensation:\n"); 
  15.  for(i = 0; i < Counter; i++)
  16. {
  17.  for(j = 0; j < Counter; j++)
  18.  printf("%d ", Condens[i][j]); 
  19.  printf("\n");
  20.  }
  21.  Span_tree ((int*)Reachability, (int*)Span); 
  22.  printf("\nSpanning Tree:\n"); 
  23.  Print_matrix((int*)Span);
  24.  return 0;

Объяснение кода листинга программы

  1. Выводится исходная матрица смежности.
  2. Вычисляется матрица достижимости.
  3. Выводится матрица достижимости.
  4. Вычисляется матрица взаимной достижимости.
  5. Выводится матрица взаимной достижимости.
  6. Вычисляется матрица сильных компонент.
  7. Вычисляется матрица конденсации.
  8. Выводится матрица конденсации.
  9. Вычисляется дерево вложения.
  10. Выводится дерево вложения.
  11. Вычисляется дерево достижимости.
  12. Выводится дерево достижимости.
  13. Вычисляется матрица достижимости графа вложения.
  14. Выводится матрица достижимости графа вложения.
  15. Вычисляется матрица взаимной достижимости графа вложения.
  16. Выводится матрица взаимной достижимости графа вложения.
  17. Вычисляется матрица сильных компонент графа вложения.
  18. Выводится матрица сильных компонент графа вложения.
  19. Вычисляется матрица конденсации графа вложения.
  20. Выводится матрица конденсации графа вложения.

ИИ поможет Вам:

  • решить любую задачу по программированию
  • объяснить код
  • расставить комментарии в коде
  • и т.д
Попробуйте бесплатно

Оцени полезность:

13   голосов , оценка 4 из 5

Нужна аналогичная работа?

Оформи быстрый заказ и узнай стоимость

Бесплатно
Оформите заказ и авторы начнут откликаться уже через 10 минут