[题解] USACO cow hopscotch(牛跳房子)

(声明:同步个人博客 http://sxysxy.org/blogs/122 到csdn

牛跳房子

题目大意:从网格左上角开始,每次只能转移到严格在当前格子右下方,上面的标记与当前格子不同的格子。求最后到达右下角的格子的方案数。

反过来考虑如何转移到当前格子,那就是从严格在左上方,标记与当前格子不同的格子转移来。所以:

一眼O((RC)^2)的递推即:

#include <cstdio>
#include <cstring>
#include <cstdarg>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
int field[800][800], f[800][800];
int main(){
  int n, m, f_ck;  // f_ck is useless
  scanf("%d %d %d", &n, &m, &f_ck); 
  for(int i = 1; i <= n; i++)for(int j = 1; j <= m; j++)
    scanf("%d", &field[i][j]);
  f[1][1] = 1;
  for(int i = 1; i <= n; i++){
    for(int j = 1; j <= m; j++){
      for(int k = 1; k < i; k++)
        for(int l = 1; l < j; l++)
          if(field[k][l] != field[i][j])
            f[i][j] = (f[i][j]+f[k][l])%1000000007;
    }
  }
  printf("%d\n", f[n][m]);
  return 0;
}

完美TLE。应该是30分。

发现我们当前决策f[i][j]依赖于它左上方的决策,并且是一个和。没错,如果没有格子上标记不同 这个限制的话,可以直接对 f 取前缀和直接加速到O(n^2)。

有颜色限制也可以前缀和加速,如果我们记g[k][i][j]为标记为k的格子的 f 的前缀和,用所有 f 的前缀和减去当前格子上标记的前缀和,也是可以的,即

每次转移到 f[i][j] ,要更新所有颜色的前缀和pre[i][j]和每种颜色的前缀和g。代码实现的时候,用了个技巧就是动态申请内存。时间复杂度是O(RCK)的

但问题就是k的范围太大,这样做空间开不下!?滚动数组来一发quq,时间的话,按上界,还是难以承受。但还是比第一种算法得分高不少,在cogs上得73分。代码:

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <cctype>
#include <list>
using namespace std;
namespace IO{
  char buf[1<<18], *fs, *ft;
  inline char readc(){
    return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<18,stdin)),fs==ft)?EOF:*fs++;
  }
  inline int readint(){
    char c; int r;
    while(c = readc()){if(c >= '0' && c <= '9'){r = c^0x30;break;}}
    while(isdigit(c = readc()))r = (r<<3)+(r<<1)+(c^0x30);
    return r;
  }
  inline int read_string(char *str){
    int len = 1;char c;
    while(!isalpha(c = readc()));str[0] = c;
    while(isalpha(c = readc()))str[len++] = c;
    str[len] = 0;
    return len;
  }
};using IO::read_string; using IO::readint;
#define MOD 1000000007
int f[751][751], field[751][751];
struct pre{
  int a[2][751];
}preall; //all f prefix sum
int main(){
  //freopen("hopscotch.in", "r", stdin);
  //freopen("hopscotch.out", "w", stdout);
  int n, m, c;
  n = readint(); m = readint(); c = readint();
  pre *g = (pre *)malloc((c+1)*sizeof(pre)); //prefix sum for each color
  for(int i = 1; i <= c; i++)g[i].a[0][0] = g[i].a[1][0] = 0;
  for(int i = 1; i <= n; i++)for(int j = 1; j <= m; j++)
    field[i][j] = readint();
  f[1][1] = 1;
  for(int i = 1; i <= n; i++)for(int j = 1, cur = i&1; j <= m; j++){
    int cl = field[i][j];
    f[i][j] = (f[i][j]+preall.a[cur^1][j-1])%MOD;
    f[i][j] = ((f[i][j]-g[cl].a[cur^1][j-1])%MOD+MOD)%MOD;

    //update preall
    preall.a[cur][j] = (f[i][j]+preall.a[cur^1][j])%MOD;
    preall.a[cur][j] = ((preall.a[cur][j]+preall.a[cur][j-1]-preall.a[cur^1][j-1])%MOD+MOD)%MOD;
    //update prefix sum of each color.
    for(int k = 1; k <= c; k++){
      g[k].a[cur][j] = ((k==cl?f[i][j]:0)+g[k].a[cur^1][j])%MOD;
      g[k].a[cur][j] = ((g[k].a[cur][j]+g[k].a[cur][j-1]-g[k].a[cur^1][j-1])%MOD+MOD)%MOD;
    }
  } 
  printf("%d\n", f[n][m]);
  free(g);
  return 0;
}

然后考虑瓶颈问题:就是 g 这个,每种颜色的前缀和的计算。我们需要用更少的空间,更高的效率维护 g 。于是考虑使用高级数据结构。

线段树就可以了。具体实现方法:对每个颜色维护一个动态开点线段树(省空间用)。维护g的时候,按行递推,同一列的 f 值直接合并就可以了(线段树单点修改操作)。时间复杂度O(RClogC)。

