jednak to dziala a tamto tak se

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <windows.h>
#include <time.h>
#include <fstream>
#include <string>
#include <sstream>
#include <vector>
#include <algorithm>
#include <iomanip>


using namespace std;

struct Wierzcholek
{
    string sek_wierzch; //fragment z sekwencji, ktory jest wierzcholkiem
    int pozycja; // pozycja wierzcholka w sekwencji
    vector<int> jakosc; // qual
    int nrsek; //sekwencja, z ktorej pochodzi podciag
    int stwierzch; //stopien wierzcholka;

};


int okno=7; //przykladowe wartosci
int wiarygodnosc=19;

vector<string> sekwencja;
vector<string> jakosc_sek;
vector<Wierzcholek*> wierzcholki;
vector<int> klika;
vector<int> maxklika;
vector< vector<int> > wektor_kliki;
vector < vector < int > > polaczenia;
int **macierz_polaczenia;


void odczyt_pliku()
{
    fstream fasta;
    fstream qual;
    string linia="";
    string linia2="";

    fasta.open( "sample.fasta");

    if( fasta.good() == true )
        {
        cout<<"Uzyskano dostep do pliku fasta "<<endl;

        while(getline(fasta,linia))
            {
                if(linia[0] != '>')
                {
                    sekwencja.push_back(linia);

                }
            }
            fasta.close();

        }
    else cout << "Dostep do pliku fasta zostal zabroniony!" << endl;



    qual.open( "sample.qual");

    if( qual.good() == true )
        {
        cout<<"Uzyskano dostep do pliku qual"<<endl;

        while(getline(qual,linia2))
            {
                if(linia2[0] != '>')
                {
                    jakosc_sek.push_back(linia2);

                }
            }
            qual.close();

        }
    else cout << "Dostep do pliku qual zostal zabroniony!" << endl;



}

void rozdzielacz_wierzcholki()

{
    for(int i = 0; i < sekwencja.size(); i++) //iterowanie po wektorze sekwencji (tzn po kazdym elemencie wektora, czyli po wszystkich jego sekwencjach)
    {
        string pomsek = sekwencja[i];  //zmienna pomocnicza, ktora jest aktualnie przetwarzana sekwencja
        int dlpomsek = pomsek.length()-1;

        string s = jakosc_sek[i];
        vector<string> jakosc_sek_pom;

        char delim=' ';
        std::stringstream ss(s);
        std::string token;
        while(std::getline(ss, token, delim))
        {
            jakosc_sek_pom.push_back(token);
            cout<<token<<" ";
        }

        for(int i=0; i<jakosc_sek_pom.size();i++)
        {
            cout<<jakosc_sek_pom[i]<<";";
        }

        //jakosc_sek[i];


        for(int j=0; j<=dlpomsek-okno+1;j++) //budowane na podstawie prototypowej funkcji rozdzielacz
        {
            Wierzcholek *wierzcholek = new Wierzcholek;

            wierzcholek->sek_wierzch = pomsek.substr(j,okno); //podciag bedacy wierzcholkiem
            wierzcholek->pozycja = j; // pozycja wierzcholka w sekwencji
            wierzcholek->nrsek = i; //index sekwencji do ktorej nalezy wierzcholek

            for(int k=j; k<(okno+j); k++)
            {
                int jksc = atoi( jakosc_sek_pom[k].c_str() );
                wierzcholek->jakosc.push_back(jksc);
            }
            wierzcholki.push_back(wierzcholek);
        }
    }


// wyswietlanie

   // for(int i=0; i<20;i++)
    for(int i=0; i<wierzcholki.size();i++)
    {

        cout<<"wierzcholek "<<wierzcholki[i]->sek_wierzch<<" ";
        cout<<"pozycja "<<wierzcholki[i]->pozycja<<" ";
        cout<<"nr sekwencji "<<wierzcholki[i]->nrsek<<" ";
        //vector<int> pom=wierzcholki[i]->jakosc;
        cout<<"jakosc ";
        for(int j=0; j<okno;j++)
        {
            cout<<wierzcholki[i]->jakosc[j]<< " ";
        }
        //cout<<wierzcholki[i]->nrsek<<" ";
        cout<<endl;


        //cout<<wierzcholki[i]->sek_wierzch;


    }


}

