POJ 2227 The Wedding Juicer FloodFill算法
这题看了以后，想了一个很脑残的做法，也过了，不过用了1.2s，哈哈。
后来看了一个高中生大牛写的 Pascal 程序。
根据函数名字来看，它用的是 floodfill 算法，提交了发现居然才用了188ms。
现在高中生真太牛逼了！佩服！
同时，作为一个即将毕业的大学生，哥表示压力很大。。
以前没见过这个算法，看了一下，发现看不大懂，但是这样做确实很有道理！
在网上面搜了一下关于floodfill算法的资料，发现很杂，还是看不大懂。。
算法的思想就是：
每个点都有一个水位，水位最小值为这个点的高度。
首先把边缘一周的点加入堆，这些点的水位初始化为点的高度。
每次都取出最小水位的点，将点周围的四个点里面，从来没有被加入过堆的点加入堆中，如果有的点的高度比水位低，那么就更新答案。
删除最小水位的点，然后重复上一步。直到不存在没有被加入过堆中的点为止。
用 C 再写了一遍，小小改动，慢了 100ms。
#include
<
stdio.h
>
#define
SIZE 332
struct
heap_node
{
int x, y;
}
;
int
W, H;
int
map[SIZE][SIZE], fil[SIZE][SIZE];
struct
heap_node heap[SIZE
*
SIZE];
int
heap_size, left, ans;inline
int
cmp(
struct
heap_node
*
a,
struct
heap_node
*
b)
{ return fil[a->y][a->x] - fil[b->y][b->x];}
inline
void
shift_down(
int
idx)
{ struct heap_node val = heap[idx]; 
while (1) { idx *= 2; if (idx > heap_size) break; if (idx + 1 <= heap_size && cmp(&heap[idx + 1], &heap[idx]) < 0) idx++; if (cmp(&val, &heap[idx]) <= 0) break; heap[idx / 2] = heap[idx];
} heap[idx / 2] = val;}
inline
void
shift_up(
int
idx)
{ struct heap_node val = heap[idx]; while (1) { if (idx / 2 <= 0) break; if (cmp(&heap[idx / 2], &val) <= 0) break; heap[idx] = heap[idx / 2]; idx /= 2; } heap[idx] = val;}
inline
void
insert(
int
y,
int
x,
int
f
=
-
1
)
{ if (y < 0 || y >= H || x < 0 || x >= W || fil[y][x]) return ; if (map[y][x] > f) f = map[y][x]; else ans += f - map[y][x]; fil[y][x] = f; heap_size++; heap[heap_size].y = y; heap[heap_size].x = x; shift_up(heap_size); left--;}
inline
void
extract()
{ heap[1] = heap[heap_size--]; shift_down(1);}
int
main()
{ int i, j; freopen("e:\\test\\in.txt", "r", stdin); scanf("%d%d", &W, &H); for (i = 0; i < H; i++) for (j = 0; j < W; j++) scanf("%d", &map[i][j]); left = W * H; for (i = 0; i < H; i++) { insert(i, 0); insert(i, W - 1); } for (i = 1; i < W - 1; i++) { insert(0, i); insert(H - 1, i); } while (left) { i = heap[1].y; j = heap[1].x; extract(); insert(i - 1, j, fil[i][j]); insert(i + 1, j, fil[i][j]); insert(i, j - 1, fil[i][j]); insert(i, j + 1, fil[i][j]); } printf("%d\n", ans); return 0;}
Pascal：
Pascal：
{$m $100000}
{由于我是做的DFS进行FLOODFILL，所以不免开了点栈深度}
Program Gp ;
const
maxn
=
300
; dx : array[
0
..
3
] of
-
1
..
1
=
(
0
,
1
,
0
,
-
1
) ; dy : array[
0
..
3
] of
-
1
..
1
=
(
1
,
0
,
-
1
,
0
) ; zy
=
trunc( 1e9 ) ;type heaptype
=
record x , y , val : longint ; end ;var map , f : array[
0
.. maxn ,
0
.. maxn ] of longint ; use , u : array[
0
.. maxn ,
0
.. maxn ] of boolean ; heap : array[
0
.. maxn
*
maxn ] of heaptype ; n , m , ans , len : longint ; cant : boolean ;procedure init ;var i , j : longint ;begin fillchar( f ,
sizeof
( f ) ,
0
) ; readln( m , n ) ;
for
i :
=
1
to n
do
for
j :
=
1
to m
do
begin read( map[ i , j ] ) ; f[ i , j ] :
=
zy ; end ;end ;procedure ins( x , y , val : longint ) ;var t : heaptype ; i : longint ;begin t.x :
=
x ; t.y :
=
y ; t.val :
=
val ; inc( len ) ; i :
=
len ;
while
( i
<>
1
) and ( heap[ i div
2
] . val
>
val )
do
begin heap[ i ] :
=
heap[ i div
2
] ; i :
=
i div
2
; end ; heap[ i ] :
=
t ;end ;procedure sort( ii : longint ) ;var j : longint ; num : heaptype ;begin num :
=
heap[ ii ] ; j :
=
ii
*
2
;
while
j
<=
len
do
begin
if
( j
<
len ) and ( heap[ j ] . val
>
heap[ j
+
1
] . val ) then inc( j ) ;
if
num . val
>
heap[ j ] . val then begin heap[ ii ] :
=
heap[ j ] ; ii :
=
j ; j :
=
ii
*
2
; end
else
break
; end ; heap[ ii ] :
=
num ;end;procedure dfs( x , y , max , deep : longint ) ;var i , xx , yy : longint ;begin u[ x , y ] :
=
false
;
if
( max
<
f[ x , y ] ) then f[ x , y ] :
=
max ;
for
i :
=
0
to
3
do
begin xx :
=
x
+
dx[ i ] ; yy :
=
y
+
dy[ i ] ;
if
( xx
<=
0
) or ( xx
>
n ) or ( yy
<=
0
) or ( yy
>
m ) or ( not u[ xx , yy ] ) then
continue
;
if
map[ xx , yy ]
<=
max then dfs( xx , yy , max , deep
+
1
)
else
begin
if
use[ xx , yy ] then begin ins( xx , yy , map[ xx , yy ] ) ; use[ xx , yy ] :
=
false
; end ; end ; end ;end ;procedure floodfill( x : heaptype ) ;var cici , i , a , b : longint ;begin
if
f[ x.x , x.y ]
=
zy then f[ x.x , x.y ] :
=
map[ x.x , x.y ] ; dfs( x.x , x.y , f[ x.x , x.y ] ,
1
) ;end ;procedure solve ;var i , j : longint ; now : heaptype ;begin fillchar( u ,
sizeof
( u ) ,
true
) ; fillchar( use ,
sizeof
( use ) ,
true
) ; len :
=
0
;
for
i :
=
1
to n
do
begin
if
use[ i ,
1
] then ins( i ,
1
, map[ i ,
1
] ) ; use[ i ,
1
] :
=
false
; f[ i ,
1
] :
=
map[ i ,
1
] ;
if
use[ i , m ] then ins( i , m , map[ i , m ] ) ; use[ i , m ] :
=
false
; f[ i , m ] :
=
map[ i , m ] ; end ;
for
i :
=
1
to m
do
begin
if
use[
1
, i ] then ins(
1
, i , map[
1
, i ] ) ; use[
1
, i ] :
=
false
; f[
1
, i ] :
=
map[
1
, i ] ;
if
use[ n , i ] then ins( n , i , map[ n , i ] ) ; use[ n , i ] :
=
false
; f[ n , i ] :
=
map[ n , i ] ; end ;
while
len
>
0
do
begin now :
=
heap[
1
] ; heap[
1
] :
=
heap[ len ] ; heap[ len ] . val :
=
maxlongint ; dec( len ) ; sort(
1
) ; floodfill( now ) ; end ;end ;procedure print ;var i , j , ans : longint ;begin ans :
=
0
;
for
i :
=
1
to n
do
for
j :
=
1
to m
do
inc( ans , f[ i , j ]
-
map[ i , j ] ) ; writeln( ans ) ;end ;procedure main ;begin init ; solve ; print ;end ;Begin main ;end .