dziala ale 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; //przykladowe wartosci
int wiarygodnosc;

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

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

    fasta.open( "sample1.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( "sample1.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);
        }
    }


}


void wyswietl_wierzcholki()
{
        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()
{

    int delmax;
    //delmax=(okno/2)-1;
    if(delmax == 4)
        delmax = 1;
    if(delmax == 5 )
        delmax = 1;
    if(delmax == 6 )
        delmax = 2;
    if(delmax == 7 )
        delmax = 2;

    macierz_polaczenia.resize(wierzcholki.size());

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

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




    for(int i=0; i<wierzcholki.size(); i++)
    {
        for(int j=i+1; j<wierzcholki.size(); j++)
            {
                //sprawdzane czy sa z roznych sekwencji
                if(wierzcholki[i]->nrsek != wierzcholki[j]->nrsek) //jesli wierzcholki pochodza z roznych sekwencji
                {
                    //jesli sekwencje sa takie same to logiczne, laczymy krawedzia nieskierowana
                    if(wierzcholki[i]->sek_wierzch == wierzcholki[j]->sek_wierzch)
                    {
                        macierz_polaczenia[i][j]=1;
                        macierz_polaczenia[j][i]=1;
                    }

                    if(wierzcholki[i]->sek_wierzch != wierzcholki[j]->sek_wierzch)
                    {
                        int pom;
                        pom=0;

                        string i_pomocnik=wierzcholki[i]->sek_wierzch;
                        string j_pomocnik=wierzcholki[j]->sek_wierzch;


                        for(int k=0; k<okno; k++)
                        {
                            if(wierzcholki[j]->jakosc[k] < wiarygodnosc) //gdy jakosc danego nukleotydu z podciagu (wierzcholka
                            {                                       // jest mniejsza niz nasza wiarygodnosc
                                i_pomocnik.erase(pom,1);  //usuwam nukleotyd na pozycji pom
                            }
                            else{pom++;};        // jest mniejsza niz nasza delmax
                        }


                        if(i_pomocnik.size() > delmax)
                        {
                            if(wierzcholki[j]->sek_wierzch.find(i_pomocnik) != string::npos)
                            {
                                macierz_polaczenia[i][j]=1;
                                macierz_polaczenia[j][i]=1;
                            }
                        }


                    }


                }
            }
    }

}



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;
    }

    */
        for(int i=0; i<wierzcholki.size(); i++)
            stopnie.push_back(0);

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



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


}


vector<int> sasiedzi_wierzcholka(int index_wierzch)        // znajduje sasiadow danego wierzcholka i zwraca ich vektor
{
    vector <int> sasiedzi_wierzcholka;
    for(int i = 0; i < wierzcholki.size(); i++)
    {
        if(macierz_polaczenia[index_wierzch][i] == 1)
        {
            sasiedzi_wierzcholka.push_back(i);
        }
    }
    return sasiedzi_wierzcholka;
}







int wierzcholek_naj_stopien(vector<int> wyb_sasiedzi) // znajduje wierzcholek o najwyzszym stopniu
{
    int najst_wierzch=0;
    int najst=0;
    int dany_sasiad_index;

    for (int i = 0; i < i<wyb_sasiedzi.size(); i++)
    {
        dany_sasiad_index = wyb_sasiedzi[i];
        if(stopnie[dany_sasiad_index] > najst)
        {
            najst = stopnie[dany_sasiad_index];
            najst_wierzch = dany_sasiad_index;
        }
    }
    return najst_wierzch;
}







vector<int> najsasiedzi_wierzcholka(int iwierzch, int st) //sasiedzi wierzcholka o najwyzszym stopniu
{
    vector <int> sasiedzi_najstwierzch;

    for(int i = 0; i < wierzcholki.size(); i++)
    {
        if(macierz_polaczenia[iwierzch][i] == 1 && stopnie[i] >= st)
        {
            sasiedzi_najstwierzch.push_back(i);
        }
    }
    return sasiedzi_najstwierzch;
}