void polacz_wierzcholki()
{
    /*
    polaczenia.resize(wierzcholki.size());

    for(int i=0; i<polaczenia.size(); i++)      // macierz wypelniamy zerami
    {
        for(int j=0; j<polaczenia.size(); j++)
        {
          polaczenia[i].push_back(0);
        }

    }


        for(int i=0; i<polaczenia.size(); i++)      // macierz wypelniamy zerami
    {
        for(int j=0; j<polaczenia.size(); j++)
        {
          cout<<polaczenia[i];
        }

    }
    */


//    macierz.resize[wierzcholki.size()][wierzcholki.size()];


cout<<" ROZMIAR WEKTORA WIERZCHOLKI***********"<<endl;
cout<<wierzcholki.size()<<endl;

int rozmiarvwierz=wierzcholki.size();

    macierz_polaczenia = new int *[rozmiarvwierz]; //przydzielamy pamiec na n wierszy
    for (int i=0; i<rozmiarvwierz; i++) // idzemy po macierzy
    {
        macierz_polaczenia[i] = new int[rozmiarvwierz]; //przydzielamy dla kazdego wiersza po n kolumn
        for (int j = 0; j <rozmiarvwierz; j++) //zerujemy wszystkie pola w macierzy
            macierz_polaczenia[i][j]=0;
    }

/*
cout << "   ";
        for(int i = 0; i < rozmiarvwierz; i++)
            cout << setw(3) << i;

        cout << endl << endl;

        for(int i = 0; i < rozmiarvwierz; i++){
            cout << setw(3) << i;
            for(int j = 0; j < rozmiarvwierz; j++)
                cout << setw(3) << macierz_polaczen[i][j];
            cout << endl;
        }
    cout << endl;
*/


/*

    polaczenia.resize(wierzcholki.size());
    for(int i=0; i<polaczenia.size(); i++)      // wypelniamy macierz zerami
        for(int j=0; j<polaczenia.size(); j++)
            polaczenia[i].push_back(0);

*/


    int delmax = (okno/2)-1;

    for(int i=0; i<wierzcholki.size();i++)
    {
        for(int j=i+1; j<wierzcholki.size();j++)
        {

            if(wierzcholki[i]->nrsek!=wierzcholki[j]->nrsek       // jezeli podciag nie podchodzi z tej samej sekwencji
               && wierzcholki[i]->sek_wierzch==wierzcholki[j]->sek_wierzch) // oraz je¿eli podciagi sa takie same
            {
                macierz_polaczenia[i][j]=1;
                macierz_polaczenia[j][i]=1;  // mozna polaczyc; ij oraz ji, bo przeciez krawedz nieskierowana
            }

            else
            {
                if(wierzcholki[i]->nrsek!=wierzcholki[j]->nrsek) //podciagi z roznych sekwencji
                 {

                    macierz_polaczenia[i][j]=1;
                    macierz_polaczenia[j][i]=1;


                            int delecjepom=0;

                            for(int k=0; k<okno;k++)
                            {
                                delecjepom++;

                                if(wierzcholki[i]->sek_wierzch[k] != wierzcholki[j]->sek_wierzch[k]) //gdy dwa nukleotydy nie sa takie tame

                                {
                                    if(delecjepom>delmax) // jesli przekroczono maksymalna ilosc delecji, to nie mozemy polaczyc
                                    {
                                        macierz_polaczenia[i][j]=0;
                                        macierz_polaczenia[j][i]=0;
                                    }

                                    if(wierzcholki[i]->jakosc[k]>wiarygodnosc || wierzcholki[j]->jakosc[k]>wiarygodnosc) //jakosc ktoregos bedzie wieksza od wiarygodnosci to tez nie mozemy polaczyc
                                    {
                                        macierz_polaczenia[i][j]=0;
                                        macierz_polaczenia[j][i]=0;
                                    }

                                    /* else // czyli moze wystapic polaczenie
                                    {
                                        macierz_polaczenia[i][j]=1;
                                        macierz_polaczenia[j][i]=1;
                                        //delecjepom++;
                                    } */
                                }
                            }

                 }
            }
        }
    }


/*

    cout << "   ";
        for(int i = 0; i < rozmiarvwierz; i++)
            cout << setw(3) << i;

        cout << endl << endl;

        for(int i = 0; i < rozmiarvwierz; i++){
            cout << setw(3) << i;
            for(int j = 0; j < rozmiarvwierz; j++)
                cout << setw(3) << macierz_polaczenia[i][j];
            cout << endl;
        }
    cout << endl;

*/

}


