VijosNT Mini 2.0.5.7 Special for Vijos 

编译通过... 

├ 测试数据 01：运行时错误... (0ms, 19272KB) 

堆栈溢出 

├ 测试数据 02：答案正确... (0ms, 2908KB) 

├ 测试数据 03：答案正确... (0ms, 2908KB) 

├ 测试数据 04：答案正确... (0ms, 2908KB) 

├ 测试数据 05：答案正确... (0ms, 2908KB) 

├ 测试数据 06：答案正确... (0ms, 2908KB) 

├ 测试数据 07：答案正确... (0ms, 2908KB) 

├ 测试数据 08：答案正确... (0ms, 2908KB) 

├ 测试数据 09：答案正确... (0ms, 2908KB) 

├ 测试数据 10：答案正确... (0ms, 2908KB) 

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

Unaccepted / 90 / 0ms / 2908KB 

这是为什么T^T

这题DP蛮简单的，一维就可以了，再写个递归搞定！ 怎么没人来类。

var

i,n,m,root,z:longint;

l,r,w,f,opt:array [1..200000] of longint;

function ccl(a,b,opt:longint):longint;

begin

case opt of

1: exit(a and b);

2: exit(a or b);

3: exit(a xor b);

end;

end;

procedure dfs(v:longint);

var j1,j2,f1,f2,min:longint;

begin

if l[v]=0 then exit;

dfs(l[v]);

dfs(r[v]);

w[v]:=ccl(w[l[v]],w[r[v]],opt[v]);

min:=maxlongint;

for j1:=0 to 1 do

for j2:=0 to 1 do

if ccl(j1,j2,opt[v])w[v] then

begin

if j1=w[l[v]] then f1:=0 else f1:=f[l[v]];

if j2=w[r[v]] then f2:=0 else f2:=f[r[v]];

if f1+f2

对于30%的数据，1

为什么我看不懂题..

一次ac真的不好意思了，水题

树形dp

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

hehe

2次ac,读入都错了……

有一段时间不做题了，结果一上手差点想放弃……

怎么样避免低级错误呀呀

***|\**|\**|\**|\**|以上是废话\**|\**|\**|\**|\**|\**|\**|*

我看到下面几位一种一种的枚举，我觉得是很糜烂的！！

可以枚举子树的状态么，然后判断一下是否改变了输出值，再递归做进去

程序55行，不知各位觉得怎样。

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

树形动规

编译通过...

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

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

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

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

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

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

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

├ 测试数据 08：运行时错误...|错误号: -1073741571

├ 测试数据 09：运行时错误...|错误号: 170

├ 测试数据 10：运行时错误...|错误号: -1073741571

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

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

数组少打一个0出这种错误...

vijos你怎么报错的啊害我交了4次..

谁帮我看看为什么错两个点啊？

编译通过...

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

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

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

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

├ 测试数据 05：答案错误...

　├ 标准行输出 3

　├ 错误行输出 2

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

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

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

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

├ 测试数据 10：答案错误...

　├ 标准行输出 5

　├ 错误行输出 1

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

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

Program Raoyu;

Const MaxN=140000;

Var L,R,W:Array[1..MaxN]of Longint;

A:Array[1..MaxN]of Boolean;

N,M,I,J,X,Y,Root:Longint;

Function Calc(X:Longint):Boolean;

Begin

If(L[X]=0)And(R[X]=0)Then

Exit(A[X]);

Case W[X] of

1:A[X]:=Calc(L[X]) And Calc(R[X]);

2:A[X]:=Calc(L[X]) Or Calc(R[X]);

3:A[X]:=Calc(L[X]) Xor Calc(R[X]);

End;

Exit(A[X]);

End;

Function Min(A,B:Longint):Longint;

Begin

If(A

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

A了，YEAH

看题目要半天

看懂了题意,发现是基础树规

那个zMS没用

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

好慢啊~

巨丑的记忆化

int search(int num,bool t)

{

if(f[num][t]!=-1) return f[num][t];

if(a[num].typ==1){

if(t)

f[num][t]=search(a[num].lef,1)+search(a[num].rig,1);

else{

f[num][t]=min(search(a[num].lef,1)+search(a[num].rig,0),

search(a[num].lef,0)+search(a[num].rig,1));

f[num][t]=min(search(a[num].lef,0)+search(a[num].rig,0),f[num][t]);

}

return f[num][t];

}

if(a[num].typ==2){

if(!t)

f[num][t]=search(a[num].lef,0)+search(a[num].rig,0);

else{

f[num][t]=min(search(a[num].lef,1)+search(a[num].rig,0),

search(a[num].lef,0)+search(a[num].rig,1));

f[num][t]=min(search(a[num].lef,1)+search(a[num].rig,1),f[num][t]);

}

return f[num][t];

}

else{

if(!t)

f[num][t]=min(search(a[num].lef,1)+search(a[num].rig,1),

search(a[num].lef,0)+search(a[num].rig,0));

else

f[num][t]=min(search(a[num].lef,0)+search(a[num].rig,1),

search(a[num].lef,1)+search(a[num].rig,0));

return f[num][t];

}

}

tree DP

不错的题,虽然很基础

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

├ 测试数据 09：运行超时|无输出...

├ 测试数据 10：运行超时|无输出...

编译通过...

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

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

　├ 错误行输出

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

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

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

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

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

　├ 错误行输出

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

　├ 错误行输出

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

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

　├ 错误行输出

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

Unaccepted 有效得分：60 有效耗时：41ms

？？？？？？？？

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

竟然……我不允许这个错误！！！！！

那就是

AND 与 XOR 看反了！！！！！

其实很简单

两次递归搞定：

用F表示改变第I个元件需要最少次数；

如果I是AND那么

子女原信息都是0：F：=F[LEFT]+F[RIGHT]；

~~~~~~~~~1：F：=MIN（F[LEFT]，F[RIGHT]）；

有一个是一：取是0的那个；

如果是OR：这个自己推，与AND差不多，反一下；

如果是XOR：F：=MIN（F[LEFT]，F[RIGHT]；

先递归求出原信息，在记忆化求F[ROOT]；

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

一开始彻底把题目看错了。好郁闷。