ZOJ 2278 Fight for Food(LIS)

题意:给出主人公的初始位置,老鼠的出现位置和时间,主人公每一个单位时间只能向邻近的格子走一步,如果走到某个格子上的时候老鼠正好出现在那个位置,那么就可以抓住它,求主人公最多能抓到多少老鼠.

看起来三维的结构,其实只需要时间这一维就够了,因为两个格子的最短距离必然是曼哈顿距离,距离的计算可以是常数的,那么就相当于转换成了类似LIS的问题了.

预处理的时候可以把每个点到其他所有点的所需时间都找出来存到dis[i1][j1][i2][j2]里.

然后按时间对老鼠排个序,因为主人公的出现时间相当于0,所以我这里做的是不升序,再进行普通的O(n^2)的LIS算法dp[i] = max(dp[j]) + 1, 0<=j<i.

因为这里的P可能有30000, 普通的LIS会超时,所以必须要优化.

这里提几个优化:

1.如果主人公到不了某个格子(被石头挡住了),那么出现在这个位置上的老鼠就可以删除掉了.

2.预处理的时候计算出每个格子能到的最远格子的所需时间max_dis[i][j],再在LIS算法中维护一个maxv[i]代表dp[0]到dp[i]的最大值,在LIS算法的内层循环里:

由于老鼠出现时间是降序的,当两个格子i, j的老鼠出现时间差大于max_dis[i][j]的时候,就意味着这个点可以走到任何的k<=j的格子位置上,这里就可以break出来了.

只需要求一下dp[i] = max(dp[i], dp[j] + 1)就肯定是最优了.

#include <cstdio>
#include <queue>
#include <algorithm>
#include <memory.h>
#include <cmath>
using namespace std;
const int INF = 0x6f6f6f6f;
const int MAX = 30052;

struct Node{
int i, j, step;
Node(int i_ = 0, int j_ = 0, int step_ = 0):i(i_), j(j_), step(step_){}
};
struct State{
int i, j, time, dp;
State(int i_ = 0, int j_ = 0, int time_ = 0, int dp_ = 0):i(i_), j(j_), time(time_), dp(dp_){}
bool operator<(const State & rhs)const{
return time > rhs.time;
}
}s[MAX];

char mat[11][11];
bool vis[11][11];
int dis[11][11][11][11];
int max_dis[11][11], maxv[MAX];
int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int N, M, P, si, sj;

void bfs(int si, int sj, int dis[11][11]){
memset(vis, false, sizeof(vis));
queue<Node> q;
q.push(Node(si, sj, 0));
vis[si][sj] = true;
while(q.size()){
Node f = q.front();
q.pop();
dis[f.i][f.j] = f.step;
max_dis[si][sj] = f.step;
for(int i = 0; i < 4; ++i){
int ni = f.i + dir[i][0], nj = f.j + dir[i][1];
if(ni >= 0 && ni < N && nj >= 0 && nj < M && mat[ni][nj] != '#' && !vis[ni][nj]){
vis[ni][nj] = true;
q.push(Node(ni, nj, f.step + 1));
}
}
}

}

void preprocess(){
memset(dis, 0x6f, sizeof(dis));
for(int i = 0; i < N; ++i){
for(int j = 0; j <= M; ++j){
if(mat[i][j] != '#'){
if(mat[i][j] == 'L'){
si = i, sj = j;
}
bfs(i, j, dis[i][j]);
}
}
}
}

int main(int argc, char const *argv[]){
while(scanf("%d%d", &N, &M) == 2){
memset(max_dis, 0, sizeof(max_dis));
memset(maxv, 0, sizeof(maxv));
for(int i = 0; i < N; ++i){
scanf("%s", mat[i]);
}
preprocess();

int TP;
P = 0;
scanf("%d", &TP);
for(int i = 0; i < TP; ++i){
int x, y, T;
scanf("%d%d%d", &x, &y, &T);
s[P] = State(x - 1, y - 1, T);
if(dis[si][sj][x - 1][y - 1] != INF){//can't reach that grid
++P;
}
}

s[P++] = State(si, sj, 0);
sort(s, s + P);

for(int i = 0; i < P; ++i){
s[i].dp = 1;
int j = i - 1;
for(; j >= 0 && s[j].time - s[i].time < max_dis[s[i].i][s[i].j]; --j){
if(dis[s[i].i][s[i].j][s[j].i][s[j].j] <= s[j].time - s[i].time && s[j].dp + 1 > s[i].dp){
s[i].dp = s[j].dp + 1;
}
}
if(j >= 0 && s[i].dp < maxv[j] + 1){
s[i].dp = maxv[j] + 1;
}
if(i == 0)maxv[i] = s[i].dp;
else maxv[i] = max(maxv[i - 1], s[i].dp);
}
printf("%d\n", s[P - 1].dp - 1);
}
return 0;
}