CCF 201903-4 消息传递接口

分析：

这次的出题老师貌似特别擅长操作系统，第三道才考磁盘阵列，第四道立刻又来了道死锁。本着默认第四道是图论或者DP的想法，看完题目觉得可能不会像表面那么简单，但是做完发现还真的只是道模拟题。

比较坑的是开始做题一直提交二十分，提示错误。仔细重新读题若干遍，又检查代码若干遍，不管如何改都是二十分。最后看了下别人满分的代码，按照他的思路写了下，提交四十分，遂又检查整个逻辑，确认逻辑完全一致后，提交前顺手删掉了禁止同步的语句，提交就ac了。再提交下原来的代码，同样可以ac，原来浪费这么久时间查错竟然只是禁用同步后同时使用了getchar和cin造成输出结果有所差异的。下面进入主题：

第一点需要注意的是，在用cin读取了T和n之后，直接用getline读下面的行会读到回车字符，一般情况下需要加上getchar（）去掉回车字符，但是如果要加上禁用同步的语句后便不能使用getchar（）了，可以使用cin.get()代替。

首先，确定存储，对于每组程序，会有n行，每行不超过8条指令，所以可以用string类型的二维数组存储。同时，再读入每行后，需要按空格分割下读入的命令。

const int maxn = 11005;
string task[maxn][9];
string s, str;
res = 0;
for (int i = 0; i < n; i++) {
    getline(cin, s);
    int p = 0, q = 0;
    while (p < s.size()) {
        if (s[p] == ' ') {
        task[i][q++] = str;
        str.clear();
        }
	else{
		str += s[p];
	}
	p++;
    }
    task[i][q] = str;
    str.clear();
    res += q + 1;
}

 然后就是逐行遍历指令集，看看有没有配对的指令。对于一条string类型的指令，比如0号进程的R1，需要1号进程的S0来配对。这里先介绍一种方法就是当指令的第一个字符不等，且后面对应的数字配对时指令才配对。这里要注意，进程的编号可能不止一位数，所以不能直接取字符串的第二位作为与之通信的进程编号，自己封装一个函数即可。

int findnum(string &s) {
	int p = 1, n = s.size(), ans = 0;
	while (p < n) {
		ans = ans * 10 + s[p++] - '0';
	}
	return ans;
}

 鉴于进程匹配的函数较为简单，直接给出再进行解释。

bool match(int cur) {
	string s = task[cur][pos[cur]];
	if (!s.size())	return false;
	int p = findnum(s);
	if (!task[p][pos[p]].size() || findnum(task[p][pos[p]]) != cur)	return false;
	if (s[0] == task[p][pos[p]][0])	return false;
	pos[cur]++, pos[p]++;
	res -= 2;
	if (p < cur)	while (match(p));
	return true;
}

 cur-当前遍历到的进程编号，pos[cur]当前进程遍历到的指令下标，s就是当前进程遍历到的指令了。p-需要寻找与之配对进程的编号。如果想要配对的进程p正在执行的指令不是在等待cur进程的消息或者两个进程收发消息方向一致（R-R，S-S）则不匹配，反之则匹配，指向两个进程正在运行指令下标的指针++。为了不从头多次遍历进程，当与cur配对成功的进程p小于cur，说明已经遍历过的进程还在往下指向，便需要继续执行p进程。总的代码如下：

方法一：

#include 
#include 
#include 
#include 
#include 
using namespace std;
int T, n;
const int maxn = 11005;
string task[maxn][9];
int pos[maxn];//进程执行到的位置
int res = 0;
int findnum(string &s) {//找到指令后面的编号
	int p = 1, n = s.size(), ans = 0;
	while (p < n) {
		ans = ans * 10 + s[p++] - '0';
	}
	return ans;
}
bool match(int cur) {//执行cur号进程能否成功
	string s = task[cur][pos[cur]];
	if (!s.size())	return false;//s为空说明遍历到指令末尾了
	int p = findnum(s);//与之通信的进程
	if (!task[p][pos[p]].size() || findnum(task[p][pos[p]]) != cur)	return false;
	if (s[0] == task[p][pos[p]][0])	return false;
	pos[cur]++, pos[p]++;
	res -= 2;//总指令数-2
	if (p < cur)	while (match(p));//已经遍历过的进程指针发生了移动
	return true;
}
int main() {
	ios::sync_with_stdio(false);
	cin >> T >> n;
	cin.get();
	while (T--) {
		string s, str;
		res = 0;
		for (int i = 0; i < n; i++) {
			getline(cin, s);
			int p = 0, q = 0;
			while (p < s.size()) {
				if (s[p] == ' ') {
					task[i][q++] = str;
					str.clear();
				}
				else
				{
					str += s[p];
				}
				p++;
			}
			task[i][q] = str;
			str.clear();
			res += q + 1;
		}
		for (int i = 0; i < n; i++) {
			while (match(i));//返回true继续执行，减少递归深度
		}
		
		if (res)	cout << "1" << endl;
		else
		{
			cout << "0" << endl;
		}
		for (int i = 0; i < n; i++) {
			fill(task[i], task[i] + sizeof(task[i]), "");//执行完一组程序给二维数组置空
		}
		memset(pos, 0, sizeof pos);
	}
	return 0;
}

注意：如果二维数组的maxn设为10005时，只能得80分，不知为啥会越界导致运行错误，所以开大点就能得100分了。 

方法二：

方法二则是直接用队列模拟该过程，不同的是处理S，R时，将R映射为0，S映射为1，直接将字符x（R or S） 减去'0'即可得到映射后的数。奇怪的是，这里的队列数组开10005并不会运行错误，可以直接ac。

#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
int T, n;
const int maxn = 10005;
struct node {
	int type;//S-1,R-0
	int need;//期望收到need号进程的消息
};
queue qu[maxn];
int findnum(string &s) {
	int p = 1,n = s.size(),ans = 0;
	while (s[p]) {
		ans = ans * 10 + (s[p++] - '0');
	}
	return ans;
}

int main() {
	ios::sync_with_stdio(false);
	cin >> T >> n;
	cin.get();
	while (T--){
		string s,str;
		for (int i = 0; i < n; i++) {
			getline(cin, s);
			int p = 0, q = 0;
			while (p < s.size()) {
				if (s[p] == ' ') {
					qu[i].push({ str[0] - 'R',findnum(str) });
					str.clear();
				}
				else
				{
					str += s[p];
				}
				p++;
			}
			qu[i].push({ str[0] - 'R',findnum(str) });
			str.clear();
		}
		int cnt;
		while (1) {
			cnt = 0;
			for (int i = 0; i < n; i++) {
				if (qu[i].empty())	continue;//当前进程已执行完成
				node u = qu[i].front();
				if (qu[u.need].empty())	break;
				node v = qu[u.need].front();
				if (u.type + v.type != 1 || v.need != i)	continue;
				qu[i].pop(), qu[u.need].pop();
				i--,cnt++;//i--为了继续执行i号进程
			}
			if (!cnt)	break;//一趟遍历没有减少指令数
		}
		bool flag = true;
		for (int i = 0; i < n; i++) {
			if (qu[i].size()) {
				cout << "1" << endl;
				flag = false;
				break;
			}
		}
		if (flag)	cout << "0" << endl;
		for (int i = 0; i < n; i++) {
			if (qu[i].size()) {
				qu[i] = queue();//队列置空
			}
		}
	}
	return 0;
}