月模拟题

CSP201604-3路径解析
解题过程
题面有些难读很容易就理解错了题意
在处理需要规范化的路径时，如果输入的路径如果是相对路径，将当前路径加到它的前面使其变为绝对路径，并在path末尾加上/以便后续分割路径。使用vector型变量spath存放当前处理的字符串的每一部分。
对path进行遍历，若当前遍历到的字符是/，则访问下一个字符直到找到不是/的字符或者遍历结束，如果找到则将/之后的内容提取出来，存放到string变量part中，并记录此时遇到的/的位置。如果part等于…，则将最晚进入spath的元素取出，即返回上一级目录，使用vector而不是stack是方便后续的路径输出；若part不等于.说明part是规范的，就将part放入spath中，持续分割路径。最后将spath的每一部分用/间隔输出。

#include<iostream>
#include<cstring>
#include<vector>
using namespace std;

vector<string> spath;

int main()
{
	int n;			
	string path;	
	string nowpath;	//当前目录
	cin >> n;
	cin >> nowpath;
	getchar();		
	for(int k=0;k<n;k++)
	 {
		getline(cin, path);
		if (path == "") {//空串
			cout << nowpath << endl;
			continue;
		}
		if (path[0] != '/')//相对路径
			path = nowpath + "/" + path;
			
		int len = path.length();
	     path += "/";
	     string part;
	     int i=0;
	    while(i < len) {
	    	i++;
		  while (i < len && path[i] == '/')//寻找第一个文件（夹）名
		    i++;
		   if (i == len)
			break;
		int index = path.find('/', i);//找下一个/的位置
		part = path.substr(i, index - i);
		i = index;
		if (part == "..") 
		{//返回上一级目录
			if (!spath.empty())
				spath.pop_back();
		}
		else if(part != ".")
			spath.push_back(part);
	}
		
		if (!spath.size())
			cout << '/';
		else
			for (int j=0;j<spath.size();j++)
				cout << "/" << spath[j];
		cout << endl;
		spath.clear();
	}
	return 0;
}

炉石传说
解题过程
该模拟题中一共有3种操作，summon召唤随从，attack随从攻击，end结束回合切换玩家，有两个玩家。用结构体表示角色状态有属性血量hp和攻击力ack。用1个vector数组将两个玩家的信息包括英雄与随从分别储存。然后通过循环来模拟实现游戏规则。在vector数组中两个玩家对应的下标分别是0，1，可以通过异或操作方便地进行切换。
体会
模拟题需要读题并且细心，不然就会出现一些很难找到的问题以至于严重影响心态。

#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
struct state
{ int hp;
  int ack;	
 } ;
 int n,s,now;
 char c[500];
 vector<state> pe[3];
 int main()
 { state one;one.ack=0;one.hp=30;
   pe[0].push_back(one);
   pe[1].push_back(one);
   now=0;
   cin>>n;
   while(n--)
   { scanf("%s",c);
     if(c[0]=='s')
     {int x,y,z;
      scanf("%d%d%d",&x,&y,&z);
      one.ack=y;one.hp=z;
	  pe[now].insert(pe[now].begin()+x,one);	
	 }
	 else if(c[0]=='a')
	 { int x,y,z;
	   scanf("%d%d",&x,&y);
	   pe[now][x].hp=pe[now][x].hp-pe[now^1][y].ack;
	   pe[now^1][y].hp=pe[now^1][y].hp-pe[now][x].ack;
	   if(pe[now][x].hp<=0)
	   pe[now].erase(pe[now].begin()+x);		
	   if(pe[now^1][y].hp<=0&&y!=0)
	   pe[now^1].erase(pe[now^1].begin()+y);		
	 }
	 else if(c[0]=='e')
	 now=now^1;
   	  
	   } 	
 	  if(pe[0][0].hp<=0)
   	  cout<<"-1"<<endl;
   	  else if(pe[1][0].hp<=0)
   	  cout<<"1"<<endl;
   	  else if(pe[0][0].hp>0&&pe[1][0].hp>0)
   	  cout<<"0"<<endl;
   	  
   	  cout<<pe[0][0].hp<<endl;
   	  cout<<pe[0].size()-1<<" ";
      for(int i=1;i<pe[0].size();i++) 
	  cout<<pe[0][i].hp	<<" ";
	  cout<<endl;
	  cout<<pe[1][0].hp<<endl;
   	  cout<<pe[1].size()-1<<" ";
      for(int i=1;i<pe[1].size();i++) 
	  cout<<pe[1][i].hp	<<" ";
   	  return 0;
 	
 	
 }