void polacz_wierzcholki2()
{

cout<<" ROZMIAR WEKTORA WIERZCHOLKI***********"<<endl;
cout<<wierzcholki.size()<<endl;

int rozmiarvwierz=wierzcholki.size();

    macierz_polaczenia = new int *[rozmiarvwierz]; //przydzielamy pamiec na n wierszy
    for (int i=0; i<rozmiarvwierz; i++) // idzemy po macierzy
    {
        macierz_polaczenia[i] = new int[rozmiarvwierz]; //przydzielamy dla kazdego wiersza po n kolumn
        for (int j = 0; j <rozmiarvwierz; j++) //zerujemy wszystkie pola w macierzy
            macierz_polaczenia[i][j]=0;
    }


    int max_deletion;
    if(okno == 4 || okno == 5)
        max_deletion = 1;
    if(okno == 6 || okno == 7)
        max_deletion = 2;

    for(int i=0; i<wierzcholki.size(); i++)
        for(int j=i+1; j<wierzcholki.size(); j++)
        {
            if(wierzcholki[i]->sek_wierzch == wierzcholki[j]->sek_wierzch && wierzcholki[i]->nrsek != wierzcholki[j]->nrsek)
            {
                macierz_polaczenia[i][j] = 1;
                macierz_polaczenia[j][i] = 1;
            }
            else
            {
                if(wierzcholki[i]->nrsek != wierzcholki[j]->nrsek)
                {
                    // zakladamy ze delecja
                    macierz_polaczenia[i][j] = 1;
                    macierz_polaczenia[j][i] = 1;

                    int tmp = 0;
                    for(int y=0; y<okno; y++)
                    {
                        tmp++;
                        if(wierzcholki[i]->sek_wierzch[y] != wierzcholki[j]->sek_wierzch[y]) // dla nukleotydu ktory sie nie zgadza
                        {
                            if(wierzcholki[i]->jakosc[y] > wiarygodnosc || wierzcholki[j]->jakosc[y] > wiarygodnosc )
                            {
                                macierz_polaczenia[i][j] = 0;
                                macierz_polaczenia[j][i] = 0;
                            }
                            if(tmp > max_deletion)
                            {
                                macierz_polaczenia[i][j] = 0;
                                macierz_polaczenia[j][i] = 0;
                            }
                        }

                    }
                }
            }
        }



}


void polacz_wierzcholki3()
{

   int n = wierzcholki.size();

    macierz_polaczenia = new int *[n]; //przydzielamy pamiec na n wierszy
    for (int i=0; i< n; i++) // idzemy po macierzy
    {
        macierz_polaczenia[i] = new int[n]; //przydzielamy dla kazdego wiersza po n kolumn
        for (int j = 0; j < n; j++) //zerujemy wszystkie pola w macierzy
            macierz_polaczenia[i][j]=0;
    }


    string litera1;
    string litera2;
    int ile_delecji = 0;
    int znacznik =0;
    int maks_delecji = okno/2 - 1;

    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            ile_delecji = 0;
            znacznik = 0;



            if(wierzcholki[i]->nrsek == wierzcholki[j]->nrsek) // jesli wierzcholki sa z tej samej sekwencji to sprawdzaj nastepne
                continue;
            if(wierzcholki[i]->sek_wierzch== wierzcholki[j]->sek_wierzch)
            {
                macierz_polaczenia[i][j] = 1;
                macierz_polaczenia[j][i] = 1;
                continue;
            }

            string tmp = wierzcholki[i]->sek_wierzch;
            int licznik = 0;

            for(int k = 0; licznik < tmp.size(); k++)
            {
                ile_delecji = k - licznik;
                if(ile_delecji > maks_delecji)
                {
                    znacznik = 1;
                    break;
                }

                litera1 = tmp.substr(licznik, 1);
                litera2 = (wierzcholki[j]->sek_wierzch).substr(licznik, 1);


                if(litera1!=litera2)
                {
                    if (wierzcholki[i]->jakosc[k] < wiarygodnosc) {
                        tmp.erase(licznik, 1);
                    }else{
                        znacznik = 1;
                        break;
                    }

                }else
                    licznik++;
            }

            if(znacznik==0)
            {
                macierz_polaczenia[i][j] = 1;
                macierz_polaczenia[j][i] = 1;
            }
        }
    }



}



