1024 Programmer's Day | C++ NOIP2014 Popularization Group T3 Spiral Matrix

Olá a todos, hoje vou postar uma solução para um problema sério.

Portal:

ano 1967

Embora esta pergunta seja a terceira pergunta no grupo de popularização, na verdade não é muito difícil. Mas, aham, não para quem gosta de violência .

Dê uma olhada na escala de dados:

Para $50\%$ os dados, $1 \leqslant n \leqslant 100$ ;

Para $100\%$ os dados, $1 \leqslant n \leqslant 30.000,1 \leqslant i \leqslant n,1 \leqslant j \leqslant n$ .

Se for violento, um é que o array de 900 milhões não consegue acompanhar, e o outro é $O\left ( 900000000 \right )$ que a complexidade do tempo não pode ser tolerada.

$50%$ No entanto, aqui está um código raso e fraco para um:

#include <iostream>
using namespace std;
int a[105][105];
int main() {
    int n, x, y, m = 1; cin >> n >> x >> y;
    for (int i = 0; i < n / 2 + 1; ++i) {
        for (int j = i; j < n - i; ++j)a[i][j] = m++;
        for (int j = i + 1; j < n - i; ++j)a[j][n - i - 1] = m++;
        for (int j = n - i - 2; j > i; --j)a[n - i - 1][j] = m++;
        for (int j = n - i - 1; j > i; --j)a[j][i] = m++;
    }
    cout << a[x - 1][y - 1] << endl;
}

Então, é só pedir de outra forma.

Esta questão pode ser considerada como uma recursão, definindo uma função $f(int$ $n,int$ $eu, int$ $j)$ , cada vez que as regras são as seguintes:

Se na camada mais externa, seja n o comprimento do lado, tente calcular:

Em cima: $Retorna$ $j;$

à esquerda: $Retorna$ $n+i-1;$

a direita: $Retorna$ $3*n-2-d+1;$

debaixo: $Retorna$ $4*n-4-i+2;$

Caso contrário, empurre uma camada para dentro:

$Retorna$ $f(n-2,i-1,j-1)+4*(n-1);$

Ou seja, esse algoritmo precisa ser empurrado para o nível dessa matriz na maioria das vezes , então a complexidade de tempo é $O(n/2)$ .

Código:

#include<iostream>
using namespace std;
int f(int n, int i, int j) {
    if (i == 1)return j;
    if (j == n)return n + i - 1;
    if (i == n)return 3 * n - 2 - j + 1;
    if (j == 1)return 4 * n - 4 - i + 2;
    return f(n - 2, i - 1, j - 1) + 4 * (n - 1);
}
int main() {
    int n, i, j; cin >> n >> i >> j;
    cout << f(n, i, j) << endl;
}

Eu: No entanto, ainda estou $O(n/2)$ insatisfeito e quero transformá-lo em $O\esquerda ( 1 \direita)$ .

Audiência: Como você está, eu quero pensar sobre o código! Não pode fazer isso $O\esquerda ( 1 \direita)$ de jeito nenhum!

Eu: No entanto, existe alguma maneira de determinarmos diretamente em qual anel esse número está e qual é o primeiro número desse anel ou o último número do anel anterior?

público:. . .

...

Depois de uma longa derivação, eu descobri!

O acima é um parágrafo, e então a análise começará oficialmente.

É relativamente simples descobrir a qual anel pertence, basta observar as distâncias de i e j da borda, respectivamente. Seja o número de camadas $f$ , a expressão simplifica para:

$f=min(min(i,j),(n+1)-max(i,j))$

No entanto, na verdade usamos a declaração de julgamento, para descobrir qual das quatro direções é para cima, para baixo, para a esquerda e para a direita.

Para encontrar o primeiro número desse anel, a expressão relacional deve ser derivada.

(Aqui, digo uma palavra ao meu amigo: sim, é o "teste de álgebra" ensinado pelo nosso professor)

Como o último número do anel anterior é a soma dos perímetros de cada camada fora dessa camada, defina $m$ :

$m=4(n-1)+4(n-3)+4(n-5)+...+4[n-(2f-3)]$

$=4(n-1+n-3+n-5+...+n-2f+3)$

$=4\esquerda \{ (f-1)n-[1+(2f-3)]*(f-1)/2\direita \}$

$=4[(f-1)n-(2f-2)*(f-1)/2]$

$=4[(f-1)n-(f-1)(f-1)]$

$=4(f-1)(n-f+1)$

Desta forma, podemos calcular os quatro casos de acordo com os pontos acima mencionados.

Bem, aqui estão as idéias, vamos escrever!

Código:

#include<iostream>
using namespace std;
int main() {
	int n, i, j, f, flag, m, ans, c; cin >> n >> i >> j;
	if (min(i, j) < (n + 1) - max(i, j)) {
		if (i < j)flag = 1;
		else flag = 4;
	}
	else {
		if (i > j)flag = 3;
		else flag = 2;
	}
	f = min(min(i, j), (n + 1) - max(i, j));
	m = 4 * (f - 1) * (n - f + 1);
	c = (n - 1) - 2 * (f - 1) + 1;
	i -= f - 1, j -= f - 1;
	if(flag == 1)ans = m + j;
	else if(flag == 2)ans = m + c + i - 1;
	else if(flag == 3)ans = m + 3 * c - j - 1;
	else ans = m + 4 * c - i - 2;
	cout << ans << endl;
	return 0;
}

Bom, hoje postei uma solução para um problema sério, acho muito bom. Tchau tchau!

1024 Programmer's Day | C++ NOIP2014 Popularization Group T3 Spiral Matrix

Acho que você gosta