=== 热血的ICPC校赛 ===

初入算法竞赛，代码水平虽然很弱，然而第一次参加icpc的发挥还是可以的- v-  最后的两个多小时写了这个，时间所迫代码相当混乱

最后10分钟冒冒失失地写完。。本来早就不抱希望 然而奇迹就发生了——完全没查过边界条件什么的居然一遍AC了！！（感觉要上天了

下面是题目和代码（各种梦幻

听说全球气候变暖，冰川融化，海水淹大地。着实好奇要融化多少冰川会淹没我的宿舍，哦不，淹没南京，反正NJUST应该总会是第一批被淹的。现将整个NJUST简化成一个N×M的棋盘。每个小格子代表一个区域，并且拥有一个值表示海拔。一个6×5的棋盘像下面这样：

4 4 4 3 3

4 2 9 1 3

4 1 9 1 3 

2 6 3 8 2 

2 1 7 1 2 

2 1 2 2 2

大雨倾盆，水淹的到处都是。棋盘边缘不会有无限高的墙，而是什么都没有！也就是说，如果水没过了这个棋盘的四周边缘，水就会流出去。现在我们想知道这个棋盘最多能装多少水！每个地区每个单位海拔能装一单位的水。上图中，棋盘最后能装水的情况如下：

4 4 4 3 3

4 4 9 3 3

4 4 9 3 3

2 6 6 8 2

2 1 7 2 2

2 1 2 2 2

总计：13单位的水无论哪儿再多水，都会从边缘流走。

#include
#include
using namespace std;
int check[300][300];
int land[300][300];
int edge_x[2000];
int edge_y[2000];
int edge_height[2000];
int edge_num;
int new_land_x[90000];
int new_land_y[90000];
int new_land_height[90000];
int new_land_num;
int new_edge_x[2000];
int new_edge_y[2000];
int new_edge_height[2000];
int new_edge_num;
int sum;
int M,N;
void dfs(int x,int y,int height,int flag)
{
if(flag==0){
if(check[x][y]==1)return;}
if(land[x][y] {
check[x][y]=1;
if(flag==0){sum+=height-land[x][y];
}
if(x>0)
dfs(x-1,y,height,0);
if(x dfs(x+1,y,height,0);
if(y>0)
dfs(x,y-1,height,0);
if(y dfs(x,y+1,height,0);
}
else{
new_land_x[new_land_num]=x;
new_land_y[new_land_num]=y;
new_land_height[new_land_num]=height;
new_land_num++;
}
}
void sort_edge(){
for(int i=0;i for(int j=i;j if(edge_height[j] {
swap(edge_x[i],edge_x[j]);
swap(edge_y[i],edge_y[j]);
swap(edge_height[i],edge_height[j]);
}
}
int search_new_edge(int m,int n){
int tmp,have_top=0,have_land,counts_d,not_found,mass;
for(int i=0;i {    have_land=0;
not_found=0;
for(int j=0;j {  if(check[i][j]==0)
{ mass=j;
not_found=0;
break;
}
else 
not_found=1;
}

if(not_found==0)
{ have_land=1;
if(have_top==1)
{
new_edge_x[new_edge_num]=i;
new_edge_y[new_edge_num]=mass;
new_edge_height[new_edge_num]=land[i][mass];
new_edge_num++;
if(check[i][mass+1]!=1){
for(int b=mass+1;b {if(check[i][b]==1)
{ new_edge_x[new_edge_num]=i;
new_edge_y[new_edge_num]=b-1;
new_edge_height[new_edge_num]=land[i][b-1];
new_edge_num++;
break;
} } } }
else//图的顶端
{
have_top=1;
for(int a=mass;a { if(check[i][a]==0)
{      new_edge_x[new_edge_num]=i;
new_edge_y[new_edge_num]=a;
new_edge_height[new_edge_num]=land[i][a];
new_edge_num++;}
}
}
}//check[i][j]=0




{if(have_land==0&&have_top==0)//覆盖结束
tmp=0;
else tmp=1;}
//j
///////////////////////////////////////
if(have_land==0&&have_top==1)//寻找底端
{
counts_d=0;
for(int yu=0;yu {
if(check[i-1][yu]==0)
counts_d++;
}
new_edge_x[new_edge_num]=0;
new_edge_y[new_edge_num]=0;  //要啥可读性
new_edge_height[new_edge_num]=0;
new_edge_num--;
if(counts_d==2)
{new_edge_x[new_edge_num]=0;
new_edge_y[new_edge_num]=0;
new_edge_height[new_edge_num]=0;
new_edge_num--;}
for(int c=0;c {if(check[i-1][c]==0)
for(int u=c;u
if(check[i-1][u]!=0)break;
new_edge_x[new_edge_num]=i-1;
new_edge_y[new_edge_num]=u;
new_edge_height[new_edge_num]=land[i-1][u];
new_edge_num++;}
}
}
//////////////////////////////////
}//i
for(int i=0;i for(int j=i;j if(new_edge_height[j] {
swap(new_edge_x[i],new_edge_x[j]);
swap(new_edge_y[i],new_edge_y[j]);
swap(new_edge_height[i],new_edge_height[j]);
}
return tmp;
}
void edge_copy()
{
for(int i=0;i edge_x[i]=new_edge_x[i];
edge_y[i]=new_edge_y[i];
edge_height[i]=new_edge_height[i];}
}
int main(){
int m[1000];
int n[1000];
int p[10][300][300];
int Count=0;

while(cin>>m[Count]>>n[Count])
{
for(int i=0;i for(int j=0;j cin>>p[Count][i][j];
Count++;
}



for(int count=0;count {
M=m[count];
N=n[count];
for(int ii=0;ii for(int jj=0;jj {check[ii][jj]=0;
land[ii][jj]=p[count][ii][jj];
}
edge_num=0;
new_land_num=0;
new_edge_num=0;
for(int j=0;j {
if(j==0||j==n[count]-1)
for(int k=0;k { edge_height[edge_num]=land[j][k];
edge_x[edge_num]=j;
edge_y[edge_num]=k;
edge_num++;
}
else
{   edge_height[edge_num]=land[j][0];
edge_x[edge_num]=j;
edge_y[edge_num]=0;
edge_num++;
edge_height[edge_num]=land[j][m[count]-1];
edge_x[edge_num]=j;edge_y[edge_num]=m[count]-1;
edge_num++;}
}
sort_edge();
for(int d=0;d { dfs(edge_x[d],edge_y[d],edge_height[d],0);

for(int uy=0;uy dfs(edge_x[uy],edge_y[uy],edge_height[d],1);
}
new_edge_num=0;
while(search_new_edge(n[count],m[count]))//每淹一层
{
edge_copy();
for(int q=0;q dfs(edge_x[q],edge_y[q],edge_height[q],0);

for(int uy=0;uy dfs(edge_x[uy],edge_y[uy],edge_height[q],1);

}
new_edge_num=0;
}
cout< }//count
return 0;
}