Algoritmo para combinar rangos de un segmento - ayuda para crear - página 2

Nuevo comentario
  
struct SAllVariants{
   int m_cut[][2];
   int len;
   int li;
   void Init(int aLen){
      ArrayResize(m_cut,aLen);
      len=0;
   }
   void AddCut(int & a[][2],int i){
      m_cut[len][0]=a[i][0];
      m_cut[len][1]=a[i][1];
      len++;
      li=i;
   }
   void Set(SAllVariants & a){
      len=a.len;
      li=a.li;
      for(int i=0;i<len;i++){
         m_cut[i][0]=a.m_cut[i][0];
         m_cut[i][1]=a.m_cut[i][1];
      }
   }
};

SAllVariants av[];

int cut[][2];

void OnStart(){

   Print("=============================================================");
  
   // заполняем массив сотней каких-нибудь отрезков
   FillArray(cut,100);

   //=== алгоритм ====================
   
   // поправить все отрезки, чтобы первая координата была меньше второй   
   int itmp;
   for(int i=0;i<ArrayRange(cut,0);i++){
      if(cut[i][0]>cut[i][1]){
         itmp=cut[i][0];
         cut[i][0]=cut[i][1];
         cut[i][1]=itmp;
      }
   }
   
   // сортировка массива по первой координате
   ArraySort(cut);
   ArrayPrint(cut);
   // удалить отрезки нулевой длины и повтряющиеся отрезки
   bool ex;
   int ti=0;
   for(int i=0;i<ArrayRange(cut,0);i++){
      if(cut[i][0]!=cut[i][1]){
         ex=false;
         for(int j=i-1;j>=0 && cut[j][0]==cut[i][0];j--){
            if(cut[j][0]==cut[i][0] && cut[j][1]==cut[i][1]){
               ex=true;
               break;
            }
         }
         if(!ex){
            cut[ti][0]=cut[i][0];
            cut[ti][1]=cut[i][1];
            ti++;
         }
      }
   }
   ArrayResize(cut,ti);
   
   // добавить первый отрезок в массив всех вариантов и еще отрезков с наименьшей координатой
   ArrayResize(av,1);
   av[0].Init(ArrayRange(cut,0)); // вдруг ряд получится из всех отрезков
   av[0].AddCut(cut,0);
   for(int i=1;i<ArrayRange(cut,0);i++){ 
      if(cut[0][0]==cut[i][0]){
         ArrayResize(av,ArraySize(av)+1);
         av[ArraySize(av)-1].Init(ArrayRange(cut,0));
         av[ArraySize(av)-1].AddCut(cut,i);
      }
   }

   // добавить в начало еще отрезков, начинающихся чуть позже, но не позднее конца самого длинного из начальных
   
   // на сначала найти диапазон
   int mn=av[0].m_cut[0][0];
   int mx=av[0].m_cut[0][1];
   for(int i=1;i<ArraySize(av);i++){
      mx=MathMax(mx,av[i].m_cut[0][1]);
   }
   
   // добавить
   for(int i=1;i<ArrayRange(cut,0);i++){
      if(cut[i][0]>mn && cut[i][0]<mx){
         ArrayResize(av,ArraySize(av)+1);
         av[ArraySize(av)-1].Init(ArrayRange(cut,0));
         av[ArraySize(av)-1].AddCut(cut,i);
      }
   }   

   // а теперь самое интересное
   double r;
   bool n;
   for(int i=0;i<ArraySize(av) && !IsStopped();i++){ // для каждого варианта
      //Comment(i," ",ArraySize(av));
      // найти ближайшее расстояние до следующего отрезка
      r=DBL_MAX;
      for(int j=av[i].li+1;j<ArrayRange(cut,0);j++){
         if(cut[j][0]>=av[i].m_cut[av[i].len-1][1]){
            r=MathMin(r,cut[j][0]-av[i].m_cut[av[i].len-1][1]); // потому что допускаются пропуски (важнее составить ряд, чем чтобы он был непрерывным)
         }
      }
      if(r!=DBL_MAX){
         n=false;
         for(int j=av[i].li+1;j<ArrayRange(cut,0);j++){
            if(cut[j][0]-av[i].m_cut[av[i].len-1][1]==r){
               if(!n){
                  n=true;
                  av[i].AddCut(cut,j);
               }
               else{
                  ArrayResize(av,ArraySize(av)+1);
                  av[ArraySize(av)-1].Init(ArrayRange(cut,0));
                  av[ArraySize(av)-1].Set(av[i]);
                  av[ArraySize(av)-1].AddCut(cut,j);
               }
            }
         }
         if(n){
            i--;
         }
      }
   }

   string str="";
   for(int i=0;i<ArraySize(av) && !IsStopped();i++){
      str="";
      for(int j=0;j<av[i].len;j++){
         str=str+(string)av[i].m_cut[j][0]+"-"+(string)av[i].m_cut[j][1]+" ";
      }
      Print("Вариант ",i," - ",str);
   }

}
//+------------------------------------------------------------------+

