Forum Pasja Informatyki - Najnowsze z tagiem złożoność

Złożoność obliczeniowa algorytmy

Tue, 16 Apr 2024 22:43:52 +0000

Witam, mógłby mi ktoś pomóc określić złożoność obliczeniową algorytmu i wytłumaczyć dlaczego tak?

wynik := n;

 for i := 1 to n do

   if (i < wynik and r[i]+r[wynik] <= R)

    wynik := wynik-1;

Zadanie A + B - szkopuł

Tue, 30 May 2023 20:06:22 +0000

Witam,

Zacząłem robić zadanie: https://szkopul.edu.pl/problemset/problem/kzUlU--NjB0KKAGvz2es62f8/site/?key=statement

I udało mi się zrobić wybitnie nieoptymalne rozwiązanie za które dostałem 30pkt:

#include <iostream>
#include <string>

unsigned long long strange_add(unsigned long long a, unsigned long long b) {
	std::string s1 = std::to_string(a);
	std::string s2 = std::to_string(b);

	if (s2.length() > s1.length())
		std::swap(s1, s2);

	size_t diff = s1.length() - s2.length();
	std::string result = s1.substr(0, diff);
	s1.erase(0, diff);

	for (int i = 0; i < s2.length(); i++) {
		int x = s1[i] - '0';
		int y = s2[i] - '0';

		result.append(std::to_string(x + y));
	}

	return std::stoull(result);
}

int main()
{
	unsigned long long n;
	std::cin >> n;

	int combinations = 2;
	for (unsigned long long i = 1; i < n; i++) {
		for (unsigned long long j = n; j >= i; j--) {
			if (strange_add(i, j) == n) {
				combinations += i == j ? 1 : 2;
			}
		}
	}

	std::cout << combinations;

	return 0;
}

Ogółem to na początku miałem całkiem inne podejście - chciałem badać kolejne cyfry podanej liczby i dla każdej z nich liczyć możliwe rozwiązania. Zauważyłem, że dla każdej cyfry < 20 liczba możliwości to cyfra+1 (przynajmniej tak mi się wydaje). I kiedy iterując cyfry od końca kolejna to 1 to właśnie robiłem te operacje dla liczby dwucyfrowej zamiast pojedyńczo. Ta technika sprawdza się w wielu przypadkach, np. dla 188 to będzie możliwości dla 8 * możliwości dla 18, czyli 9*19, czyli 171. Ale w pewnych przypadkach to nie działa. Np. własnie dla liczby 112. Powinno być możliwości dla 12 * dla 1, czyli 13*2 co daje 26, a prawidłowa odpowiedź to 50.

Ten sposób psuje się przy kilku jedynkach obecnych w liczbie, np. właśnie dla 112 lub 1111. Bo wtedy nie wiadomo, w przypadku np. 112, czy jako całość uważać 11 czy 12, a może każda cyfra jest odrębna. Jest wiele kombinacji.

Więc w jaki sposób mógłbym znacznie zmniejszyć złożonośc tego algorytmu?

Złożoność obliczeniowa

Wed, 22 Mar 2023 21:51:21 +0000

Mam takie pytanie odnośnie złożoności obliczeniowej dla programu. Dokładnie chodzi mi o przypadek kiedy mam np. tablice dwuwymiarową 5x5 więc ma ona 25 elementów, jeśli dobrze rozumiem n=25 i w przypadku przejścia po całej tablicy dwoma forami np:

for(int i=0;i<5;i++){

for(int j=0;j<5;j++){

}

czy ta złożoność jest równa O(n), ponieważ myślałem nad przykladem, w którym miałbym doczynienia z tablica jednowymiarowa o dlugości 25 i użyłbym do przejścia przez jej elementy jednego fora:

for(int i=0;i<25;i++)

i w tym przypadku wiem ze ta złożoność jest równa O(n)

Dlatego tutaj pojawia się moje pytanie czy to ,że używam dwóch pętli tworzy złożoność mojego algorytmu jest równy O(n^2) ,a może O(n*m) mimo tego, że wykonuje tyle samo kroków jak dal tablicy jednowymiarowej. Jeśli tak bardzo prosiłbym o wyjaśnienie .

Z góry dziękuje

Złożoność czasowa, a pamięciowa

Fri, 24 Feb 2023 11:03:26 +0000

Wie ktos moze, czy duza zlozonosc pamieciowa moze wplynac na zlozonosc czasowa? np jak potrzebne mi jest do programu 1000 zmiennych w tablicy, a ja utworze milion to czy moze to wplynac na czas dzialania programu? mam na mysli zadanka na szkopule

Jaką ten algorytm ma złożonność?, Zadanie Zawody 1 etap OI, Algorytm Dijkstry

Sun, 12 Feb 2023 15:29:36 +0000

Natknąłem się na zadanie Zawody z 1 etapu XI OI: https://szkopul.edu.pl/problemset/problem/UiDG8sd_wsS2RfUPL3zQQ1XW/site/?key=statement

Napisałem algorytm, który wydaje mi się, że działa w O(N^2 * lg(N) ), odpalam Dijkstrę z każdego wierzchołka x, do którego wychodzi krawędź z wierzchołka 1 -> x (wierzchołek 1 to wejściowy). Kod wchodził na 70pkt, ale po dodaniu linii 57 i 58(żeby nie iśc niepotrzebnie tą Dijkstrą, jak wynik i tak będzie większy) daje 100pkt z bardzo dużym zapasem. Myślałem, że to poprostu przyśpieszy, ale myślałem, że nie wejdzie na 100, bo dalej jest O(N^2 * lg(N)). Więc zastanawiam się, czy złożonność się amortyzuje do lepszej złożonności, czy poprostu dlatego, że jest tylko 10 testów właściwych + 5 przykładowych(W wszystkich się szybko kończy)? W ksiażce "Przygody Bajtazara 25 lat Olimpiady Informatycznej" jest opisane rozwiązanie O((N+M) * lg(N)), którego jeszcze nie rozumiem, ale tez używają tam Dijkstry. Poglądowy rysunek mojego rozwiązania, jakbym źle opisał. Na czerwono zaznaczone wierzchołki, z których puszczam Dijkstrę(osobno), na zielono jakieś przykładowe wierzchołki z krawędziami(gdzie zwroty to wierzchołki), a wierzchołek "wejsciowy", ma numer 1.

Kod:

#include <iostream>
#include <vector>
#include <set>

using namespace std;

struct Krawedz
{
    int do_kogo;
    int waga;
};

struct Element_seta
{
    int wierzcholek;
    int wartosc;
    bool operator < (const Element_seta &element_seta) const
    {
        if (wartosc == element_seta.wartosc)
            return wierzcholek < element_seta.wierzcholek;
        return wartosc < element_seta.wartosc;
    }
};

int n = 0, m = 0, a = 0, b = 0, c = 0, d = 0, wyn = 0, min_wyn = 1e9+20;
vector<vector<Krawedz>> krawedzie;
vector<int> dp;
set<Element_seta> S;

int main()
{
    // O(N^2 * lg(N))???
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    cin >> n >> m;
    krawedzie.assign(n+1,{});
    dp.assign(n+1,-1);
    for (int i = 0; i < m; ++i)
    {
        cin >> a >> b >> c >> d;
        krawedzie[a].push_back({b,c});
        krawedzie[b].push_back({a,d});
    }

    for (int i = 0; i < krawedzie[1].size(); ++i)
    {
        fill(dp.begin(),dp.end(),-1);
        S.clear();
        dp[krawedzie[1][i].do_kogo] = krawedzie[1][i].waga;
        S.insert({krawedzie[1][i].do_kogo,krawedzie[1][i].waga});
        wyn = -1;
        while(!S.empty())
        {
            Element_seta spr = *S.begin();
            if (spr.wartosc > min_wyn)
                break;
            S.erase(spr);
            if (spr.wierzcholek == 1)
            {
                wyn = spr.wartosc;
                break;
            }
            for (int j = 0; j < krawedzie[spr.wierzcholek].size(); ++j)
            {
                int v = krawedzie[spr.wierzcholek][j].do_kogo;
                if (v == 1 && spr.wierzcholek == krawedzie[1][i].do_kogo)
                    continue;
                if (dp[v] == -1 || spr.wartosc + krawedzie[spr.wierzcholek][j].waga < dp[v])
                {
                    auto it = S.find({v,dp[v]});
                    if (it != S.end())
                        S.erase(*it);
                    dp[v] = spr.wartosc + krawedzie[spr.wierzcholek][j].waga;
                    S.insert({v,spr.wartosc + krawedzie[spr.wierzcholek][j].waga});
                }
            }
        }
        if (wyn != -1)
            min_wyn = min(min_wyn,wyn);
    }

    cout << min_wyn << '\n';

    return 0;
}

Z góry dziękuję za pomoc i poświęcony czas!

c++, wczytywanie z pliku do tablicy, złożoność obliczeniowa

Wed, 14 Dec 2022 11:46:47 +0000

Napisz program, który określi czy wczytany z pliku do tablicy ciąg jest palindromem tekstowym. Podaj złożoność obliczeniową stworzonego przez siebie algorytmu.

#include <iostream>
#include <fstream>

using namespace std;

int main()
{
    string linia;
    fstream plik;
    int *tablica;
    int ile;
    cin>>ile;
    tablica=new int[ile];

    plik.open("palindromy.txt", ios::in);
    if(plik.good() == true)
    {
        while(!plik.eof())
        {
            getline(plik, linia);
            cout << linia << endl;//wyświetlenie linii
        }
    }
        else cout<<"Plik jest bad";
        int temp;
        for(int i = 0; i < ile && plik >> temp; ++i)   // (1)
        {
            tablica[i] = temp; // (2)
            cout<<tablica[i];
        }
        plik.close();



    int i=0;
    int j=ile-1;
    while(i<j)
    {
        if(tablica[i]==tablica[j])
        {
            i++;
            j--;
        }
        else break;
    }
    cout<<endl;
    if(i<j) cout<<"To nie jest palindrom"<<endl;
    else cout<<"To jest palindrom"<<endl;


    return 0;
}

Próbowałam robić to w ten sposób, ale gdy wpisałam do pliku słowo kajak które jest palindromem program wyświetlał mi i tak to nie jest palindrom. I w jaki sposób mam podać złożoność obliczeniową algorytmu?

Sumowanie przedziałów - mała złożoność

Tue, 18 Oct 2022 11:48:17 +0000

Witam, dostałem zadanie w którym na wejściu dostaję liczbę całkowitą n oraz poniżej n par liczb. W każdej parze pierwsza liczba to początek a druga to koniec przedziału. Moim zadaniem jest wypisanie liczby l (ile przedziałów udało sie stworzyć po zsumowaniu przedziałów z wejścia) oraz właśnie te zsumowane przedziały. Zrobiłem to zadanie ze złożonością czasową n^2, a potrzebuję jakiegoś rozwiązania z mniejszą złożonością (najlepiej liniową). Kompletnie nie mam żadnego pomysłu jak to zrobić aby złożoność była mniejsza niż n^2. Proszę o pomoc. Piszę to w C++.
Przykład:
we:
2
1 3
2 5
wy:
1
1 5

Zlozonnośc czasowa

Thu, 19 May 2022 19:53:24 +0000

Cześc,

Dodawanie elementów na set ma O(log n). A czy dodanie seta na set - kod poniżej.

#include <iostream>
#include <set>

using namespace std;

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    set<set<int>> zbior_main;

    zbior_main.insert({1,2,3});
    return 0;
}

Też ma O(log n)?

Wiem, że jest coś takiego jak sumy harmoniczne i z tego co czytałem, to może to być identyfikatorem. Wie ktoś jak to działa?

Jak oszacować złożoność czasową mojego algorytmu?

Sun, 30 Jan 2022 01:46:30 +0000

Cześć . Właśnie napisałem algorytm w C# , który wypełnia „jodełką” tablicę kwadratową o wymiarze n.
Np. dla n równego 5, tablica ta jest postaci:
1 1 1 1 1
1 2 2 2 2
1 2 3 3 3
1 2 3 4 4
1 2 3 4 5

Muszę oszacować złożoność czasową mojego algorytmu , jednakże nie za bardzo pojmuje czy dobrze myślę byłbym bardzo wdzięczny za wskazówki jak i doradzenie w tej sprawie.

Operacja dominująca :

pętla for?

Funkcja złożoności (w najgorszym przypadku):