void polacz_wierzcholki4()
{

    cout<<" ROZMIAR WEKTORA WIERZCHOLKI***********"<<endl;
cout<<wierzcholki.size()<<endl;

int rozmiarwierz=wierzcholki.size();

    macierz_polaczenia = new int *[rozmiarwierz]; //przydzielamy pamiec na n wierszy
    for (int i=0; i<rozmiarwierz; i++) // idzemy po macierzy
    {
        macierz_polaczenia[i] = new int[rozmiarwierz]; //przydzielamy dla kazdego wiersza po n kolumn
        for (int j = 0; j <rozmiarwierz; j++) //zerujemy wszystkie pola w macierzy
            macierz_polaczenia[i][j]=0;
    }

    int delmax = (okno/2)-1;


    for (int i=0;i<rozmiarwierz;i++)
    {
        for(int j=i+1; j<rozmiarwierz; j++)
        {


            if(wierzcholki[i]->sek_wierzch == wierzcholki[j]->sek_wierzch && wierzcholki[i]->nrsek != wierzcholki[j]->nrsek)
            {
                macierz_polaczenia[i][j] = 1;
                macierz_polaczenia[j][i] = 1;
            }
            else
            {
                if(wierzcholki[i]->nrsek != wierzcholki[j]->nrsek)
                {
                    // zakladamy ze delecja
                    macierz_polaczenia[i][j] = 1;
                    macierz_polaczenia[j][i] = 1;

                    int tmp = 0;
                    for(int y=0; y<okno; y++)
                    {
                        tmp++;
                        if(wierzcholki[i]->sek_wierzch[y] != wierzcholki[j]->sek_wierzch[y]) // dla nukleotydu ktory sie nie zgadza
                        {
                            if(wierzcholki[i]->jakosc[y] > wiarygodnosc || wierzcholki[j]->jakosc[y] > wiarygodnosc )
                            {
                                macierz_polaczenia[i][j] = 0;
                                macierz_polaczenia[j][i] = 0;
                            }
                            if(tmp > delmax)
                            {
                                macierz_polaczenia[i][j] = 0;
                                macierz_polaczenia[j][i] = 0;
                            }
                        }

                    }
                }
            }

        }
    }



}

void stopnie_wierzcholkow()
{
    int st=0;
    for(int i=0; i<wierzcholki.size(); i++)
    {
        for(int j=0; j<wierzcholki.size(); j++)
        {
            st=macierz_polaczenia[i][j]+st;
        }
        wierzcholki[i]->stwierzch = st;
        st=0;
    }



        /////////////  WYPISANIE WSZYSTKICH WIERZCHOLKOW  //////////////

        // /*
    for(int i = 0; i < wierzcholki.size(); i++)
    {
        cout << "Numer wierzcholka: " << i << " ";
        cout << "Numer sekwecji: " << wierzcholki[i]->nrsek <<" ";
        cout << "Podciag: "<<wierzcholki[i]->sek_wierzch << " ";
        cout << "Wiarygodnosci: ";
        for(int j =0; j < okno; j++)
        {
            cout << wierzcholki[i]->jakosc[j] <<" ";
        }
        cout << "Pozycja: "<<wierzcholki[i]->pozycja << " ";
        cout << "Stopien: "<<wierzcholki[i]->stwierzch<< " ";
        cout << endl;
    }
     // */



}