void FillArray(int & a[][2],int cutCnt){
   ArrayResize(a,cutCnt);
   for(int i=0;i<cutCnt;i++){
      a[i][0]=MathRand()%30;
      a[i][1]=a[i][0]+MathRand()%15;
   }   
}

De alguna manera...

 
Dmitry Fedoseev:

De alguna manera...

Gracias. ¡Se nota enseguida la mano del maestro! Lo probaré mañana a ver qué sale.

 
Dmitry Fedoseev:

De alguna manera...

Empezó a probar el código, creó un ejemplo artificial - rellenó el array

FillArray(cut,4);
cut[0][0]=0;
cut[0][1]=1;
cut[1][0]=3;
cut[1][1]=6;
cut[2][0]=2;
cut[2][1]=5;
cut[3][0]=7;
cut[3][1]=9;

Lo tengo:

2021.04.21 00:52:08.328 Q_Podbor (Si-6.21,W1)       [,0][,1]
2021.04.21 00:52:08.328 Q_Podbor (Si-6.21,W1)   [0,]   0   1
2021.04.21 00:52:08.328 Q_Podbor (Si-6.21,W1)   [1,]   2   5
2021.04.21 00:52:08.328 Q_Podbor (Si-6.21,W1)   [2,]   3   6
2021.04.21 00:52:08.328 Q_Podbor (Si-6.21,W1)   [3,]   7   9
2021.04.21 00:52:08.328 Q_Podbor (Si-6.21,W1)   Вариант 0 - 0-1 2-5 7-9

Es decir, tenemos una variante, pero también esperamos otra.

Вариант 1 - 0-1 3-6 7-9

¿Es posible enseñar al algoritmo a encontrarlo también?

 
Aleksey Vyazmikin:

Empezó a probar el código, creó un ejemplo artificial - rellenó el array

Lo tengo:

Es decir, tenemos una variante, pero estamos esperando otra variante también.

¿Puede el algoritmo aprender a encontrarlo también?

Y la variante "0-1 3-6 7-9" no es mejor que la variante "0 - 0-1 2-5 7-9" - ambas son de 0 a 1 y tienen 2 saltos de longitud 1 cada una.

En este caso aparecen dos opciones:

1 - hacer lo mismo, pero desde el final del conjunto de saltos.

2 - buscar de inmediato no el segmento más cercano, sino con una tolerancia. Pero en este caso habrá aún más si hay muchos datos y muchas secuencias de acoplamiento.

Sin embargo, después de la variante 1, querrás empezar a construir cadenas desde todas las posiciones iniciales posibles. Esto es correcto, pero la cantidad de trabajo para el algoritmo aumenta considerablemente.

Sí, es necesario comenzar la construcción de variantes desde cada uno de los segmentos del conjunto inicial y continuar la construcción hasta el principio y el final.

 
Dmitry Fedoseev:

Y la opción "0-1 3-6 7-9" no es mejor que la opción "0 - 0-1 2-5 7-9" - ambas son de 0 a 1 y tienen 2 saltos de longitud 1 cada una.

En este caso son iguales, estoy de acuerdo, pero son diferentes y por los términos del problema tendremos que estimar la suma de sus puntuaciones, y hasta que no construyamos una línea no sabremos la puntuación combinada de todos los segmentos.

Dmitry Fedoseev:

Sin embargo, después de la opción 1, habrá un deseo de empezar a construir cadenas desde todas las posiciones iniciales posibles. Esto es correcto, pero la cantidad de trabajo para el algoritmo aumenta considerablemente.

