POJ2227(优先队列)

The Wedding Juicer

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 3440		Accepted: 1551

Description

Farmer John's cows have taken a side job designing interesting punch-bowl designs. The designs are created as follows:

* A flat board of size W cm x H cm is procured (3 <= W <= 300, 3 <= H <= 300)

* On every 1 cm x 1 cm square of the board, a 1 cm x 1 cm block is placed. This block has some integer height B (1 <= B <= 1,000,000,000)

The blocks are all glued together carefully so that punch will not drain through them. They are glued so well, in fact, that the corner blocks really don't matter!

FJ's cows can never figure out, however, just how much punch their bowl designs will hold. Presuming the bowl is freestanding (i.e., no special walls around the bowl), calculate how much juice the bowl can hold. Some juice bowls, of course, leak out all the juice on the edges and will hold 0.

Input

* Line 1: Two space-separated integers, W and H

* Lines 2..H+1: Line i+1 contains row i of bowl heights: W space-separated integers each of which represents the height B of a square in the bowl. The first integer is the height of column 1, the second integers is the height of column 2, and so on.

Output

* Line 1: A single integer that is the number of cc's the described bowl will hold.

Sample Input

4 5
5 8 7 7
5 2 1 5
7 1 7 1
8 9 6 9
9 8 9 9

Sample Output

12

Hint

OUTPUT DETAILS:

Fill-up the two squares of height 1 to height 5, for 4 cc for each square. Fill the square of height 2 to height 5, for 3 cc of joice. Fill the square of height 6 to height 7 for 1 cc of juice. 2*4 + 3 + 1 = 12.

Source

USACO 2005 January Gold

 

先将边界加入优先队列，每次取高度最小的点，找与其相邻且未访问过的点，若邻点高度大于等于它，直接加入优先队列更新边界，否则更新答案，并将邻点的高度置为该点高度，然后加入优先队列更新边界。

 //2017-08-17
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <queue>
 
 using namespace std;
 
 const int N = ;
 int G[N][N], vis[N][N], n, m;
 int dx[] = {, , , -};
 int dy[] = {, , -, };
 struct Node{
     int x, y, h;
     bool operator<(const Node X) const{
         return h > X.h;
     }
     Node(int _x, int _y, int _h):x(_x), y(_y), h(_h){}
 };
 priority_queue<Node> pq;
 
 void work(){
     int ans = , cnt = ;
     while(!pq.empty()){
         Node node = pq.top();
         pq.pop();
         for(int i = ; i < ; i++){
             int nx = node.x + dx[i];
             int ny = node.y + dy[i];
             if(nx< || nx>=n || ny< || ny>=m || vis[nx][ny])continue;
             vis[nx][ny] = ;
             if(G[nx][ny] >= node.h){
                 Node tmp(nx, ny, G[nx][ny]);
                 pq.push(tmp);
             }else{
                 ans += node.h-G[nx][ny];
                 Node tmp(nx, ny, node.h);
                 pq.push(tmp);
             }
             cnt++;
         }
         if(cnt >= (n-)*(m-))break;
     }
     printf("%d\n", ans);
 }
 
 int main()
 {
     //freopen("input2227.txt", "r", stdin);
     while(scanf("%d%d", &m, &n) != EOF){
         while(!pq.empty())pq.pop();
         memset(vis, , sizeof(vis));
         for(int i = ; i < n; i++)
           for(int j = ; j < m; j++){
               scanf("%d", &G[i][j]);
               if(i ==  || i == n- || j ==  || j == m-){
                     Node node(i, j, G[i][j]);
                     pq.push(node);
                     vis[i][j] = ;
               }
           }
         work();
     }
 
     return ;
 }