编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

递推递推……

========================puppy的分割线========================

program v1232;

var f:array[0..51] of qword;

i,n,m,j:longint;

function q(x:longint):qword;

var j:longint;

begin

q:=1;

for j:=1 to x do q:=q*2;

end;

begin

readln(n,m);

for i:=0 to m-1 do

f[i]:=q(i);

for i:=m to n do

for j:=1 to m do

f[i]:=f[i]+f;

writeln(f[n]);

end.

超水！！！！！

编译通过...

├ 测试数据 01：运行超时...

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：运行超时...

├ 测试数据 07：运行超时...

├ 测试数据 08：运行超时...

├ 测试数据 09：运行超时...

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Unaccepted 有效得分：50 有效耗时：0ms

搜后，伤心中...

貌似有错排递推的嫌疑，不过我没想到，看了各位大牛的方法才知道。不过好像还有些问题，当i

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

不开int64不行啊

program ex1;

var

a,b,c,d:longint;

e:int64;

arr:array[1..50,0..5] of int64;

n,m:longint;

begin

readln(n,m);

arr[1,0]:=1;

arr[1,1]:=1;

for a:=2 to n do

for b:=0 to m-1 do

begin

arr[a,0]:=arr[a,0]+arr[a-1,b];

arr[a,b+1]:=arr[a,b+1]+arr[a-1,b];

end;

for a:=0 to m-1 do

e:=e+arr[n,a];

writeln(e);

end.

我悲剧了..刚忘了把E定义成INT64直接导致我连交3遍不过,哎~~这可恶的变量

看了牛们的题解

很强大

要用int64.

我沙茶。

用状态DP

几个月以前写的 我都不知道我写的这是啥 不过和楼下的各位不太一样 不过是等价的 f[i]=Σf[j](0

longint=60

int64=AC

深度优先搜索：

编译通过...

├ 测试数据 01：运行超时...

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：运行超时...

├ 测试数据 07：运行超时...

├ 测试数据 08：运行超时...

├ 测试数据 09：运行超时...

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Unaccepted 有效得分：50 有效耗时：0ms

#include

using namespace std;

int n,m;

int now=0;

__int64 ans=0;

void dfs(int t)

{

int i;

if(t==n+1)

{

ans++;

return ;

}

if(now==m) return ;

if(now==m-1)

{

dfs(t+1);

now=0;

}

else

{

now++;

dfs(t+1);

now--;

dfs(t+1);

now=0;

}

}

int main()

{

cin >> n >> m;

dfs(1);

cout n >> m;

memset(f,0,sizeof(f));

f[4]=1;

f[5]=1;

for(i=6;i

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

var i,j,n,m:longint; f:array[-3..100,-3..10]of int64;

w:int64;

begin

readln(n,m);

f[0,0]:=1;

for i:=1 to n do

begin

for j:=0 to m-1 do f:=f+f;

for j:=0 to m-1 do f:=f+f;

end;

w:=0;

for i:=0 to m-1 do w:=w+f[n,i];

write(w);

end.

太水了

参考了之前大牛们的分析，花了1小时，总算明白了!

假设用数组F记录前I-1个不爆炸的总数，你就会发现，第I个坑有两个选择，一个是放，一个是不放，所以得出F:=F*2；

如果后M-1个全都放了核弹了，那么这个坑也就不能放核弹了；

那就想，到底在前I-1个可行性的方案中，有几种，他的后M-1项全都放了核弹的，其实只要知道第I-M个坑没有放核弹（如果第I-M个坑放了核弹，那么到达I-1的时候，已经爆炸）的方案数K，那么，会有K种情况，使得后M-1都放核弹；

最后，这个K从哪里得知，K为第I-M个坑没有放核弹的数目，其实在第F【I-M-1】的可行性方案总数就是K，因为F个坑之后肯定有一种情况，那就是第I-M个坑我不放核弹，所以K=F；

所以会有f[i]:=f*2-f的规律！！

Program P1232;

var f:array[-6..100] of int64;

k,i,j,n,m:longint;

Begin

fillchar(f,sizeof(f),0);

readln(n,m);

f[-1]:=1;

f[0]:=1;

for i:=1 to n do

f[i]:=f*2-f;

writeln(f[n]);

end.

递推很简单的

倒着想（最多爆炸数），结果想不出，貌似组合数学也可以。copy了

var i,m,n:longint;

a:array[-5.. 50] of int64;

begin

read(n,m);

a[-1]:=1;

a[0]:=1;

for i:=1 to n do

a[i]:=a*2-a;

writeln(a[n]);

end.

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

懒得优化方程了……直接状态压缩……

要用 long long 晕.........通过率快要跌破50%了.........

嗯，方程很强，明白以后就觉得这题出的很有水平啊。

其实去年做过一编，忘了......失败阿

各位太牛拉.....

我一开始是这么想的,总共的组合数为2^N,不会发生爆炸的数目的等于2^N-会发生爆炸的数目,会发生爆炸的数目就枚举每一种发生爆炸的方法,爆炸长度为M,故有N-M+1个可能位置,每个位置选定后其他的地方就随便放不放嘛,于是就是(N-M+1)*2^(N-M),再用2^N减....无奈怎么也不对..那位大牛能告诉我怎么会错呢..

var k:array[0..5] of int64;

m,n,s:int64;

i:longint;

begin

readln(n,m);

fillchar(k,sizeof(k),0);

k[0]:=1;

if m1 then k[1]:=1;

while n1 do begin

dec(n);

s:=0;

for i:=0 to m-1 do inc(s,k[i]);

for i:=m-1 downto 1 do k[i]:=k;

k[0]:=s;

end;

s:=0;

for i:=0 to m-1 do inc(s,k[i]);

writeln(s);

end.

本人写的WS程序，把变量都合到一个数组里去了，有点难看懂。