拼多多的笔试题目总结

拼多多笔试题目（没有参加只是自己看看）

第一题：思路大体能有

void  panduan(vector &A, vector B)
{
	//两次遍历的算法
	int lenA = A.size();
	int lenB = B.size();
	int gaibian = 0;
	for (int i = 0; i < lenA; ++i)//首先找到i表示这个数字需要改变
	{
		if (i == 0)
			continue;
		else
		{
			if (A[i - 1] > A[i])
			{
				gaibian = i;
				break;
			}
		}
	}
	//找到
	sort(B.begin(), B.end());
	int maxI=INT_MIN;
	//先判断是否能改变gaibian，然后判断是否能改变gaibian-1，这样可以保证最大
	for (int j = lenB-1; j < lenB; ++j)
	{
		//判断边界的一种方式
		if (B[j] > A[gaibian - 1] && (gaibian==lenA-1||B[j] < A[gaibian + 1]))
		{
			A[gaibian] = B[j];
			for (int i = 0; i < lenA; ++i)
			{
				if (i == lenA - 1)
					cout << A[i];
				else
					cout << A[i] << " ";
			}
			return;
		}		
	}
	for (int j = lenB - 1; j < lenB; ++j)
	{
		//判断边界的一种方式
		if (B[j] < A[gaibian] && (0==gaibian-1|| B[j] > A[gaibian-2]))
		{
			A[gaibian-1] = B[j];
			for (int i = 0; i < lenA; ++i)
			{
				if (i == lenA - 1)
					cout << A[i];
				else
					cout << A[i] << " ";
			}
			return;
		}
	}
	cout << "NO" << endl;
}

第二题

思路是使用回溯法

bool DFS_danci(vector& v_s,vector& flag,int count,string result)//有了单词的vector使用DFS进行遍历
{
	int len = v_s.size();
	int len_s = result.size();
	if (count == len)
	{
		//表明可以了，就把最后一个和第一个进行比较
		if (result[0] == result[len_s - 1])
			return true;
		else
			return false;
	}
	for (int i = 0; i < len; ++i)//开始一个个遍历
	{
		if (flag[i] == 0)//如果满足条件就进来，进行后续的遍历，不满足直接下一个
		{
			flag[i] = 1;
			if (result[len_s-1]==v_s[i][0]&&DFS_danci(v_s,flag,count+1,result+v_s[i]))
				return true;
			flag[i] = 0;
		}
	}
	return false;
}
int main() 
{
	vector v_s = { "TRUE","GNEDF","ENTG","FGTD" };
	int len_s = v_s.size();
	vector flag(len_s,0);
	int count = 0;
	string result;
	
	for (int i = 0; i < len_s; ++i)
	{
		flag[i] = 1;
		if (DFS_danci(v_s, flag, count + 1, result + v_s[i]))
		{
			cout << "可以" << endl;
			return 0;
		}
		flag[i] = 0;
	}
	cout << "不可以" << endl;
	cout << result << endl;
}

第三题

/class bijiao
{
public:
	bool operator()(pair a,pair b)
	{
		return a.first > b.first;	
	}
};
void tuopu_paixu(int numWorks, vector>& prq, vector shijian)//使用拓扑排序算法的代码是什么呢？？？？
{
	//建立映射的机制过程，最短作业优先算法，首先选择时间最短的进行相应的计算
	//先将入度存储起来
	int time_dangqian = 0;
	vector result;
	map zhouzhuanshijian;//每个事件的周转时间记录下来
	vector rudu(numWorks+1,0);//时间的长度也是从1开始的
	//使用优先队列的算法
	//从1开始进行相应的计算,现在所有的入度都已经计算好了
	for (auto pr : prq)//pr 是0则将表示入度，1出度
	{
		++rudu[pr[1]];
	}
	priority_queue, vector>, bijiao > res;
	//先把入度为0的进行
	for (int i = 1; i < numWorks; ++i)//入度的话需要怎么计算呢
	{
		if (rudu[i] == 0)//不需要排序
		{			
			res.push(pair(shijian[i],i) );
		}
	}
	while (!res.empty())//如果不为空的话我们就可以使用对应的
	{
		int temp =( res.top() ).second;
		res.pop();
		result.push_back(temp);
		time_dangqian = time_dangqian + shijian[temp];
		zhouzhuanshijian[temp] = time_dangqian;
		//这里要将时间排好序
		//如何使用这种排序呢
		//vector linshi(numWorks, 0);
		//multimap linshi;//有重复时间
		for (auto re : prq)
		{
			if (re[0] == temp)
			{
				--rudu[re[1]];
				//如何能找到最小的呢				
				if (rudu[re[1]] == 0)//选择对于每种时间的选择
					res.push(pair(shijian[re[1]], re[1]));
			}
			
		}
	}
	int result_1=0;
	for (int i = 1; i <= numWorks; ++i)
	{
		result_1 = result_1 + zhouzhuanshijian[i];
	}
	cout << result_1 << endl;
	cout << "得到的结果是" << endl;
	for (auto res : result)
		cout << res << endl;
}

第四题

关于金字塔的问题：题目就不写了，使用的是动态规划的算法来做的

class node
{
public:
	int l;
	int w;
	node(int len=0, int width=0):l(len),w(width) {};
};
//首先按照高度排序，如果高度一样就按照质量排序一下
bool comp(const node& a, const node& b)
{
	if (a.l == b.l)
		return a.w < b.w;
	else
		return a.l < b.l;
}
int jinzita(vector& nums)
{
	//合成一个pair的算法,遇到这种情况的话需要选择建立一个node节点来进行相应的
	//操作
	int len = nums.size();
	sort(nums.begin(), nums.end(), comp);
	//首先初始化以第i块为低高度为h的最小重量,这种题目一定是需要dp二维的数组的
	vector> dp(len,vector(len+1,-1));//
	int res=INT_MIN;
	dp[0][1] = nums[0].w;
	for(int i = 1; i < len; ++i)//i表示为第i个木板,并且重量是限制l的因素
	{
		dp[i][1] = nums[i].w;//高度为1
		for (int h = 2; h <= len; ++h)//对于每一种进行遍历
		{
			for (int j = i - 1; j >= 0; --j)//因为已经排好序了，所以在前面找d
			{
				if (dp[j][h - 1] != -1 && dp[j][h - 1] <= 2 * nums[i].w)
				{
					res = max(res, h);
					//更新一下dp状态
					if (dp[i][h] > dp[j][h - 1] + nums[i].w||-1==dp[i][h])//如果第一次条件得到满足了
						dp[i][h] = dp[j][h - 1] + nums[i].w;
				}
			}
		}
	}
	return res;
}