F(N)=O[(1+n)/2]*n=O[(n/2)+(n^2)/2]=O(n^2) - złożoność kwadratowa.

Rząd złożoności w najgorszym przypadku:

tutaj nie wiem?

Mam też pytanie czy jest jakiś program , który po wrzuceniu kodu wyrzuci mi wykres zależności czasu wypełnienia tablicy kwadratowej? Jeżeli nie to w jaki sposób mógłbym to zrobić?

Mój kod:

class Program
    {
        static void Main(string[] args)
        {
            int n = 8;

            int[,] tab = new int[n, n];  //tworzenie tablicy kwadratowej o wymiarze n

            int number = 1;  //numer od jakiego zaczynamy wstawiać do tablicy
            int index = 0;  //index od ktorego wstawiamy do tablicy

            for (int i = 0; i < n; i++)  //pętla wstawiająca elementy
            {
                for (int j = index; j < n; j++)
                {
                    tab[index, j] = number;  //przypisywanie elementów
                    tab[j, index] = number;  //przypisywanie elementów
                }
                index++;  //zwiekszanie indexu
                number++;  //zwiekszanie liczby
            }

            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    Console.Write(tab[i, j]);
                }
                Console.WriteLine("");
            }
        }
    }

Złożoność Obliczeniowa i Poprawność programu - gdzie się uczyć?

Sun, 09 Jan 2022 08:44:37 +0000

Hej :)

Potrzebuje waszej porady - szukam materiałów najlepiej video które w prosty i jasny sposób wyjaśniły by mi z programowania (w oparciu o c++) tematy dotyczące:

- Złożoności Obliczeniowej: Tutaj ogarniam trochę teorię, że jest m.in duże O które może przyjmować różne wartości od stałych, liniowe kwadratowe, logarytmy itp. ale właśnie nie wiem jak już odczytać z kodu tą właśnie złożoność jak np. wychodzi tam log (bo pętle for to są O(n) ale też nie zawsze bo jak jest jedna pętla zależna od drugiej to już inaczej wychodzi...)

- Częściowej Poprawności programów oraz Całkowitej Poprawności programu : Tutaj może rozumiem założenia co ma na myśli ta część tematu ale nie rozumiem jak ją sprawdzić itp. bo na wykładzie były trudne zagadnienia dotyczące trójki hoera, trudne zapisy itp. za to na laboratorium pokazał nam wykładowca funkcję assert w c++ i to, że są asercje początkowe (czyli jakie warunki musi spełnić dane przed rozpoczęciem programu), niezmiennik (czyli jakaś operacja typu if, dodawanie itp która zawsze jest taka sama) i asercja końcowa gdzie sprawdzamy czy wynik który wyszedł jest poprawny) - tylko te assert c++ to dla mnie jest to samo co if tylko że sam generuje błąd jak nie spełnia warunku

Ponieważ nie ogarniam tych tematów na studiach, a prezentacje i materiały z mojej uczelni są nie jasne - jeszcze będę iść na konsultacje i zobaczę ale i tak wolałbym może obejrzeć jak ktoś to lepiej lub w inny sposób tłumaczy :)

Złożoność algorytmów

Mon, 14 Jun 2021 16:55:55 +0000

Ile razy przeciętnie algorytm sortowania przez wybieranie jest szybszy niż algorytm sortowania bąbelkowego dla zbioru złożonego z 256 elementów?

Policzyłem to zadanie i wyszło mi 2. Czy to poprawna odpowiedź?

Złożoność czasowa algorytmu - Matura próbna 2020

Thu, 07 Jan 2021 13:05:15 +0000

Witam,

Podczas przeglądania arkuszy maturalnych z informatyki natknąłem się na zadanie polegające na określeniu rodzaju złożoności czasowej algorytmu podanego w zadaniu. Stąd pytanie: na jakiej podstawie wyznacza się ów rodzaj? Odpowiedź to sześcienna, kwadratowa, liniowa lub logarytmiczna. Ze źródeł dostępnych w internecie wynikają jakieś wzory, których nie rozumiem, więc proszę o pomoc wszystkich mających wiedzę na ten temat.

Problem wystąpił przy robieniu zadania 1.3 z matury próbnej z informatyki, kwiecień 2020.

Pozdrawiam.

Algorytmy i Struktury danych

Mon, 16 Nov 2020 23:27:23 +0000

Czy można ograniczyć duże O (ograniczenie górne) Omegą (ograniczenie dolne) inną niż Omega(1)? Pytałam się dwóch ćwiczeniowców i jeden mówi ze odpowiedz błędna a drugi że wszystko się zgadza. (Chodzi o pierwsza odpowiedz z Omegą) lepsza jakość - Screen zadania: https://imgur.com/a/ssboyXh
Skoro we wszystkich sytuacjach nasze W posiada górne ograniczenie W(Alg, n) = O (...) to wydawało mi się że jedyne czym możemy ograniczyć duże O z dołu jest Ω(1).

Złożoność czasowa algorytmu

Sun, 01 Nov 2020 19:38:41 +0000

Witam
Potrzebuje pomocy w obliczeniu średniej złożoności Algorytmu.
Mamy Algorytm1() o Średniej złożoności A(n) = Θ(n^(1/2)), oraz poniższy pseudo kod:

Algorytm( int n ){
   for(i=0; i<lg(n); i++){
      Algorytm1(i)
   }
}

Zastanawiam się czy tym przypadku "i" można potraktować jako stałą c gdzie A(n) = lg(n) * Θ(c^(1/2)) = Θ(lg(n)), czy jednak takie podejście jest błędne?
Z góry dziękuje

Złożoność obliczeniowa algorytmu

Sun, 01 Nov 2020 17:06:22 +0000

Witam, mam do obliczenia złożoność obliczeniową następującego algorytmu:

#include <iostream>
#include "List.h"

void menu(void);

