编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Vijos Easy

一次AC很爽

我承认我写得很诡异

用f表示状态为i，当前在第j点所能得到的最小值

i是用2进制表示的状态

初始化f[1 shl(i-1),i]=0

然后把所有的1 shl(i-1)存到一个队列里

就是记录当前已经扩展的状态

之后每次从队头拿一个状态出来

枚举i，j

其中i表示队头状态当前所到达的点

j表示从i出发走到的下一个点

i要走过，j不能走过（这个用位运算判断）

然后去更新状态

把新生成的状态加入到队尾

一直做到队列里面剩一个状态

也就是那个最后全部都走过的状态

最后输出f[1 shl n-1,i]的最大值

其实就是用宽搜生成状态然后进行dp

下面是主过程

fillchar(f,sizeof(f),$7f);//初始化

fillchar(h,sizeof(h),0);//记录当前状态是否出现过的数组

for i:=1 to n do

begin

s[i]:=1 shl(i-1);

f[s[i],i]:=0;

h[s[i]]:=true;

end;

p:=1;q:=n;//初始队头队尾

while pf[s[p],i]+a then f[x,j]:=f[s[p],i]+a; //更新f数组

if not h[x] then //判断新状态是否出现过，没出现过就加入队尾

begin

h[x]:=true;

inc(q);

s[q]:=x;

end;

end;

inc(p);

end;

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

#2,又写错预处理。。。。囧。。。

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

├ 测试数据 16：答案正确... 103ms

├ 测试数据 17：答案正确... 103ms

├ 测试数据 18：答案正确... 197ms

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

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

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

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

water

编译通过...

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

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

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

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

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

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

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

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

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

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

├ 测试数据 11：答案正确... 41ms

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

├ 测试数据 13：答案正确... 275ms

├ 测试数据 14：答案正确... 634ms

├ 测试数据 15：答案正确... 650ms

├ 测试数据 16：答案正确... 681ms

├ 测试数据 17：答案正确... 697ms

├ 测试数据 18：答案正确... 681ms

├ 测试数据 19：答案正确... 697ms

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

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

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

囧~~~时间太难看了！！！！还是推荐用搜索把！

我用的是位压缩动规

卡时就是牛x，没想到最后竟然是卡时过的。

orz lemon牛的剪枝

朴素搜索45分

用贪心计算出优先的搜索顺序40分(不是puppy跑的)

加上lemon牛的最优性剪枝80分

最后加上卡时间的剪枝AC

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

From yuhc

最小总代价（赛） 2008江中信奥模拟 系列

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

├ 测试数据 15：答案正确... 134ms

├ 测试数据 16：答案正确... 134ms

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

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

├ 测试数据 19：答案正确... 166ms

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

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

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

比jacklv慢。。。。。。。。。。

从最后状态进行记忆化搜索。f[i][j]表示现在轮到i倒推，当前的状态是j。j事实上是一个二进制串，第i位是1表示当时i已经拿到了球。边界是f[i][0] = 0. 然后枚举所有可以传球的人（事实上是被传球）。

强大的位运算，0秒，一次AC

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

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

├ 测试数据 14：答案正确... 134ms

├ 测试数据 15：答案正确... 134ms

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

├ 测试数据 17：答案正确... 41ms

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

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

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

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

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

dp

记忆化搜索，状态压缩，位运算

总体来说

水题

大家要细心

力求一次a掉

一次AC....

挺麻烦的一道题...用位运算记忆化

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

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

├ 测试数据 14：答案正确... 494ms

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

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

├ 测试数据 17：答案正确... 541ms

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

├ 测试数据 19：答案正确... 541ms

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

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

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

状态压缩+位运算

“新年趣事之红包”的方程在这居然不能用了.....

原来这里不是凸多边形啊.......

看了大牛的题解，去用二进制试试，果然神奇~~

不过我打了50+行....

编译通过...

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

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

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

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

├ 测试数据 05：答案错误...　├ 标准行输出

　├ 错误行输出

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

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

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

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

├ 测试数据 10：答案错误...　├ 标准行输出

　├ 错误行输出

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

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

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

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

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

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

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

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

├ 测试数据 19：答案错误...　├ 标准行输出

　├ 错误行输出

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

退火就能这样 牛B

位运算部分 。。不错的位运算压缩题。。。状态定义比较猥琐。。转移不是特别方便。。

while (Tmp > 0)

{

if (Tmp % 2 == 1)

{

b = a^(1 DP[L + 1] + G[L + 1][p] && G[L + 1][p] >= 0) DP[a][p] = DP[L + 1] + G[L + 1][p];

}

Tmp >>= 1;

L += 1;

}

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

37行AC～想起以前把二进制还原。。再弄成二进制。。.....DP真爽，，，原来位运算这么爽的。。。。状态编号就用位运算～。。爽……。。

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

├ 测试数据 17：答案正确... 197ms

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

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

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

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

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

时间啊

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

感谢lemon_cn大牛的超级剪枝，拜膜。

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var

n,l,i,j,k,p,q,r :integer;

t :longint;

map,f,b :array[1..16,1..16]of longint;

vis,c :array[1..16,1..16]of string;

begin

read(n);

for i:=1 to n do

for j:=1 to n do

begin

read(map);

f:=map;

vis:='';

for k:=1 to n do

vis:=vis+'0';

vis[j]:='1';

vis[i]:='1';

end;

for l:=3 to n do

begin

for i:=1 to n do

for j:=1 to n do

if ij then

begin

t:=maxlongint;

for k:=1 to n do

if (ik)and(jk) then

begin

if (vis[j]='0')and(f

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

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

├ 测试数据 14：答案正确... 134ms

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

├ 测试数据 16：答案正确... 134ms

├ 测试数据 17：答案正确... 166ms

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

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

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

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

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

没有优化的SPFA

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

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

├ 测试数据 16：答案正确... 41ms

├ 测试数据 17：答案正确... 103ms

├ 测试数据 18：答案正确... 103ms

├ 测试数据 19：答案正确... 103ms

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

用DP 还没有 大牛们 搜索 快…………

555…………