TopCoder 1570 DesertWind

题目链接

题目大意

你在沙漠中，有一些不能去的地方和一些绿洲。你要从起点出发去绿洲（绿洲有多个），可以从一个格子走到他八联通的格子。
沙漠上会刮风，若你逆风走，需要三天的时间从一个格子到八联通，否则需要一天时间。
你会在一大早得知今天的风向，然后决定今天往哪儿走。
问到达绿洲最少需要几天。

思路

感觉一看就是DP。状态也很容易想，$f[i][j]$表示起点到$(i,j)$这个格子最少需要几天。
转移显然是枚举八个方向，最小值+3，次小值+1取min。
但是发现转移是有环的，怎么办呢？加上个Bellman-Fold转移。
发现状态有点不太对头。改一下状态：$f[i][j]$表示$(i,j)$这个格子到终点最少需要几天。

代码

#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<map>
#include<queue>
#include<vector>
#include<stack>
#include<set>
#include<cctype>
#define pa pair<int,int>
#define INF 0x3f3f3f3f
#define inf 0x3f
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define pb push_back

using namespace std;

inline ll read()
{
    long long f=1,sum=0;
    char c=getchar();
    while (!isdigit(c)) {if (c=='-') f=-1;c=getchar();}
    while (isdigit(c)) {sum=sum*10+c-'0';c=getchar();}
    return sum*f;
}
const int N=55;
const int MAXN=N*N;
struct edge{
    int next,to,from;
}e[MAXN*10];
int head[MAXN],cnt;
void addedge(int u,int v)
{
    e[++cnt].next=head[u];
    e[cnt].from=u;
    e[cnt].to=v;
    head[u]=cnt;
}
const int dx[8]={-1,-1,-1,0,1,1,1,0};
const int dy[8]={-1,0,1,1,1,0,-1,-1};
int f[MAXN],n,m,id[N][N],a[N][N];
queue <int> q;
bool inqueue[MAXN]; 
int dis[MAXN][3],from[MAXN][3];
map <char,int> opt;
struct DesertWind{
    int daysNeeded(vector <string> theMap)
    {
        opt['*']=3,opt['X']=0,opt['@']=1,opt['-']=2;
        n=(int)theMap.size(),m=(int)theMap[0].size();
        int tot=1;
        for (int i=1;i<=n;i++)
            for (int j=1;j<=m;j++)
                a[i][j]=opt[theMap[i-1][j-1]],id[i][j]=tot++;
        int pos=0;
        for (int i=1;i<=n;i++)
        {
            for (int j=1;j<=m;j++)
            {
                if (!a[i][j]) continue;
                if (a[i][j]==1) pos=id[i][j];
                for (int k=0;k<8;k++)
                {
                    int x=i+dx[k],y=j+dy[k];
                    if (x<=0 || y<=0 || x>n || y>n || !a[x][y]) continue;
                    addedge(id[i][j],id[x][y]);
                }
            }
        }
        memset(f,inf,sizeof(f));
        for (int i=1;i<=n;i++)
            for (int j=1;j<=m;j++)
                if (a[i][j]==3)
                    f[id[i][j]]=0;
        for (int _=1;_<n*m;_++)
        {
            for (int i=1;i<=n;i++)
                for (int j=1;j<=m;j++)
                {
                    if (!a[i][j]) continue;
                    int minn=INF,sec=INF;
                    for (int k=0;k<8;k++)
                    {
                        int x=i+dx[k],y=j+dy[k];
                        if (x<=0 || y<=0 || x>n || y>m) continue;
                        if (!a[x][y]) continue;
                        if (f[id[x][y]]<minn)
                            sec=minn,minn=f[id[x][y]];
                        else if (f[id[x][y]]<sec)
                            sec=f[id[x][y]];
                    }
                    if (minn!=INF)
                        f[id[i][j]]=min(f[id[i][j]],minn+3);
                    if (sec!=INF)
                        f[id[i][j]]=min(f[id[i][j]],sec+1);
                }
        }
        return f[pos]<INF?f[pos]:-1;
    }
};