1. Sa standardnog ulaza se učitava niz od n (n<100) tačaka u ravni takvih da nikoje tri tačke nisu kolinearne. Tačke se zadaju parom svojih koordinata (celi brojevi). Ispitati da li taj niz tačaka određuje konveksni mnogougao i rezultat ispisati na standardni izlaz.

ULAZ 5 117 276 214 276 244 184 166 128 88 188 IZLAZ Uneti mnogougao jeste konveksan!

ULAZ 5 301 279 397 279 428 185 347 209 270 185 IZLAZ Uneti mnogougao nije konveksan!

#include <iostream> using namespace std; typedef struct tacka { int x; int y; } TACKA;

Ako M(x,y) pripada pravoj p određenoj tačkama M1, M2, onda f(x,y)=0 Ako M(x,y) NE pripada pravoj p određenoj tačkama M1, M2,

onda f(x,y)>0 za položaj tačke M s jedne strane prave p f(x,y)<0 za položaj tačke M s druge strane prave p

Dakle, ako su tačke T3(x3,y3), T4(x4,y4) sa različitih strana prave p, onda važi f(x3,y3)*f(x4,y4)<0

/* F-ja ispituje da li se tacke T3 i T4 nalaze sa iste strane prave odredjene tackama T1 i T2.*/ int SaIsteStranePrave(TACKA T1,TACKA T2, TACKA T3, TACKA T4) { int t3= (T3.x-T1.x)* (T2.y-T1.y) - (T2.x-T1.x)*(T3.y-T1.y); // T3 sa iste strane prave T1T2??? int t4= (T4.x-T1.x)* (T2.y-T1.y) - (T2.x-T1.x)*(T4.y-T1.y);

// T4 sa iste strane prave T1T2??? return (t3 * t4 > 0); } const int Nmax=100;

int main() { ios_base::sync_with_stdio(false); TACKA mnogougao[Nmax]; int j,i; int n; int konveksan = 1; cin >>n;

//ucitavanje tacaka mnogougla //"Unesite koordinate temena mnogougla takve da nikoja tri temena nisu kolinearna! for(i=0; i<n; i++) cin >> mnogougao[i].x >> mnogougao[i].y; // Da bi mnogougao bio konveksan potrebno (i dovoljno) je da // kada se povuce prava kroz bilo koja dva susedna temena mnogougla sva ostala temena budu sa iste strane te prave. for(i=0; konveksan&&i<n-1; i++) { for(j=0; konveksan&&j<i-1; j++) konveksan=konveksan && SaIsteStranePrave(mnogougao[i],mnogougao[i+1],mnogougao[j],mnogougao[j+1]); for(j=i+2; konveksan&&j<n-1; j++) konveksan=konveksan && SaIsteStranePrave(mnogougao[i],mnogougao[i+1],mnogougao[j],mnogougao[j+1]); if(i!=0&&i!=n-1&&i+1!=0&&i+1!=n-1) konveksan=konveksan && SaIsteStranePrave(mnogougao[i], mnogougao[i+1],mnogougao[0],mnogougao[n-1]); } for(j=1; konveksan&&j<n-2; j++) konveksan=konveksan && SaIsteStranePrave(mnogougao[0], mnogougao[n-1],mnogougao[j],mnogougao[j+1]); if(konveksan) cout <<"Uneti mnogougao jeste konveksan!\n"; else cout<<"Uneti mnogougao nije konveksan!\n"; return 0; }

2. Sa standardnog ulaza se unose koordinate četiri tačke A, B, C i D (realni brojevi) koje pripadaju istoj ravni. Proveriti da li tačka D pripada ili ne pripada unutrasnjosti trougla ABC (tačke A, B, C nisu kolinearne) i dobijeni rezultat ispisati na standardni izlaz.

Hint: Tačka D je u trouglu ako: D, A je sa iste strane prave B, C && D, B je sa iste strane prave A, C && D, C je sa iste strane prave A, B

B(10,30)

/ \

/ \

/ \

/ D \ D'

/ \

A(0,0) ----------- C(20,0)

DISKUSIJA: Šta mislite o sledećoj implementaciji rešenja? #include <iostream>

#include<cmath>

using namespace std;

struct Point {

float x, y;

};

float triangleArea(Point p1, Point p2, Point p3) { //nadjimo povrsinu trougla cija temena su tacke P1, P2, P3

return abs((p1.x*(p2.y-p3.y) + p2.x*(p3.y-p1.y)+ p3.x*(p1.y-p2.y))/2.0);

}

bool isInside(Point A, Point B, Point C, Point D) { //proveri da li je D unutar ili van trougla float area = triangleArea (A, B, C); //povrsina trougla ABC

float area1 = triangleArea (D, B, C); // povrsina trougla DBC

float area2 = triangleArea (A, D, C); // povrsina trougla ADC

float area3 = triangleArea (A, B, D); // povrsina trougla ABD

return (area == area1 + area2 + area3); //indikator da li je tacka D unutar trougla

}

int main() {

Point p1={0, 0}, p2={20, 0}, p3={10, 30};

Point p = {10, 15};

if (isInside(p1, p2, p3, p))

cout << "Tacka je unutar trougla.";

else

cout << "Tacka je van trougla ";

}

TEST PRIMER Point p1={1/10.0, 1/9.0}, p2={100.0/8, 100.0/3}, p3={100.0/4, 100.0/9}; Point p = {p1.x + (3.0/7)*(p2.x - p1.x), p1.y + (3.0/7)*(p2.y - p1.y)}; //tacka unutar duzi P1P2 IZLAZ Tacka je van trougla

3.

Despacito

Vremensko ograničenje Memorijsko ograničenje ulaz izlaz

0,5 s 512 MB standardni ulaz standardni izlaz

Na datoj slici, dvostrukom linijom je predstavljen provodnik pod naponom. Provodnik se ne sme dodirnuti, kao i svaki metalni element izložen provodniku. Ali, oko provodnika su rasporedjene posebne metalne iglice.

Ulaz

U prvoj liniji standardnog ulaza dat je ukupan broj iglica i provodnika. U svakoj zasebnoj narednoj liniji standardnog ulaza, opisana je iglica preko dva para brojeva: x i y koordinata krajeva. Poslednja linija standardnog ulaza sadrži koordinate tačaka koje predstavljaju krajeve provodnika. Sve date koordinate su celi brojevi iz segmenta [0, 10000]. Ne postoji više od 1000 iglica.

Izlaz

U jedinoj liniji standardnog izlaza ispisati tačno jedan broj – broj iglica koje se mogu bezbedno dotaći golim rukama (u smislu da te iglice nemaju elektro veze sa provodnikom).

Ulaz

5 5 2 8 2 3 4 3 1

7 1 6 4

3 3 0 3

6 3 1 1

Izlaz 2

Rešenje: Potrebno je naći sve iglice povezane sa provodnikom. Zato ćemo praviti graf čiji će čvorovi biti iglice i provodnik, a grane između dva čvora pravimo ako se iglice/provodnik koje oni predstavljaju seku.

Da bi uspostavili graf, moracemo da obavimo n^2 koraka, što bi trebalo da bude dovoljno za ovo ograničenje. Moracemo da ispitamo presek svake dve iglice, tj. iglice i provodnika, i povežemo ih ukoliko njihov presek nije prazan. Na kraju cemo u O(n) koraka ispitati presek provodnika sa iglicama jednim prolaskom dfs-a.

Presek dve iglice može predstavljati problem ukoliko su one paralelne, jer ce formula tada zahtevati da delimo sa 0, pa cemo morati da razmotrimo paralelnost pre traženja preseka.

#include <iostream> using namespace std; struct Point { int x, y; }; const int NMAX = 1024; Point A[NMAX], B[NMAX]; int n; bool adj[NMAX][NMAX]; bool visited[NMAX]; int compSize; int direction(Point A, Point B, Point C) { int a1=B.x-A.x, a2=B.y-A.y; int b1=C.x-A.x, b2=C.y-A.y; int p=a1*b2, q=a2*b1; if(p>q) return +1; if(p<q) return -1; return 0;

} bool onSegment(Point A,Point B,Point C) { return min(A.x,B.x)<=C.x && C.x<=max(A.x,B.x) && min(A.y,B.y)<=C.y && C.y<=max(A.y,B.y); } bool intersect(Point A, Point B, Point C, Point D) { int d1 = direction(A,B,C); int d2 = direction(A,B,D); int d3 = direction(C,D,A); int d4 = direction(C,D,B); if (d1*d2<0 && d3*d4<0)return true; if (d1==0 && onSegment(A,B,C)) return true; if (d2==0 && onSegment(A,B,D)) return true; if (d3==0 && onSegment(C,D,A)) return true; if (d4==0 && onSegment(C,D,B)) return true; return false; } void dfs(int i) { compSize++; visited[i]=true; for(int j=0; j<n; j++) if(adj[i][j] & !visited[j]) dfs(j); } int main() { int i; cin >> n; for(i=0;i<n;i++) cin >> A[i].x >> A[i].y >> B[i].x >> B[i].y; for(int i=0; i<n; i++) for(int j=i+1; j<n; j++) adj[i][j] = adj[j][i] = intersect(A[i],B[i],A[j],B[j]); compSize=0; dfs(n-1); cout << n-compSize << endl; return 0; }

4. Na slici grada nalazi se n solitera pravougaonog oblika (mogu se preklapati). Svaki soliter je definisan početnom i krajnjom x koordinatom i visinom. Napisati program koji će izračunati površinu koji soliteri prekrivaju. (Primer primene: Line sweep algoritam)

ULAZ

U prvoj liniji standardnog ulaza zadat je ceo broj n (1<=100 000), a potom se u narednih n linija zadaju po tri cela broja u a, b, c u svakoj liniji (0<=a<b<=109 , 1<=c<=109). Ta tri broja opisuju pojedinačni pravougaonik: a je početna x koordinata pravougaonika, b je krajnja x koordinata, dok je c visina.

IZLAZ

Ispisati koliku povrsinu slike prekrivaju soliteri (pravougaonici).

ULAZ IZLAZ

9 59

10 14 4

0 3 3

2 4 6

1 6 2

16 17 4

11 14 3

12 20 1

5 9 3

15 17 3

Na slici dodana je linija koju zamišljamo kako se pomiče preko slike s leva na desno (skenira sliku). Pritom ta linija prelazi preko pravougaonika i postupno sabira površinu i kad dođe na desnu stranu znamo rešenje. Ta linija prelazi preko nekog od sledeća dva događaja:

Naišli smo na levu ivicu pravougaonika visine c

Naišli smo na desnu ivicu pravougaonika visine c

Kako pomičemo liniju, pamtimo sve pravougaonike preko kojih linija prelazi. Kad se pojavi nova leva ivica pravougaonika, zapamtimo u multiset <int> sweep njegovu visinu. Klasa multiset iz STL biblioteke set moze da ima vise istih elemenata, a ostala svojstva su ista kao kod klase set iz iste biblioteke.

Kada se pojavi desna ivica pravougaonika, izbacimo njegovu visinu iz sweep. Kako bismo mogli obilaziti dogadjaje sleva nadesno (kako se pomice zamisljene linije), moramo dogadjaje sortirati po x osi od manjeg prema vecem. Svaki pravougaonik iz unosa opisan je brojevima a,b,c i opisuje dva dogadjaja:

Leva ivica pravougaonika visine c je na koordinati a

Desna ivica pravougaonika visine c je na koordinati b

Kako bismo razlikovali dogadjaje, onda cemo prvi dogadjaj notirati kao (a,c), a drugi cemo notirati kao (b,-c).

Visina je uvek pozitivna, te ce negatovna vrednost –c oznacavati da se radi o desnoj ivici pravougaonika, a ne o levoj ivici.

Dogadjaje sortiramo i obilazimo sleva nadesno. Ako je prosli dogadjaj bio na x koordinati prosliX, a trenutni je na koordinati a, tada znamo da se svi pravougaonici cija je visina zapisana u setu protezu od koordinate prosliX do a, te zato povecavamo ukupunu povrsinu za (a-prosliX)*najveciPravougaonikTrenutnoUSetu

#include <iostream> #include <vector> #include <set> #include <algorithm> using namespace std;

int main()

{ int n; cin >> n;

vector<pair<int,int> > dogadjaj;

int a,b,c;

for(int i=0;i<n;i++) { cin >> a >> b >> c; dogadjaj.push_back(make_pair(a,c)); //zapisujemo dogadjaj: leva ivica pravougaonika dogadjaj.push_back(make_pair(b,-c)); //desna ivica pravougaonika }

sort(dogadjaj.begin(), dogadjaj.end()); //sortiramo zapisane dogadjaje

long long resenje=0; //resenje moze da prevazidje int

multiset <int> sweep; //kreiramo multiset, a ne set, jer moze postojati vise solitera iste visine

sweep.insert(0); /*vazno je da ubacimo 0, kako bismo pri dohvatu najveceg solitera uvek imali sta dohvatati, inace bi se srusio program*/

sweep.insert(dogadjaj[0].second); //ubacujemo 1. dogadjaj u sweep, a to je sigurno leva ivica pravougaonika

int prosliX=dogadjaj[0].first; //pamtimo na kojoj x koordinati je taj dogadja

for(int i=1; i<dogadjaj.size();i++) //obilazimo ostale dogadjaje { a=dogadjaj[i].first; b=dogadjaj[i].second; /*povecavamo resenje za (a-prosliX)*najveciPravougaonikTrenutnoUSetu i vodimo racuna da rezultat bude tipa long long. Najveca vrednost (multi)seta se nalazi pre kraja seta, te zato uzimamo iterator kraja i vracamo se unazad operatorom --, te uz operator * pristupamo vrednosti na koju pokazuje iterator */ resenje+=((long long)a-prosliX)* *(--sweep.end()); prosliX=a; //azuriramo vrednost promenljive prosliX /*izbacujemo vrednost iz multiseta ako se radi o desnom rubu pravougaonika */ if (b<0) sweep.erase(sweep.find(-b)); //OPREZ: ne smemo koristiti poziv sweep.erase(-b), jer bi se obrisali svi clanovi s vrednoscu -b /*u suprotnom, ubacujemo vrednost u multiset */ else sweep.insert(b); }

cout << resenje << endl;

return 0;

}

Prostorna složenost: O(n) Vremenska složenost: O(n log n), jer se nad multisetom obavlja n operacija koje imaju složenost O(log n).

Inače, čak i da koordinate na ulazu programa nisu celobrojne, zadatak bismo mogli rešiti na isti način.

Na sličan način se može rešiti i problem nalaženja najvećeg pravougaonika u histogramu.

5. Dato je n pravougaonika u koordinatnom sistemu sa stranicama paralelnim osama. Svaki pravougaonik je dat koordinatom donjeg-levog i koordinatom gornjeg-desnog temena. Naći površinu njihovih preseka.

Prvi red standardnog ulaza sadrži ceo broj n (2 <= n <= 200 000). Potom se u narednih nredova učitava po četiri broja x1i, y1i, x2i (x1i < x2i) i y2i (y1i < y2i), 1 <= i <= n. Svaka koordinata je ceo broj iz intervala [0, 100 000]. Prvi red standardnog ulaza treba da sadrži jedan ceo broj koji predstavlja površinu preseka datih pravougaonika.

Ulaz: Izlaz:

4 6 2 2 11 6 5 3 9 8 5 3 10 6 5 1 7 7

Objašnjenje: Pravougaonik sa donjim-levim temenom (5, 3) i gornjim-desnim temenom (7, 6) je presek datih pravougaonika.

Ulaz: Izlaz:

2 0 0 0 20 20 50 50 100 100

Objašnjenje: Pravougaonici nemaju presek, pa je tražena površina 0.

Rešenje:

#include <iostream> using namespace std; int main() { long n,i, dx,dy,gx,gy,x1,x2,y1,y2; cin >>n; cin >>dx >> dy >> gx >>gy; for(i=2; i<=n; i++) { cin >>x1 >>y1 >>x2 >>y2 ; if (x1>dx) dx=x1; if (x2<gx) gx=x2; if (y1>dy) dy=y1; if (y2<gy) gy=y2; if((gy-dy<1)||(gx-dx<1)) { cout <<"0\n"; return 0; } } cout << (gy-dy)*(gx-dx) << endl; return 0; } 7. Za samostalan rad: https://www.geeksforgeeks.org/total-area-two-overlapping-rectangles/ Da li je resenje korektno ako stranice pravougaonika nisu paralelne koordinatnim osama?

8. Uopšteniji problem: Unija pravougaonika

Problem površine unije pravougaonika se pojavljuje u mnogim zadacima, pa stoga postoji i dosta ideja za njegovu realizaciju. Line sweep algoritam ce nam pomoći da rešimo ovaj problem u složenosti O(NlogN), gde N predstavlja maksimalni raspon kordinata po samo jednoj osi.

Najpre ubacimo sva donja leva i gornja desna temena u niz i to, prvima dodajemo atribut znak = 1, a drugima znak=-1. Soriramo taj niz, najpre po x, a zatim po znaku . Sada postavimo pravu na koordinatu x, prve tačke niza Tacke.

Sada pomerimo pravu do sledeceg člana niza Tačke. Time ćemo ’prebrisati’ neku oblast. Površina te oblasti će biti jednaka proizvodu pomeraja po x osi i ukupne dužine prave koja pripada pravougaonicima na tom intervalu.

Sada, razmotrimo kako možemo da implementiramo ovu ’pravu’. Nama zapravo, samo treba struktura koja će moći da izvrši sledeće operacije : - ObeležiDaPravaUlaziUPravougaonik(početak,kraj)

- ObrišiDeoPraveKojiJeUlazioUPravougaonik(početak,kraj) (potrebno ako smo stigli do kraja jednog pravougaonika, tada ne želimo da naša prava više ostavlja ’trag’ tog pravouganioka.)

- dužinaPraveuPravougaonicima()

Struktura podataka koja nam je potrebna je segmentno stablo. Medjutim, ni samo poznavanje segmentnog stabla nije dovoljno, već je potrebno znati i lazy propagation metodu, kojom je moguće ’update’ovati vrednosti celom intervalu u segmentnom stablu.

Implementacija ove ideje i nije toliko zahtevna ukoliko se dobro poznaju navedene metode.

Pri svakom potezu pomeranja ’prave’ mi radimo sledeće korake.

- Povrsina= Povrsina + PomerajPoX*dužinaPraveuPravougaonicima.

- Izmeni Segmento stablo u intervalu (y0,y1) za vrednost x[i].znak.

9. Na ceremoniji otvaranja Svetskog kupa postoji plesna tačka gde mnoga deca širom sveta pokušavaju da kreiraju veliki krug na poljani. Taj krug predstavlja simbol toleranicije i multikulturalnog prijateljstva. Oni su uspeli da naprave savršeni krug, ali pošto deca nisu baš marljivo vežbala, onda nisu bili ravnomerno raspoređeni po krugu. Vi ste to brzo uočili i želite da znate koje je minimalno rastojanje između neka dva deteta. Prva linija standardnog ulaza sadrži broj 𝑁𝑁 koji predstavlja broj dece. Svaka od sledećih N linija sadrži dva realna broja zaokružena na dva decimalna mesta – koordinate svakog deteta. Garantuje se da će sve tačke biti na krugu. Prva i jedina linija standardnog ulaza treba da sadrži jedan realan broj (zaokružen na dva decimale) – Euklidsko rastojanje između dva najbliža deteta. Euklidsko rastojanje između tačke (𝑥𝑥1,𝑦𝑦1) i (𝑥𝑥2,𝑦𝑦2) je: �(𝑥𝑥1 − 𝑥𝑥2)2 + (𝑦𝑦1 − 𝑦𝑦2)2

Primer Ulaz: Izlaz: 5 1.00 4.00 -0.50 -1.60 4.00 1.00 3.12 3.12 -1.60 -0.50

1.56

Objašnjenja primera Deca na tačkama sa koordinatama (−0.50,−1.60) i (−1.60,−0.50) su najlbliža i rastojanje među njima je 1.56.

Ograničenja • 2 ≤ 𝑁𝑁 ≤ 105 • Sve koordinate će biti u intervalu [−106, 106]

OBJASNJENJE Nije teško uočiti da dve najbliže tačke će biti dve susedne tačke unutar redosleda koji prati smer kretanje kazaljke na satu. Postoji više načina da nađemo redosled tih tačaka. 1. način- Neka je 𝑃𝑃 tačka sa najmanjom 𝑦𝑦 koordinatom (tzv. najdonja tacka). Sortiramo sve tačke po polarnom uglu (ugao koji formira poluprava sa pocetkom u tacki P koja je paralelna osi O𝑥𝑥 sa polupravom koja sadrži datu tačku i tačku 𝑃𝑃). Najjednostavnije je da sortiramo tačke kao tangens ugla (formula (𝑇𝑇. 𝑦𝑦 – 𝑃𝑃. 𝑦𝑦) / (𝑇𝑇. 𝑥𝑥 – 𝑃𝑃. 𝑥𝑥) gde 𝑇𝑇 je posmatrana tacka). Nakon toga, izračunavamo rastojanje između dve susedne tačke u sortiranom nizu i sračunavamo minimalno rastojanje. 2. način- Isto to sa najlevljom tackom (tj. tačka sa minimalnom 𝑥𝑥 koordinatom). RESENJE #include <cstdio> #include <cmath> #include <algorithm> using namespace std; #define eps 0.000001 struct point { double x,y; } points[333555]; double dist(point p1, point p2) { //da li je neophodna funkcija sqrt? return sqrt((p1.x - p2.x)*(p1.x - p2.x) + (p1.y - p2.y)*(p1.y - p2.y)); } bool cmp(point p1, point p2) { double u1,u2; if (fabs(p1.y - points[0].y) < eps) return false; //da ne delimo nulom if (fabs(p2.y - points[0].y) < eps) return true;//da ne delimo nuloma

u1 = (p1.x - points[0].x) / (p1.y - points[0].y); u2 = (p2.x - points[0].x) / (p2.y - points[0].y); return (u1 < u2); } int main() { int n,p,i; double d,res; point tmp; scanf("%d", &n); //broj dece p = 0; //nalazenje ekstrem tacke P for(i=0; i<n; i++) { scanf("%lf%lf", &points[i].x, &points[i].y); if (points[i].y < points[p].y || (fabs(points[i].y - points[p].y) < eps && points[i].x < points[p].x) ) { p = i; } } tmp = points[0]; points[0] = points[p]; points[p] = tmp; sort(points+1,points+n,cmp); res = dist(points[0], points[n-1]); for(i=1; i<n; i++) { d = dist(points[i], points[i-1]); if (d < res) res = d; } printf("%.2lf\n", res); return 0; }

10. Dato je N (3<=N<=26) tačaka u ravni nazivom i koordinatama. Kreirajte program koji pronalazi sve trouglove čija tri temena mogu biti date tačke.

ULAZ Prva linija standardnog ulaza sadrži broj tačaka N. U sledećih N redova standardnog ulaza nalazi se naziv, apcisa i ordinata svake tačke. Apcisa i ordinata su celi brojevi iz intervala (–2000, 2000).

IZLAZ Ispisati u svakoj liniji standardnog izlaza nazive temena koji obrazuju trouglove. Temena svakog trougla postujuci leksikografski poredak na ulazu. Ako zadate tačke ne obrazuju niti jedan trougao ispisati tekst Nema trouglova.

TEST PRIMERI

ULAZ IZLAZ 5 A 0 0 B 5 0 C 0 4 D 10 0 E 0 8

A B C A B E A C D A D E B C D B C E

B D E C D E

4 B 0 0 C 3 3 D 7 7 E 4 4

Nema trouglova.

5 A 0 0 B 5 0 C 0 4 D 0 4 E 0 4

A B C A B D A B E

REŠENJE:

Važno je uociti da za date dimenzije ulaznih parametra N, X, Y, možemo na izlazu imati relativno veliki broj trojki.

IDEJA: proveriti uredjene trojke tacaka (i,j,k) i svaka trojka tacaka koja nije kolinearna obrazuje trougao Vremenska složenost provere kolineranosti za tri tacke je O(1)

Za samostalan rad: 1. https://www.geeksforgeeks.org/find-simple-closed-path-for-a-given-set-of-points/

2. https://www.geeksforgeeks.org/find-angles-given-triangle/