這題看了以后，想了一個很腦殘的做法，也過了，不過用了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：
{$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 .