int main(void)
{
    List *lista = list_create();

    int wybor;
    menu();
    while (std::cin >> wybor)
    {
        switch (wybor)
        {
            case 1:
            {
                for (int i = 1; i <= 100; i++)
                    list_push_front(lista, i);

                break;
            }

            case 2:
            {
                if (!list_empty(lista))
                {
                    std::cout << "\nWARTOSCI\n";
                    for (Node *i = lista->head; i != NULL; i = i->next)
                        std::cout << i->data << " ";

                    std::cout.put('\n');
                }
                else
                    std::cout << "\nWypelnij liste!\n";

                break;
            }

            case 3:
            {
                if (!list_empty(lista))
                {
                    double suma = 0.0;

                    for (Node *i = lista->head; i != NULL; i = i->next)
                        suma += i->data;

                    std::cout << "\nSrednia z listy to " << suma / lista->size << std::endl;
                }
                else
                    std::cout << "\nWypelnij liste!\n";

                break;
            }
            
            case 4:
            {
                if (!list_empty(lista))
                {
                    for (Node *i = lista->head; i != NULL; i = i->next)
                    {
                        /*
                            Jeśli element jest nieparzysty, usunie go.
                            Następnie przypisze do i element poprzedni
                            do usuniętego lub następny do usuniętego,
                            jeżeli jest różny od NULL.
                        */
                        if (i->data % 2 == 1)
                            i = list_pop(lista, i);
                    }
                }
                else
                    std::cout << "\nWypelnij liste!\n";

                break;
            }

            default: 
            {
                std::cout << "Niepoprawna opcja!\n";
                break;
            }
        }

        std::cout.put('\n');
        menu();
    }

    list_free(&lista);

    return 0;
}

void menu(void)
{
    std::cout << "1. Wypelnij liste wartosciami 1...100\n";
    std::cout << "2. Wyswietl liste\n";
    std::cout << "3. Oblicz srednia i ja wyswietl\n";
    std::cout << "4. Usun wartosci nieparzyste\n";
    std::cout << "Twoj wybor (wartosc nieliczbowa konczy): ";
}

Według mnie będzie to stała klasa złożoności obliczeniowej O(1), ponieważ pierwsza opcja wykona się zawsze 100 razy, druga też 100 razy, trzecia również, czwarta 51 razy ze względu na moją implementacje funkcji list_pop. Czy dobrze rozumuje?

Złożoności algorytmów

Mon, 29 Jun 2020 17:40:52 +0000

Czy wyjaśniłby ktoś lub podesłał jakąś lekturę jak na podstawie funkcji obliczyć złożoność algorytmu

np e^(1/x) ; 1/x ; 2 + sinx itp

Problemy algorytmiczne należące do klasy P.

Fri, 19 Jun 2020 19:09:06 +0000

Witam,

Mam takie pytanie: skoro problemy algorytmiczne należące do klasy P można rozwiązać za pomocą algorytmów o złożoności wielomianowej, to czy w grę wchodzi taka złożoność O(n) ? Wiem, że przedstawia się ją jako liniową, ale słyszałem, że jest szczególnym przypadkiem złożoności wielomianowej. Czy ktoś mógłby mi to troszkę bardziej przybliżyć? Z góry dziękuję za odpowiedz.

Zadanie - czasowa złożoność.

Thu, 21 May 2020 21:16:25 +0000

Ktoś mógłby pomóc z rozwiązaniem ego zadania?

Wyznacz czasową złożoność obliczeniową oraz klasę czasowej złożoności obliczeniowej dla następującego

algorytmu.
Wejście:
n - ilość liczb w tablicy
T[] - tablica zawierająca n liczb
Wyjście:
s - wynik pracy algorytmu
Dane pomocnicze:
i,j - indeksy elementów
Krok 1: s=0
Krok 2: i=0
Krok 3: Jeśli j=n-0, to zakończ
Krok 4: j=0
Krok 5: Jeśli j=10, to idź do kroku 9
Krok 6: s=s+T[i+j]
Krok 7: j=j+1
Krok 8: Idź do kroku 5
Krok 9: i=i+1
Krok 10: Idź do kroku 3

Złożoność obliczeniowa algorytmu

Sat, 25 Apr 2020 18:31:49 +0000

Cześć, robię sprawozdanie w którym musi znaleźć się ocena złożoności obliczeniowej tego algorytmu. Nie jestem pewien, czy dobrze liczę, ale wyszło mi:

4*n+2

#include <stdio.h>

void hanoi(char From, char To, char Other, int n)
{
    if (n == 0) return;
    hanoi(From, Other, To, n-1);
    printf("Przesuwanie dysku z kolka %c do %c\n", From, To);
    hanoi(Other, To, From, n-1);
}
int main()
{
    int n = 4;                      
    hanoi('A','B','C', n);
    return 0;
}

Złożoność algorytmu z prawdopodobieństwem

Mon, 20 Apr 2020 15:57:57 +0000

Cześć.
Dzięki za naprowadzenie z poprzednim problemem, jednakże znów muszę prosić o pomoc w innym zadaniu. Nie proszę o rozwiązanie, a raczej o jakieś wskazówki. Potrzebuję pomocy z obliczeniem złożoności algorytmu z zmienną losową. Doszedłem do tego, jak można zobrazować problem za pomocą grafu lecz nic poza tym. W wierzchołkach znajdują się wartości, natomiast krawędzie symbolizują prawdopodobieństwo z jakim może zostać wybrany następny wierzchołek:

Problem pojawia się, ponieważ istnieje prawdopodobieństwo, że algorytm "cofnie" się o 1, gdyby tego nie było, obliczenie złożoności obliczeniowej tego algorytmu byłoby w miarę proste. Nie pytam też o odpowiedź, a raczej o jakieś wskazówki jak do niej dojść.

Edit: myślałem też, zeby przedstawić to jako przeszukiwanie stringa i znajdowanie podciągu w którym będzie o n więcej 1 niż 0. Tylko to też niezbyt mi pomaga.

Złożoność czasowa a wyrażenia listowe [Python]

Fri, 27 Mar 2020 11:53:50 +0000

Czy wyrażenie listowe jest liczone jako jedno działanie (jak np. dodawanie) czy jako pętla, jaka jest złożoność czasowa wyrażenia listowego?

for n in lista:
    z = [str(n) for n in lista]

Złożoność czasowa tego algorytmu wynosi O(n) czy O(n^^2)?

Dziękuje za pomoc :)

Co to jest dokładnie ta złożoność obliczeniowa?

Sat, 11 Jan 2020 10:02:39 +0000

Wszędzie mówi się o złożoności obliczeniowej, że jest pesymistyczna, oczekiwana oraz optymistyczna, ale co to dokładnie jest? Służy do oceny algorytmów, ale co to formalnie jest? Jak to wyjaśnić?

Złożoność obliczeniowa algorytmów

