题目传送门(内部题90)


输入格式

  前四行依次表示每种属性:$Might$、$Speed$、$Sanity$、$Knowledge$。每行一个$8$位数表示该属性的$8$个档的值,第二个数表示初始在哪一档。
  第五行一个正整数$N$,表示事件数。
  接下来$N$行,每行表示一个事件,分为$2$大类,举例如下:
  $1$)
  直接生效的事件:
  $Speed\ +1$或$Speed\ -1$表示$Speed$属性值增加/减少一档。
  $Speed\ +2?$或$Speed\ -2?$表示$Speed$属性值增加/减少$2$个骰子的“判定”。
  $2$)
  通过“判定”决定是否生效的事件:
  $Speed<10\ Might\ +1$表示$Speed$的“判定”小于$10$的话,$Might$加$1$。
  $Speed>10\ Might\ +1?$表示$Speed$的“判定”大于$10$的话,$Might$增加$1$个骰子的“判定”。
  同样的,也有$>=$和$<=$的“判定”条件。


输出格式

  第一行一个数表示探险者中途退出探险的概率,百分比制,保留$2$位小数。
  接下来四行,每行$8$个数,表示最终探险者该属性值为$1\sim 8$的概率,百分比制,保留$2$位小数。注:如探险者任何时刻退出探险,游戏结束,所有属性值都视为$0$。


样例

样例输入1:

23345568 3
33346677 4
14445567 4
34456778 3
4
Might +1
Speed +1
Sanity -3
Knowledge +8

样例输出1:

0.00
0.00 0.00 0.00 100.00 0.00 0.00 0.00 0.00
0.00 0.00 0.00 0.00 0.00 100.00 0.00 0.00
100.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 100.00

样例输入2:

23345568 3
33346677 4
14445567 4
34456778 3
4
Might +1?
Speed -1?
Sanity -3
Sanity < 2 Knowledge -3

样例输出2:

66.67
0.00 0.00 11.11 11.11 11.11 0.00 0.00 0.00
0.00 0.00 22.22 11.11 0.00 0.00 0.00 0.00
33.33 0.00 0.00 0.00 0.00 0.00 0.00 0.00
0.00 0.00 0.00 33.33 0.00 0.00 0.00 0.00


数据范围与提示

对于$30\%$的数据,只有直接生效的事件,不存在“判定”,玩家没有退出探险。
对于$60\%$的数据,只有直接生效的事件。
对于$100\%$的数据,$N\leqslant 100$。
数据保证属性值条是单调不降的,初始值是合法的($1\sim 8$)。


题解

又是一道假期望,然而却是一道模拟……

开一个数组记录一下当前情况下所有的概率即可。

死亡概率就是$1-$其中一行的概率和。

但是我真心希望你不要把它打成这样$\downarrow$

而应该把它打成这样$\downarrow$

时间复杂度:$\Theta(65536\times n)$(根据打法不同各有不同,这个时间复杂度是我的打法的时间复杂度)。

期望得分:$100$分。

实际得分:$100$分。


代码时刻

我的极丑的代码:

