[Codeforces 24D] Broken Robot

[题目链接]

         http://codeforces.com/contest/24/problem/D

[算法]

        用f[i][j]表示从(i,j)走到第n行的某个位置的期望步数 

        那么有 ：

        当机器人在第1列时 : f[i][1] = 1 / 3 * (f[i][1] + f[i][2]+ f[i+1][1]) + 1

        当机器人在第m列时 : f[i][m] = 1 / 3 * (f[i][m] + f[i][m-1] + f[i+1][m]) +1

        否则 : f[i][j] = 1 / 4 * (f[i][j] + f[i][j-1]+ f[i][j+1] + f[i+1][j]) + 1

         但是，如果这样设计状态转移方程，无法确定递推顺序，怎样解决这个问题？

         高斯消元。

         我们将i+1行已经求出的值当作已知的数，第i行当做未知数，那么就很容易列出m个方程，但是若采取普通的消元法，复杂度是O(m^2)，我们不妨将这些方程在草稿纸上列出，

         发现每一行只有2-3个位置需要消元，只需O(m)的时间即可解出所有的未知数

         至此，问题迎刃而解

[代码]

        此题细节较多

        要注意浮点数的运算

        

#include<bits/stdc++.h>
using namespace std;
#define MAXN 2020

int i,j,n,m,x,y;
double f[MAXN],b[MAXN];
double dp[MAXN][MAXN],a[MAXN][MAXN];
double rate;

int main()
{
    
    scanf("%d%d%d%d",&n,&m,&x,&y);
    if (m == 1)
    {
        for (i = n - 1; i >= 1; i--) f[i] = f[i+1] + 2;
        printf("%.10lf\n",f[x]);
    } else
    {
        for (i = 1; i <= m; i++) dp[n][i] = 0.0;
        for (i = n - 1; i >= 1; i--)
        {
            a[1][1] = -(2.0 / 3.0); 
            a[1][2] = 1.0 / 3.0;
            b[1] = -(1.0 / 3.0) * dp[i+1][1] - 1;
            for (j = 2; j < m; j++)
            {
                a[j][j-1] = 1.0 / 4.0;
                a[j][j] = -(3.0 / 4.0);
                a[j][j+1] = 1.0 / 4.0;
                b[j] = -(1.0 / 4.0) * dp[i+1][j] - 1;
            }
            a[m][m-1] = 1.0 / 3.0;
            a[m][m] = -(2.0 / 3.0);
            b[m] = -(1.0 / 3.0) * dp[i+1][m] - 1;
            for (j = 2; j <= m; j++)
            {
                rate = 1.0 * a[j][j-1] / a[j-1][j-1];
                a[j][j-1] = 0;
                a[j][j] = 1.0 * a[j-1][j] * rate - a[j][j];
                a[j][j+1] = 1.0 * a[j-1][j+1] * rate - a[j][j+1];
                b[j] = 1.0 * b[j-1] * rate - b[j];
            }
            dp[i][m] = b[m] / a[m][m];
            for (j = m - 1; j >= 1; j--) 
            {
                dp[i][j] = 1.0 * (b[j] - a[j][j+1] * dp[i][j+1]) / a[j][j];
            }
        }
        printf("%.10lf\n",dp[x][y]);
    }
    
    return 0;
}