Sí, es necesario comenzar la construcción de variantes desde cada uno de los segmentos del conjunto inicial y continuar la construcción hasta el principio y el final.

También me parece que ésta es la estrategia más correcta. Sin embargo, creo que puede haber variantes duplicadas.

¿Puedes ayudar escribiendo algo de código?

  
struct SAllVariants{
   
   int m_cut[][2];
   int len;

   int m_cut1[][2]; // к концу
   int len1;
   int li1;
   
   int m_cut2[][2]; // с началу
   int len2;
   int li2;   
   
   bool isDopel;
   
   void Init(int aLen){
      ArrayResize(m_cut1,aLen);
      len1=0;
      ArrayResize(m_cut2,aLen);
      len2=0;      
   }
   void AddCut1(int & a[][2],int i){
      m_cut1[len1][0]=a[i][0];
      m_cut1[len1][1]=a[i][1];
      len1++;
      li1=i;
   }
   void AddCut2(int & a[][2],int i){
      m_cut2[len2][0]=a[i][0];
      m_cut2[len2][1]=a[i][1];
      len2++;
      li2=i;
   }   
   void Set(SAllVariants & a){
      len1=a.len1;
      li1=a.li1;
      for(int i=0;i<len1;i++){
         m_cut1[i][0]=a.m_cut1[i][0];
         m_cut1[i][1]=a.m_cut1[i][1];
      }
      len2=a.len2;
      li2=a.li2;
      for(int i=0;i<len2;i++){
         m_cut2[i][0]=a.m_cut2[i][0];
         m_cut2[i][1]=a.m_cut2[i][1];
      }      
   }
   
   bool Eq(SAllVariants & a){
      if(len1!=a.len1 || len2!=a.len2){
         return(false);
      }
      for(int i=0;i<len1;i++){
         if(m_cut1[i][0]!= a.m_cut1[i][0] || m_cut1[i][1]!= a.m_cut1[i][1]){
            return(false);
         }
      }
      for(int i=0;i<len2;i++){
         if(m_cut2[i][0]!= a.m_cut2[i][0] || m_cut2[i][1]!= a.m_cut2[i][1]){
            return(false);
         }      
      }      
      return(true);
   }
   
   void Combine(){
      len=len1+len2-1;
      ArrayResize(m_cut,len);
      int j=0;
      for(int i=len2-1;i>0;i--){
         m_cut[j][0]=m_cut2[i][0];
         m_cut[j][1]=m_cut2[i][1];         
         j++;
      }
      for(int i=0;i<len1;i++){
         m_cut[j][0]=m_cut1[i][0];
         m_cut[j][1]=m_cut1[i][1]; 
         j++;
      }      
   }
};

SAllVariants av[];

int cut[][2];

