const py=100000;
type dd=array[0..50] of longint;
var
f:array[0..51,0..600] of dd;
d:array[0..51,0..51] of longint;
n,l,i,j,k:longint;
ans,t:dd;
function add(a,b:dd):dd;
var i,len:longint;
begin
fillchar(add,sizeof(add),0);
if a[0]>b[0] then len:=a[0] else len:=b[0];
for i:=1 to len do
begin
add[i]:=add[i]+a[i]+b[i];
add[i+1]:=add[i+1]+add[i] div py;
add[i]:=add[i] mod py
end;
if add[len+1]>0 then inc(len);
add[0]:=len;
end;
begin
readln(n,l);
for i:=0 to n do
for j:=0 to n do
d[i,j]:=maxlongint;

for i:=1 to n do
begin
read(d[i,i+1]);
d[i+1,i]:=d[i,i+1];
end;
d[n,1]:=d[n,n+1]; d[1,n]:=d[n,1];

for i:=1 to n do
begin
read(d[0,i]);
d[i,0]:=d[0,i];
end;
f[0,0][0]:=1; f[0,0][1]:=1;
for j:=1 to l do
for i:=0 to n do
begin
fillchar(t,sizeof(t),0);
for k:=0 to n do
if (d[i,k]<=j) and (d[i,k]<>maxlongint) then
t:=add(t,f[k,j-d[i,k]]);
f[i,j]:=t;
end;
ans:=f[0,l];
write(ans[ans[0]]);
for i:=ans[0]-1 downto 1 do
begin
if ans[i]<10 then write('0');
if ans[i]<100 then write('0');
if ans[i]<1000 then write('0');
if ans[i]<10000 then write('0');
write(ans[i]);
end;

end.

const py=100000;
type dd=array[0..50] of longint;
var
f:array[0..51,0..600] of dd;
d:array[0..51,0..51] of longint;
n,l,i,j,k:longint;
ans,t:dd;
function add(a,b:dd):dd;
var i,len:longint;
begin
fillchar(add,sizeof(add),0);
if a[0]>b[0] then len:=a[0] else len:=b[0];
for i:=1 to len do
begin
add[i]:=add[i]+a[i]+b[i];
add[i+1]:=add[i+1]+add[i] div py;
add[i]:=add[i] mod py
end;
if add[len+1]>0 then inc(len);
add[0]:=len;
end;
begin
readln(n,l);
for i:=0 to n do
for j:=0 to n do
d[i,j]:=maxlongint;

for i:=1 to n do
begin
read(d[i,i+1]);
d[i+1,i]:=d[i,i+1];
end;
d[n,1]:=d[n,n+1]; d[1,n]:=d[n,1];

for i:=1 to n do
begin
read(d[0,i]);
d[i,0]:=d[0,i];
end;
f[0,0][0]:=1; f[0,0][1]:=1;
for j:=1 to l do
for i:=0 to n do
begin
fillchar(t,sizeof(t),0);
for k:=0 to n do
if (d[i,k]<=j) and (d[i,k]<>maxlongint) then
t:=add(t,f[k,j-d[i,k]]);
f[i,j]:=t;
end;
ans:=f[0,l];
write(ans[ans[0]]);
for i:=ans[0]-1 downto 1 do
begin
if ans[i]<10 then write('0');
if ans[i]<100 then write('0');
if ans[i]<1000 then write('0');
if ans[i]<10000 then write('0');
write(ans[i]);
end;

end.

DP:=SIGMA(DP[k,j-('边长')])(k为i相邻的点);

谁详细解释一下

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

....Victoria Roo....

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

。。。。哦~~~~~~原来如此

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

Vijos Sunny

诧异了，看了大牛的解释之后终于明白这题意....

然后自己去写，按最白痴的方法+高精，居然过了.....

虽然时间不是很好看.....

这个每个点是可以多次通过的……

准确的说，是多条可重复的 关于O点的哈密顿回路 组成的满足总长度为L的路径。

或者说，多次从O点出发回到O点，对于每一次之中不能有重复的点，但是不同的两次之间可以有重复的点。

重要的是理解题意。我语文学的烂一开始根本没读懂想考什么。

理解后就是一个弱弱的高精+dp

190/600(32%) 　

搜索居然全部超时！Orz...

动规第一次输出到fopen，0分（运行时）。

再交 Ac!

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

太激动了！太激动了！太激动了！太激动了！太激动了！太激动了！太激动了！太激动了！太激动了！太激动了！太激动了！太激动了！太激动了！太激动了！太激动了！

这么简单的题竟然交了9次………………郁闷…………郁闷………………

开始0分，因为题目数据有问题。

后来翻过来90分，最后一个超时。

我那时是string记录每次运算都要用int64转换，也许是慢了点…………

改成int64数组组成的高精度记录，40分…………不知缘故

改成longint数组表示8位，40分…………不知缘故

…………优化…………40分…………不知缘故

…………优化…………40分…………不知缘故

……………………………………………………………………………………

…………优化…………40分…………不知缘故

…………优化…………40分…………不知缘故

用了50 600极限数据，竟然出现了‘－’。

要知道 99999999*3＝299999997

longint的范围达到了2147483647

for i:=1 to l do begin

for j:=1 to n do begin

if i>=zhong[j] then for k:=1 to 30 do f:=f+f[i-zhong[j],0,k];

if i>=bian[j] then begin

if j=bian[j-1] then begin

if j>1 then for k:=1 to 30 do f:=f+f[i-bian[j-1],j-1,k]

else for k:=1 to 30 do f:=f+f[i-bian[j-1],n,k];

end;

for k:=1 to 29 do

if f>=max then begin

f:=f+f div max;

f:=f mod max;

end;

end;

for j:=1 to n do if i>=zhong[j] then for k:=1 to 30 do f:=f+f[i-zhong[j],j,k];

for k:=1 to 29 do

if f>=max then begin

inc(f,f div max);

f:=f mod max;

end;

end;

怎么会有‘－’呢？？？？？？？？？？？？？？

最后这一次把8位改成7位，AC了！！！！！！！！！！！

那就是说8位爆掉了。longint用8位做高精度加法竟然会爆掉！！！！

真是无语！！！！真是郁闷！！！！

可以登上世界未解之谜了吧！！！！！！！！！！！

……………………n min……………………

有个地方偷了点懒，为了节约时间而误了进位时机，所以爆掉了。

怎么会犯这样的错啊，RP啊！！！！

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

考试时0分，唉

看来我真的是沙茶了...

这种题都不会做了...

晕啊

为什么考试0分 现在AC？？？ 完全一样啊

问一下,什么是正多边形？

数据已经更新，按照题目顺序读入吧

。。。。。。Orz 全场爆零题

方程用二维表示

DP表示终点在 I 经过长度为J 的路径种类数

状态转移

DP:=SIGMA(DP[k,j-('边长')])(k为i相邻的点);

用上高精度.

构造循环需要优化，可以用路径长度来循环，再枚举点，

另外 这题跟哈密顿回路根本没有关系

可以理解为从O 点出发最后再回到O点经过长度为L的种类数.

经过的路径没有任何限制.

最后输出要WRITELN 不然第6组会TLE

rt

果然是倒一下

呜呜呜！好不容易会一道题！

竟然...

QJ

是不是圆心可以经过多次？？？