(声明:同步个人博客 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;
}