vector<int> sasiedzi_wierzcholka(int iwierzch) //szukanie sasiadow dla naszego rozpatrywanego wierzcholka
{
    vector<int> sasiedzi_w;
    for (int i = 0; i < wierzcholki.size(); i++) //sprawdzamy wszystkie wierzcholki z wektora
    {
       if (macierz_polaczenia[iwierzch][i] == 1)
       {
           sasiedzi_w.push_back(i); //jesli mamy polaczenie danego wierzcholka z innym
                                    // to dajemy ten wierzcholek (i) do wektora sasiedzi
       }

    }
    return sasiedzi_w;
}

vector<int> najsasiedzi_wierzcholka(int iwierzch, int st)
{
    vector<int> najsasiedzi_w;
    for (int i = 0; i < wierzcholki.size(); i++) //sprawdzamy wszystkie wierzcholki z wektora
    {
       if (macierz_polaczenia[iwierzch][i] == 1
           && wierzcholki[i]->stwierzch >=st)
       {
           najsasiedzi_w.push_back(i);
       }
    }
    return najsasiedzi_w;

}

vector<int>wspolni_sasiedzi(vector<int> wyb_sasiedzi, vector<int> sasiedzi_wierzch_naj_st)
{
    vector<int> wsp_sasiedzi;
    sort(wyb_sasiedzi.begin(), wyb_sasiedzi.end());
    sort(sasiedzi_wierzch_naj_st.begin(), sasiedzi_wierzch_naj_st.end());

    set_intersection(wyb_sasiedzi.begin(), wyb_sasiedzi.end(), sasiedzi_wierzch_naj_st.begin(), sasiedzi_wierzch_naj_st.end(), back_inserter(wsp_sasiedzi));

    return wsp_sasiedzi;
}

int wierzcholek_naj_stopien(vector<int> wyb_sasiedzi) //szukanie wierzcholka o najwyzszym stopniu
{
    int najstwierzch=0; //wierzcholek o najwyzszym stopniu (indeks)
    int najst=0;
   // int przetwarzany; //przetwarzany aktualnie wierzcholek z wektora sasiedzi
    int dany_sasiad;

    for(int i=0; i<wyb_sasiedzi.size(); i++) //rozpatrujemy wszystkich sasiadow
    {
        dany_sasiad = wyb_sasiedzi[i];
        //przetwarzany=dany_sasiad;

        if(wierzcholki[dany_sasiad]->stwierzch > najst)
        {
            najstwierzch = dany_sasiad;
            najst = wierzcholki[dany_sasiad]->stwierzch;
        }
    }

    return najstwierzch;

}

vector<int>& clique_heu(vector<int> &mozliwe_do_kliki, vector<int> wyb_sasiedzi, int roz, int st)
{
    if (wyb_sasiedzi.empty())
    {
        if (roz > st)
            return mozliwe_do_kliki;
    }


    int wierzch_o_naj_st = wierzcholek_naj_stopien(wyb_sasiedzi);
    mozliwe_do_kliki.push_back(wierzch_o_naj_st);

    for (int i = 0; i < wyb_sasiedzi.size(); i++) // usuwanie wierzchołka o najwyższym stopniu
    {
        if (wyb_sasiedzi[i] == wierzch_o_naj_st)
            wyb_sasiedzi.erase(wyb_sasiedzi.begin()+i);
    }


    vector<int> sasiedzi_wierzch_o_naj_st = najsasiedzi_wierzcholka(wierzch_o_naj_st, st);
    vector<int> wsp_sasiedzi = wspolni_sasiedzi(wyb_sasiedzi, sasiedzi_wierzch_o_naj_st);
    clique_heu(mozliwe_do_kliki, wsp_sasiedzi, roz + 1, st);

    return mozliwe_do_kliki;

}