vector<int>wspolni_sasiedzi(vector<int> _wyb_sasiedzi, vector<int> _sasiedzi_najstwierzch)
{
    vector<int> wsp_sasiedzi;
    sort(_wyb_sasiedzi.begin(), _wyb_sasiedzi.end());
    sort(_sasiedzi_najstwierzch.begin(), _sasiedzi_najstwierzch.end());

    set_intersection(_wyb_sasiedzi.begin(), _wyb_sasiedzi.end(), _sasiedzi_najstwierzch.begin(), _sasiedzi_najstwierzch.end(), back_inserter(wsp_sasiedzi));

    return wsp_sasiedzi;
}



vector<int> &clique_heu(vector<int> &mozliwe_do_kliki, vector<int> &sasiedzi, int roz, int &max)
{
    if (sasiedzi.empty()) //warunek zakonczenia rekurencji
    {
        if (roz > max)
            return mozliwe_do_kliki;
    }


    int wierzch_o_naj_st = wierzcholek_naj_stopien(sasiedzi); //szukanie sasiada o najwyzszym stopniu
    mozliwe_do_kliki.push_back(wierzch_o_naj_st); //i dodajemy go do kliki

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


    vector<int> sasiedzi_wierzch_o_naj_st = najsasiedzi_wierzcholka(wierzch_o_naj_st, max);
    vector<int> wsp_sasiedzi = wspolni_sasiedzi(sasiedzi, sasiedzi_wierzch_o_naj_st);

    clique_heu(mozliwe_do_kliki, wsp_sasiedzi, roz + 1, max);

    return mozliwe_do_kliki;

}


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

    for (int i = 0; i < wierzcholki.size(); i++)
    {
        mozliwe_do_kliki.push_back(i);

        if (stopnie[i] >= max)
        {
            vector<int> wyb_sasiedzi;
            vector<int> sasiedzi = sasiedzi_wierzcholka(i); //szuka sasiadow badanego wierzcholka i dodaje go do wektora
        cout<<"TEST MAX CLIQUE "<<endl;
            for (int j = 0; j < sasiedzi.size(); j++)
            {
                int tmp = sasiedzi[j]; //indeks sasiada

                if (stopnie[tmp] >= max)
                    wyb_sasiedzi.push_back(tmp);
            }

            if(!wyb_sasiedzi.empty())
                klika= clique_heu(mozliwe_do_kliki, wyb_sasiedzi, 1, max);

            if(klika.size() > maxklika.size())
            {
                wektor_kliki.push_back(klika);
                maxklika = klika;
            }

        }
        mozliwe_do_kliki.clear();
    }
}



void lewo2(vector <vector <int> > &wektor_kliki) //poszerzanie w lewo
{
    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;
    }
}





int main()
{


    cout << "Dlugosc okna (4-7): ";
    cin >> okno;
    while(1){
        if(okno < 4 || okno > 7){
            cout << "Wartosc nie nalezy do zakresu. Prosze podac prawidlowa wartosc: ";
            cin >> okno;
        }else{
            break;
        }
    }

    cout << "Wiarygodnosc (wartosc ponizej ktorej nukleotyd moze ulegac delecji (0-40): ";
    cin >> wiarygodnosc;

    while(1){
        if(wiarygodnosc > 40 || wiarygodnosc<0){
            cout << "Wartosc nie nalezy do zakresu. Prosze podac prawidlowa wartosc: ";
            cin >> wiarygodnosc;
        }else{
            break;
        }
    }

    cout<<endl;
    odczyt_pliku();
    cout<<endl;
    cout<<"Rozmiar wektora sekwencje: "<<sekwencja.size()<<endl;
    cout<<endl;
    cout<<"test1"<<endl;
    rozdzielacz_wierzcholki();



     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;

    }






    cout<<endl;
    cout<<"test2"<<endl;
    polacz();
    cout<<"test3"<<endl;
    stopnie_wierzcholkow();

    //cout<<"stopnie size " <<stopnie.size()<<endl;
    //cout<<"wierzcholki " <<wierzcholki.size()<<endl;
   // cout<<"test4"<<endl;

   // /*

    max_clique_heu(3);

    cout<<endl;

    sort(maxklika.begin(), maxklika.end());
    wektor_kliki.push_back(maxklika);

    lewo2(wektor_kliki);
    prawo2(wektor_kliki);
    wypisz(wektor_kliki);


   // */

return 0;

}