#include<bits/stdc++.h>
using namespace std;
char ch[9];
int n,Map[5][9];
double dp[9][17],f[2][9][9][9][9],sum,ans[5][9];
bool now;
void pre_work()
{
dp[0][0]=1.0;
for(int i=0;i<8;i++)
for(int j=0;j<15;j++)
{
dp[i+1][j]+=dp[i][j];
dp[i+1][j+1]+=dp[i][j];
dp[i+1][j+2]+=dp[i][j];
}
for(int i=1;i<=8;i++)
for(int j=0;j<17;j++)
for(int k=0;k<i;k++)
dp[i][j]/=3.0;
}
void work1(int id,int opt)
{
now^=1;memset(f[now],0,sizeof(f[now]));
char c;
while(c<='0'||c>'9')c=getchar();
int val=c-'0';
c=getchar();bool fl=0;
if(c=='?')fl=1;
else val*=opt;
for(int i=1;i<=8;i++)
for(int j=1;j<=8;j++)
for(int k=1;k<=8;k++)
for(int l=1;l<=8;l++)
{
if(fl)
{
for(int g=0;g<=16;g++)
{
if(id==1&&i+g*opt>0)f[now][min(i+g*opt,8)][j][k][l]+=f[!now][i][j][k][l]*dp[val][g];
if(id==2&&j+g*opt>0)f[now][i][min(j+g*opt,8)][k][l]+=f[!now][i][j][k][l]*dp[val][g];
if(id==3&&k+g*opt>0)f[now][i][j][min(k+g*opt,8)][l]+=f[!now][i][j][k][l]*dp[val][g];
if(id==4&&l+g*opt>0)f[now][i][j][k][min(l+g*opt,8)]+=f[!now][i][j][k][l]*dp[val][g];
}
}
else
{
if(id==1&&i+val>0)f[now][min(i+val,8)][j][k][l]+=f[!now][i][j][k][l];
if(id==2&&j+val>0)f[now][i][min(j+val,8)][k][l]+=f[!now][i][j][k][l];
if(id==3&&k+val>0)f[now][i][j][min(k+val,8)][l]+=f[!now][i][j][k][l];
if(id==4&&l+val>0)f[now][i][j][k][min(l+val,8)]+=f[!now][i][j][k][l];
}
}
}
void work2(int id,int opt)
{
now^=1;memset(f[now],0,sizeof(f[now]));
int ju,son,num;bool fl=0;
scanf("%d%s",&ju,ch+1);
switch(ch[2])
{
case 'i':son=1;break;
case 'p':son=2;break;
case 'a':son=3;break;
case 'n':son=4;break;
}
char c=getchar();
while(c!='+'&&c!='-'&&c!='<'&&c!='>')c=getchar();
int opp=(c=='+')?1:-1;
while(c<='0'||c>'9')c=getchar();
int val=c-'0';
c=getchar();
if(c=='?')fl=1;
else val*=opp;
for(int i=1;i<=8;i++)
for(int j=1;j<=8;j++)
for(int k=1;k<=8;k++)
for(int l=1;l<=8;l++)
{
switch(id)
{
case 1:num=Map[1][i];break;
case 2:num=Map[2][j];break;
case 3:num=Map[3][k];break;
case 4:num=Map[4][l];break;
}
for(int pd=0;pd<=16;pd++)
{
bool hsw;
switch(opt)
{
case 3:hsw=(pd>ju);break;
case 4:hsw=(pd<ju);break;
case 5:hsw=(pd>=ju);break;
case 6:hsw=(pd<=ju);break;
}
if(hsw)
{
if(fl)
{
for(int g=0;g<=16;g++)
{
if(son==1&&i+g*opp>0)f[now][min(i+g*opp,8)][j][k][l]+=f[!now][i][j][k][l]*dp[val][g]*dp[num][pd];
if(son==2&&j+g*opp>0)f[now][i][min(j+g*opp,8)][k][l]+=f[!now][i][j][k][l]*dp[val][g]*dp[num][pd];
if(son==3&&k+g*opp>0)f[now][i][j][min(k+g*opp,8)][l]+=f[!now][i][j][k][l]*dp[val][g]*dp[num][pd];
if(son==4&&l+g*opp>0)f[now][i][j][k][min(l+g*opp,8)]+=f[!now][i][j][k][l]*dp[val][g]*dp[num][pd];
}
}
else
{
if(son==1&&i+val>0)f[now][min(i+val,8)][j][k][l]+=f[!now][i][j][k][l]*dp[num][pd];
if(son==2&&j+val>0)f[now][i][min(j+val,8)][k][l]+=f[!now][i][j][k][l]*dp[num][pd];
if(son==3&&k+val>0)f[now][i][j][min(k+val,8)][l]+=f[!now][i][j][k][l]*dp[num][pd];
if(son==4&&l+val>0)f[now][i][j][k][min(l+val,8)]+=f[!now][i][j][k][l]*dp[num][pd];
}
}
else f[now][i][j][k][l]+=f[!now][i][j][k][l]*dp[num][pd];
}
}
}
void read()
{
for(int i=1;i<=4;i++)
{
scanf("%s",ch+1);
for(int j=1;j<=8;j++)Map[i][j]=ch[j]-'0';
scanf("%d",&Map[i][0]);
}
f[0][Map[1][0]][Map[2][0]][Map[3][0]][Map[4][0]]=1.0;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%s",ch+1);
int id;switch(ch[2])
{
case 'i':id=1;break;
case 'p':id=2;break;
case 'a':id=3;break;
case 'n':id=4;break;
}
char c=getchar();
while(c!='+'&&c!='-'&&c!='<'&&c!='>')c=getchar();
if(c=='+')work1(id,1);
if(c=='-')work1(id,-1);
if(c=='>'){c=getchar();if(c==' ')work2(id,3);else work2(id,5);}
if(c=='<'){c=getchar();if(c==' ')work2(id,4);else work2(id,6);}
}
}
int main()
{
pre_work();
read();
for(int i=1;i<=8;i++)
for(int j=1;j<=8;j++)
for(int k=1;k<=8;k++)
for(int l=1;l<=8;l++)
{
sum+=f[now][i][j][k][l];
ans[1][Map[1][i]]+=f[now][i][j][k][l];
ans[2][Map[2][j]]+=f[now][i][j][k][l];
ans[3][Map[3][k]]+=f[now][i][j][k][l];
ans[4][Map[4][l]]+=f[now][i][j][k][l];
}
printf("%.2lf\n",(1-sum)*100);
for(int i=1;i<=4;i++,puts(""))
for(int j=1;j<=8;j++)printf("%.2lf ",ans[i][j]*100);
return 0;
}

