SHARE
TWEET

Untitled

a guest Apr 24th, 2019 77 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2. #define _CRT_SECURE_NO_WARNINGS 1
  3.  
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7.  
  8. #define INFINIT 10000000
  9.  
  10. struct Client
  11. {
  12.     int tsm; // timp fata de statia de metrou
  13.     char* nc; // nume_client;
  14.     int sp; // suma de plati
  15. };
  16.  
  17. struct Graf_Client
  18. {
  19.     int nuc; // numar clienti;
  20.     int sic; // strazi intre clienti;
  21.     int **mat; // matrice de adiacenta timp;
  22. };
  23.  
  24. struct Statie_metrou
  25. {
  26.     char* nume;
  27.     int clc; // Comenzi livrate client - 0 sau 1 (a livrat toate comenzile)
  28.     int nc; // nuumar_clienti
  29.     struct Client *cl;
  30.     struct Graf_Client gc;
  31. };
  32.  
  33. struct Graf_Metrou
  34. {
  35.     int N, M;
  36.     struct Statie_metrou *sm;
  37.     int **mad; // matrice adiacenta distanta
  38. };
  39.  
  40. const int opersize = 12;
  41.  
  42. const char* operations[] = { "conexiune", "legatura", "blocaj_tunel", "blocaj_strada", "adauga_ruta", "sterge_ruta", "adauga_strada", "sterge_strada",
  43.                             "drum_strada", "drum_metrou", "timp_minim_statie", "comanda_statie" };
  44.  
  45. int oper_code(const char* oper)
  46. {
  47.     int i;
  48.     for (i = 0; i < opersize; i++)
  49.     {
  50.         if (strcmp(oper, operations[i]) == 0)
  51.         {
  52.             return i;
  53.         }
  54.     }
  55.     return -1;
  56. }
  57.  
  58. void conexiune(FILE * fisierout, struct Graf_Metrou* gm, const char* buf)
  59. {
  60.     char cl1[50];
  61.     char cl2[50];
  62.     sscanf(buf, "%s %s", cl1, cl2);
  63.  
  64.     int i, j;
  65.     for (i = 0; i < gm->N; i++)
  66.     {
  67.         for (j = 0; j < gm->sm[i].nc; j++)
  68.         {
  69.             if (strcmp(gm->sm[i].cl[j].nc, cl1) == 0)
  70.             {
  71.                 break;
  72.             }
  73.         }
  74.         if (j < gm->sm[i].nc)
  75.         {
  76.             break;
  77.         }
  78.     }
  79.     if (i < gm->N)
  80.     {
  81.         int j1 = j;
  82.         for (j = 0; j < gm->sm[i].nc; j++)
  83.         {
  84.             if (strcmp(gm->sm[i].cl[j].nc, cl2) == 0)
  85.             {
  86.                 break;
  87.             }
  88.         }
  89.         if (j < gm->sm[i].nc)
  90.         {
  91.             int j2 = j;
  92.             if ((gm->sm[i].gc.mat[j1][j2] < INFINIT) && (gm->sm[i].gc.mat[j1][j2] != 0))
  93.             {
  94.                 fprintf(fisierout, "OK\n");
  95.             }
  96.             else
  97.             {
  98.                 fprintf(fisierout, "NO\n");
  99.             }
  100.         }
  101.         else
  102.         {
  103.             fprintf(fisierout, "NO\n");
  104.         }
  105.     }
  106.     else
  107.     {
  108.         fprintf(fisierout, "NO\n");
  109.     }
  110. }
  111.  
  112. void legatura(FILE * fisierout, struct Graf_Metrou* gm, const char* station)
  113. {
  114.     int i, j;
  115.     for (i = 0; i < gm->N; i++)
  116.     {
  117.         if (strcmp(gm->sm[i].nume, station) == 0)
  118.         {
  119.             break;
  120.         }
  121.     }
  122.     if (i < gm->N)
  123.     {
  124.         int last = 0;
  125.         for (j = 0; j < gm->N; j++)
  126.         {
  127.             if ((gm->mad[i][j] < INFINIT) && (gm->mad[i][j] != 0))
  128.             {
  129.                 last = j;
  130.             }
  131.         }
  132.         for (j = 0; j < gm->N; j++)
  133.         {
  134.             if ((gm->mad[i][j] < INFINIT) && (gm->mad[i][j] != 0))
  135.             {
  136.                 if (j == last)
  137.                 {
  138.                     fprintf(fisierout, "%s", gm->sm[j].nume);
  139.                 }
  140.                 else
  141.                 {
  142.                     fprintf(fisierout, "%s ", gm->sm[j].nume);
  143.                 }
  144.             }
  145.         }
  146.         fprintf(fisierout, "\n");
  147.     }
  148. }
  149.  
  150. void blocaj_tunel(FILE * fisierout, struct Graf_Metrou* gm, const char* buf)
  151. {
  152.     char st1[50];
  153.     char st2[50];
  154.     sscanf(buf, "%s %s", st1, st2);
  155.     int i;
  156.     for (i = 0; i < gm->N; i++)
  157.     {
  158.         if (strcmp(gm->sm[i].nume, st1) == 0)
  159.         {
  160.             break;
  161.         }
  162.     }
  163.     int i1 = i;
  164.     for (i = 0; i < gm->N; i++)
  165.     {
  166.         if (strcmp(gm->sm[i].nume, st2) == 0)
  167.         {
  168.             break;
  169.         }
  170.     }
  171.     int i2 = i;
  172.     if ((i1 < gm->N) && (i2 < gm->N) && (i1 != i2))
  173.     {
  174.         gm->mad[i1][i2] = INFINIT;
  175.         gm->mad[i2][i1] = INFINIT;
  176.     }
  177. }
  178.  
  179. void blocaj_strada(FILE * fisierout, struct Graf_Metrou* gm, const char* buf)
  180. {
  181.     char cl1[50];
  182.     char cl2[50];
  183.     sscanf(buf, "%s %s", cl1, cl2);
  184.     int i, j;
  185.     for (i = 0; i < gm->N; i++)
  186.     {
  187.         for (j = 0; j < gm->sm[i].nc; j++)
  188.         {
  189.             if (strcmp(gm->sm[i].cl[j].nc, cl1) == 0)
  190.             {
  191.                 break;
  192.             }
  193.         }
  194.         if (j < gm->sm[i].nc)
  195.         {
  196.             break;
  197.         }
  198.     }
  199.     if (i < gm->N)
  200.     {
  201.         int j1 = j;
  202.         for (j = 0; j < gm->sm[i].nc; j++)
  203.         {
  204.             if (strcmp(gm->sm[i].cl[j].nc, cl2) == 0)
  205.             {
  206.                 break;
  207.             }
  208.         }
  209.         if (j < gm->sm[i].nc)
  210.         {
  211.             int j2 = j;
  212.             gm->sm[i].gc.mat[j1][j2] = INFINIT;
  213.             gm->sm[i].gc.mat[j2][j1] = INFINIT;
  214.         }
  215.     }
  216. }
  217.  
  218. void adauga_ruta(FILE * fisierout, struct Graf_Metrou* gm, const char* buf)
  219. {
  220.     char st1[50];
  221.     char st2[50];
  222.     int dist;
  223.     sscanf(buf, "%s %s %d", st1, st2, &dist);
  224.     int i;
  225.     for (i = 0; i < gm->N; i++)
  226.     {
  227.         if (strcmp(gm->sm[i].nume, st1) == 0)
  228.         {
  229.             break;
  230.         }
  231.     }
  232.     int i1 = i;
  233.     for (i = 0; i < gm->N; i++)
  234.     {
  235.         if (strcmp(gm->sm[i].nume, st2) == 0)
  236.         {
  237.             break;
  238.         }
  239.     }
  240.     int i2 = i;
  241.     if (i1 < gm->N && i1 < gm->N && i1 != i2)
  242.     {
  243.         gm->mad[i1][i2] = dist;
  244.         gm->mad[i2][i1] = dist;
  245.     }
  246. }
  247.  
  248. void sterge_ruta(FILE * fisierout, struct Graf_Metrou* gm, const char* buf)
  249. {
  250.     blocaj_tunel(fisierout, gm, buf);
  251. }
  252.  
  253. void adauga_strada(FILE * fisierout, struct Graf_Metrou* gm, const char* buf)
  254. {
  255.     char cl1[50];
  256.     char cl2[50];
  257.     int timp;
  258.     sscanf(buf, "%s %s %d", cl1, cl2, &timp);
  259.     int i, j;
  260.     for (i = 0; i < gm->N; i++)
  261.     {
  262.         for (j = 0; j < gm->sm[i].nc; j++)
  263.         {
  264.             if (strcmp(gm->sm[i].cl[j].nc, cl1) == 0)
  265.             {
  266.                 break;
  267.             }
  268.         }
  269.         if (j < gm->sm[i].nc)
  270.         {
  271.             break;
  272.         }
  273.     }
  274.     if (i < gm->N)
  275.     {
  276.         int j1 = j;
  277.         for (j = 0; j < gm->sm[i].nc; j++)
  278.         {
  279.             if (strcmp(gm->sm[i].cl[j].nc, cl2) == 0)
  280.             {
  281.                 break;
  282.             }
  283.         }
  284.         if (j < gm->sm[i].nc)
  285.         {
  286.             int j2 = j;
  287.             gm->sm[i].gc.mat[j1][j2] = timp;
  288.             gm->sm[i].gc.mat[j2][j1] = timp;
  289.         }
  290.     }
  291. }
  292.  
  293. void sterge_strada(FILE * fisierout, struct Graf_Metrou* gm, const char* buf)
  294. {
  295.     blocaj_strada(fisierout, gm,  buf);
  296. }
  297.  
  298. //"drum_strada"
  299.  
  300. void drum_metrou(FILE * fisierout, struct Graf_Metrou* gm, const char* buf)
  301. {
  302.     char st1[50];
  303.     char st2[50];
  304.     sscanf(buf, "%s %s", st1, st2);
  305.     int i;
  306.     for (i = 0; i < gm->N; i++)
  307.     {
  308.         if (strcmp(gm->sm[i].nume, st1) == 0)
  309.         {
  310.             break;
  311.         }
  312.     }
  313.     int i1 = i;
  314.     for (i = 0; i < gm->N; i++)
  315.     {
  316.         if (strcmp(gm->sm[i].nume, st2) == 0)
  317.         {
  318.             break;
  319.         }
  320.     }
  321.     int i2 = i;
  322.     if ((i1 < gm->N) && (i2 < gm->N))
  323.     {
  324.         int** madcopy;
  325.         madcopy = (int**)malloc(gm->N * sizeof(int*));
  326.         for (i = 0; i < gm->N; i++)
  327.         {
  328.             madcopy[i] = (int*)malloc(gm->N * sizeof(int));
  329.         }
  330.         int j;
  331.         for (i = 0; i < gm->N; i++)
  332.             for (j = 0; j < gm->N; j++)
  333.                 madcopy[i][j] = gm->mad[i][j];
  334.         int k;
  335.         for (k = 0; k < gm->N; k++)
  336.         {
  337.             for (i = 0; i < gm->N; i++)
  338.             {
  339.             }
  340.             for (j = 0; j < gm->N; j++)
  341.             {
  342.                 if (madcopy[i][k] + madcopy[k][j] < madcopy[i][j])
  343.                     madcopy[i][j] = madcopy[i][k] + madcopy[k][j];
  344.             }
  345.         }
  346.  
  347.  
  348.  
  349.     }
  350.  
  351.  
  352.  
  353.  
  354.  
  355.  
  356.  
  357. }
  358.  
  359.  
  360. //"timp_minim_statie"
  361.  
  362. //"comanda_statie"
  363.  
  364.  
  365. void CitireDate(FILE * fisierin, struct Graf_Metrou* gm)
  366. {
  367.     fscanf(fisierin, "%d", &gm->N);
  368.     gm->sm = (struct Statie_metrou*)malloc(gm->N * sizeof(struct Statie_metrou));
  369.     int i, j, k, m;
  370.     char buf[100];
  371.     for (i = 0; i < gm->N; i++)
  372.     {
  373.         fscanf(fisierin, "%s", buf);
  374.         gm->sm[i].nume = (char*)malloc(strlen(buf) + 1);
  375.         strcpy(gm->sm[i].nume, buf);
  376.         fscanf(fisierin, "%d", &gm->sm[i].nc);
  377.         gm->sm[i].cl = (struct Client*)malloc(gm->sm[i].nc * sizeof(struct Client));
  378.         for (j = 0; j < gm->sm[i].nc; j++)
  379.         {
  380.             fscanf(fisierin, "%s", buf);
  381.             gm->sm[i].cl[j].nc = (char*)malloc(strlen(buf) + 1);
  382.             strcpy(gm->sm[i].cl[j].nc, buf);
  383.             fscanf(fisierin, "%d", &gm->sm[i].cl[j].tsm);
  384.             fscanf(fisierin, "%d", &gm->sm[i].cl[j].sp);
  385.             gm->sm[i].gc.nuc = gm->sm[i].nc;
  386.         }
  387.         fscanf(fisierin, "%d", &gm->sm[i].gc.sic);
  388.         gm->sm[i].gc.mat = (int**)malloc(gm->sm[i].nc * sizeof(int*));
  389.         for (k = 0; k < gm->sm[i].nc; k++)
  390.         {
  391.             gm->sm[i].gc.mat[k] = (int*)malloc(gm->sm[i].nc * sizeof(int));
  392.             for (j = 0; j < gm->sm[i].nc; j++)
  393.             {
  394.                 if (k == j)
  395.                 {
  396.                     gm->sm[i].gc.mat[k][k] = 0;
  397.  
  398.                 }
  399.                 else
  400.                 {
  401.                     gm->sm[i].gc.mat[k][j] = INFINIT;
  402.                 }
  403.             }
  404.         }
  405.         for (k = 0; k < gm->sm[i].gc.sic; k++)
  406.         {
  407.             fscanf(fisierin, "%s", buf);
  408.             for (m = 0; m < gm->sm[i].gc.sic; m++)
  409.             {
  410.                 if (strcmp(buf, gm->sm[i].cl[m].nc) == 0)
  411.                 {
  412.                     break;
  413.                 }
  414.             }
  415.             int i1 = m;
  416.             fscanf(fisierin, "%s", buf);
  417.             for (m = 0; m < gm->sm[i].gc.sic; m++)
  418.             {
  419.                 if (strcmp(buf, gm->sm[i].cl[m].nc) == 0)
  420.                 {
  421.                     break;
  422.                 }
  423.             }
  424.             int i2 = m;
  425.             int timp;
  426.             fscanf(fisierin, "%d", &timp);
  427.             // simetrica
  428.             gm->sm[i].gc.mat[i1][i2] = timp;
  429.             gm->sm[i].gc.mat[i2][i1] = timp;
  430.         }
  431.     }
  432.     fscanf(fisierin, "%d", &gm->M);
  433.     // matrice adiacenta distanta
  434.     gm->mad = (int**)malloc(gm->N * sizeof(int*));
  435.     for (i = 0; i < gm->N; i++)
  436.     {
  437.         gm->mad[i] = (int*)malloc(gm->N * sizeof(int));
  438.         for (j = 0; j < gm->N; j++)
  439.         {
  440.             if (i == j)
  441.             {
  442.                 gm->mad[i][i] = 0;
  443.             }
  444.             else
  445.             {
  446.                 gm->mad[i][j] = INFINIT;
  447.             }
  448.         }
  449.     }
  450.     for (i = 0; i < gm->M; i++)
  451.     {
  452.         fscanf(fisierin, "%s", buf);
  453.         for (m = 0; m < gm->N; m++)
  454.         {
  455.             if (strcmp(buf, gm->sm[m].nume) == 0)
  456.             {
  457.                 break;
  458.             }
  459.         }
  460.         int i1 = m;
  461.         fscanf(fisierin, "%s", buf);
  462.         for (m = 0; m < gm->N; m++)
  463.         {
  464.             if (strcmp(buf, gm->sm[m].nume) == 0)
  465.             {
  466.                 break;
  467.             }
  468.         }
  469.         int i2 = m;
  470.         int dist;
  471.         fscanf(fisierin, "%d", &dist);
  472.         // simetrica
  473.         gm->mad[i1][i2] = dist;
  474.         gm->mad[i2][i1] = dist;
  475.     }
  476. }
  477.  
  478. void DealocareMemorie(struct Graf_Metrou* gm)
  479. {
  480.     int i, j;
  481.     // Dealocare statii metrou
  482.     for (i = 0; i < gm->N; i++)
  483.     {
  484.         // Dealoca nume statie
  485.         free(gm->sm[i].nume);
  486.         // Dealoca clienti
  487.         for (j = 0; j < gm->sm[i].nc; j++)
  488.         {
  489.             free(gm->sm[i].cl[j].nc);
  490.         }
  491.         free(gm->sm[i].cl);
  492.         // Dealoca graf clienti
  493.         for (j = 0; j < gm->sm[i].nc; j++)
  494.         {
  495.             free(gm->sm[i].gc.mat[j]);
  496.         }
  497.         free(gm->sm[i].gc.mat);
  498.     }
  499.     free(gm->sm);
  500.     // Dealocare matrice de adiacenta
  501.     for (i = 0; i < gm->N; i++)
  502.     {
  503.         free(gm->mad[i]);
  504.     }
  505.     free(gm->mad);
  506. }
  507.  
  508. int main(int argc, char* argv[])
  509. {
  510.     // argv[0]) - "curier.exe"
  511.     // argv[1]) - "date.txt"
  512.     // argv[2]) - "rezultate.out"
  513.  
  514.     FILE* fisierin = fopen(argv[1], "rt");
  515.     if (fisierin == NULL)
  516.     {
  517.         printf("Cannot open the input file.\n");
  518.         exit(1);
  519.     }
  520.     FILE* fisierout = fopen(argv[2], "wt");
  521.     if (fisierout == NULL)
  522.     {
  523.         printf("Cannot open the output file.\n");
  524.         exit(1);
  525.     }
  526.  
  527.     //int nsm; // numar strazi matrice
  528.     //int **mpss; // matrice de parcurgere strazi la sediu
  529.  
  530.     int i;
  531.     struct Graf_Metrou gm;
  532.     CitireDate(fisierin, &gm);
  533.  
  534.     int nc = 0;
  535.     fscanf(fisierin, "%d\n", &nc);
  536.     char oper[201];
  537.     for (i=0; i< nc; i++)
  538.     {
  539.         fgets(oper, 200, fisierin);
  540.         int len = (int)strlen(oper);
  541.         oper[len - 1] = 0;
  542.         len--;
  543.         if (len == 0) break;
  544.         int ipos = 0;
  545.         int i;
  546.         for (i = 0; i < len; i++)
  547.         {
  548.             if (oper[i] == ' ')
  549.             {
  550.                 oper[i] = '\0';
  551.                 ipos = i + 1;
  552.                 break;
  553.             }
  554.         }
  555.         int cod_oper = oper_code(oper);
  556.  
  557.         switch (cod_oper)
  558.         {
  559.         case 0:
  560.             conexiune(fisierout, &gm, oper + ipos);
  561.             break;
  562.  
  563.         case 1:
  564.             legatura(fisierout, &gm, oper + ipos);
  565.             break;
  566.  
  567.         case 2:
  568.             blocaj_tunel(fisierout, &gm, oper + ipos);
  569.             break;
  570.  
  571.         case 3:
  572.             blocaj_strada(fisierout, &gm, oper + ipos);
  573.             break;
  574.  
  575.         case 4:
  576.             adauga_ruta(fisierout, &gm, oper + ipos);
  577.             break;
  578.  
  579.         case 5:
  580.             sterge_ruta(fisierout, &gm, oper + ipos);
  581.             break;
  582.  
  583.         case 6:
  584.             adauga_strada(fisierout, &gm, oper + ipos);
  585.             break;
  586.  
  587.         case 7:
  588.             sterge_strada(fisierout, &gm, oper + ipos);
  589.             break;
  590.  
  591.         case 8:
  592.             // drum_strada x y – Calculeaza cel mai scurt timp de la x la y(x si y sunt clienti).
  593.             //finish(fisierout, &cproc, &idle, &ca, &cf, &lp, &lm, T);
  594.             break;
  595.  
  596.         case 9:
  597.             drum_metrou(fisierout, &gm, oper + ipos);
  598.             break;
  599.  
  600.         case 10:
  601.             // timp_minim_statie x
  602.             //finish(fisierout, &cproc, &idle, &ca, &cf, &lp, &lm, T);
  603.             break;
  604.  
  605.         case 11:
  606.             // comanda_statie valoare_suma
  607.             //finish(fisierout, &cproc, &idle, &ca, &cf, &lp, &lm, T);
  608.             break;
  609.  
  610.         default:
  611.             fprintf(fisierout, "Unknown order.\n");
  612.         }
  613.     }
  614.  
  615.     DealocareMemorie(&gm);
  616.  
  617.     fclose(fisierin);
  618.     fclose(fisierout);
  619.  
  620.     return 0;
  621. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top