vector<int> max_clique_heu(int st)
{
    vector<int> mozliwe_do_kliki;

    for (int i = 0; i < wierzcholki.size(); i++)
    {
        mozliwe_do_kliki.push_back(i);
        if (wierzcholki[i]->stwierzch >= st)
        {
            vector<int> wyb_sasiedzi_rozpatrywanego;
            vector<int> sasiedzi_rozpatrywanego = sasiedzi_wierzcholka(i);

            for (int j = 0; j < sasiedzi_rozpatrywanego.size(); j++)
            {
                int tmp = sasiedzi_rozpatrywanego[j];
                if (wierzcholki[i]->stwierzch >= st)
                    wyb_sasiedzi_rozpatrywanego.push_back(tmp);
            }

            klika= clique_heu(mozliwe_do_kliki, wyb_sasiedzi_rozpatrywanego, 1, st);

            if (klika.size() > maxklika.size())
                maxklika = klika;
        }
        mozliwe_do_kliki.clear();
    }
}


/*


void lewo(vector<int>&lewa_klika)
{
    for(int i=0; i<lewa_klika.size();i++)
    {
        if(lewa_klika[i] <=0)
        {
            return;
        }
    }

    for(int i=0; i<lewa_klika.size();i++)
    {
        for(int j=i+1; j<lewa_klika.size();j++)
        {
            if (macierz_polaczenia[lewa_klika[i] - 1][lewa_klika[j] - 1] != 1)
            {
					return;
            }

        }
    }

    for(int i=0; i<lewa_klika.size();i++)
    {
        lewa_klika[i]--;
    }

    return;

}


void prawo(vector<int>&prawa_klika)
{
    for(int i=0; i<prawa_klika.size();i++)
    {
        if(prawa_klika[i] <=0)
        {
            return;
        }
    }

    for(int i=0; i<prawa_klika.size();i++)
    {
        for(int j=i+1; j<prawa_klika.size();j++)
        {
            if (macierz_polaczenia[prawa_klika[i] + 1][prawa_klika[j] + 1] != 1)
            {
					return;
            }

        }
    }

    for(int i=0; i<prawa_klika.size();i++)
    {
        prawa_klika[i]++;
    }

    return;

}





void  kliki_seria() {

		vector<int> lewa_klika = maxklika;
		vector<int> prawa_klika = maxklika;
		vector<string> numerysek; //sekwencje, z ktorej pochodza wierzcholki

		for (int i = 0; i < maxklika.size(); i++)
        {
            int tmp=maxklika[i];
            numerysek.push_back(wierzcholki[tmp]->nrsek);
        }


		lewo(lewa_klika);
		prawo(prawa_klika);

		for (int i = 0; i < maxklika.size(); i++) {
			int start = wierzcholki[left_clique[i]].position.first + 1;
			int end = vertices[right_clique[i]].position.second - vertices[left_clique[i]].position.first;
			string seq = find_sequence(max_clique_found[i], start, end);
			max_clique_series.push_back(make_tuple(seq_ids[i], start, start + seq.size(), seq));
		}
	}
*/




void lewo2(vector <vector <int> > &wektor_kliki)
{
    for(int i = 0; i < wektor_kliki[0].size(); i++)
    {
        if(wektor_kliki[0][i] == 0)
             return;
        if(wierzcholki[wektor_kliki[0][i]]->nrsek != wierzcholki[wektor_kliki[0][i]-1]->nrsek)
            return;

        for(int j = i+1; j < wektor_kliki[0].size(); j++)
        {
            if(macierz_polaczenia[wektor_kliki[0][i]-1][wektor_kliki[0][j]-1] != 1)
                return;
        }
    }
    vector <int> tmp;
    for(int i =0; i < wektor_kliki[0].size(); i++)
    {
        tmp.push_back(wektor_kliki[0][i]-1);
    }

    wektor_kliki.insert(wektor_kliki.begin(), tmp);
    lewo2(wektor_kliki);
    return;
}