Rorschach_XR的代码(仅供欣赏,请勿消费):

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
int lev[6][11],ini[6],n;
double res[15][105];
struct thing
{
int sk;
int op;
int num;
int consk,conp,conum;
}t[105];
double ans[6][11],dead;
int abss(int x)
{
return x>0?x:-x;
}
void pre()
{
res[1][0]=0.333333333333333;
res[1][1]=0.333333333333333;
res[1][2]=0.333333333333333;
res[2][0]=0.111111111111111;
res[2][1]=0.222222222222222;
res[2][2]=0.333333333333333;
res[2][3]=0.222222222222222;
res[2][4]=0.111111111111111;
res[3][0]=0.037037037037037;
res[3][1]=0.111111111111111;
res[3][2]=0.222222222222222;
res[3][3]=0.259259259259259;
res[3][4]=0.222222222222222;
res[3][5]=0.111111111111111;
res[3][6]=0.037037037037037;
res[4][0]=0.012345679012346;
res[4][1]=0.049382716049383;
res[4][2]=0.123456790123457;
res[4][3]=0.197530864197531;
res[4][4]=0.234567901234568;
res[4][5]=0.197530864197531;
res[4][6]=0.123456790123457;
res[4][7]=0.049382716049383;
res[4][8]=0.012345679012346;
res[5][0]=0.004115226337449;
res[5][1]=0.020576131687243;
res[5][2]=0.061728395061728;
res[5][3]=0.123456790123457;
res[5][4]=0.185185185185185;
res[5][5]=0.209876543209877;
res[5][6]=0.185185185185185;
res[5][7]=0.123456790123457;
res[5][8]=0.061728395061728;
res[5][9]=0.020576131687243;
res[5][10]=0.004115226337449;
res[6][0]=0.001371742112483;
res[6][1]=0.008230452674897;
res[6][2]=0.028806584362140;
res[6][3]=0.068587105624143;
res[6][4]=0.123456790123457;
res[6][5]=0.172839506172840;
res[6][6]=0.193415637860083;
res[6][7]=0.172839506172840;
res[6][8]=0.123456790123457;
res[6][9]=0.068587105624143;
res[6][10]=0.028806584362140;
res[6][11]=0.008230452674897;
res[6][12]=0.001371742112483;
res[7][0]=0.000457247370828;
res[7][1]=0.003200731595793;
res[7][2]=0.012802926383173;
res[7][3]=0.035208047553727;
res[7][4]=0.073616826703246;
res[7][5]=0.121627800640146;
res[7][6]=0.163237311385458;
res[7][7]=0.179698216735253;
res[7][8]=0.163237311385458;
res[7][9]=0.121627800640146;
res[7][10]=0.073616826703246;
res[7][11]=0.035208047553727;
res[7][12]=0.012802926383173;
res[7][13]=0.003200731595793;
res[7][14]=0.000457247370828;
res[8][0]=0.000152415790276;
res[8][1]=0.001219326322207;
res[8][2]=0.005486968449931;
res[8][3]=0.017070568510898;
res[8][4]=0.040542600213382;
res[8][5]=0.076817558299041;
res[8][6]=0.119493979576286;
res[8][7]=0.154854442920286;
res[8][8]=0.168724279835390;
res[8][9]=0.154854442920286;
res[8][10]=0.119493979576286;
res[8][11]=0.076817558299041;
res[8][12]=0.040542600213382;
res[8][13]=0.017070568510898;
res[8][14]=0.005486968449931;
res[8][15]=0.001219326322207;
res[8][16]=0.000152415790276;
}
int judge(char c1,char c2)
{
if(c1=='M')return 1;
else if(c1=='S'&&c2=='p')return 2;
else if(c1=='S'&&c2=='a')return 3;
else if(c1=='K')return 4;
return -1;
}
int isop(char s)
{
if(s=='+')return 1;
else if(s=='-')return -1;
return 0;
}
double dp[103][12][12][12][12];
#define Poss dp[x][n1][n2][n3][n4]
void work(int x,int n1,int n2,int n3,int n4)
{
if(t[x].op==1)
{
if(t[x].sk==1)
{
int nxt=min(n1+t[x].num,8);
if(nxt<=0)dead+=Poss;
else dp[x+1][nxt][n2][n3][n4]+=Poss;
}
else if(t[x].sk==2)
{
int nxt=min(n2+t[x].num,8);
if(nxt<=0)dead+=Poss;
else dp[x+1][n1][nxt][n3][n4]+=Poss;
}
else if(t[x].sk==3)
{
int nxt=min(n3+t[x].num,8);
if(nxt<=0)dead+=Poss;
else dp[x+1][n1][n2][nxt][n4]+=Poss;
}
else if(t[x].sk==4)
{
int nxt=min(n4+t[x].num,8);
if(nxt<=0)dead+=Poss;
else dp[x+1][n1][n2][n3][nxt]+=Poss;
}
}
else if(t[x].op==2)
{
if(t[x].sk==1)
{
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*res[abss(t[x].num)][i];
}
}
else if(t[x].sk==2)
{
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*res[abss(t[x].num)][i];
}
}
else if(t[x].sk==3)
{
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*res[abss(t[x].num)][i];
}
}
else if(t[x].sk==4)
{
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*res[abss(t[x].num)][i];
}
}
}
else if(t[x].op==3)
{
if(t[x].sk==1)
{
if(t[x].conp==1)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].conp==2)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].conp==3)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].conp==4)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n1+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
}
else if(t[x].sk==2)
{
if(t[x].conp==1)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].conp==2)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].conp==3)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].conp==4)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n2+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
}
else if(t[x].sk==3)
{
if(t[x].conp==1)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].conp==2)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].conp==3)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].conp==4)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n3+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
}
else if(t[x].sk==4)
{
if(t[x].conp==1)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].conp==2)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].conp==3)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].conp==4)
{
if(t[x].consk==1)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[1][n1]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==2)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[2][n2]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==3)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[3][n3]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].consk==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[4][n4]][i];
int nxt=min(8,n4+t[x].num);
if(nxt<=0)dead+=Poss*ok;
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok;
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
}
}
else if(t[x].op==4)
{
if(t[x].sk==1)
{
if(t[x].consk==1)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].consk==2)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].consk==3)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].consk==4)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n1+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][nxt][n2][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
}
else if(t[x].sk==2)
{
if(t[x].consk==1)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].consk==2)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].consk==3)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].consk==4)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n2+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][nxt][n3][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
}
else if(t[x].sk==3)
{
if(t[x].consk==1)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].consk==2)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].consk==3)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].consk==4)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n3+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][nxt][n4]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
}
else if(t[x].sk==4)
{
if(t[x].consk==1)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[1][n1];i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[1][n1]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].consk==2)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[2][n2];i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[2][n2]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].consk==3)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[3][n3];i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[3][n3]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
else if(t[x].consk==4)
{
if(t[x].conp==1)
{
double ok=0;
for(int i=t[x].conum+1;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==2)
{
double ok=0;
for(int i=t[x].conum;i<=2*lev[4][n4];i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==3)
{
double ok=0;
for(int i=0;i<=t[x].conum-1;i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
else if(t[x].conp==4)
{
double ok=0;
for(int i=0;i<=t[x].conum;i++)
ok+=res[lev[4][n4]][i];
for(int i=0;i<=abss(t[x].num)*2;i++)
{
int f=t[x].num>0?1:-1;
int nxt=min(n4+f*i,8);
if(nxt<=0)dead+=Poss*ok*res[abss(t[x].num)][i];
else dp[x+1][n1][n2][n3][nxt]+=Poss*ok*res[abss(t[x].num)][i];
}
dp[x+1][n1][n2][n3][n4]+=Poss*(1.0-ok);
}
}
}
}
} int main()
{
char str[105];pre();
for(int i=1;i<=4;i++)
{
scanf("%s",str+1);
int len=strlen(str+1);
for(int j=1;j<=len;j++)
lev[i][j]=str[j]-'0';
scanf("%d",&ini[i]);
}
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%s",str+1);
t[i].sk=judge(str[1],str[2]);
scanf("%s",str+1);
if(isop(str[1]))
{
int len=strlen(str+1);
if(str[len]!='?')t[i].op=1;
else t[i].op=2;
int x=0,j=2;
while(isdigit(str[j]))x=x*10+str[j]-'0',j++;
t[i].num=isop(str[1])*x;
}
else
{
int len=strlen(str+1);
if(len==1)
{
if(str[1]=='>')t[i].conp=1;
else if(str[1]=='<')t[i].conp=3;
}
else
{
if(str[1]=='>')t[i].conp=2;
else if(str[1]=='<')t[i].conp=4;
}
scanf("%s",str+1);
int x=0,j=1;
while(isdigit(str[j]))x=x*10+str[j]-'0',j++;
t[i].conum=x;
scanf("%s",str+1);
t[i].consk=judge(str[1],str[2]);swap(t[i].consk,t[i].sk);
scanf("%s",str+1);
len=strlen(str+1);
if(str[len]=='?')t[i].op=4;
else t[i].op=3;
x=0,j=2;
while(isdigit(str[j]))x=x*10+str[j]-'0',j++;
t[i].num=isop(str[1])*x;
}
}
dp[1][ini[1]][ini[2]][ini[3]][ini[4]]=1.0;
for(int x=0;x<=n;x++)
for(int now1=1;now1<=8;now1++)
for(int now2=1;now2<=8;now2++)
for(int now3=1;now3<=8;now3++)
for(int now4=1;now4<=8;now4++)
work(x,now1,now2,now3,now4); for(int now1=1;now1<=8;now1++)
for(int now2=1;now2<=8;now2++)
for(int now3=1;now3<=8;now3++)
for(int now4=1;now4<=8;now4++)
{
ans[1][lev[1][now1]]+=dp[n+1][now1][now2][now3][now4];
ans[2][lev[2][now2]]+=dp[n+1][now1][now2][now3][now4];
ans[3][lev[3][now3]]+=dp[n+1][now1][now2][now3][now4];
ans[4][lev[4][now4]]+=dp[n+1][now1][now2][now3][now4];
}
printf("%.2lf\n",dead*100);
for(int i=1;i<=4;i++)
{
for(int j=1;j<=8;j++)
printf("%.2lf ",ans[i][j]*100);
putchar('\n');
}
return 0;
}

