HihoCoder - 1702 矩阵迷宫（dp）

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

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

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

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

Input

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

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

Output

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

Sample Input

3  
1 3 5  
1 1 2  
5 1 1

Sample Output

9

解：我们可以d[i][j][k][h]  i , j 代表坐标  k代表改变几次方向 ，h代表目前方向 向下还是向右

我一开始的想法是

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<iostream>
#include<math.h>
#include<queue>
#include<map>
#include<vector>
#include<set>
using namespace std;
#define inf 0x3f3f3f3f
#define ll long long
int d[110][110][20][2];
int a[110][110];
int aa[20];//第i次改变方向要付出的代价 存了,0,1,2,4,8....
int dir[2][2]={{0,1},{1,0}};
int n;
struct node
{
   int x,y;//坐标
   int time;//花费代价
   int op;//方向0或1
   int o;//改变方向次数
};
int go(int x,int y)
{
    if(1<=x&&x<=n&&1<=y&&y<=n)
        return 1;
    return 0;
}
void bfs()
{
    queue<node>q;
    node st,ed;
    st.x=st.y=1;
    st.time=a[1][1];
    st.o=1;
    st.op=0;//起点出发，方向向右
    q.push(st);
    st.op=1;//起点出发，方向向下
    q.push(st);
    while(!q.empty())
    {
        st=q.front();
        q.pop();
        for(int i=0;i<=1;i++)
        {
            ed.x=st.x+dir[i][0];
            ed.y=st.y+dir[i][1];
            ed.op=i;
            if(!go(ed.x,ed.y))  continue;
            if(st.op==ed.op)//方向相同,不需要改变方向
            {
                ed.time=st.time+a[ed.x][ed.y];
                ed.o=st.o;
            }
            else//相反，加上改变方向的额外代价
            {
                ed.time=st.time+a[ed.x][ed.y]+aa[st.o];
                ed.o=st.o+1;
            }
            if(ed.o>17) continue;//显然超过17后，代价过大
            if(d[ed.x][ed.y][ed.o][ed.op]<=ed.time)
                    continue;
            d[ed.x][ed.y][ed.o][ed.op]=ed.time;
            if(ed.x==n&&ed.y==n) continue;
            q.push(ed);
        }
    }
}
int main()
{
    aa[1]=1;
    for(int i=2;i<=17;i++)
        aa[i]=aa[i-1]*2;
    memset(d,inf,sizeof(d));
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
         scanf("%d",&a[i][j]);
    if(n==1)
    {
        printf("%d\n",a[1][1]);
        return 0;
    }
   bfs();
   int ans=inf;
   for(int i=0;i<=17;i++)
   {
       for(int j=0;j<=1;j++)
     ans=min(ans,d[n][n][i][j]);
   }
   printf("%d\n",ans);
}

后来想了一下，感觉用结构体 ，队列的存取花费的时间太多了，其实并不需要

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<iostream>
#include<math.h>
#include<queue>
#include<map>
#include<vector>
#include<set>
using namespace std;
#define inf 0x3f3f3f3f
#define ll long long
int a[110][110];
int d[110][110][20][2];
int aa[20];//此时aa存的是改变方向i次花费总时间 ，存的是 0,1,1+2,1+2+4,....
int n;
int main()
{
    aa[0]=0;
    for(int i=1;i<=17;i++)
        aa[i]=aa[i-1]*2+1;
  scanf("%d",&n);
   for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
       scanf("%d",&a[i][j]);
    memset(d,inf,sizeof(d));
    d[1][1][0][1]=d[1][1][0][0]=a[1][1];
   for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
       for(int k=0;k<=17;k++)//转向次数
       {
           if(j<n)//可以向右
           {
               if(d[i][j][k][0]!=inf)//当前位置不为极限大
                 d[i][j+1][k][0]=min(d[i][j+1][k][0],d[i][j][k][0]+a[i][j+1]);//面朝右向右走1格
               if(d[i][j][k][1]!=inf)
                 d[i][j+1][k+1][0]=min(d[i][j+1][k+1][0],d[i][j][k][1]+a[i][j+1]);//面朝下向右走1格
           }
           if(i<n)//可以向下
           {
               if(d[i][j][k][0]!=inf)
                d[i+1][j][k+1][1]=min(d[i+1][j][k+1][1],d[i][j][k][0]+a[i+1][j]);//面朝右向下走1格
               if(d[i][j][k][1]!=inf)
                d[i+1][j][k][1]=min(d[i+1][j][k][1],d[i][j][k][1]+a[i+1][j]);//面朝下向下走1格
           }
       }
    int ans=inf;
    for(int i=0;i<=17;i++)
    {
        for(int j=0;j<=1;j++)
         ans=min(ans,d[n][n][i][j]+aa[i]);
    }
    printf("%d\n",ans);
}