zoj 1022 Parallel Expectations

假设目前的状态是已经执行完程序1的第i条指令，并且执行完了程序2的第j条指令，那么记到达该状态的概率为p[i][j]

那么到达p[i][j]状态有两种可能，一种是程序1已经执行了i-1条指令，程序2执行了j条指令，另一种是程序1执行了i条指令，程序2执行了j-1条指令

所以我们有

if (i < p_line1&&j < p_line2){
	p1 = 0.5*prob[i - 1][j]; p2 =0.5* prob[i][j - 1];
}

else if (i < p_line1){//如果程序2全部执行完了，那么执行程序1的概率不变了

	p1 = prob[i - 1][j]; p2 = 0.5*prob[i][j - 1];
}
else if (j < p_line2){//如果程序1全部执行完了，那么执行程序2的概率不再变化
	p1 = prob[i - 1][j] * 0.5; p2 = prob[i][j - 1];
}
else{
	p1 = prob[i - 1][j]; p2 = prob[i][j - 1];
}
prob[i][j] = p1 + p2;

p_line1表示的是程序1的总指令条数，p_line2表示的程序2的总指令条数

源代码（附注释）如下：

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<cstdio>
using namespace std;

int t;
int number1, number2;
string word[3];
int line1, line2;

typedef struct{
	bool is_const;
	string name;
	double value;
}var;

typedef struct{
	int index1;
	int index2;
	char op;
}com;
com command[2][110];
var variable[150];
double prob[110][110],p1,p2,p;
double excute[110][110][40];

void resolve2(int aim,int source,int machine,char op,int current){
	command[machine][current].index1 = aim;
	command[machine][current].index2 = source;
	command[machine][current].op = op;
}

void resolve(int flag1,int flag2,int flag3,int machine,char op,int current){
	int R1 = 2 * machine;
	int R2 = 2 * machine + 1;
	resolve2(R1,flag2,machine,':',4*current+1);//记录每一条机器指令的操作数以及对应的操作符，便于后面的分析
	resolve2(R2,flag3,machine,':',4*current+2);
	resolve2(R1,R2,machine,op,4*current+3);
	resolve2(flag1,R1,machine,':',4*current+4);
}

int store_variable(string name,int &cur){
	if (name[0] >= '0'&&name[0] <= '9'){
		int value = 0;
		for (int i = 0; i < name.size(); i++){
			value = value * 10 + (name[i]-'0');
		}
		variable[cur].is_const = true;
		variable[cur].name = "const";
		variable[cur].value = value;
		return cur++;
	}
	else{
		for (int i = 0; i < cur; i++){
			if (variable[i].is_const) continue;
			if (variable[i].name == name) return i;
		}
		variable[cur].is_const = false;
		variable[cur].name = name;
		variable[cur].value = 0;
		return cur++;
	}
}

void init(){//variable中的前四个元素用来存储寄存器
	for (int i = 0; i < 4; i++){
		variable[i].is_const = true;
		variable[i].name = "Rx";
		variable[i].value = 0;
	}
}

int read_command(int machine,int& number3){//machine用来表示程序的编号
										  //number用来标识从第几个变量开始存储
	string s1;
	int lines = 0;
	while (getline(cin, s1)){
		if (s1 == "") continue;//如果当前读入的是回车字符，则继续读入
		if (s1 == "END")  break;
		string s="";
		for (int i = 0; i < s1.size(); i++){//去掉读入的字符串中的空格符，并且将所有的字母都统一成大写形式
			//便于后续的管理，注意题目中的Case insensitive
			if (s1[i] == ' ') continue;
			if (s1[i] >= 'a'&&s1[i] <= 'z'){
				s1[i] = toupper(s1[i]);
			}
			s+=s1[i];
		}
		lines++;
		int index1, index2, index3;
		for (int i = 0; i < s.size(); i++){
			if (s[i] == ':'){//记录冒号的位置
				index1 = i;
			}
			else if (s[i] == '+'||s[i]=='-'){//记录符号的位置
				index2 = i;
				break;
			}
		}
		word[0] = s.substr(0,index1);//提取变量名
		word[1] = s.substr(index1+2,index2-index1-2);
		word[2] = s.substr(index2+1);
		int flag1, flag2, flag3;
		flag1 = store_variable(word[0], number3);//如果变量在variabel数组中已经存在，那么就直接返回下标，否则就在variable中找一个位置存储
		//同时让variable中的已用长度增加1
		flag2 = store_variable(word[1], number3);
		flag3 = store_variable(word[2], number3);
		resolve(flag1, flag2, flag3, machine, s[index2],lines-1);//将每行代码翻译成为对应的四条机器指令
	}
	return lines;
}