Thu, 05 Dec 2019 11:42:46 +0000

Cześć,

Potrzebuję zapisać złożoność obliczeniową trzech różnych algorytmów:

function znajdzNajw($tab, $comment){
    $max1 = $tab[0];
    $max2 = $tab[1];
    
    for($i = 2; $i < count($tab); $i++){
        $max1 >= $max2 ? ($tab[$i] > $max2 ? $max2 = $tab[$i] : $max2 = $max2) : ($tab[$i] > $max1 ? $max1 = $tab[$i] : $max1 = $max1);
    }
    
    $najw = array($max1, $max2);
    return wyswietlPare($najw, $comment);
}

function znajdzNajm($tab, $comment){
    $min1 = $tab[0];
    $min2 = $tab[1];
    
    for($i = 2; $i < count($tab); $i++){
        $min1 > $min2 ? ($min1 > $tab[$i] ? $min1 = $tab[$i] : $min1 = $min1) : ($min2 > $tab[$i] ? $min2 = $tab[$i] : $min2 = $min2);
    }
    
    $najm = array($min1, $min2);
    return wyswietlPare($najm, $comment); 
}

function sortujTab($tab){
    
    for($i = 0; $i < count($tab); $i++){
        for($j = 0; $j < count($tab) - 1; $j++){
            if($tab[$j] > $tab[$j + 1]){
                $tmp = $tab[$j + 1];
                $tab[$j + 1] = $tab[$j];
                $tab[$j] = $tmp;
            }
        }
    }
    
    return $tab;
}

Czy złożonością obliczeniową dla funkcji:

znajdzNajw i znajdzNajm to O(N)

sortujTab to O(N^2)

Ile zajmie komputerowi mnożenie liczb rzędu 2^128

Mon, 02 Dec 2019 20:37:34 +0000

Weźmy liczbę 2^128-1 i pomnóżmy ją razy 1,5 oraz dodajmy 0,5. Powtórzmy operację 128 razy. Ile zajmie komputerowi obliczenie końcowej liczby? Zaznaczę tylko, że nie chodzi mi o matematyczne rozwiązanie, bo wiem, że będzie to 3^128-1. Chcę wiedzieć ile zajmują operacje na tak dużych liczbach i czy są to jakieś rozsądne czasy.

Złożoność algorytmów

Sun, 14 Apr 2019 18:23:42 +0000

Cześć, mam problem z podaniem funkcji złożoności obliczeniowej do następującego programu :

for(int i=1; i<=n; i++){
 int j=n;
 while(j>=1){
 j= j/2;
 }
}

Mniej więcej wiem jak to robić tylko mam problem z funkcją wew.

Jeśli byłby ktoś wstanie dać jakąś wskazówkę i to wytłumaczyć byłbym wdzięczny :)

Radosna nowina - mnożenie liczb całkowitych przechodzi na wyższy poziom

Wed, 27 Mar 2019 16:24:56 +0000

Dzień dobry, ja tu tylko zostawiam nowo opublikowany PDF zawierający nowy algorytm mnożenie integerów w czasie

O(n*log(n)).

Gratuluję odkrywcom!!!

Jak obliczyć złożoność mojego algorytmu?

Thu, 07 Feb 2019 20:17:09 +0000

Hej mam problem z napisaniem złożoności czasowej do podanego algorytmu. Mógłbym ktoś pomóc :).

function result=palindrome(TAB)   
    K=length(TAB)   
    I=floor(K/2)+1
    L=1
    J=1
    result='JEDNA Z POŁÓWEK TABLICY NIE JEST PALINDROMEM.'
    
    if modulo(K,2) == 1 then
        I = I + 1
    end
    
    firstPart = slice(TAB,L,floor(K/2))
    secondPart = slice(TAB,I,K)
    
    if checkIsPalindrome(firstPart) == 1 then
        if checkIsPalindrome(secondPart) == 1 then
             result='OBIE POŁÓWKI SĄ PALINDROMAMI!'
        end
    end
endfunction

function TAB=slice(TAB, startindex, endindex)
      TAB = TAB(startindex:endindex)
endfunction

function result=checkIsPalindrome(TAB)
    result = 0 
    i = 1;
    n = length(TAB) 
    while i*2<n do

        if TAB(i) == TAB((n-i)+1) then
            i = i + 1
        else
            return;
        end
    end    
    result = 1
endfunction

Złożoność algorytmu

Mon, 03 Dec 2018 13:33:42 +0000

Mam za zadanie udowodnić, że f(n)= n(n+1)/2 jest O(n^2).
Czy zapisanie: f(x)=n(n+1) => f(x)=n*(n) => f(x) = n^2 => O(n^2), jest poprawne i wystarczy?

Złożoność algorytmów (notacja asymptotyczna)

Mon, 05 Nov 2018 21:25:57 +0000

Chciałbym zapytać konkretnie o coś ale problem jest taki, że nie pomimo przeczytania połowy internetu dalej nie mam pojęcia o co w tym chodzi. Język tych prac jest dla mnie niezrozumiały :T Wytłumaczy ktoś o co chodzi w notacji asymptotycznej i złożoności algorytmów na "chłopski rozum"?

Zadanie. Złożoność

Tue, 18 Sep 2018 14:45:47 +0000

Ile czasu zajmie wykonanie zadania dla danych wejściowych rozmiaru 8 algorytmem A o złożoności n^3, wiedząc że wykonanie zadania o rozmiarze 16 zajmuje(przy użyciu tego samego algorytmu) 2^11 jednostek czasu.

zlozonosc algorytmu - jak obliczyc

Wed, 05 Sep 2018 17:00:54 +0000

Witam, jak wykonać takie zadanie, jak obliczyć te zlozonosc?

Zadanie OIG - Kafelki

Wed, 25 Jul 2018 23:29:23 +0000

Hej!

Rozwiązywałem ostatnio zadanie pt. Kafelki z ubiegłorocznej edycji Olimpiady informatycznej gimnazjalistów

Treść zadania:

Piotrek jest nowym administratorem systemu Olimpiady Informatycznej 
Gimnazjalistów. Jednym z jego obo- wiązków jest opieka nad serwerownią. 
Pomieszczenie musi spełnić szereg kryteriów zarówno technicznych, jak i 
estetycznych. Aby zapewnić poprawne działanie serwerów, ważne jest, aby podłoga 
została pokryta no- woczesnymi kafelkami chłodzącymi.
Piotrek może wybrać jeden z n rodzajów kwadratowych kafelków. Zakładamy, że 
kafelków danego rodza- ju można kupić dowolnie wiele, ale nie wolno w jakikolwiek 
sposób zmieniać ich wymiarów. Piotrek musi rozpatrzyć wszystkie rodzaje kafelków, 
którymi da się całkowicie wyłożyć podłogę i zdecydować, które kupi. Niestety, 
nigdy nie był w serwerowni, i nie wie, jakie ma ona wymiary. Pomóż młodemu 
administratorowi i napisz program, który dla zadanych wymiarów podłogi w 
serwerowni wyliczy, ile różnych rodzajów kafelków może użyć.

Wejście:

W pierwszym wierszu standardowego wejścia zapisano dwie liczby naturalne n i m 
(1 <= n, m <= 200 000), oznaczające odpowiednio liczbę rodzajów kafelków i liczbę 
zapytań o wymiary serwerowni. W drugim wierszu zapisano n liczb naturalnych xi 
(1 <= xi <= 106), oznaczających długość boku i-tego rodzaju kafelków. 
W ko-lejnych m wierszach zapisano po jednej parze liczb naturalnych ai, bi (1 <= ai, bi <= 106),
oznaczających zadane wymiary. W testach wartych 50% punktów możesz założyć,
 że podłoga serwerowni jest zawsze kwadratem (ai = bi).

Wyjście:

W i-tym wierszu wyjścia powinna znaleźć się jedna liczba naturalna, oznaczająca 
liczbę różnych rodzajów kafelków, którymi można wyłożyć podłogę o wymiarach 
zadanych w i-tym zapytaniu.

Najprostsze rozwiązanie problemu to po prostu sprawdzenie czy dany rozmiar pokoju jest podziely bez reszty przez i-ty kafelek, ale będzie to rozwiązanie o złożoności m * n => ok. O(n^2), więc w tego typu konkursie nie byłoby to zbyt wysoko punktowane.

Wymyśliłem, że można by to zoptymalizować w taki sposób, że tablicę z wartościami kafelków sortujemy rosnąco quicksortem, i sprawdzamy czy NWD wymiarów pokoju jest podzielny przez i-ty kafelek iterując do czasu aż i-ty kafelek jest mniejszy bądź równy NWD wymiarów pokoju. Jest jednak pewien problem. Mianowicie przy najbardiej pesymistycznym założeniu (czyli takim, że wszystkie kafelki będą mniejsze od NWD każdego pokoju) ten algorytm będzie jeszcze mniej wydajny niż najprostszy o którym wspomniałem wyżej.

Moje pytanie jest następujące - czy w takim przypadku warto "zaryzykować", że zestawy danych będą w miarę optymistyczne i algorytm będzie działał znacząco szybciej niż O(n^2)? Dzięki za pomoc ;)

Złożoność O(log n)

Sat, 30 Jun 2018 23:43:51 +0000

Witam, mam pytanie jak sprawdzić czy jakieś złożoności są równe złożoności O(log n) ? Generalnie wiem, że relacji f(x)=O(g(x)), trzeba znaleźć takie c, żeby dla dowolnego n>=n0 zachodziło f(x)<=c*g(x), tylko że nie potrafię rozpisać tego dla przypadków kiedy sprawdzam takie równanie z logarytmem... Gdyby ktoś mógł rozpisać mi jak to sie dokładnie liczy np. dla n^(1/2) = O(log n) ?

Uporządkowanie funkcji od najmniej złożonej do najbardziej złożonej

Sun, 24 Jun 2018 22:29:43 +0000

Mam 5 funkcji, którę muszę uporządkowac w kolejności od najmniej złożonej do najbardziej złożonej:

f1=O(n^(3n))

f2=O(1)

f3=O(n lg n)

f4=O(n^4)

f5=O(n^(2.45))

Ja posegregowałem tak:

f2,f4,f5,f1,f3

Ale widziałem inne rozwiązanie z inną kolejnością i nie jestem pewien czy dobrze rozwiązałem.

Za n podstawiam przykładową wartość, np. 3

Podajcie proszę swoje typy. Czy moje rozwiązanie jest prawidłowe?

Złożoność pamięciowa algorytmu C#

Mon, 04 Jun 2018 10:02:05 +0000

Jak mogę zbadać złożoność pamięciową algorytmu? Czy istnieje jakaś klasa w C#, która będzie badać (sprawdzać) ilość wykorzystanej pamięci RAM, podczas działania algorytmu?:)

Z góry dziękuję

Najszybszy algorytm odnajdujący liczby pierwsze (Złożoność czasowa log(n))

Sun, 15 Apr 2018 16:25:11 +0000

Witam, mam pytanie! Jaki algorytm do odnajdywania liczb pierwszych do przedziału określonego wartością n można użyć w swoim kodzie? Widziałem Sito Eratostenesa, Sito Atkina, ale nie jestem pewien czy nie ma aby szybszego algorytmu na to. Czytałem, że najszybszą możliwą złożonością czasową jest log(n), czy istnieje taki algorytm odnajdywania liczb pierwszych?

Metody oceniania złożoności obliczeniowej algorytmów

Wed, 14 Mar 2018 17:03:18 +0000

Witam, jakie są najpopularniejsze metody oceniania złożoności obliczeniowej algorytmów? Wiem, że jest jest metoda polegająca na badaniu jak zwiększają się zasoby potrzebne do wykonania algorytmu wraz ze wzrostem rozmiaru danych wejściowych.

Jeśli są jakieś jeszcze to proszę o wyjaśnienie

dzięki

Złożoność Algorytmów

Thu, 01 Feb 2018 17:43:41 +0000

Witam,

Często w pytaniach ABCD pojawiają się pytania o złożoność algorytmu. Przeważnie wygląda to tak, że jest podany kod i my mamy podać jaka jest złożoność algorytmu np O(n^2), O(Logn).

I teraz rodzi się pytanie jak mogę oszacować, złożoność, za pomocą kartki + długopisu w krótkim (przeważnie 1 minutowym) czasie? Ma ktoś radę jak to robić?

Pozdrawiam

Badanie czy liczba jest liczba pierwsza - złożoność

