codeforces 1064 D. Labyrinth（利用优先队列的bfs）

题目：http://codeforces.com/contest/1064/problem/D

题意：给出一个迷宫，给出初始位置，分别限定向左向右的次数，向上向下的次数不限，问从初始位置出发，最多能到达的点的个数。

思路：若直接用dfs或者bfs，因为到达过某点，其vis就已经被改掉了，导致走那条路径的时候已经用完向左或向右的次数而不能往后走了，而走别的路径的时候还能往后走，但由于该点vis改掉了，即对于其他路径来说这条路已经被堵死了。

所以，需要优先去走那些剩余的向左或向右次数多的点，以保证到每个点时，当前所剩下的能向左或向右的次数是最多的最优的。

这一点可以通过bfs里面用优先队列来实现。（优先队列默认从大到小排）

#include <bits/stdc++.h>
//#pragma GCC optimize(3)
//#pragma GCC optimize("unroll-loops")
//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define pb push_back
#define mkp(a,b) make_pair(a,b)
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define fi first
#define se second
#define lc (d<<1) //d*2
#define rc (d<<1|1) //d*2+1
#define eps 1e-9
#define dbg(x) cerr << #x << " = " << x << "\n";
#define mst(a,val) memset(a,val,sizeof(a))
#define stn(a) setprecision(a)//小数总有效位数
#define stfl setiosflags(ios::fixed)//点后位数:cout<<stfl<<stn(a);
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double PI=3.1415926535897932;
const int MAXN=1e5+10;
const ll mod=1e9+7;
ll inline mpow(ll a,ll b){ll ans=1;a%=mod;while(b){if(b&1)ans=(ans*a)%mod;a=(a*a)%mod,b>>=1;}return ans;}
int inline sgn(double x){return (x>-eps)-(x<eps);} //a<b:sgn(a-b)<0
priority_queue<int,vector<int>,greater<int> > qu; //up
priority_queue<int,vector<int>,less<int> > qd; //dn
const int inf = 0x3f3f3f3f; //9
const ll inff = 0x3f3f3f3f3f3f3f3f; //18

int n,m;
int r,c;
int le,ri;
char s[2010][2010];
int vis[2010][2010];
int ans;
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
struct Node
{
    int y,x;
    int r,l;
    bool operator < (Node a)const
    {
        if(l==a.l) return r<a.r;
        return l<a.l;
    }
}pos;

void bfs()
{
    priority_queue<Node>que;
    pos.y=r,pos.x=c,pos.r=ri,pos.l=le;
    que.push(pos);
    vis[r][c]=1;
    while(que.size())
    {
        Node now=que.top();
        que.pop();
        ans++;
        int ny=now.y,nx=now.x;
        if(ny+1<n&&vis[ny+1][nx]==0&&s[ny+1][nx]=='.'){pos.y=ny+1,pos.x=nx,pos.r=now.r,pos.l=now.l;que.push(pos);vis[ny+1][nx]=1;}
        if(ny-1>=0&&vis[ny-1][nx]==0&&s[ny-1][nx]=='.'){pos.y=ny-1,pos.x=nx,pos.r=now.r,pos.l=now.l;que.push(pos);vis[ny-1][nx]=1;}
        if(nx+1<m&&vis[ny][nx+1]==0&&s[ny][nx+1]=='.'&&now.r>0){pos.y=ny,pos.x=nx+1,pos.r=now.r-1,pos.l=now.l;que.push(pos);vis[ny][nx+1]=1;}
        if(nx-1>=0&&vis[ny][nx-1]==0&&s[ny][nx-1]=='.'&&now.l>0){pos.y=ny,pos.x=nx-1,pos.r=now.r,pos.l=now.l-1;que.push(pos);vis[ny][nx-1]=1;}
    }
}

int main()
{
    fio;
    cin>>n>>m>>r>>c>>le>>ri;
    for(int i=0;i<n;i++) cin>>s[i];
    r--,c--;
    bfs();
    cout<<ans<<endl;
//    for(int i=0;i<n;i++)
//    {
//        for(int j=0;j<m;j++)
//        {
//            if(vis[i][j]) cout<<'+';
//            else cout<<s[i][j];
//        }
//        cout<<endl;
//    }
}

/*
//不是 简单的利用bfs求最短路即可，这个例子中，第六排最右边走最短路无法到达，而绕远路可以到达
10 10
10 4
10 9
...*******
.*.*******
.*.*******
.*.*******
.*.*******
.*.*......
.*.*.*****
.*........
.********.
..........

正解：
43
普通bfs结果：
41
+++*******
+*+*******
+*+*******
+*+*******
+*+*******
+*+*++++..
+*+*+*****
+*++++++++
+********+
++++++++++

11 11
5 3
100 9
*********..
*********.*
..........*
.********.*
....*...*.*
***.*.*.*.*
***.*.*.*.*
***.*.*.*.*
***.*.*.*.*
***.*.*.*.*
***...*...*

正解：
49
普通bfs结果：
48
*********+.
*********+*
++++++++++*
+********+*
++++*+++*+*
***+*+*+*+*
***+*+*+*+*
***+*+*+*+*
***+*+*+*+*
***+*+*+*+*
***+++*+++*

*/