void cal(double* temp11,int index, int machine){
	int index1 = command[machine][index].index1;
	int index2 = command[machine][index].index2;
	if (command[machine][index].op == ':'){
		temp11[index1] = temp11[index2];
	}
	else if (command[machine][index].op == '+'){
		temp11[index1] += temp11[index2];
	}
	else if (command[machine][index].op == '-'){
		temp11[index1] -= temp11[index2];
	}
}

bool compare(var a,var b){
	if (a.is_const != b.is_const) return a.is_const > b.is_const;
	else{
		return a.name < b.name;
	}
}

void dp(int p_line1,int p_line2){
	prob[0][0] = 1;
	for (int i = 0; i < number2; i++){//在所有代码开始执行之前保存已有的每一个常量和变量的值
		excute[0][0][i] = variable[i].value;
	}
	for (int i = 1; i <= p_line1; i++){//仅仅开始执行第一段程序的每一行所出现的结果都保存
		prob[i][0] = 0.5*prob[i-1][0];
		for (int k = 0; k < number2; k++) excute[i][0][k] = excute[i-1][0][k];
		cal(excute[i][0],i,0);
	}
	for (int j = 1; j <= p_line2; j++){//仅仅开始执行第二段程序的每一行所出现的结果都保存
		prob[0][j] = 0.5*prob[0][j-1];
		for (int k = 0; k < number2; k++) excute[0][j][k] = excute[0][j-1][k];
		cal(excute[0][j],j,1);
	}
	double temp1[40], temp2[40];//分析交叉执行的情况
	for (int i = 1; i <= p_line1; i++){
		for (int j = 1; j <= p_line2; j++){
			for (int k = 0; k < number2; k++){
				temp1[k] = excute[i - 1][j][k];
				temp2[k] = excute[i][j - 1][k];
			}
			cal(temp1, i, 0);
			cal(temp2, j, 1);
			if (i < p_line1&&j < p_line2){
				p1 = 0.5*prob[i - 1][j]; p2 =0.5* prob[i][j - 1];
			}
			else if (i < p_line1){
				p1 = prob[i - 1][j]; p2 = 0.5*prob[i][j - 1];
			}
			else if (j < p_line2){
				p1 = prob[i - 1][j] * 0.5; p2 = prob[i][j - 1];
			}
			else{
				p1 = prob[i - 1][j]; p2 = prob[i][j - 1];
			}
			prob[i][j] = p1 + p2;
			for (int k = 0; k < number2; k++){
				excute[i][j][k] = (p1*temp1[k] + p2*temp2[k]) / (prob[i][j]);
			}
		}
	}
	for (int k = 0; k < number2; k++){//利用variable保存交叉执行的最终结果
		variable[k].value = excute[p_line1][p_line2][k];
	}
	sort(variable+4,variable+number2,compare);//排序
	int start = 4;
	while (start < number2&&variable[start].is_const) start++;
	for (int i = start; i < number2; i++) printf("%.4lf\n",variable[i].value);//输出最终结果
}

int main(){
	cin >> t;//读入Case的数量
	string temp;
	getline(cin,temp);//消除回车符
	while (t--){
		init();//初始化，在所定义的variable中，前两个用作第一个程序的寄存器，后两个用作第二个程序的寄存器
		number1 = 4;//后面变量的记录从第四个开始
		line1 = read_command(0,number1);//开始读入第一个程序
		number2 = number1;
		line2 = read_command(1,number2);//开始读入第二个程序
		dp(4*line1,4*line2);//开始进行计算
		if (t) printf("\n");
	}
	return 0;
}