今日头条2017后端工程师实习生笔试题

魔法权值

给出 n 个字符串，对于每个 n 个排列 p，按排列给出的顺序(p[0] , p[1] … p[n-1])依次连接这 n 个字符串都能得到一个长度为这些字符串长度之和的字符串。所以按照这个方法一共可以生成 n! 个字符串。

一个字符串的权值等于把这个字符串循环左移 i 次后得到的字符串仍和原字符串全等的数量，i 的取值为 [1 , 字符串长度]。求这些字符串最后生成的 n! 个字符串中权值为 K 的有多少个。

注：定义把一个串循环左移 1 次等价于把这个串的第一个字符移动到最后一个字符的后面。

1、模拟过程：位移后不变的情况数为K的字符串个数。

2、全排列：next_permutation(pos.begin(), pos.end())，注意写法do-while。

3、对于位移后字符串的比较直接循环就好了，不必真正的去构造位移后的字符串。

Reference：全排列

http://zh.cppreference.com/w/cpp/algorithm/next_permutation

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
bool isEqual(string &str, int offset, int &len) {
if (offset == len)  return true;
for(int i=offset,j=0;i<len;++i,++j){//位移后的字符串开始
if(str[i]!=str[j])  return false;
}
for(int i=len-offset,j=0;i<len;++i,++j){//
if(str[i]!=str[j])  return false;
}
return true;
}
//结果求取
int getResult(vector<string> &v, int &n, int &k) {
int A = 1, n0 = n;
while (n0 != 1) {
A *= n0;
--n0;
}
vector<vector<int>> vA(A);
vector<string> vsA(A);
vector<int> pos(n);
for (int i = 0;i < n;++i) {
pos[i] = i;
}
int i = 0;
//全排列
do {
for (const int &im : pos) {
vA[i].push_back(im);
}
++i;
} while (next_permutation(pos.begin(), pos.end()));
//全排列转换为相应字符串
for (i = 0;i<A;++i) {
string str;
for (int j = 0;j<n;++j) {
str.append(v[vA[i][j]]);
}
vsA[i] = str;
}
//judge
int sz = vsA[0].length(), res{ 0 };
for (i = 0;i<A;++i) {
int kvalue = 1;
for (int j = 1;j<sz;++j) {
if (vsA[i][j] == vsA[i][0] && isEqual(vsA[i], j, sz)) {
++kvalue;
}
}
if (kvalue == k)    ++res;
}
return res;
}
int main() {
int n, k;
while (cin >> n >> k) {
vector<string> v(n);
for (int i = 0;i<n;++i) {
cin >> v[i];
}
cout << getResult(v, n, k) << endl;
}
return 0;
}

最大映射

有 n 个字符串，每个字符串都是由 A-J 的大写字符构成。现在你将每个字符映射为一个 0-9 的数字，不同字符映射为不同的数字。这样每个字符串就可以看做一个整数，唯一的要求是这些整数必须是正整数且它们的字符串不能有前导零。现在问你怎样映射字符才能使得这些字符串表示的整数之和最大？

1、学会权重解决贪心问题。个位+1，百位+100。

2、让map根据关键字降序排列。

multimap<ULL, int,greater<ULL>> mNum;//降序排列

3、权重*映射值。