void OnStart(){

   Print("=============================================================");
  
   // заполняем массив сотней каких-нибудь отрезков
   FillArray(cut,100);

   //=== алгоритм ====================
   
   // поправить все отрезки, чтобы первая координата была меньше второй   
   int itmp;
   for(int i=0;i<ArrayRange(cut,0);i++){
      if(cut[i][0]>cut[i][1]){
         itmp=cut[i][0];
         cut[i][0]=cut[i][1];
         cut[i][1]=itmp;
      }
   }
   
   // сортировка массива по первой координате
   ArraySort(cut);
   ArrayPrint(cut);
   // удалить отрезки нулевой длины и повтряющиеся отрезки
   bool ex;
   int ti=0;
   for(int i=0;i<ArrayRange(cut,0);i++){
      if(cut[i][0]!=cut[i][1]){
         ex=false;
         for(int j=i-1;j>=0 && cut[j][0]==cut[i][0];j--){
            if(cut[j][0]==cut[i][0] && cut[j][1]==cut[i][1]){
               ex=true;
               break;
            }
         }
         if(!ex){
            cut[ti][0]=cut[i][0];
            cut[ti][1]=cut[i][1];
            ti++;
         }
      }
   }
   ArrayResize(cut,ti);
   
   // добавить каждый отрезок в массив всех вариантов
   ArrayResize(av,ArrayRange(cut,0));
   for(int i=0;i<ArrayRange(cut,0);i++){
      av[i].Init(ArrayRange(cut,0));
      av[i].AddCut1(cut,i); // в массив, идущий к концу
      av[i].AddCut2(cut,i); // в массив, идущий к началу
   }


   // а теперь самое интересное
   
   // к концу
   
   double r;
   bool n;
   for(int i=0;i<ArraySize(av) && !IsStopped();i++){ // для каждого варианта
      // найти ближайшее расстояние до следующего отрезка
      r=DBL_MAX;
      for(int j=av[i].li1+1;j<ArrayRange(cut,0);j++){
         if(cut[j][0]>=av[i].m_cut1[av[i].len1-1][1]){
            r=MathMin(r,cut[j][0]-av[i].m_cut1[av[i].len1-1][1]); // потому что допускаются пропуски (важнее составить ряд, чем чтобы он был непрерывным)
         }
      }
      if(r!=DBL_MAX){
         n=false;
         for(int j=av[i].li1+1;j<ArrayRange(cut,0);j++){
            if(cut[j][0]-av[i].m_cut1[av[i].len1-1][1]==r){
               if(!n){
                  n=true;
                  av[i].AddCut1(cut,j);
               }
               else{
                  ArrayResize(av,ArraySize(av)+1);
                  av[ArraySize(av)-1].Init(ArrayRange(cut,0));
                  av[ArraySize(av)-1].Set(av[i]);
                  av[ArraySize(av)-1].AddCut1(cut,j);
               }
            }
         }
         if(n){
            i--;
         }
      }
   }
   
   // к началу
   
   for(int i=0;i<ArraySize(av) && !IsStopped();i++){ // для каждого варианта
      // найти ближайшее расстояние до следующего отрезка
      r=DBL_MAX;
      for(int j=av[i].li2-1;j>=0;j--){
         if(cut[j][1]<=av[i].m_cut2[av[i].len2-1][0]){
            r=MathMin(r,av[i].m_cut2[av[i].len2-1][0]-cut[j][1]); // потому что допускаются пропуски (важнее составить ряд, чем чтобы он был непрерывным)
         }
      }
      if(r!=DBL_MAX){
         n=false;
         for(int j=av[i].li2-1;j>=0;j--){
            if(av[i].m_cut2[av[i].len2-1][0]-cut[j][1]==r){
               if(!n){
                  n=true;
                  av[i].AddCut2(cut,j);
               }
               else{
                  ArrayResize(av,ArraySize(av)+1);
                  av[ArraySize(av)-1].Init(ArrayRange(cut,0));
                  av[ArraySize(av)-1].Set(av[i]);
                  av[ArraySize(av)-1].AddCut2(cut,j);
               }
            }
         }
         if(n){
            i--;
         }
      }
   } 
   
   // пометить дубли
   
   for(int i=0;i<ArraySize(av);i++){   
      av[i].isDopel=false;
      for(int j=0;j<i;j++){   
         if(av[i].Eq(av[j])){
            av[i].isDopel=true;
            break;
         }
      }
   }
   
   // соединить два массива в 1
   
   for(int i=0;i<ArraySize(av);i++){
      if(!av[i].isDopel){
         av[i].Combine();
      }
   }
   
   // вывод
   
   int h=FileOpen("Выстраивание отрезков.txt",FILE_TXT|FILE_WRITE);
   
   for(int i=0;i<ArrayRange(cut,0);i++){
      FileWrite(h,(string)cut[i][0]+"-"+(string)cut[i][1]);
   }   
   
   FileWrite(h,"");
   
   string str="";
   int vn=0;
   for(int i=0;i<ArraySize(av) && !IsStopped();i++){
      if(!av[i].isDopel){
         str="";
         for(int j=0;j<av[i].len;j++){
            str=str+(string)av[i].m_cut[j][0]+"-"+(string)av[i].m_cut[j][1]+" ";
         }
         Print("Вариант ",vn," - ",str);
         FileWrite(h,"Вариант ",vn," - ",str);
         vn++;
      }
   }
   
   FileClose(h);

}
//+------------------------------------------------------------------+

void FillArray(int & a[][2],int cutCnt){
   ArrayResize(a,cutCnt);
   for(int i=0;i<cutCnt;i++){
      a[i][0]=MathRand()%30;
      a[i][1]=a[i][0]+MathRand()%15;
   }   
}

Los duplicados no se han tamizado del array, sólo se han marcado. Como cada variante almacena ahora los segmentos en dos arrays, para que sea más cómodo, se pueden combinar en un solo array utilizando el métodoCombine().

 
Dmitry Fedoseev:

No he tamizado los duplicados del array, sólo los he marcado. Como ahora cada variante almacena los segmentos en dos arrays, puedes combinarlos en un solo array usando el métodoCombine() para que sea más cómodo.

Dmitry, ¡gracias por el nuevo algoritmo!

Sí, efectivamente hay muchas copias.

2021.04.22 16:55:43.829 Q_Podbor_02 (Si-6.21,M1)        Вариант 0 - 0-1 2-5 7-9 
2021.04.22 16:55:43.829 Q_Podbor_02 (Si-6.21,M1)        Вариант 1 - 0-1 2-5 7-9 
2021.04.22 16:55:43.829 Q_Podbor_02 (Si-6.21,M1)        Вариант 2 - 0-1 3-6 7-9 
2021.04.22 16:55:43.829 Q_Podbor_02 (Si-6.21,M1)        Вариант 3 - 0-1 3-6 7-9

Según tengo entendido, no se pueden contar. No he conseguido esperar la combinación de 1000 elementos - mi netbook empezó a quedarse sin memoria :(

¿Y es posible no utilizar todas las combinaciones al añadir un segmento, sino sólo un cierto número de posibles en el paso actual, digamos, las 10 mejores?

 
Aleksey Vyazmikin:

Dmitry, ¡gracias por el nuevo algoritmo!

Sí, efectivamente hay muchas copias.

Según tengo entendido, no se pueden contar. No pude esperar a la combinación de 1000 elementos - mi netbook empezó a quedarse sin memoria :(

¿Es posible no utilizar todas las combinaciones al añadir un segmento, sino sólo un determinado número de posibles en el paso actual, por ejemplo, las 10 mejores?

Para saber que son los mejores, hay que compararlos con otros, es decir, hay que conseguirlos todos primero. Otra cosa es optimizar de alguna manera el algoritmo, pero no tengo el objetivo de dedicar mi vida a este algoritmo).

Tal vez decida el criterio de suficiencia y obtenga primero todas las opciones, empezando por un solo segmento, elegido al azar, y así sucesivamente, hasta que aparezca una opción satisfactoria.

Y la segunda opción puede ser acelerada - para escalar la matriz con variantes no un elemento a la vez, pero varias decenas de elementos a la vez, y al final para recortarlo.

 
Dmitry Fedoseev:

Para saber que son los mejores, hay que compararlos con otros, es decir, hay que conseguirlos todos primero. Otra cosa es optimizar el algoritmo de alguna manera, pero no tengo el objetivo de dedicar mi vida a este algoritmo).

Estoy hablando de un solo segmento, digamos que tiene un coeficiente para evaluar su calidad, entonces después de cada iteración nos ramificamos, por ejemplo, sólo en los 10 primeros de estos coeficientes.

Dmitry Fedoseev:

Tal vez se decida un criterio de suficiencia y se obtengan primero todas las variantes, empezando por un solo segmento, elegido al azar y así sucesivamente, hasta que aparezca una variante satisfactoria.

Desgraciadamente, la "suficiencia" es difícil de estimar aquí - aquí es necesario conocer una norma, luego a partir de ella es posible definir una tolerancia, y yo no tengo una norma.

Dmitry Fedoseev:

Y la segunda opción puede ser acelerado - para escalar matriz con opciones no un elemento a la vez, pero varias decenas de elementos, y al final para alinearlo.

No sé muy bien a qué te refieres con lo de paralelizar usando OpenCL.

 
Aleksey Vyazmikin:

1. Estoy hablando de un solo segmento, digamos que tiene un coeficiente para evaluar su calidad, entonces después de cada iteración nos ramificamos a, por ejemplo, sólo los 10 mejores de esos coeficientes.

2. Desgraciadamente, la "suficiencia" es difícil de estimar en este caso: hay que conocer el punto de referencia, y a partir de ahí se puede determinar la tolerancia, y yo no tengo un punto de referencia.

3. No sé muy bien a qué te refieres con lo de paralelizar usando OpenCL.

1. ¿Dónde está este coeficiente?

2. ¿qué pasa con el punto 1?

3. No, es más sencillo. Ok, trataré de acelerarlo mañana.

12345678
Nuevo comentario