API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 24th, 2019
97
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 11.33 KB | None | 0 0
raw download clone embed print report
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!