#define ULL unsigned long long
#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <functional>
using namespace std;
ULL getMaxSum(vector<string> &vs, int &n) {
ULL hash[10]{ 0 };//weight
for (int i = 0;i<n;++i) {//计算权重
ULL k = 1;
for (auto iter = vs[i].rbegin();iter != vs[i].rend();++iter) {
hash[*iter - 65] += k;
k *= 10;
}
}
multimap<ULL, int,greater<ULL>> mNum;//降序排列
for (int i = 0;i<10;++i) {
mNum.insert({ hash[i],0 });
}
int i = 9;
for (auto iter = mNum.begin();iter != mNum.end();++iter) {//权重赋值
iter->second = i--;
}
ULL nhash[10]{ 0 };//tran number
for (i = 0;i<10;++i) {
for (auto beg = mNum.lower_bound(hash[i]), end = mNum.upper_bound(hash[i])
;beg != end;++beg) {
if (beg->second != -1) {
nhash[i] = beg->second;
beg->second = -1;
break;
}
}
}
int fitHash[10]{ 0 };
//前导0问题
for (i = 0;i<10;++i) {
fitHash[i] = nhash[i];
}
for (i = 0;i<n;++i) {
fitHash[vs[i][0] - 65] = 10;
}
int minPos = 10, minVal = 10;
for (i = 0;i<10;++i) {
if (fitHash[i] != 10 && fitHash[i]<minVal) {
minVal = fitHash[i];
minPos = i;
}
}
if (minVal) {
for (i = 0;i<10;++i) {
if (nhash[i]<minVal) {
++nhash[i];
}
}
nhash[minPos] = 0;
}
ULL res{ 0 };
for (i = 0;i<10;++i) {//求和：权重乘以映射值，免去重复扫描字符串
res += hash[i]*nhash[i];
}
return res;
}
int main() {
int n;
while (cin >> n) {
vector<string> vs(n);
for (int i = 0;i<n;++i) {
cin >> vs[i];
}
cout << getMaxSum(vs, n) << endl;
}
return 0;
}

木棒拼图

有一个由很多木棒构成的集合，每个木棒有对应的长度，请问能否用集合中的这些木棒以某个顺序首尾相连构成一个面积大于 0 的简单多边形且所有木棒都要用上，简单多边形即不会自交的多边形。

初始集合是空的，有两种操作，要么给集合添加一个长度为 L 的木棒，要么删去集合中已经有的某个木棒。每次操作结束后你都需要告知是否能用集合中的这些木棒构成一个简单多边形。

不得不说，这是我这套题中唯一按时完成的一题。

1、sum，可以在数据插入的时候解决。不必最后求取。

2、mset.erase(iter);set除了支持关键字删除，还可以迭代器删除，可以传入一个或是一对。

3、sum-max_len>max_len即符合要求。

4、相比我之前使用的vector要好太多。

#include <iostream>
#include <set>
using namespace std;
bool judge(multiset<int> &mset,int &sum){
if(mset.size()<3){
return false;
}
auto iter=mset.rbegin();
if(sum-*iter<=*iter) return false;
else    return true;
}

int main(){
int n;
while(cin>>n){
multiset<int> mset;
int i,l,sum=0;
for(int j=0;j<n;++j){
cin>>i>>l;
if(i==1){
mset.insert(l);
sum+=l;
}
else{
auto iter=mset.find(l);
if(iter!=mset.end()){
mset.erase(iter);
sum-=l;
}
}
if(judge(mset,sum)){
cout<<"Yes"<<endl;
}
else{
cout<<"No"<<endl;
}
}
}
return 0;
}

或与加

给定 x, k ，求满足 x + y = x | y 的第 k 小的正整数 y 。 | 是二进制的或(or)运算，例如 3 | 5 = 7。

比如当 x=5，k=1时返回 2，因为5+1=6 不等于 5|1=5，而 5+2=7 等于 5 | 2 = 7。

这一题，我怎么写都超时，直到看了别人的代码，才发现，自己活该超时。

1、寻找规律，其实y的bit位的1就出现在x的bit位不为1的地方，将这些置位对应为排列起来便是普通的1、2、3….

2、如何利用这些规律？其实我本来已经找到了这个规律，但是我想到的还是加比如5，y=0，y+=2,y+=6,y+=2,y+=6交叉加k次。结果超时。

3、我们要将规律转化为位运算，既然我们是通过位的变化找到的规律，那么我们一定可以通过位运算获取结果。

4、结果的位变化全部发生在x的非置位上面，并且是正常的进位，与k同步，那么我们可以将k的值放在对应x的非置位位上面，其余位置0。

#include <iostream>
#include <vector>
using namespace std;
unsigned long long getY(unsigned long long &x,unsigned long long &k){
unsigned long long ans=0,bitNum=1;
//bitNum表示bit位
while(k){
if(!(x&bitNum)){//非置位位
ans+=(bitNum*(k&1));//获取k的最低位
k>>=1;
}
bitNum<<=1;
}
return ans;
}
int main(){
unsigned long long x,k;
while(cin>>x>>k){
cout<<getY(x,k)<<endl;
}
return 0;
}