rp++

[CSP-S模拟测试]:山屋惊魂(模拟)的更多相关文章

  1. [CSP-S模拟测试]:表达式密码(模拟)

    题目传送门(内部题87) 输入格式 从文件$expression.in$中读入数据.输入一行,一个字符串$S$,表示原表达式,保证为合法表达式 输出格式 输出到文件$expression.out$中. ...

  2. [CSP-S模拟测试]:天空龙(模拟)

    题目描述 奥西里斯之天空龙很喜欢颜色,有一天他找到了三种颜色——红黄蓝.奥西里斯有$a$个红色,$b$个黄色,$c$个蓝色,他想用画出最好的画,可是需要至少$x$个红色,$y$个黄色和$z$个蓝色,似 ...

  3. [CSP-S模拟测试]:折纸(模拟)

    题目描述 小$s$很喜欢折纸.有一天,他得到了一条很长的纸带,他把它从左向右均匀划分为$N$个单位长度,并且在每份的边界处分别标上数字$0\sim n$.然后小$s$开始无聊的折纸,每次他都会选择一个 ...

  4. [CSP-S模拟测试]:引子(大模拟)

    题目描述 网上冲浪时,$Slavko$被冲到了水箱里,水箱由上而下竖直平面.示意图如下: 数字$i$所在的矩形代表一个编号为$i$的水箱.1号水箱为水箱中枢,有水管连出.除了$1$号水箱外,其他水箱上 ...

  5. [CSP-S模拟测试]:Median(暴力+模拟)

    题目描述 定义两个数列: $$S=\{S(1),S(2),...,S(n)\}\text{和}S_2\{S_2(1),S_2(2),...,S_2(n)\}$$ $$S(k)=(p_k\times k ...

  6. [CSP-S模拟测试]:走格子(模拟+BFS+Dijkstra)

    题目描述 $CYJ$想找到他的小伙伴$FPJ$,$CYJ$和$FPJ$现在位于一个房间里,这个房间的布置可以看成一个$N$行$M$列的矩阵,矩阵内的每一个元素会是下列情况中的一种:$1.$障碍区域—这 ...

  7. [考试反思]1026csp-s模拟测试88:发展

    不用你们说,我自己来:我颓闪存我没脸. 昨天的想法, 今天的回答. 生存, 发展. 总分榜应该稍有回升,但是和上面的差距肯定还是很大. 继续. 为昨天的谬误,承担代价. T2和T3都值得张记性. T2 ...

  8. Android单元测试与模拟测试详解

    测试与基本规范 为什么需要测试? 为了稳定性,能够明确的了解是否正确的完成开发. 更加易于维护,能够在修改代码后保证功能不被破坏. 集成一些工具,规范开发规范,使得代码更加稳定( 如通过 phabri ...

  9. [开源]微信在线信息模拟测试工具(基于Senparc.Weixin.MP开发)

    目前为止似乎还没有看到过Web版的普通消息测试工具(除了官方针对高级接口的),现有的一些桌面版的几个测试工具也都是使用XML直接请求,非常不友好,我们来尝试做一个“面向对象”操作的测试工具. 测试工具 ...

随机推荐

  1. 【6.24校内test】T3 棠梨煎雪

    [题目背景] 岁岁花藻檐下共将棠梨煎雪. 自总角至你我某日辗转天边. 天淡天青,宿雨沾襟. 一年一会信笺却只见寥寥数言. ——银临<棠梨煎雪> [问题描述] 扶苏正在听<棠梨煎雪&g ...

  2. c语言小技巧:C语言学习笔记之位运算求余

    我们都知道,求一个数被另一个数整除的余数,可以用求余运算符”%“,但是,如果不 允许使用求余运算符,又该怎么办呢?下面介绍一种方法,是通过位运算来求余,但是注 意:该方法只对除数是2的N次方幂时才有效 ...

  3. python requests的content和text方法的区别【转】

    requests对象的get和post方法都会返回一个Response对象,这个对象里面存的是服务器返回的所有信息,包括响应头,响应状态码等.其中返回的网页部分会存在.content和.text两个对 ...

  4. LOCATE()和FIND_IN_SET()

    locate(substr,str) 查找substr在str中第一次出现的位置,为空时返回0 SELECT login_name, LOCATE('ning',login_name) FROM us ...

  5. mysql 函数GROUP_CONCAT(temp.amount SEPARATOR ',')的用法

    mysql 函数GROUP_CONCAT(temp.amount SEPARATOR ',')的用法 使用场景:例如:想要查询用户的最喜欢购买的几种商品,这个时候就需要使用group_concat(字 ...

  6. 使用html2canvas实现屏幕截图

    相关文件(vue3.0) <script src="https://cdn.jsdelivr.net/bluebird/latest/bluebird.js">< ...

  7. python 中if __name__ = '__main__' 的作用

    python 中if __name__ = '__main__' 的作用 前言 首先我们要知道在python里面万物皆对象,模块也是对象,并且所有的模块都有一个内置属性 __name__. 一个模块的 ...

  8. laravel 学习之第二章

    Controller Controller之Request 获取请求的值 namespace App\Http\Controllers; use Illuminate\http\Request; pu ...

  9. 深度学习优化器 optimizer 的选择

    网址:https://blog.csdn.net/g11d111/article/details/76639460

  10. php字符串大小写转换

    strtoupper().strtolower().ucfirst().ucfirst().ucwords().mb_strtoupper().mb_strtolower()和mb_convert_c ...