代码:

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <cctype>
#include <list>
using namespace std;
#define MOD 1000000007
namespace IO{
  char buf[1<<18], *fs, *ft;
  inline char readc(){
    return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<18,stdin)),fs==ft)?EOF:*fs++;
  }
  inline int readint(){
    char c; int r;
    while(c = readc()){if(c >= '0' && c <= '9'){r = c^0x30;break;}}
    while(isdigit(c = readc()))r = (r<<3)+(r<<1)+(c^0x30);
    return r;
  }
  inline int read_string(char *str){
    int len = 1;char c;
    while(!isalpha(c = readc()));str[0] = c;
    while(isalpha(c = readc()))str[len++] = c;
    str[len] = 0;
    return len;
  }
};using IO::read_string; using IO::readint;
struct node{
  node *ls, *rs;
  int sum;
  node(){
    ls = rs = NULL; sum = 0;
  }
};
void insert(node *&x, int p, int d, int L, int R){
  if(!x)x = new node();
  x->sum = ((x->sum+d)%MOD+MOD)%MOD;
  if(L == R && R == p)return;
  int M = (L+R)>>1;
  if(p <= M)insert(x->ls, p, d, L, M);
  if(p > M)insert(x->rs, p, d, M+1, R);
}
int query(node *x, int l, int r, int L, int R){
  if(!x)return 0;
  if(l <= L && R <= r)return x->sum;
  int M = (L+R)>>1, ret = 0;
  if(l <= M)ret += query(x->ls, l, r, L, M);
  if(r > M)ret = ((ret+query(x->rs, l, r, M+1, R))%MOD+MOD)%MOD;
  return ret;
}
int field[751][751];
int f[751][751];
int pre[751][751];
node *root[751*751];
int main(){
  //freopen("hopscotch.in", "r", stdin);
  //freopen("hopscotch.out", "w", stdout);
  int n, m, c; n = readint(); m = readint(); c = readint();
  for(int i = 1; i <= n; i++)for(int j = 1; j <= m; j++)
    field[i][j] = readint();
  for(int i = 1; i <= n; i++){
    for(int j = 1; j <= m; j++){
      if(i == 1 && j == 1)f[i][j] = 1;
      else
      f[i][j] = ((pre[i-1][j-1]-query(root[field[i][j]], 1, j-1, 1, m))%MOD+MOD)%MOD;
    }
    for(int j = 1; j <= m; j++){
      pre[i][j] = (((pre[i][j-1]+pre[i-1][j])%MOD-pre[i-1][j-1])%MOD+MOD)%MOD;
      pre[i][j] = (pre[i][j]+f[i][j])%MOD;
      insert(root[field[i][j]], j, f[i][j], 1, m);
    }
  }
  printf("%d\n", f[n][m]);
  return 0;
}

还有一种方法就是cdq分治了。。。具体做法是这样:

先%Mike和rapiz

然后cdq按列分治,然后。。。。。。woc为什么我就想不到可以cdq分治mdzz。。。。

基本上就是把前面那个73分的算法套到一个分治的框架里面,还是按照那个推导出来的公式是算。

结果就不会爆空间而且跑得也非常快。。

它通过这样一个分治的框架,分多次累计对每个f[i][j]答案的贡献,这一点很重要。直接递推的方法,要直接一次得出f[i][j],再往后推对f[i][j]就没有影响了。而cdq分治每个f[i][j]的答案可能来自多个分治得到的贡献。前者直接递推的话,需要f[i][j]之前的数据,所以才有了时间,空间难以承受这样的问题(当然通过高级数据结构解决了)。后者就很巧妙了。。感觉对cdq分治理解加深了一些。

代码:

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
using namespace std;
#define MAXN 800
const int MOD = 1000000007;
int field[MAXN][MAXN], f[MAXN][MAXN], sum[MAXN*MAXN];
int n, m, k;
void cdq(int l, int r){
  if(l == r)return;
  int mid = (l+r)>>1, allsum = 0;
  cdq(l, mid);
  for(int i = 1; i <= n; i++){
    for(int j = mid+1; j <= r; j++)
      f[i][j] = ((f[i][j]+allsum-sum[field[i][j]])%MOD+MOD)%MOD;
    for(int j = l; j <= mid; j++){
      allsum = (allsum+f[i][j])%MOD;
      sum[field[i][j]] = (sum[field[i][j]] + f[i][j])%MOD;
    }
  }
  for(int i = 1; i <= n; i++)
    for(int j = l; j <= mid; j++)sum[field[i][j]] = 0;
  cdq(mid+1, r);
}
int main(){
 // freopen("hopscotch.in", "r", stdin);
 // freopen("hopscotch.out", "w", stdout);
  scanf("%d %d %d", &n, &m, &k);
  for(int i = 1; i <= n; i++)for(int j = 1; j <= m; j++)scanf("%d", &field[i][j]);
  f[1][1] = 1;
  cdq(1, m);
  printf("%d\n", f[n][m]);
  return 0;
}
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值