1.飞行棋，输入K(距离)，N（掷骰子的次数），问最后飞行棋到终点的距离是多少？，需要返回多少次？（因为飞行棋如果超出终点的话会返回的）如果为0的话输出“paradox”。
        思路很简单，用初始距离挨个减去给的距离，如果是正数，continue；如果是0，break，输出paradox；如果是负数，回退次数加1，然后将距离取反。（好像只过了96%， 知道原因的大佬麻烦给解答一下。有大佬解答了，是因为当最后一步到达终点时，应该输出0而不是paradox）
输入：
10 2
6 3
输出：
1 0
因为6+3=9,10-9=1，还剩1步，且没有后退。 
#include<iostream>
#include<vector>

using namespace std;

int main()
{
	int len, step;
	cin >> len >> step;

	if (len == 0)
	{
		cout << "paradox" << endl;
		return 0;
	}

	vector<int> arr(step, 0);
	for (int i = 0; i < arr.size(); i++)
		cin >> arr[i];

	bool flag = false;
	int res = len;
	int back_step = 0;
	for (int i = 0; i < arr.size(); i++)
	{
		len -= arr[i];
		if (len < 0)
		{
			back_step++;
			len = -len;
		}
		else if (len == 0)
		{
			flag = true;
			break;
		}
		else
			continue;
	}

	if (flag)
		cout << "paradox" << endl;
	else
		cout << len << " " << back_step << endl;

	return 0;
}

2、两个骰子如果同类，则通过上下，左右，前后反转，它们都相同，求不同种类的骰子的数量各是多少？
输入：
2
1 2 3 4 5 6
1 2 6 5 3 4
输出
1
2

        思路：直接暴力，选定一个值，比如1，在给定骰子中找出1的位置，同时求出1上下左右的值，保存，然后取后面的骰子，也找出1的位置，求出1上下左右的值。然后对比两个骰子1的上下左右位置是否对应相等，旋转后相等也算相等。
        然后用一个数组记录已经被搜寻过的骰子，下次直接跳过。
代码： 
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

void aroundNum(vector<int> arr, vector<int> &res, int pos)
{
	if (pos == 0)
	{
		res[0] = arr[5];
		res[1] = arr[4];
		res[2] = arr[2];
		res[3] = arr[3];
	}
	else if (pos == 1)
	{
		res[0] = arr[4];
		res[1] = arr[5];
		res[2] = arr[2];
		res[3] = arr[3];
	}
	else if (pos == 2)
	{
		res[0] = arr[0];
		res[1] = arr[1];
		res[2] = arr[5];
		res[3] = arr[4];
	}
	else if (pos == 3)
	{
		res[0] = arr[0];
		res[1] = arr[1];
		res[2] = arr[4];
		res[3] = arr[5];
	}
	else if (pos == 4)
	{
		res[0] = arr[0];
		res[1] = arr[1];
		res[2] = arr[2];
		res[3] = arr[3];
	}
	else if (pos == 5)
	{
		res[0] = arr[0];
		res[1] = arr[1];
		res[2] = arr[3];
		res[3] = arr[2];
	}
}

bool isSame(vector<int> arr1, vector<int> arr2)
{
	int pos1, pos2;
	vector<int> index1(4, 0);
	vector<int> index2(4, 0);
	for (int i = 0; i < 6; i++)
		if (arr1[i] == 1)
			pos1 = i;
	aroundNum(arr1, index1, pos1);
	for (int i = 0; i < 6; i++)
		if (arr2[i] == 1)
			pos2 = i;
	aroundNum(arr2, index2, pos2);

	if ((index1[0] == index2[0] && index1[1] == index2[1] && index1[2] == index2[2] && index1[3] == index2[3]) || 
             (index1[0] == index2[3] && index1[1] == index2[2] && index1[2] == index2[0] && index1[3] == index2[1]) || 
             (index1[0] == index2[1] && index1[1] == index2[0] && index1[2] == index2[3] && index1[3] == index2[2]) || 
             (index1[0] == index2[2] && index1[1] == index2[3] && index1[2] == index2[1] && index1[3] == index2[0]))
		return true;
	else
		return false;
}

int main()
{
	int num;
	cin >> num;
	vector<vector<int>> arr(num, vector<int>(6, 0));
	//读取数据
	for (int i = 0; i < num; i++)
		for (int j = 0; j < 6; j++)
			cin >> arr[i][j];
	vector<int> used(num, 0);
	vector<int> res;
	for (int i = 0; i < arr.size(); i++)
	{
		int times = 1;
		if (!used[i])
		{
			for (int j = 0; j < arr.size(); j++)
			{
				if (i != j && isSame(arr[i], arr[j]) && used[j] == 0)
				{
					used[j] = 1;
					times++;
				}
			}
			res.push_back(times);
		}
	}

	cout << res.size() << endl;
	sort(res.begin(), res.end());
	for (int i = res.size() - 1; i >= 0; i--)
		cout << res[i] << " ";
	//cout << endl;

	return 0;
}
3、吃东西，N,M是中餐和晚餐的个数，T是需要满足的最少的美味值
输入：N行，每行两个数，xi和yi分别表示热量和美味值，再输入M行，每行两个数，xi和yi分别表示热量和美味值。
输出：中餐和晚餐的美味值>=T的情况下，热量值是多少？
        思路：暴力。。。。对。。只会暴力。。
        选中餐中一个，判断美味值是否满足，满足的话记录最小值；不满足的话再从晚餐中选，如果两个美味值加起来满足，则记录最小值。
        当然，这种方法只能过50%……………………
        答完后，请教一个大佬同学，得知可以对这个暴力方法进行优化：先按照热量，将早餐和晚餐进行排序。 然后单独判断午餐，找到符合要求的美味值后，后面剩余的都不需要遍历了，单独判断晚餐的情况同理。对于午餐和晚餐都选的情况，当找出复合要求的晚餐后，对于后续的遍历，就不需要遍历该晚餐之后的晚餐了。（这种方法可以AC）
这里就只贴自己的代码了。 
#include<iostream>
#include<vector>

using namespace std;

class FoodInf
{
public:
	int X;
	int Y;
};


int main()
{
	int N, M, T;
	cin >> N >> M >> T;

	if (T == 0)
	{
		cout << 0 << endl;
		return 0;
	}

	FoodInf fd;
	vector<FoodInf> ZhongC;
	vector<FoodInf> WanC;
	for (int i = 0; i < N; i++)
	{
		cin >> fd.X;
		cin >> fd.Y;
		ZhongC.push_back(fd);
	}
	for (int i = 0; i < M; i++)
	{
		cin >> fd.X;
		cin >> fd.Y;
		WanC.push_back(fd);
	}

	int minX = 99999;
	int selX = 0, selY = 0;

	for (int i = 0; i < N; i++)
	{
		selX = ZhongC[i].X;
		selY = ZhongC[i].Y;
		if (selY >= T)
			if (selX < minX)
				minX = selX;    //只吃一顿

		for (int j = 0; j < M; j++)
		{
			if (selY + WanC[j].Y >= T)
				if (selX + WanC[j].X < minX)
					minX = selX + WanC[j].X;
		}
	}
	for (int i = 0; i < M; i++)
	{
		selX = WanC[i].X;
		selY = WanC[i].Y;
		if (selY >= T)
			if (selX < minX)
				minX = selX;    //只吃一顿
	}

	cout << (minX == 99999 ? -1 : minX) << endl;

	return 0;
}