Como medir a classificação

Gostaria de saber se existe uma maneira padrão de medir a "ordenação" de uma matriz? Uma matriz com o número médio de inversões possíveis seria considerada maximamente sem classificação? Com isso, quero dizer que é basicamente o mais longe possível de ser classificado ou reverso.

Não, isso depende da sua aplicação. As medidas de ordenação são freqüentemente chamadas de medidas de desordem , que são funções de a , onde é a coleção de todas as seqüências finitas de números inteiros não negativos distintos. A pesquisa de Estivill-Castro e Wood [1] lista e discute 11 medidas diferentes de desordem no contexto de algoritmos de classificação adaptativa. R N < $N^{<N}$$\mathbb{R}$$N^{<N}$

O número de inversões pode funcionar em alguns casos, mas às vezes é insuficiente. Um exemplo dado em [1] é a sequência

que possui um número quadrático de inversões, mas consiste apenas em duas execuções ascendentes. Está quase classificado, mas isso não é capturado por inversões.

[1] Estivill-Castro, Vladmir e Derick Wood. "Uma pesquisa de algoritmos de classificação adaptativa". Pesquisas ACM Computing (CSUR) 24.4 (1992): 441-476.

Mannila [1] axiomatiza a pré-classificação (com foco em algoritmos baseados em comparação) da seguinte maneira (parafraseando).

Vamos um conjunto totalmente ordenado. Então, um mapeamento de (as seqüências de elementos distintos de ) para os naturais é uma medida de pré - ordenação, se satisfizer abaixo das condições.m Σ ⋆$\Sigma$$m$$\Sigma^{\star}$$\Sigma$

1. Se estiver classificado, então . m ( X ) = $X \in \Sigma^{\star}$$m(X) = 0$

2. Se com , e para todos os , então .$X,Y \in \Sigma^{\star}$$X = x_1 \dots x_n$$Y = y_1 \dots y_n$$x_i < x_i \iff y_i < y_j$$i,j \in [1..n]$$m(X) = m(Y)$

3. Se é uma subsequência de Y ∈ Σ ⋆ , então m ( X ) ≤ m ( Y ) .$X$$Y \in \Sigma^{\star}$$m(X) \leq m(Y)$

4. Se para todos os i ∈ [ 1 .. | X | ] e j ∈ [ 1 .. | Y | ] para alguns X , Y ∈ Σ ⋆ , então m ( X ⋅ Y ) ≤ m ( X ) + m ( Y ) .$x_i < y_j$$i \in [1..|X|]$$j \in [1..|Y|]$$X,Y \in \Sigma^{\star}$$m(X \cdot Y) \leq m(X) + m(Y)$

5. para todos os X ∈ Σ ⋆ e um ∈ E ∖ X .$m(a \cdot X) \leq |X| + m(X)$$X \in \Sigma^{\star}$$a \in E \setminus X$

Exemplos de tais medidas são os

• número de inversões,
• número de swaps,
• o número de elementos que não são máximos da esquerda para a direita e
• o comprimento de uma subsequência crescente mais longa (subtraída do comprimento de entrada).

Observe que foram definidas distribuições aleatórias usando essas medidas, ou seja, que tornam as seqüências mais / menos ordenadas mais ou menos prováveis. Estes são chamados de distribuições do tipo Ewens [2, cap. 4-5; 3, exemplo 12; 4], cujo caso especial é a chamada distribuição de Mallows . Os pesos são paramétricos em uma constante e cumprem$\theta > 0$

.$\qquad\displaystyle \operatorname{Pr}(X) = \frac{\theta^{\,m(X)}}{\sum_{Y \in \Sigma^{\star} \cap \Sigma^{|X|}} \theta^{\,m(Y)}}$

Observe como define a distribuição uniforme (para todos os m ).$\theta = 1$$m$

Como é possível amostrar permutações através dessas medidas de forma eficiente, esse corpo de trabalho pode ser útil na prática ao comparar os algoritmos de classificação.

1. Medidas de Pré-Sortimento e Algoritmos de Classificação Ótima por H. Mannila (1985)
2. Estruturas combinatórias logarítmicas: uma abordagem probabilística por R. Arratia, AD Barbour e S. Tavaré (2003)
3. Ao adicionar uma lista de números (e outros processos determinantes dependentes de um) por A. Borodin, P. Diaconis e J. Fulman (2010)
4. Distribuições do tipo Ewens e Análise de Algoritmos por N. Auger et al. (2016)

Eu tenho minha própria definição de "ordenação" de uma sequência.

Dada qualquer sequência [a, b, c,…], a comparamos com a sequência classificada que contém os mesmos elementos, contamos o número de correspondências e a dividimos pelo número de elementos na sequência.

Por exemplo, dada sequência [5,1,2,3,4], procedemos da seguinte forma:

1) classifique a sequência: [1,2,3,4,5]

2) compare a sequência classificada com a original movendo-a uma posição de cada vez e contando o número máximo de correspondências:

        [5,1,2,3,4]
[1,2,3,4,5]                            one match

        [5,1,2,3,4]
  [1,2,3,4,5]                          no matches

        [5,1,2,3,4]
    [1,2,3,4,5]                        no matches

        [5,1,2,3,4]
      [1,2,3,4,5]                      no matches

        [5,1,2,3,4]
        [1,2,3,4,5]                    no matches

        [5,1,2,3,4]
          [1,2,3,4,5]                  4 matches

        [5,1,2,3,4]
            [1,2,3,4,5]                no matches

                ...

         [5,1,2,3,4]
                 [1,2,3,4,5]            no matches

3) O número máximo de correspondências é 4, podemos calcular a "classificação" como 4/5 = 0,8.

A classificação de uma sequência classificada seria 1 e a classificação de uma sequência com elementos colocados em ordem inversa seria 1 / n.

A idéia por trás dessa definição é estimar a quantidade mínima de trabalho que precisaríamos fazer para converter qualquer sequência na sequência classificada. No exemplo acima, precisamos mover apenas um elemento, o 5 (existem várias maneiras, mas mover 5 é o mais eficiente). Quando os elementos seriam colocados em ordem inversa, precisaríamos mover 4 elementos. E quando a sequência foi classificada, nenhum trabalho é necessário.

Espero que minha definição faça sentido.

Se você precisar de algo rápido e sujo (os sinais de soma me assustam), escrevi uma função de desordem super fácil em C ++ para uma classe chamada Array, que gera matrizes int preenchidas com números gerados aleatoriamente:

void Array::disorder() {
    double disorderValue = 0;
    int counter = this->arraySize;
    for (int n = 0; n < this->arraySize; n++) {
        disorderValue += abs(((n + 1) - array[n]));
//      cout << "disorderValue variable test value = " << disorderValue << endl;
        counter++;
    }
    cout << "Disorder Value = " << (disorderValue / this->arraySize) / (this->arraySize / 2) << "\n" << endl;
}

A função simplesmente compara o valor em cada elemento com o índice do elemento + 1, de modo que uma matriz na ordem inversa tenha um valor de desordem igual a 1 e uma matriz classificada com um valor de desordem igual a 0. Não sofisticado, mas funcional.

Michael