Strings extenso piazza

#include <iostream>
#include <vector>
#include <string.h>
#include <ctype.h>
#include <algorithm>
#include <map>
#include <stdio.h>
#include <cmath>
using namespace std;
int main()
{
    string aux;
    std::vector<string> no_usadas,parrafos;
    std::map<string, std::map<string, int> > map;//almacena minuscula, mayuscula, repeticiones cte
    std::map<string, std::map<string, int> > texto_palabra,parrafo_cant_textos;//almacena el texto, sus palabras(mayuscula) y repeticiones
    while(cin>>aux)
    {
        if (aux=="::")
        {
            getline(cin,aux);
            while(getline(cin,aux))
            {
                string letras;
                parrafos.push_back(aux);
                //aux2.resize(aux.size());
                for (int i = 0; i < aux.size(); ++i)
                {
                    if (aux[i]!=' ')
                        letras+=aux[i];
                    else
                    {
                        string minuscula;
                        minuscula.resize(letras.size());
                        for (int j = 0; j < letras.size(); ++j)
                            minuscula[j]=tolower(letras[j]);
                        if(find(no_usadas.begin(), no_usadas.end(),minuscula)==no_usadas.end())
                        {
                            map[minuscula][letras]++;
                            //palabras_usadas.push_back(letras);
                            texto_palabra[aux][letras]++;
                            parrafo_cant_textos[aux][letras]++;
                        }
                        letras.clear();
                    }
                    if(i+1==aux.size())
                    {
                        string minuscula;
                        minuscula.resize(letras.size());
                        for (int j = 0; j < letras.size(); ++j)
                            minuscula[j]=tolower(letras[j]);
                        if(find(no_usadas.begin(), no_usadas.end(),minuscula)==no_usadas.end())
                        {
                            map[minuscula][letras]++;
                            texto_palabra[aux][letras]++;
                            parrafo_cant_textos[aux][letras]++;
                        }
                    }
                    //aux2[i]=tolower(aux[i]);
                }
                //map[aux]=aux2;
            }
            break;
        }
        else
            no_usadas.push_back(aux);
    }
    std::map< string, std::map<string, int> >::iterator p=map.begin();
    std::map<string, int>::iterator p2;
    while(p!=map.end())//recorro palabra en orden lexicografico
    {
        p2=(p->second).begin();
        //cout<<p2->first<<endl;
        int tamanio=p2->second;
        for (int i = 0; i < tamanio; ++i)//recorro todas sus repeticiones
        {
            //cout<<"palabra:"<<p2->first<<endl;
            //map[p->first][p2->first]--;//
            std::map< string, std::map<string, int> >::iterator p3=texto_palabra.begin();
            std::map<string, int>::iterator p4;
            int iterador=0;
            while(iterador<parrafos.size())//recorro los parrafos
            {
                //cout<<"parrafo:"<<p3->first<<" le quedan:"<<texto_palabra[p3->first][p2->first]<<endl;

                if(texto_palabra[parrafos[iterador]][p2->first]>=1)//si la palabra no se ha ocupado hasta agotarse en el txt
                {
                    //cout<<"cant txt:"<<parrafo_cant_textos[parrafos[iterador]][p2->first]<<" "<<texto_palabra[parrafos[iterador]][p2->first]<<endl;
                    texto_palabra[parrafos[iterador]][p2->first]--;//la ocupé
                    string texto_auxiliar,palabra_auxiliar;
                    std::size_t found;

                    int veces=parrafo_cant_textos[parrafos[iterador]][p2->first]-texto_palabra[parrafos[iterador]][p2->first];
                    int pos=0;
                    //cout<<"parrafo:"<<parrafos[iterador]<<" veces:"<<veces<<endl;
                    found=parrafos[iterador].find(p2->first);
                    pos++;
                    while(pos++!=veces && veces!=0)
                    {
                        found=parrafos[iterador].find(p2->first,found+1);
                    }
                    //palabra_auxiliar.resize(parrafos[iterador].size());
                    for (int j = 0; j < parrafos[iterador].size(); ++j)
                    {
                        if(parrafos[iterador][j]!=' ')
                            palabra_auxiliar+=tolower(parrafos[iterador][j]);
                        if(parrafos[iterador][j]==' ')
                        {
                            texto_auxiliar+=palabra_auxiliar+" ";
                            palabra_auxiliar.clear();
                        }

                        if(j==found)
                        {
                            palabra_auxiliar.clear();
                            for (int k = 0; k < (p2->first).size(); ++k)
                            {
                                palabra_auxiliar+=toupper(parrafos[iterador][j++]);
                            }
                            j--;
                            texto_auxiliar+=palabra_auxiliar;
                            /*
                            if(j+1!=parrafos[iterador].size())
                            {
                                //j++;
                                //texto_auxiliar+=".";
                            }*/
                            palabra_auxiliar.clear();
                        }
                        if(j+1==parrafos[iterador].size() and !palabra_auxiliar.empty())
                        {
                            texto_auxiliar+=palabra_auxiliar;
                            palabra_auxiliar.clear();
                        }
                    }
                    cout<<texto_auxiliar<<endl;
                    texto_auxiliar.clear();
                    break;
                }
                //p3++;
                iterador++;
            }
            //cout<<p2->first<<" "<<p2->second<<endl;
        }
        p++;
    }
    return 0;
}