void prawo2(vector <vector <int> > &wektor_kliki)
{

    for(int i = 0; i < wektor_kliki[wektor_kliki.size()-1].size(); i++)
    {

        if(wektor_kliki[wektor_kliki.size()-1][i] == wierzcholki.size()-1)
            return;
        if(wierzcholki[wektor_kliki[wektor_kliki.size()-1][i]]->nrsek != wierzcholki[wektor_kliki[wektor_kliki.size()-1][i]+1]->nrsek)
            return;

        for(int j = i+1; j < wektor_kliki[wektor_kliki.size()-1].size(); j++)
        {
            if(macierz_polaczenia[wektor_kliki[wektor_kliki.size()-1][i]+1][wektor_kliki[wektor_kliki.size()-1][j]+1] !=1)
                return;
        }
    }
    vector <int> tmp;
    for(int i =0; i < wektor_kliki[wektor_kliki.size()-1].size(); i++)
    {
        tmp.push_back(wektor_kliki[wektor_kliki.size()-1][i]+1);
    }
    wektor_kliki.push_back(tmp);
    prawo2(wektor_kliki);
    return;
}


void wypisz (vector <vector <int> > &wektor_kliki )
{
    int nr_sekwencji = 0;
    int poczatek = 0;
    int koniec = 0;
    int dlugosc = 0;
    //cout << wektor_kliki.size() << endl;
 //   cout << endl << endl;


    for(int j = 0; j < wektor_kliki[0].size(); j++)
    {
        nr_sekwencji = wierzcholki[wektor_kliki[0][j]]->nrsek;
        cout << "W sekwencji nr " << nr_sekwencji << ": ";
       // cout << instancja.m_sekwencje[nr_sekwencji]->m_nukleotydy << endl;
        poczatek = wierzcholki[wektor_kliki[0][j]]->pozycja;
        koniec = wierzcholki[wektor_kliki[wektor_kliki.size()-1][j]]->pozycja + okno-1;
        cout << "Start " << poczatek << " Koniec " << koniec << ":   ";
        dlugosc = koniec - poczatek +1;
        cout << sekwencja[nr_sekwencji].substr(poczatek, dlugosc) << endl;
    }
}



void rozdzielacz()
{

    string przyklad="ACGTAGTCCGT";
    int dl= przyklad.length()-1;
    string sub2;
    cout<<przyklad<<endl;
    for(int i=0; i<=dl-okno+1;i++)
    {
        sub2 = przyklad.substr(i, okno); //rozdzielanie ciagu na podciag, zaczynajacy sie w i o dlugosci okna
        cout<<sub2<<" ";
    }
}



int main()
{
    cout << "Hello world!" << endl;
odczyt_pliku();

/*
cout<<endl<<endl<<endl<<"***************SEKWENCJE"<<endl;

     for(int i=0; i<sekwencja.size(); i++ )
                {
                    cout<<sekwencja[i]<<endl;
                };

                cout<<endl<<endl<<endl<<"***************JAKOSCI"<<endl;

    for(int i=0; i<jakosc_sek.size(); i++ )
                {
                    cout<<jakosc_sek[i]<<endl;
                };
*/

//rozdzielacz();

cout<<sekwencja.size()<<endl;


rozdzielacz_wierzcholki();
                cout<<endl<<endl<<endl<<"***************WIERZCHOLKI"<<endl;

    for(int i=0; i<wierzcholki.size(); i++ )
                {
                    cout<<wierzcholki[i]->sek_wierzch<<" ";
                };
polacz_wierzcholki3();
stopnie_wierzcholkow();
max_clique_heu(3);

cout<<endl<<endl;

cout<<"rozmiar wektora wierzcholki: "<<wierzcholki.size()<<endl;

sort(maxklika.begin(), maxklika.end());
cout<<"rozmiar maxkliki: "<<maxklika.size()<<endl;
for(int i =0; i < maxklika.size(); i++)
    {
        int nr_wierzcholka = maxklika[i];
        cout << wierzcholki[nr_wierzcholka]->nrsek << " ";
        cout<<  wierzcholki[nr_wierzcholka]->sek_wierzch << " ";
        cout<<wierzcholki[nr_wierzcholka]->pozycja << " ";
        cout<<endl;

    }
    cout << endl;

  //////////////////////////////POSZERZANIE

  wektor_kliki.push_back(maxklika);

  lewo2(wektor_kliki);
  prawo2(wektor_kliki);

wypisz(wektor_kliki);






    return 0;
}