Tempo de cálculo, derivação de complexidade de tempo e análise de algoritmo clássico de dividir e conquistar

Dividir e conquistar é uma ideia para resolver problemas complexos, podendo dividir um problema em vários pequenos problemas e obter a solução do problema original mesclando esses problemas. Este artigo analisa a complexidade do método de dividir e conquistar, e analisa a complexidade de tempo de vários algoritmos específicos por este método.

1 Análise de Complexidade de Dividir e Conquistar

Dividir e conquistar pode ser de tamanho nO problema de$n$$k$ escalas$\frac{}{m}$subproblemas a resolver. Definir o limite de decomposição $n_{}=1$ , e leva 1 unidade de tempo para resolver um problema de tamanho 1 com o algoritmo para resolver o menor subproblema. Vamos decompor o problema original em$k$ subproblemas e$A\; solução\; de\; k$ subproblemas é combinada na solução do problema original usando$f\left(n\right)$ unidades de tempo. com$T\left(n\right)$ significa que a escala de solução do método de dividir e conquistar é$O\; tempo\; de\; cálculo\; necessário\; para\; o\; problema\; n$ é:
$$T\left(n\right)=\{\begin{array}{ll}O\left(1\right)& n=1\\ kT\left(\frac{}{m}\right)+f(n& n>\end{array}$$
则$$T\left(n\right)=n^{lo{g}_{}k}+\sum _{j=0}^{lo{g}_{}\left(n\right)-}{k}^{j}f\left(\frac{}{m^j}\right)\text{\hspace{1em}( 1.1 )}$$
"Introduction to Algorithms" usa uma árvore recursiva no processo de derivação da fórmula (1.1), aqui tentamos usar outro método para deduzir:
quando$n>1$ °,$$T\left(n\right)=kT\left(\frac{}{m}\right)+f\left(n\right),$$
seja$n=m^t$ , 令$G\left(t\right)=T\left(m^t\right)=T\left(n\right)$ , então
$$\begin{array}{rl}T\left(m^t\right)& =kT\left(m^{t-1}\right)+f\left(m^t\right)\\ G\left(t\right)& =kG(t-1)+f\left(m^t\right)\\ & =k\left(kG\right(t-2)+f(m^{t-1}))+f\left(m^t\right)\\ & =k^{2}G(t-2)+kf\left(m^{t-1}\right)+f\left(m^t\right)\\ & =\cdots \\ & =k^{t}G\left(0\right)+k^{t-1}f\left(m\right)+k^{t-2}f\left(m^2\right)+\cdots +kf\left(m^{t-1}\right)+f\left(m^t\right)\\ & =k^{t}G\left(0\right)+\sum _{j=0}^{t-}{k}^{j}f\left(m^{t-j}\right)\\ & =k^{lo{g}_{}n}+\sum _{j=0}^{lo{g}_{}\left(n\right)-}{k}^{j}f\left(\frac{}{m^j}\right)\\ & =n^{lo{g}_{}k}+\sum _{j=0}^{lo{g}_{}\left(n\right)-}{k}^{j}f(\frac{}{m^j}\end{array}$$
Assim, obtém-se a fórmula (1.1): $$T\left(n\right)=n^{lo{g}_{}k}+\sum _{j=0}^{lo{g}_{}\left(n\right)-}{k}^{j}f\left(\frac{}{m^j}\right)$$
Ao calcular a complexidade de tempo, você pode usar diretamente$n,m,K$ é substituído na fórmula para resolver.

2 Análise de Algoritmo Clássico

2.1 Pesquisa binária

A pesquisa binária está em uma sequência ordenada $um[0:n]$ para encontrar um elemento específico$O\; método\; de\; x$ retorna a posição do elemento na sequência se for encontrado e retorna uma falha de pesquisa se o elemento não estiver na sequência. Tomando como exemplo a sequência ascendente, na busca, cada vez que o elemento encontrado for$x$ e o elemento do meio da sequência$midd$ para comparação, se$x==midd$ , retorna a posição; se$x<midmid$ , indicando que o elemento que você procura pode estar em$Na\; frente\; de$$mid$ , logo antes de$um[0:midd]$ continue a procurar da mesma forma; se$x>midmid$ , indicando que o elemento que você procura pode estar em$Depois$$do\; meio$ , logo depois de$a[mid:n]$ para continuar a busca da mesma forma. O código (linguagem C) é o seguinte:

int binary_search(int a[], int num, int low, int high)
//a：要查找的序列，num：要查找的数，low：查找序列的第一个元素，high：查找序列的最后一个元素
{
    
    
	int mid = 0;
	while (low <= high) 
	{
    
    
		mid = (low + high) / 2;
		if (num == a[mid]) return mid;
		else if (num < a[mid]) high = mid - 1;
		else low = mid + 1;
	}
	return -1;
}

O problema de busca binária será 1 de tamanho $O\; problema\; de\; n$ é dividido em 1 tamanho$\frac{}{2}$O subproblema do problema, o custo de dividir o problema vem da comparação de números, e no final não há necessidade de mesclar, então basta uma ordem constante de tempo para decompor um problema e fundi-lo em um só problema, ou seja, f (n) = cf(n)= $f\left(n\right)=c$ , pela fórmula (1.1), podemos saber que o tempo necessário para a busca binária é
$$\begin{array}{rl}T\left(n\right)& =n^{lo{g}_{}1}+\sum _{j=0}^{lo{g}_{}\left(n\right)-}c\\ & =1+clo{g}_{}\end{array}$$
Então a complexidade de tempo da busca binária é $O\left(lo{g}_{}n\right)$ .

2.2 Classificação por mesclagem bidirecional

No processo de classificação de mesclagem bidirecional, uma sequência não ordenada $a[baixo,\_\_high]$ será dividido em duas sequências do mesmo tamanho$a[baixo,\_\_mid]$ ,$a[mid+1,high]$ e, em seguida, classifique as duas sequências separadamente. Após a conclusão da classificação, as duas sequências são classificadas separadamente e a classificação pode ser concluída mesclando as duas sequências. O código da linguagem C é o seguinte:

void merge(int a[], int tmp[], int low, int mid, int high)
//合并算法，a[low,mid]有序，a[mid+1,high]有序，merge函数使得a[low,high]有序
{
    
    
	int i, j, k;
	for (i = low; i <= high; i++) tmp[i] = a[i];
	//将a[low,high]复制到tmp[low,high]中
	i = low, j = mid+1, k = low;
	//i,j用来指示数组tmp中的位置，k用来指示数组a中的位置
	while (i <= mid && j <= high)
	{
    
    
		if (tmp[i] <= tmp[j])
		//从tmp的两个有序段中挑出最小的元素放入a的下一个位置
		{
    
    
			a[k] = tmp[i];
			i++;
		}
		else
		{
    
    
			a[k] = tmp[j];
			j++;
		}
		k++;
	}
	while (i <= mid) //tmp[mid+1,high]已经在a中，将tmp[low,mid]中的剩余元素填入a
	{
    
    
		a[k] = tmp[i];
		i++, k++;
	}
	while (j <= high) //tmp[low,mid]已经在a中，将tmp[mid+1,high]中的剩余元素填入a
	{
    
    
		a[k] = tmp[j];
		j++, k++;
	}
}


void merge_sort(int a[], int tmp[], int low, int high)
//归并排序算法，a：要排序的数组，tmp：相同长度的辅助数组，low：排序序列的第一个元素，high：排序序列的最后一个元素
{
    
    
	int mid = 0, i;
	if (low < high)
	{
    
    
		mid = (low + high) / 2;
		merge_sort(a, tmp, low, mid);
		merge_sort(a, tmp, mid + 1, high);
		//将排序问题分成两个规模减半的子问题
		merge(a, tmp, low, mid, high);
		//将子问题的结果合并
	}
}

O algoritmo de classificação por mesclagem bidirecional terá um tamanho de $O\; problema\; de\; n$ é dividido em 2 escalas$\frac{}{2}$subproblema. O problema de divisão é implementado por meio de chamadas de função e o problema de mesclagem gasta principalmente tempo no array $a$ e a matriz$tmp$ transferem elementos entre si, então$f\left(n\right)=n$ , da fórmula (1.1), pode-se saber que o tempo necessário para a ordenação de mesclagem bidirecional é:
$$\begin{array}{rl}T\left(n\right)& =n^{lo{g}_{}2}+\sum _{j=0}^{lo{g}_{}\left(n\right)-}{2}^j\frac{}{2^j}\\ & =n+nlo{g}_{}\end{array}$$
Então a complexidade de tempo da ordenação de mesclagem bidirecional é $O\left(nlo{g}_{}n\right)$ .