Descripción del Título
Descripción
Hay una llanura n * n, algunas de las cuales tienen agua de manantial. Obtendrá un grupo de cadenas, que se utiliza como mapa para describir el plano. La cadena tiene n cadenas, cada cadena tiene una longitud de n y cada carácter es un número del 0 al 9. El número 0 representa que no hay agua en esta cuadrícula; los números del 1 al 9 representan agua de manantial y el número es la tasa de agua que sale del manantial. Por ejemplo, el número 5 representa un manantial que produce 5 unidades de agua por unidad de tiempo.
Hay 4n elefantes alrededor de la llanura: alrededor del borde de la llanura, hay un elefante a cada lado del cuadrado, como se muestra en la figura siguiente. Estos elefantes beben agua con sus narices largas, pero sus narices solo pueden extenderse en línea recta en la dirección en la que miran. Por lo tanto, por ejemplo, los elefantes en el borde izquierdo de la llanura solo pueden estirar la nariz hacia la derecha. Sorprendentemente, sus narices son tan largas que pueden tocar el borde en el lado opuesto de la llanura. Los elefantes pueden beber agua de manantial en cualquier caso, pero el agua de manantial que no se cuida con la nariz será absorbida por el suelo.
Hay dos restricciones adicionales en esta pregunta: las trompas del elefante no pueden cruzarse. Por cada manantial, solo puede ser ocupado por un elefante como máximo.
Por ejemplo, la Figura (a) muestra un esquema legal. Las rejillas con agua de manantial son azules, los elefantes son verdes y sus narices son rojas. Hay cuatro elefantes bebiendo agua en esta imagen. La imagen (b) y © son esquemas ilegales. Ambos tienen trompas de elefante que se cruzan.
Tu tarea es calcular cuánta agua pueden beber los elefantes por unidad de tiempo.
Ingrese
múltiples conjuntos de datos, lea hasta el final del archivo.
La primera línea de cada grupo de datos es un número entero n (como la descripción del título) y las siguientes n líneas dan un grupo de cadenas. Cada una de estas n filas es una cadena de longitud n, y los caracteres de la cadena son los números 0-9.
La salida
genera un número entero en una sola línea para cada conjunto de datos, es decir, cuántas unidades de agua pueden beber los elefantes en ese conjunto de datos.
Entrada de muestra
5
00000
00110
01000
00100
00000
3
111
191
111
4
1010
0011
1100
1111
4
0011
1110
0111
0101
5
11100
00100
11111
00100
10111
6
023771
509514
675579
367472
575198
115281
Salida de muestra
4
dieciséis
10
10
13
112
[Explicación de muestra]
• El primer conjunto de datos: este es el plano que se muestra en la imagen en la descripción del título. La tasa de salida de agua de todos los manantiales es 1.
Como se muestra en la figura (a), cuatro elefantes pueden beber agua al mismo tiempo, y solo tenemos agua en cuatro rejillas, por lo que obviamente esta es la solución óptima.
• El segundo conjunto de datos: en la solución óptima, habrá 7 elefantes bebiendo agua de un manantial con una tasa de agua de 1, y un elefante bebiendo agua de un manantial central con una tasa de agua de 9. El agua de manantial consumida por estos elefantes por unidad de tiempo es 7 * 1 + 1 * 9 = 16 unidades.
Restricción de datos
Para el 30% de los datos, n, m <= 5, el número de grupos de datos <= 7
Para 100% de datos, 2 <= n, m <= 50, el número de grupos de datos <= 17
responder
Problema de cultivo de código (3/3)
Como todos sabemos, los elefantes son verdes.
Considere dp.
Hay cuatro situaciones:
① La
flecha es la dirección del elefante
②
Dar la vuelta ①
③
④
Invertir ③
Trate las soluciones óptimas comenzando desde las cuatro esquinas, maneje la selección de cada fila / columna y elija la solución óptima en ambos lados de una determinada fila / columna,
y luego hágalo de manera casual.
Puede encontrar que estas situaciones incluyen todas las soluciones.
código
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
using namespace std;
int map[51][51];
int mx[4][52][52];//→←↓↑
int f[4][52][52]; //↘↖↙↗
int b[2][52]; //→↓
int c[4][52]; //→←↓↑
int n,i,j,k,l,s,ans;
char ch;
int Get()
{
ch=getchar();
while (ch<'0' || ch>'9')
ch=getchar();
return ch-'0';
}
int main()
{
// freopen("S8_10_3.in","r",stdin);
while (~scanf("%d",&n))
{
ans=0;
memset(mx,0,sizeof(mx));
memset(f,0,sizeof(f));
memset(b,0,sizeof(b));
memset(c,0,sizeof(c));
fo(i,1,n)
{
fo(j,1,n)
map[i][j]=Get();
}
fo(i,1,n)
{
fo(j,1,n)
mx[0][i][j]=max(mx[0][i][j-1],map[i][j]);
}
fo(i,1,n)
{
fd(j,n,1)
mx[1][i][j]=max(mx[1][i][j+1],map[i][j]);
}
fo(j,1,n)
{
fo(i,1,n)
mx[2][i][j]=max(mx[2][i-1][j],map[i][j]);
}
fo(j,1,n)
{
fd(i,n,1)
mx[3][i][j]=max(mx[3][i+1][j],map[i][j]);
}
fo(i,1,n)
{
fo(j,1,n)
f[0][i][j]=max(f[0][i-1][j]+mx[0][i][j],f[0][i][j-1]+mx[2][i][j]);
}
fd(i,n,1)
{
fd(j,n,1)
f[1][i][j]=max(f[1][i+1][j]+mx[1][i][j],f[1][i][j+1]+mx[3][i][j]);
}
fo(i,1,n)
{
fd(j,n,1)
f[2][i][j]=max(f[2][i-1][j]+mx[1][i][j],f[2][i][j+1]+mx[2][i][j]);
}
fd(i,n,1)
{
fo(j,1,n)
f[3][i][j]=max(f[3][i+1][j]+mx[0][i][j],f[3][i][j-1]+mx[3][i][j]);
}
fo(i,1,n)
{
fo(j,0,n)
b[0][i]=max(b[0][i],mx[0][i][j]+mx[1][i][j+1]);
}
fo(j,1,n)
{
fo(i,0,n)
b[1][j]=max(b[1][j],mx[2][i][j]+mx[3][i+1][j]);
}
fo(j,1,n)
{
fo(i,0,n)
c[0][j]=max(c[0][j],f[0][i][j]+f[3][i+1][j]);
}
fd(j,n,1)
{
fo(i,0,n)
c[1][j]=max(c[1][j],f[2][i][j]+f[1][i+1][j]);
}
fo(i,1,n)
{
fo(j,0,n)
c[2][i]=max(c[2][i],f[0][i][j]+f[2][i][j+1]);
}
fd(i,n,1)
{
fo(j,0,n)
c[3][i]=max(c[3][i],f[3][i][j]+f[1][i][j+1]);
}
fo(i,0,n) //lie
{
s=0;
fo(j,i+1,n+1)
{
ans=max(ans,c[0][i]+s+c[1][j]);
s+=b[1][j];
}
}
fo(i,0,n) //hang
{
s=0;
fo(j,i+1,n+1)
{
ans=max(ans,c[2][i]+s+c[3][j]);
s+=b[0][j];
}
}
fo(i,0,n)
{
fo(j,0,n)
{
fo(k,i+1,n+1)
{
fo(l,j+1,n+1)
ans=max(ans,max(f[0][i][l-1]+f[1][k][j+1]+f[2][k-1][l]+f[3][i+1][j],f[0][k-1][j]+f[1][i+1][l]+f[2][i][j+1]+f[3][k][l-1]));
}
}
}
printf("%d\n",ans);
}
}