道路 [NOIP模拟]

Description

我们看见了一个由 m 行 n 列的 1*1 的格子组成的矩阵,每个格子(I,j)有对应的高度 h[i][j]和初始的一个非负权值 v[i][j].我们可以随便选择一个格子作为起点,然后在接下来的每一步当中,我们能且只能到达与当前格子有边相邻的四个格子中的高度不超过当前格子高度的格子,每当我们到达一个新格子(包括一开始选择的初始格子),我们就能得到该格子的权值分,然后该格子的权值就会等概率变成不比当前的权值大的一个非负权值。每一个格子在满足前面条件情况下,可以走任意多次。我们希望得到一个最大的期望权值和路径,并给出这个最大的期望权值和。

Input
第一行两个正整数表示 m,n。
接下来的 m 行,每行 n 个正整数,表示 h[i][j].
接下来的 m 行,每行 n 个非负整数,表示 v[i][j].

Output
一行一个实数,表示所求的最大期望权值和。保留零位小数。

Sample Input
1 3
1 2 1
1 2 3

Sample Output
5

Data Range
对于 30%的数据,保证 n,m 不超过 100.
对于另外 20%的数据,保证不存在相同的高度的格子。
对于 100%的数据,保证 n,m 不超过 1000.所有权值与高度不超过 10^9.

Solution

对于高度相同的点可以重复来回走，把他们整体看成一个点，权值为v，每走完一次，他的权值变成[0,v]内的一个值的概率一样，那么期望的平均值为0.5v。每走一次，v'=0.5v，那么看成一个等比数列{v_i}，其中v1=v,v_i=0.5v_i-1,那么记等差数列前i项和为Si，当i→+∞时，Si→2v（形象理解：一个饼每次切1/2，最后切到无限小;严谨推理：等比数列求和公式，在次不做赘述）

那么对于相同高度的点，缩成一个点，如果缩点前的点数>1，最后权值×2，最后对于每个缩的点跑一边最长路即可(SPFA/DP)

要注意缩点BFS的写法，不要队列弹出时再记录，加入队列前就记录，否则可能会WA

Code

 #include<set>
 #include<map>
 #include<queue>
 #include<stack>
 #include<cstdio>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #define inf (1<<30)
 #define ll long long
 #define RG register int
 #define rep(i,a,b)    for(RG i=a;i<=b;i++)
 #define per(i,a,b)    for(RG i=a;i>=b;i--)
 #define maxn 1005
 #define add(x,y) e[++cnt].v=y,e[cnt].next=head[x],head[x]=cnt
 using namespace std;
 typedef pair<int,int> pir;
 int n,m,id,cnt;
 int h[maxn][maxn],val[maxn][maxn],head[maxn*maxn];
 int rec[maxn][maxn];
 int dir[][]={{,},{-,},{,},{,-}};
 ll ans,V[maxn*maxn],f[maxn*maxn];
 struct E{
     int v,next;
 }e[];
 inline int read()
 {
     int x=,f=;char c=getchar();
     while(c<''||c>''){if(c=='-')f=-;c=getchar();}
     while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
     return x*f;
 }
 
 void DO(int x,int y)
 {
     ++id;int num=;
     queue<pir> que;
     que.push((pir){x,y});
     pir u;int tx,ty;
     while(!que.empty())
     {
         u=que.front();que.pop(),++num;
         rec[u.first][u.second]=id,V[id]+=val[u.first][u.second];
         rep(i,,)
         {
             tx=u.first+dir[i][],ty=u.second+dir[i][];
             if(tx<||tx>n||ty<||ty>m)    continue;
             if(rec[tx][ty])                continue;
             if(h[tx][ty]!=h[u.first][u.second])    continue;
             que.push((pir){tx,ty});
         }
     }
     if(num>)    V[id]<<=;
 }
 
 ll LongPath(int u)
 {
     if(f[u]!=-)    return f[u];
     f[u]=;
     for(int i=head[u];i;i=e[i].next)
     {
         f[u]=max(f[u],LongPath(e[i].v));
     }
     f[u]+=V[u];
     return f[u];
 }
 
 int main()
 {
     freopen("road.in","r",stdin);
     freopen("road.out","w",stdout);
     n=read(),m=read();
     rep(i,,n)rep(j,,m)    h[i][j]=read();
     rep(i,,n)rep(j,,m)    val[i][j]=read();
     rep(i,,n)rep(j,,m)    if(!rec[i][j])    DO(i,j);
     int tx,ty;
     rep(x,,n)rep(y,,m)rep(i,,)
     {
         tx=x+dir[i][],ty=y+dir[i][];
         if(tx<||tx>n||ty<||ty>m||h[tx][ty]>=h[x][y])    continue;
         add(rec[x][y],rec[tx][ty]);
     }
     memset(f,-,sizeof(f));
     rep(i,,id) ans=max(ans,LongPath(i));
     cout<<ans;
     return ;
 }