Mon, 08 Jan 2018 18:08:25 +0000

Witam,
Witam czy można określić złożoność algorytmu sprawdzającego czy liczba jest liczba pierwsza? np. podobnego do tego tutaj:
http://www.algorytm.edu.pl/algorytmy-maturalne/badanie-czy-liczba-pierwsza.html

Pobieramy jedną liczbę, sprawdzamy do sqrt tej liczby. Jak wyznaczyć złożoność, dwa scenariusze? Mógłby ktoś pomóc?

Złożoność algorytmów

Wed, 06 Dec 2017 20:18:25 +0000

Witam, mam zadanie:

Klasy złozonosci czasowej, w których funkcje s ̨a wył ̨acznie asymptotyczne:

Poszukaj w literaturze oraz podaj wyjaśnienie:

klasy EXP oraz
klasy NEXP

mam podane tylko to:

EX P

– deterministyczny czas wykładniczy,

NEX P

– niedeterministyczny czas wykładniczy.

, niestety nie mogę nic znaleźć, czy mógłby ktos pomoc?

złożoność czasowa i pamięciowa algorytmu inOrder (chyba inaczej sortowanie Stogowe) w drzewie poszukiwań binarnych

Thu, 24 Aug 2017 12:43:45 +0000

hej, ostatnio natknąłem się na bardzo ciekawy algorytm sortowania wykorzystujący drzewo binarne - *a nie kopiec* (nigdy o nim nie słyszałem w kursie Pana Mirosława ani na żadnych stronach) ,mowa tu o inOrder (przynajmniej ja tak to nazwałem :D) . Nie mogłem znaleźć na temat tego algorytmu więcej informacji ,nie wiem czemu bo dla mnie jest bardzo ciekawy (może nawet lepszy od Heap sort którego niezbyt lubię) . By uniknąć problemów podam cały kod sortowania oraz moją implementacje całego drzewa binarnego - co o niej sądzicie co mogę poprawić ? . Z góry dziękuje za odpowiedzi i komentarze oraz pozdrawiam :)

oto kod samego inOrder:

void inOrder(DataTrees *parent) { //sosrtowaanioe
	if (parent) {
		inOrder(parent->leftChild);
		cout << parent->data << " ";
		inOrder(parent->rightChild);
	}
}

Cały program (napisany w VS więc w pliku stdafx mamy biblioteki):

#include "stdafx.h"

using namespace std;

struct DataTrees {
	int data;
	DataTrees *leftChild;
	DataTrees *rightChild;
};

void add(DataTrees *&parent, int value) { //wstawaianie elementu 
	if (!parent) { //jezeli jest tu puste mijsce
		parent = new DataTrees;
		parent->data = value;
		parent->leftChild = nullptr;
		parent->rightChild = nullptr;
	}
	else { //pezeszukiwanie 
		if (value >= parent->data) add(parent->rightChild, value);
		else add(parent->leftChild, value);
	}
}

void inOrder(DataTrees *parent) { //sosrtowaanioe
	if (parent) {
		inOrder(parent->leftChild);
		cout << parent->data << " ";
		inOrder(parent->rightChild);
	}
}

void find(DataTrees *parent, DataTrees *&element, int value) { //poszukiwanie danej wartosci i ustawianie wskaznika na odpowiedni obiekt 
	if (!parent) { //jezeli nie znaleziono i nie ma juzz wiecej elementow 
		cout << "error" << endl;
	}
	else if (parent->data == value) { //jezeli znaleziono
		element = parent;
		cout << "is good! " << endl;
	}
	else { //poszukiwanie binarne 
		if (value < parent->data) find(parent->leftChild,element,value);
		else find(parent->rightChild, element, value);
	}
}

void deleteTree(DataTrees *&element) { //usowanie drzewa 
		if(element)deleteTree(element->leftChild);
		if(element)deleteTree(element->rightChild);
		element = nullptr;
}


int main()
{
	DataTrees *root = nullptr;
	DataTrees *element = nullptr;

	while (true) {
		cout << "---MENU---" << endl;
		cout << "1. add" << endl;
		cout << "2. inOrder" << endl;
		cout << "3. find" << endl;
		cout << "4. show find element" << endl;
		cout << "5. delete tree" << endl;
		cout << "----------" << endl;

		char z = _getch();

		switch (z) {
		case '1': {
			cout << "value: ";
			int v; cin >> v;
			add(root, v);
			break;
		}
		case '2': {
			if (root) {
				cout << "sort: ";
				if(root) inOrder(root);
				else cout << 0;
			}
			else cout << 0 << endl;

			_getch();
			break;
		}
		case '3': {
			cout << "value: ";
			int v; cin >> v;
			find(root, element, v);
			_getch();
			break;
		}
		case '4': {
			if (element) {
				cout << "value: " << element->data << endl;
			}
			else cout << 0 << endl;
			_getch();
			break;
		}
		case '5': {
			deleteTree(root);
			break;
		}
		}

		system("cls");
	}

    return 0;
}

Pisanie Algorytmów ,planowanie ,sposoby ...

Fri, 21 Jul 2017 09:28:15 +0000

Hej ,dzisiaj mam takie nietypowe pytanie :) Mianowicie czy wy też tak czasami macie że bierzecie się z pisanie jakiegoś algorytmu ,(może być to sortowanie ,konwersja liczb czy cokolwiek) posiłkując się tylko ogólnym sposobem jego działania . Np ja raz się wziąłem za napisanie programu sortującego liczby przez selekcję ,kombinowałem aż napisałem niestabilny ,zbugowany i bardzo poplątany sposób rozwiązania problemu (praktycznie nie działający (: ) . Kiedy zobaczyłem kod na internecie to się przeraziłem ,pomysł był tak prosty ,elegancki i niesamowicie krótki ze byłem zły na siebie że na to sam nie wpadłem . Czy wy też tak czasami macie że aż was złość bierze że sami nie potrafiliście czegoś napisać mimo iż to było takie proste Tu rodzi mi się kolejne pytanie ,w jaki sposób zabrać się za pisanie jakiegoś algorytmu ,czy od razu siąść do kodu i zacząć kombinować ? Czy może wcześniej planować rozwiązanie problemu na algorytmach blokowych itp... Jakie wy macie sprawdzone sposoby podejścia do rozwiązywania problemu ? Będe wdzięczny za wszelkie rady :)

