SHARE
TWEET

Untitled

a guest May 26th, 2019 64 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <algorithm>
  2. #include <iostream>
  3.  
  4. using namespace std;
  5.  
  6. // Punkt.
  7. struct point
  8. {
  9.     // Wspó³rzêdna x.
  10.     double x;
  11.  
  12.     // Wspó³rzêdna y.
  13.     double y;
  14.  
  15.     // Id odcinka, do którego nale¿y punkt.
  16.     int segment_id;
  17.  
  18.     // Czy lewy kraniec odcinka.
  19.     bool left;
  20.  
  21.     bool operator < (const point &other) const
  22.     {
  23.         return x < other.x;
  24.     }
  25. };
  26.  
  27. // Odcinek.
  28. struct segment
  29. {
  30.     // Id odcinka.
  31.     int id;
  32.  
  33.     // Punkt 1.
  34.     point p1;
  35.  
  36.     // Punkt 2.
  37.     point p2;
  38.  
  39.     double get_left_y;
  40.  
  41.     bool operator < (const segment &other) const
  42.     {
  43.         return get_left_y < other.get_left_y;
  44.     }
  45.  
  46.     /*
  47.     // Zwraca wspó³rzêdn¹ y lewego krañca.
  48.     double get_left_y() const
  49.     {
  50.         return (p1.x < p2.x) ? p1.y : p2.y;
  51.     }
  52.     */
  53. };
  54.  
  55. // Dodanie odcinka do zbioru.
  56. void add(segment t[], int t_count, segment seg)
  57. {
  58.     t[t_count] = seg;
  59.     sort(t, t + t_count);
  60. }
  61.  
  62. // Utworzenie zbioru punktów.
  63. void get_points(segment segments[], int segment_count, point points[])
  64. {
  65.     int i;
  66.     for (i = 0; i < segment_count; i++) {
  67.         points[2 * i] = segments[i].p1;
  68.         points[2 * i + 1] = segments[i].p2;
  69.     }
  70. }
  71.  
  72. // Pobranie iloœci odcinków od u¿ytkownika.
  73. void get_segment_count(int &segment_count)
  74. {
  75.     segment_count = 6;
  76. }
  77.  
  78. // Pobranie wspó³rzêdnych odcinków od u¿ytkownika.
  79. void get_segments(segment segments[])
  80. {
  81.     segments[0].id = 0;
  82.     segments[0].p1.segment_id = 0;
  83.     segments[0].p2.segment_id = 0;
  84.     segments[0].p1.x = 1;
  85.     segments[0].p1.y = 4;
  86.     segments[0].p2.x = 5;
  87.     segments[0].p2.y = 3;
  88.     segments[0].p1.left = (segments[0].p1.x < segments[0].p2.x) ? true : false;
  89.     segments[0].p2.left = (segments[0].p2.x < segments[0].p1.x) ? true : false;
  90.     segments[0].get_left_y = (segments[0].p1.x < segments[0].p2.x) ? segments[0].p1.y : segments[0].p2.y;
  91.  
  92.     segments[1].id = 1;
  93.     segments[1].p1.segment_id = 1;
  94.     segments[1].p2.segment_id = 1;
  95.     segments[1].p1.x = 2;
  96.     segments[1].p1.y = 1;
  97.     segments[1].p2.x = 10;
  98.     segments[1].p2.y = 10;
  99.     segments[1].p1.left = (segments[1].p1.x < segments[1].p2.x) ? true : false;
  100.     segments[1].p2.left = (segments[1].p2.x < segments[1].p1.x) ? true : false;
  101.     segments[1].get_left_y = (segments[1].p1.x < segments[1].p2.x) ? segments[1].p1.y : segments[1].p2.y;
  102.  
  103.     segments[2].id = 2;
  104.     segments[2].p1.segment_id = 2;
  105.     segments[2].p2.segment_id = 2;
  106.     segments[2].p1.x = 3;
  107.     segments[2].p1.y = 3;
  108.     segments[2].p2.x = 4;
  109.     segments[2].p2.y = 6;
  110.     segments[2].p1.left = (segments[2].p1.x < segments[2].p2.x) ? true : false;
  111.     segments[2].p2.left = (segments[2].p2.x < segments[2].p1.x) ? true : false;
  112.     segments[2].get_left_y = (segments[2].p1.x < segments[2].p2.x) ? segments[2].p1.y : segments[2].p2.y;
  113.  
  114.     segments[3].id = 3;
  115.     segments[3].p1.segment_id = 3;
  116.     segments[3].p2.segment_id = 3;
  117.     segments[3].p1.x = 4;
  118.     segments[3].p1.y = 5;
  119.     segments[3].p2.x = 2;
  120.     segments[3].p2.y = 10;
  121.     segments[3].p1.left = (segments[3].p1.x < segments[3].p2.x) ? true : false;
  122.     segments[3].p2.left = (segments[3].p2.x < segments[3].p1.x) ? true : false;
  123.     segments[3].get_left_y = (segments[3].p1.x < segments[3].p2.x) ? segments[3].p1.y : segments[3].p2.y;
  124.  
  125.     segments[4].id = 4;
  126.     segments[4].p1.segment_id = 4;
  127.     segments[4].p2.segment_id = 4;
  128.     segments[4].p1.x = 5;
  129.     segments[4].p1.y = 2;
  130.     segments[4].p2.x = 4;
  131.     segments[4].p2.y = 9;
  132.     segments[4].p1.left = (segments[4].p1.x < segments[4].p2.x) ? true : false;
  133.     segments[4].p2.left = (segments[4].p2.x < segments[4].p1.x) ? true : false;
  134.     segments[4].get_left_y = (segments[4].p1.x < segments[4].p2.x) ? segments[4].p1.y : segments[4].p2.y;
  135.  
  136.     segments[5].id = 5;
  137.     segments[5].p1.segment_id = 5;
  138.     segments[5].p2.segment_id = 5;
  139.     segments[5].p1.x = 6;
  140.     segments[5].p1.y = 6;
  141.     segments[5].p2.x = 5;
  142.     segments[5].p2.y = 8;
  143.     segments[5].p1.left = (segments[5].p1.x < segments[5].p2.x) ? true : false;
  144.     segments[5].p2.left = (segments[5].p2.x < segments[5].p1.x) ? true : false;
  145.     segments[5].get_left_y = (segments[5].p1.x < segments[5].p2.x) ? segments[5].p1.y : segments[5].p2.y;
  146. }
  147.  
  148. // Pobranie wspó³rzêdnych odcinków od u¿ytkownika.
  149.  
  150. int main()
  151. {
  152.     // Iteratory;
  153.     int i, j;
  154.  
  155.     // Iloœæ odcinków.
  156.     int segment_count;
  157.  
  158.     // Pobranie iloœci odcinków od u¿ytkownika.
  159.     get_segment_count(segment_count);
  160.  
  161.     // Odcinki.
  162.     segment segments[segment_count];
  163.  
  164.     // Pobranie wspó³rzêdnych odcinków od u¿ytkownika.
  165.     get_segments(segments);
  166.  
  167.     cout << "Ilosc odcinkow: " << endl << segment_count << endl << endl;
  168.     cout << "Odcinki: " << endl;
  169.  
  170.     for (i = 0; i < segment_count; i++) {
  171.         cout << segments[i].id << " | ";
  172.         cout << "(" << segments[i].p1.x << ", " << segments[i].p1.y << ")";
  173.         cout << " | ";
  174.         cout << "(" << segments[i].p2.x << ", " << segments[i].p2.y << ")";
  175.         cout << endl;
  176.     }
  177.  
  178.     cout << endl;
  179.  
  180.     // Iloœæ punktów.
  181.     int point_count = segment_count * 2;
  182.  
  183.     // Punkty.
  184.     point points[point_count];
  185.  
  186.     // Utworzenie zbioru punktów.
  187.     get_points(segments, segment_count, points);
  188.  
  189.     // Posortowanie zbioru punktów po wspó³rzêdnej x.
  190.     sort(points, points + point_count);
  191.  
  192.     cout << "Punkty: " << endl;
  193.  
  194.     for (i = 0; i < point_count; i++) {
  195.  
  196.         cout << "(" << points[i].x << ", ";
  197.         cout << points[i].y << ") | ";
  198.         cout << "segment_id: " << points[i].segment_id << " | ";
  199.         cout << "left: " << points[i].left << endl;
  200.     }
  201.  
  202.     cout << endl;
  203.  
  204.     // Zbiór odcinków.
  205.     segment t[segment_count];
  206.  
  207.     // Iloœæ odcinków w zbiorze.
  208.     int t_count = 0;
  209.  
  210.     // Aktualnie sprawdzany odcinek.
  211.     segment current_segment;
  212.  
  213.     for (i = 0; i < point_count; i++) {
  214.  
  215.         // Odciek, do którego nale¿y punkt.
  216.         current_segment = segments[points[i].segment_id];
  217.  
  218.         if (points[i].left == true) {
  219.  
  220.             // Dodanie odcinka do zbioru.
  221.             add(t, t_count, current_segment);
  222.             t_count++;
  223.             /*
  224.             seg_prev = prev()
  225.             seg_next = next()
  226.  
  227.             if (seg_prev != null) {
  228.                 czy_sie_przecinaja(current_segment, seg_prev)
  229.             }
  230.  
  231.             if (seg_next != null) {
  232.                 czy_sie_przecinaja(current_segment, seg_next)
  233.             }
  234.             */
  235.         } else {
  236.             /*
  237.             seg_prev = seg_prev
  238.             seg_next = seg_next
  239.  
  240.             if (
  241.                 seg_prev != null
  242.                 && seg_next != null
  243.             ) {
  244.                 czy_sie_przecinaja(seg_prev, seg_next)
  245.             }
  246.  
  247.             delete(t, t_count, current_segment);
  248.             t_count--;
  249.             */
  250.         }
  251.  
  252.         cout << "Zbior odcinkow: " << endl;
  253.  
  254.         for (j = 0; j < t_count; j++) {
  255.             cout << t[j].id << " | ";
  256.             cout << "(" << t[j].p1.x << ", " << t[j].p1.y << ")";
  257.             cout << " | ";
  258.             cout << "(" << t[j].p2.x << ", " << t[j].p2.y << ")";
  259.             cout << endl;
  260.         }
  261.  
  262.         cout << endl;
  263.     }
  264. }
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