元素选择器
代码描述
这道题是一个树形结构，每个节点可有多个孩子，一个元素是由id和标签组成，可以没有id。这道题只需要记算元素数量所以可以不用建立树结构。
节点node中，parnum表示该节点父节点文件中所在位置，num表示该节点文件中所在位置，level表示该节点的层数可以通过标签前的缩进…计算，tag储存标签。第一行的节点不存在父节点和层数。
由于该题目中的标签大小写不敏感所以将标签字符串转化为小写。filee函数用来处理输入，通过…的个数计算层数，截去所有的…获得标签如果标签后有空格说明id存在记录id，通过从当前层数向上寻找找到该节点上一层的元素即为父节点记录其行数作为parnum。
标签选择器与id选择器即在节点数值中遍历寻找对应的标签或id记录答案。
后代选择器需要找到满足B且B的祖先满足A的元素，其中A、B可能是不同的选择器。先将两个元素分开储存，再先寻找后代元素，如果找到开始通过父节点位置寻找该后代的祖先，如果祖先不是要求的祖先就找父节点的父节点
如果找到就记录答案，如果到根节点也没有找到就break。
最后按要求输出答案。

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


struct node {
	int num;
	int parnum;
	int level;
	string tag;
	string  id;
	
} Node[105];
int m, n;

string change(string s) //把大写字母变为小写
{
	int i = 0;
	while (s[i] != '\0') {
		if (s[i] >= 'A'&&s[i] <= 'Z') 
		{
			s[i] = s[i]-32;
		}
		i++;
	}
	return s;
}

void filee()
{
	for (int i = 1; i <= n; i++) {
		string s;
		getline(cin,s);  
		int level = 0;
		while (s[level] == '.') 
		{
			level++;
			
		}//计算..的个数记录层数level
		s.erase(0,level);//删掉..
		level = level / 2;//..两个一算 
		Node[i].level = level;
		Node[i].num = i;
		int pos;
		if ((pos = s.find(" ")) != -1) //有空格有id
		{
			Node[i].tag = change(s.substr(0, pos));
			Node[i].id = s.substr(pos + 1, s.length()-pos);
		}
		else {
			Node[i].tag = change(s);
			Node[i].id = "NULL";
		}
		for (int j = i- 1; j >= 0; j--)
		 {
			if (Node[j].level == level - 1) 
			{
				Node[i].parnum = j;
				break;
			}
		}
	}
 } 

int main()
{
	
	cin>>n>>m;
	Node[0].level = -1;
	Node[0].parnum = -1;
	getchar();
	filee();
	while (m--) 
	{
		string s;
		getline(cin, s);
		vector<int> ans;//储存答案 
		//后代选择器
		if (s.find(" ") != -1)
		 {
			int pos = 0, pre = 0;
			vector<string> ances;//记录祖先
			string child;
			while (s[pos] != '\0') {
				while (s[pos] != '\0'&&s[pos] != ' ') 
				{
					pos++;
				}
				if (s[pos] == '\0') {
					child = s.substr(pre, pos - pre);
				}
				else {
					ances.push_back(s.substr(pre, pos - pre));
					pre = pos + 1;
					pos = pre;
				}
			}
			
			for (int i = n; i >= 1; i--) 
			{
				//找到child
				if (Node[i].id == child || Node[i].tag == child) 
				{
					//遍历找祖先
					int now = Node[i].parnum;
					int j = ances.size() - 1;
					while (j >= 0)
					 {
					while (now != -1 && Node[now].id != ances[j] && Node[now].tag != ances[j]) 
						{
							now = Node[now].parnum;
						}
						if (now == -1)
							break;
						j--;
						now = Node[now].parnum;
					}
					if (now == -1) 
					{
						break;
					}
					else if (j == -1) 
					{
						ans.push_back(i);
					}
						
				}
			}
		}
		else {
			//id选择器
			if (s[0] == '#') 
			{
				for (int i = 1; i <= n; i++) 
				{
					if (Node[i].id == s) 
						ans.push_back(i);
					
				}
			}
			//标签选择器
			else 
			{
				s = change(s);
				for (int i = 1; i <= n; i++) 
				{
					if (Node[i].tag == s) 
						ans.push_back(i);
					
				}
			}
		}
		cout << ans.size() << " ";
		sort(ans.begin(), ans.end());
		for (int i = 0; i < ans.size(); i++) {
			cout << ans[i] << " ";
		}
		cout << endl;
	}
	return 0;
}