Algorytm o złożoności obliczeniowej czasowej O(n*n)

Wed, 21 Jun 2017 14:56:43 +0000

Witam, potrzebuje trzech przykładów algorytmów, które mają poszczególne złożoności obliczeniowe czasowe: Algorytm o złożoności obliczeniowej czasowej rzędu O(1). Algorytm o złożoności obliczeniowej czasowej rzędu O(n). Algorytm o złożoności obliczeniowej czasowej rzędu O(n*n). Do każdego algorytmu należy dodać opis analizy jego złożoności. Liczę na Waszą pomoc bo nie wiem jak się do tego w ogóle zabrać :)

Uszereguj złożoności obliczeniowe algorytmów.

Wed, 14 Jun 2017 17:54:34 +0000

Czy jest jakiś prosty sposób aby uszeregować złożoności w kolejności powiedzmy malejącej? Słyszałem, że można skorzystać z czegoś takiego :

lim(n->∞) f(n)/ g(n) = 0  to daje nam Θ(f(n)) < Θ(g(n))
lim(n->∞) f(n)/ g(n) = c; c > 0 to daje nam  Θ(f(n)) = Θ(g(n))
lim(n->∞) f(n)/ g(n) = ∞  to daje nam Θ(f(n)) > Θ(g(n))

Jednak jest tutaj dużo roboty przy wielu przykładach do uszeregowania. Podam jakiś krótki przykład dla zobrazowania: O(n), O(1), O(n^2), O(loglogn), O(2^n), O1), O(10^logn)

Sortowanie- złożoność czasowa

Thu, 18 May 2017 23:14:55 +0000

Czy ktoś wykonałby zadanie :

Porównaj czasową złożoność obliczeniową algorytmów: sortowania przez wstawianie i sortowania przez scalanie. Algorytmy mam napisane tylko czas potrzebuję. Za niewielka opłata. Wiecej informacji na priv

złożoność pamięciowa

Sun, 05 Feb 2017 18:14:31 +0000

Witam :)

Jak liczy się złożoność pamięciową funkcji rekurencyjnej?

Chodzi tu dokładnie o sortowanie przez scalanie, wywoływane z parametrami (int l, int p, int A[max]), ponadto w każdym wykonaniu funkcji tworzona jest tablica pomocnicza B[max], w treści funkcji rekurencyjnie wywoływana jest ona dwa razy plus pojawiają się pętle.

Moja sugestia S(n)=2S(n/2)+o(n), ale nie jestem co do niej przekonana. Jakieś wskazówki?

Licząc złożoność pamięciową, bierze się również pod uwagę parametry, z którymi funkcja została wywołana, prawda?

Oszacuj złożoność algorytmu.

Mon, 16 Jan 2017 22:49:11 +0000

Cześć,

walczę z tematem "złożoności czasowej algorytmów".

Mogę Was prosić o wytłumaczenie dwóch poniższych przykładów?

1.

• i=0;
• wykonuj:
• j=i;
• wykonuj:
• j=j+1;
• dopóki (j<n);
• i=i+1;
• dopóki (i<n);

2.
• i=0;
• wykonuj:
• j=1;
• wykonuj:
• j=j*2;
• dopóki (j<n);
• i=i+1;
• dopóki (i<n);

Dziękuję za pomoc.

Złożoność algorytmów

Sun, 03 Jul 2016 08:25:23 +0000

Witam, mam zadańko do egzaminu. Proszę o pomoc :)

Mamy algorytm który ma złożoność n^3, zwiększamy dwukrotnie dane wejściowe. Ile razy zwiększy się złożoność obliczeniowa przy większych danych.

No więc podstawiamy pod n = 2n

Mamy (2n)^3=8n^3

Widzimy że złożoność jest 8 razy większa.
I tu jest wszystko jasne, prosty jest również przykład gdzie wstępna złożoność to log n, wtedy jest ona o jakąś liczbę kroków większa. Problem pojawia się przy n log n. Przypuśćmy że rozmiar danych wejściowych również zwiększ się 2 razy. Rozpisując (2n log(n))/(n log(n)) możemy dojść do
(2 log(n) + 2)/log(n). Tego chyba nie da się dokładnie wyliczyć. Pozostaje chyba uznać za mało istotną to "wolną" dwójkę i zaokrąglić to do 2. Proszę o pomoc :)

Jak obliczyć złożoność mojego algorytmu?

Mon, 18 Jan 2016 11:32:43 +0000

Witam. Napisałem bardzo prosty algorytm w C++, który wyświetla dwie macierze. Zadanie to było "transponowanie macierzy". Mam wielką prośbę. Algorytm został napisany po tygodniu nauki z youtubem i nie bardzo znam się na C++ jak i samym programowaniu. Jak obliczyć jego złożoność? bardzo, ale to bardzo proszę o wyjaśnienie jak to się liczy i jaką złożoność posiada mój algorytm. Przepraszam z góry, że nie wstawiam kodu, ale jestem w pracy i nie mam w tym momencie do projektu dostępu.
W każdym razie alg jest bardzo prosty i posiada 2x dwie pętle for(int i=0; i<n; i++) for(int j=0; j<n; j++)
jedna para "for" dla jednej macierzy druga dla drugiej. Bardzo proszę o pomoc w zrozumieniu złożoności takiego algorytmu.

Złożoność czasowa algorytmu - problem ze zrozumieniem

Tue, 20 Oct 2015 20:32:45 +0000

Cześć wszystkim!
Chciałbym prosić Was o pomoc w zrozumieniu zagadnienia złożoności czasowej. Domyślam się, iż jest to podstawa całej algorytmiki, dlatego brak wiedzy na ten temat skreśla moją przyszlość związaną z pisaniem dobrych algorytmów, bo wiadomo można klepać dużo, ale moża też mądrze :)

Otóż sam problem pojawił się już na wykładzie. Intuicyjnie domyślam się, iż chodzi o liczbę instrukcji która wykonała się w danym algorytmie, a także, że zależna jest ona od zmiennych wejściowych.

Myśle, że zrozumiem o na tym przykładzie:

Problemem jest liczba instukcji, nie rozumiem skąd się wzięła, mimo że rozumiem algorytm. Chciałbym prosić was o poprowadzenie mnie "za rączkę" podczas liczenia.

Pozdrawiam :)