👤
a fost răspuns

se da o multime in plan sa se calculeze cea mai mica distanta din oricare 2 puncte posibile
se da 3 numere intrebi a,b,c sa se determine cel mai mare divizor comun al numerelor.

Răspuns :

TIBERIU02EZ
Prima problemă este una foarte, dar foarte, grea și are o rezolvare stufoasă. Numai câțiva elevi știu rezolvarea aceasta. Ai aici sursa:

# include <iostream>

# include <vector>
# include <cmath>
# include <algorithm>

using namespace std;

# define infinity 10000000

struct point {
    double x, y;
};

bool cmpX( point a, point b ) {
    return a.x < b.x;
}
bool cmpY( point a, point b ) {
    return a.y < b.y;
}

double dist( point a, point b ) {
    double deltaX = ( a.x - b.x );
    double deltaY = ( a.y - b.y );

    return sqrt( deltaX * deltaX + deltaY * deltaY );
}

double stripClosest( vector<point> strip, int n, double d ) {
    double m = d;
    int i, j;

    for ( i = 0; i < n; i ++ )
        for ( j = i + 1; j < n && ( strip[j].y - strip[i].y) < m; j ++ )
            m = min( m, dist( strip[i], strip[j] ) );

    return m;
}

double closestUtil( point * px, vector<point> py, int n ) {
    if ( n == 1 )
        return infinity;
    if ( n == 2 )
        return dist( px[0], px[1] );

    int m = n / 2;
    point mid = px[m];

    vector<point> pyl, pyr;
    pyl.reserve( m + 1 );
    pyr.reserve( n - m - 1 );

    int i;
    for ( i = 0; i < n; i ++ )
        if ( py[i].x <= mid.x )
            pyl.push_back( py[i] );
        else
            pyr.push_back( py[i] );

    double dl, dr, d;
    dl = closestUtil( px, pyl, m );
    dr = closestUtil( px + m + 1, pyr, n - m - 1 );
    d = min( dr, dl );

    vector<point> strip;
    for ( i = 0; i < n; i ++ )
        if ( abs( py[i].x - mid.x ) < d )
            strip.push_back( py[i] );

    return min( d, stripClosest( strip, strip.size(), d ) );
}

double closest( point * p, int n ) {
    point px[n];
    vector<point> py;
    py.reserve( n );

    int i;
    for ( i = 0; i < n; i ++ ) {
        p[i].x += 0.000001 * i;
        p[i].y += 0.000001 * i;

        px[i] = p[i];
        py.push_back( p[i] );
    }

    sort( px, px + n, cmpX );
    sort( py.begin(), py.end(), cmpY );

    return closestUtil( px, py, n );
}

int main() {
    int n, i;

    cin >> n;

    point p[n];
    for ( i = 0; i < n; i ++ ) {
        cin >> p[i].x >> p[i].y;
    }

    double r = closest( p, n );
    cout << round( r * 100 + 0.5 ) / 100;

    return 0;
}

A doua problema este foarte simplă, ai aici rezolvarea:

# include <iostream>

using namespace std;

int gcd( int a, int b ) {
    int r;

    while ( b > 0 ) {
        r = a % b;
        a = b;
        b = r;
    }

    return a;
}

int main() {
    int a, b, c;

    cin >> a >> b >> c;
    cout << gcd( a, gcd( b, c ) );

    return 0;
}
Vă mulțumim că ați vizitat platforma noastră dedicată Informatică. Sperăm că informațiile oferite v-au fost utile. Dacă aveți întrebări sau aveți nevoie de asistență suplimentară, nu ezitați să ne contactați. Așteptăm cu nerăbdare să vă revedem și nu uitați să ne salvați în lista de favorite!


Ez Askings: Alte intrebari