时间限制:10000ms

单点时限:1000ms

内存限制:256MB

描述

给定一个NxN的方格矩阵迷宫，每个格子中都有一个整数Aij。最初小Hi位于迷宫左上角的格子A11，他每一步可以向右或向下移动，目标是移动到迷宫的出口——右下角ANN。  

小Hi需要支付的代价包括路径中经过的所有格子中的整数之和，以及改变移动方向需要支付的代价。  

小Hi第一次改变方向的代价是1，第二次的代价是2，第三次的代价是4，…… 第K次的代价是2K-1。  

请你帮小Hi算出要离开迷宫代价最小的路径，并输出要支付的代价。

输入

第一行一个整数N。  (1 ≤ N ≤ 100)  

以下N行每行N个整数，代表矩阵A。  (1 ≤ Aij ≤ 100)

输出

从左上角到右下角路径的最小的代价。

样例输入

3  
1 3 5  
1 1 2  
5 1 1

样例输出

9

/*

*/
#include <cstdio>
#include <queue>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <bitset>
#include <stack>
#define ll long long
#define ull unsigned long long
#define inf 0x3f3f3f3f
const int mod=997;
const int N=110;
using namespace std;
int mp[N][N];
int dpr[N][N][20],dpd[N][N][20];
int poww(int x)
{
    int ans=1;
    while(x--)
        ans<<=1;
    return ans;
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            scanf("%d",&mp[i][j]);
        }
    }
    memset(dpd,inf,sizeof(dpd));
    memset(dpr,inf,sizeof(dpr));
    dpd[1][1][0]=mp[1][1];
    dpr[1][1][0]=mp[1][1];
    for(int i=2;i<=n;i++)
    {
        dpr[1][i][0]=dpr[1][i-1][0]+mp[1][i];
        dpd[i][1][0]=dpd[i-1][1][0]+mp[i][1];
    }
//    for(int i=1;i<=n;i++)
//        printf("%d ",dpr[1][i][0]);
    for(int i=2;i<=n;i++)
    {
        for(int j=2;j<=n;j++)
        {
            dpr[i][j][0]=dpr[i][j-1][0]+mp[i][j];
            dpd[i][j][0]=dpd[i-1][j][0]+mp[i][j];
            for(int k=1;k<20;k++)//换方向次数
            {   //此时向右有由，左边向下方向的节点向右转转，或者左边的节点继续向右
                dpr[i][j][k]=min(dpd[i][j-1][k-1]+poww(k-1),dpr[i][j-1][k])+mp[i][j];
                dpd[i][j][k]=min(dpr[i-1][j][k-1]+poww(k-1),dpd[i-1][j][k])+mp[i][j];
                //此时向下由，上面向右方向的节点向下转转，或者上面的节点继续向下
            }
        }
    }
    int sum=inf;
    for(int i=0;i<20;i++)
    {
        sum=min(sum,dpd[n][n][i]);
        sum=min(sum,dpr[n][n][i]);
    }
    printf("%d\n",sum);
    return 0;
}