zoj1022 Parallel Expectations(DP)

/*
这道题算不上难题，不过算得上的麻烦题了。
设状态 T[ i ][ j ] 为程序1执行i条指令，程序2执行j条指令后的变量平均值，P1为程序1指令i的概率，P2为程序2指令j的概率
则容易推出，T[ i ][ j ] = (T[ i-1 ][ j ]*P1+T[ i ][ j-1 ]*P2)/(P1+P2) 不过需要注意几点：
1.理解题意很重要，这个题很容易误解 。
如果认为每种指令执行的情况是一样的话，就会求错方程：(设N[ i ][ j ]为状态T[ i ][ j ]数量 )
P1 = N[ i-1 ][ j ]/N[ i ][ j ]
P2 = N[ i ][ j-1 ]/N[ i ][ j ]
下面是POJ discuss 离得解释，看了这个就会明白了。
Example :
Exactly one execution of the sample input results in S=8, and the
probability of that execution is not 1/C(8,4)=1/70, but (1/2)^4=1/16,
since the program automatically execute remaining operations.
It is true that there are 70 different executions, but not all of
them have the same probability.
正确的概率计算为：(设N1为程序1指令总条数，N2为程序2指令总条数 )
if ( i == N1 && j == N2 ) P1 = P[ i-1 ][ j ] ,P2 = P[ i ][ j-1 ]
if ( i < N1 && j == N2 ) P1 = P[ i-1 ][ j ] ,P2 = P[ i ][ j-1 ]/2
if ( i == N1 && j < N2 ) P1 = P[ i-1 ][ j ]/2,P2 = P[ i ][ j-1 ]
if ( i < N1 && j < N2 ) P1 = P[ i-1 ][ j ]/2,P2 = P[ i ][ j-1 ]/2
P[ i ][ j ] = P1 + P2
(囧，把P[ i-1 ][ j ]当成P1，P[ i ][ j-1 ]当成P2，WA了N次，关键是测试样例都没过，不过这题的数据有点弱的说，
样例一过，题马上就过了。)
2.实现起来有点麻烦，要是比赛，只能无题可做时才会做吧，因为这类似个小型的编译器了。
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))

char Command[ 2 ][ 26 ][ 65 ];

struct asmmble {
int  Varible1;
int  Varible2;
char Operator;
}Asmmble[ 2 ][ 105 ];

int Read( char Command[][ 65 ] )
{
int  List 	= 0;
char ch		= 0;
while ( 1 ) {
int  Count  = 0;
while ( ( ch = getchar() ) != '\n' ) {
while ( ch == ' ' ) ch = getchar();
Command[ List ][ Count ++ ] = ch;
}
Command[ List ][ Count ] = '\0';
if ( !strcmp( Command[ List ], "END" ) ) break;
if ( strcmp( Command[ List ], "" ) ) ++ List;
}
return List;
}

struct word {
int Start;
int End;
}Word[ 3 ];

struct varible {
char 	Name[ 21 ];
int 	Length;
double	Value;
bool    IsConst;
}Varible[ 155 ];

int Search( int& Number, char* String, int number )
{
for ( int i = 4 ; i < Number ; ++ i )
if ( Varible[ i ].Length == number && !strcmp( Varible[ i ].Name, String ) )
return i;
strcpy( Varible[ Number ].Name, String );
Varible[ Number ].Length  = number;
Varible[ Number ].IsConst = false;
Varible[ Number ].Value	  = 0.0;
return Number ++;
}

char Change( char ch )
{
if ( ch >= 'a' && ch <= 'z' )
return ch - 'a' + 'A';
return ch;
}

int searchVarible( char* Command, word Word, int& Number )
{
int  count = 0;
char String[ 21 ];
if ( Command[ Word.Start ] >= '0' && Command[ Word.Start ] <= '9' ) {
count = Command[ Word.Start ++ ]-'0';
while ( Word.Start <= Word.End ) {
count *= 10;
count += Command[ Word.Start ++ ]-'0';
}
strcpy( Varible[ Number ].Name, "0");
Varible[ Number ].Length	= 1;
Varible[ Number ].IsConst 	= true;
Varible[ Number ].Value		= count;
return Number ++;
}else {
int number = 0;
String[ number ++ ] = Change( Command[ Word.Start ++ ] );
while ( Word.Start <= Word.End )
String[ number ++ ] = Change( Command[ Word.Start ++ ] );
String[ number ] = '\0';
return Search( Number, String, number );
}
}

void commbine( int m, int n, int v1, int v2 ,char o3 )
{
Asmmble[ m ][ n ].Varible1 = v1;
Asmmble[ m ][ n ].Varible2 = v2;
Asmmble[ m ][ n ].Operator = o3;
}

void Operat( int n, int m, int XX, int YY, int ZZ, char O )
{
int R1 = 2*m+0;
int R2 = 2*m+1;
commbine( m, 4*n+1, R1, YY, ':' );
commbine( m, 4*n+2, R2, ZZ, ':' );
commbine( m, 4*n+3, R1, R2,  O  );
commbine( m, 4*n+4, XX, R1, ':' );
}

int FindChar( char* p, char O )
{
int count = 0;
while ( p[ count ] ) {
if ( p[ count ] == O )
return count;
++ count;
}
return -1;
}

int command( int machine, char Command[][ 65 ], int List, int Number )
{
for ( int i = 0 ; i < List ; ++ i ) {
int space1 = FindChar( Command[ i ], ':' );
int space2 = max( FindChar( Command[ i ], '+' ), FindChar( Command[ i ], '-' ) );
int space3 = strlen( Command[ i ] );
Word[ 0 ].Start = 0;		Word[ 0 ].End = space1-1;
Word[ 1 ].Start = space1+2; Word[ 1 ].End = space2-1;
Word[ 2 ].Start = space2+1; Word[ 2 ].End = space3-1;

int X = searchVarible( Command[ i ], Word[ 0 ], Number );
int Y = searchVarible( Command[ i ], Word[ 1 ], Number );
int Z = searchVarible( Command[ i ], Word[ 2 ], Number );

Operat( i, machine, X, Y, Z, Command[ i ][ space2 ] );
}
return Number;
}

void calculate( double* Var, asmmble Asm )
{
switch( Asm.Operator ) {
case ':':	Var[ Asm.Varible1 ]  = Var[ Asm.Varible2 ];break;
case '+':	Var[ Asm.Varible1 ] += Var[ Asm.Varible2 ];break;
case '-':	Var[ Asm.Varible1 ] -= Var[ Asm.Varible2 ];break;
}
}

int cmpstr( char* a, char* b, int n )
{
for ( int i = 0 ; i < n ; ++ i )
if ( a[ i ] != b[ i ] )
return a[ i ] - b[ i ];
return 0;
}

int cmp( const void* a, const void* b )
{
struct varible* p = (struct varible*)a;
struct varible* q = (struct varible*)b;
if ( p->IsConst == q->IsConst ) {
int value = cmpstr( p->Name, q->Name, min( p->Length, q->Length ) );
if ( !value )
return p->Length - q->Length;
else return value;
}else return q->IsConst - p->IsConst;
}

double M1[ 55 ],M2[ 55 ];
double P[ 105 ][ 105 ],P1,P2;
double T[ 101 ][ 101 ][ 35 ];

void dp( int number1, int number2, int count )
{
P[ 0 ][ 0 ] = 1.0;

for ( int k = 0 ; k < count ; ++ k )
if ( Varible[ k ].IsConst )
T[ 0 ][ 0 ][ k ] = Varible[ k ].Value+0.0;
else
T[ 0 ][ 0 ][ k ] = 0.0;

for ( int i = 1 ; i <= number1 ; ++ i ) {
P[ i ][ 0 ] = 0.5*P[ i-1 ][ 0 ];
for ( int k = 0 ; k < count ; ++ k )
T[ i ][ 0 ][ k ] = T[ i-1 ][ 0 ][ k ];
calculate( T[ i ][ 0 ], Asmmble[ 0 ][ i ] );
}

for ( int j = 1 ; j <= number2 ; ++ j ) {
P[ 0 ][ j ] = 0.5*P[ 0 ][ j-1 ];
for ( int k = 0 ; k < count ; ++ k )
T[ 0 ][ j ][ k ] = T[ 0 ][ j-1 ][ k ];
calculate( T[ 0 ][ j ], Asmmble[ 1 ][ j ] );
}

for ( int i = 1 ; i <= number1 ; ++ i )
for ( int j = 1 ; j <= number2 ; ++ j ) {
for ( int k = 0 ; k < count ; ++ k ) {
M1[ k ] = T[ i-1 ][ j ][ k ];
M2[ k ] = T[ i ][ j-1 ][ k ];
}
calculate( M1, Asmmble[ 0 ][ i ] );
calculate( M2, Asmmble[ 1 ][ j ] );

if ( i < number1 && j < number2 ) {
P1 = P[ i-1 ][ j ]/2;P2 = P[ i ][ j-1 ]/2;
}else if ( i < number1 ) {
P1 = P[ i-1 ][ j ];  P2 = P[ i ][ j-1 ]/2;
}else if ( j < number2 ) {
P1 = P[ i-1 ][ j ]/2;P2 = P[ i ][ j-1 ];
}else {
P1 = P[ i-1 ][ j ]  ;P2 = P[ i ][ j-1 ];
}
P[ i ][ j ] = P1 + P2;
//用 P[ i-1 ][ j ],P[ i ][ j-1 ] 代替 P1,P2的值了。。。
for ( int k = 0 ; k < count ; ++ k )
T[ i ][ j ][ k ] = (P1*M1[ k ]+P2*M2[ k ])/(P[ i ][ j ]);
}

for ( int k = 0 ; k < count ; ++ k )
Varible[ k ].Value = T[ number1 ][ number2 ][ k ];

qsort( &Varible[ 4 ], count-4, sizeof( Varible[ 0 ] ), cmp );

int start = 4;
while ( Varible[ start ].IsConst ) ++ start;
for ( int i = start ; i < count ; ++ i )
printf("%.4lf\n",Varible[ i ].Value);
}

void Initial( void )
{
for ( int k = 0 ; k < 4 ; ++ k ) {
Varible[ k ].IsConst = false;
Varible[ k ].Value 	 = 0.0;
}
}

int main()
{
int t,line1,line2,numb1,numb2;
while ( scanf("%d",&t) != EOF )
while ( t -- ) {
Initial();

line1 = Read( Command[ 0 ] );
line2 = Read( Command[ 1 ] );

numb1 = command( 0, Command[ 0 ], line1, 00004 );
numb2 = command( 1, Command[ 1 ], line2, numb1 );

dp( 4*line1, 4*line2, numb2 );
if ( t ) printf("\n");
}
return 0;
}