2015华为校园招聘机试模拟题及解答

1、模拟n个人参加选举的过程，并输出选举结果：假设候选人有四人，分别用“A”、”B”、”C”、”D”表示，选举时开始计票, 若输入的不是“A”、”B”、”C”、”D”则视为无效票。选举结束后获取各个候选人的得票数以及无效票的个数，输出结果以添加候选人的顺序进行顺序输出,最后一行为无效的数量。同时getVoteResult命令为结束命令。

输入为多行形式输入，每一行为一条命令。输入的命令只会是有效命令且不存在非法命令，但可能存在非法的投票，上面已经描述了。

添加候选人的命令如下：addCandidate为命令 xx1为候选人：addCandidate xx1

投票的命令如下：vote为命令 xx1为候选人的字符串：vote xx1

统计投票的命令如下：getVoteResult为命令：getVoteResult

void main()
{
std::string commond;
std::string add = "addCandidate";
std::string vote = "vote";
std::string getResult = "getVoteResult";
std::cin>>commond;
std::map<std::string,int> voteResult;
std::vector<std::string> candidate;
int useless = 0;
while(commond != getResult)
{
if(commond == add)
{
std::cin>>commond;
voteResult.insert(std::make_pair(commond,0));
candidate.push_back(commond);
}
if(commond == vote)
{
std::cin>>commond;
if(voteResult.count(commond) != 0)
voteResult[commond]++;
else
useless++;
}
std::cin>>commond;
}
std::vector<std::string>::iterator iter = candidate.begin();
while(iter != candidate.end())
{
std::string can = *iter;
std::cout<<can<<" "<<voteResult.find(can)->second<<std::endl;
iter++;
}
std::cout<<useless<<std::endl;
//system("pause");
}

2、描述:输入一串数字，找到其中包含的最大递增数。递增数是指相邻的数位从小到大排列的数字。如： 2895345323，递增数有：289，345，23, 那么最大的递减数为345。运行时间限制:无限制内存限制:无限制输入:输入一串数字，默认这串数字是正确的，即里面不含有字符/空格等情况输出:输出最大递增数样例输入:123526897215样例输出:2689

bool isLarger(std::string first,std::string second)
{
int firstLen = first.length();
int secondLen = second.length();

if(firstLen != secondLen)
return firstLen > secondLen;
else
{
int i = 0;
while(i < firstLen && first.at(i) == second.at(i))
++i;
if(i < firstLen)
return first.at(i) > second.at(i);
else
return false;
}
}
void main()
{
std::string number;
std::cin>>number;
int length = number.length();
std::string maxNum = "0";
int start = 0;
int end = 0;
for(int i = 1; i < length;++i)
{
while(i < length && number.at(i) > number.at(i -1))
i++;

end = i - 1;
std::string subStr = number.substr(start,end - start + 1);
if(isLarger(subStr,maxNum))
{
maxNum = subStr;
}
start = i;
end = i;
}
std::cout<<maxNum<<std::endl;
//system("pause");
}

在n*m字符迷宫中寻找指定单词，单词需在迷宫中连续出现，存在返回YES，否则返回NO，

bool foundWord(char* matrix,int n,int m,int i, int j,std::string words,int k)
{
if(k == words.length())
return true;
if(i - 1 > -1)
{
if(*(matrix + (i-1) * m + j) == words.at(k))
{
return foundWord(matrix,n,m,i - 1,j,words,k + 1);
}
}
if(i + 1 < n)
{
if(*(matrix + (i+1) * m + j) == words.at(k))
{
return foundWord(matrix,n,m,i + 1,j,words,k + 1);
}
}
if(j - 1 > -1)
{
if(*(matrix + i * m + j - 1) == words.at(k))
{
return foundWord(matrix,n,m,i,j - 1 ,words,k + 1);
}
}
if(j + 1 < m)
{
if(*(matrix + i * m + j + 1) == words.at(k))
{
return foundWord(matrix,n,m,i,j + 1,words,k + 1);
}
}
return false;
}
void main()
{
int n = 0;
int m = 0;
std::string words;
int length = words.length();
std::cin>>n>>m;
std::cin>>words;
char *matrix = new char[n * m];
for(int i = 0; i < n; i++)
{
for(int j = 0; j < m; j++)
{
std::cin>>*(matrix + i * m + j);
}
}
int i = 0;
int j = 0;
bool found = false;

for(i = 0;!found && i < n; ++i)
{
for(j = 0; !found && j < m; ++j)
{
if(*(matrix + i * m + j) == words.at(0))
{
found = true;
}
}
}
if(!found)
{
std::cout<<"NO";
return;
}
if(foundWord(matrix,n,m,i,j,words,1))
std::cout<<"YES";
else
std::cout<<"NO";

system("pause");
}

上一个代码中存在一个明显的问题，就是假设首个字母出现多次的情形下，无法正常判断

typedef struct _position
{
int col;
int row;
_position()
{
col = -1;
row = -1;
}
_position(int r,int c)
{
row = r;
col = c;
}

}Position,*PositionPtr;

void main()
{
//新的思路，记录单词字母对应的矩阵下标，判断其是否连成链
//关键问题，如何进行存储，
//由于一个字符可能对应多个下标，选择使用multimap进行存储<key,value1><key,value2>
int n = 0;
int m = 0;
std::string words;
int length = words.length();
std::cin>>n>>m;
std::cin>>words;
std::multimap<char,Position> record;
typedef std::multimap<char,Position>::size_type map_size;
for(int i = 0; i < words.length(); i++)//记录所有字母
{
record.insert(std::make_pair(words.at(i),Position(-1,-1)));
}

char *matrix = new char[n * m];
for(int i = 0; i < n; i++)
{
for(int j = 0; j < m; j++)
{
std::cin>>*(matrix + i * m + j);
}
}
for(int i = 0; i < n; i++)
{
for(int j = 0; j < m; j++)
{
map_size entries = record.count(*(matrix + i * m + j));//字符在multimap中的个数
if(entries != 0)
{
record.insert(std::make_pair(*(matrix + i * m + j),Position(i,j)));//记录单词字母在矩阵中的位置
}
}
}
//记录的位置<-1,-1>,<真实位置>
//对记录进行查找，并判断是否连续，如何进行判断
//使用栈操作，将多个可行节点入栈
std::pair<int,Position> stack[10];//int 是word中下标， Positiono下标字母对应坐标
int top = 0;//指向栈顶
map_size count = record.count(words.at(0));
std::multimap<char,Position>::iterator iter = record.find(words.at(0));
iter++;//首个为<-1,-1>
for(map_size cnt = 1; cnt != count; cnt++,iter++)
{
int col = iter->second.col;
int row = iter->second.row;
stack[top++] = std::make_pair(0,Position(row,col));
}

while(top != 0)//堆栈操作
{
std::pair<int,Position> cur = stack[--top];//栈顶元素输出
int index = cur.first;
if(index == words.length() - 1)//表示当前栈元素已经遍历到单词的尾端
{
std::cout<<"YES"<<std::endl;
system("pause");
return;
}
Position cur_pos = cur.second;

map_size count = record.count(words.at(index + 1));
std::multimap<char,Position>::iterator iter = record.find(words.at(index + 1));
iter++;
for(map_size cnt = 1; cnt != count; cnt++,iter++)
{
int col = iter->second.col;
int row = iter->second.row;
if(std::abs(col - cur_pos.col) + std::abs(row - cur_pos.row) == 1)//当前单词与上一单词邻近
stack[top++] = std::make_pair(index + 1,Position(row,col));
}
}
std::cout<<"NO"<<std::endl;
system("pause");
}