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

最新推荐文章于 2023-04-17 13:51:21 发布

HfCloud

最新推荐文章于 2023-04-17 13:51:21 发布

阅读量1.4k

点赞数 1

分类专栏：算法文章标签：算法

本文链接：https://blog.csdn.net/u013632138/article/details/61418772

版权

算法专栏收录该内容

23 篇文章 1 订阅

订阅专栏

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

牛跳房子

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

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

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

$f[i][j] = \sum_{k=1}^{i-1} \sum_{l=1}^{j-1} f[k][l], tag[i][j] != tag[k][l]$, where f[1][1] = 1$$

#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-1][j-1]-g[tag[i][j]][i-1][j-1] $, where f[1][1] = 1$$

每次转移到 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;
}

HfCloud

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
[题解] USACO cow hopscotch(牛跳房子)

牛跳房子题目大意：从网格左上角开始，每次只能转移到严格在当前格子右下方，上面的标记与当前格子不同的格子。求最后到达右下角的格子的方案数。反过来考虑如何转移到当前格子，那就是从严格在左上方，标记与当前格子不同的格子转移来。所以：一眼O((RC)^2)的递推即：#include <cstdio>#include <cstring>#include <cstdarg>#include <queue
复制链接

扫一扫

专栏目录