sicily 1018之模拟题

最新推荐文章于 2021-02-12 08:02:47 发布

xujqiao

最新推荐文章于 2021-02-12 08:02:47 发布

阅读量597

点赞数

分类专栏： sicily 文章标签： 1018

本文链接：https://blog.csdn.net/xujqiao/article/details/38925049

版权

sicily 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

题目在这里1018

这也是一道模拟题，更上篇博客说的一样，模拟题重要的是看懂题意，审好题，AC不是问题。

这道题的意思是这样的：

1、给你五张牌，数字是从A-K（A, 2， 3， 4， 5， 6， 7， 8，9， 10，J， Q， K），花色分别是C, D, H, S。假如给你的是10H, 10S, 10D, 10C, 5C

2、让你给出一个这五张牌的序列，使得满足下面的条件：

a.第一张牌跟第二张牌花色一样

a.第一张牌的数字等于第二章牌的数字加上另外三张牌里，最小的那张牌在三张牌里的位置（1或2或3）。再判断剩下两张牌是否是顺序的，如果不是，那么还要加上3

比如：对于上面给出的五张牌，10C 5C 10H 10S 10D就是一个解。因为，10C跟5C是一样的花色。剩下的三张牌里（10H 10S 10D），10S最小，在第二个位置，所以要加上2，同时，10H和10D的位置乱序了，10H大于10D，所以还要加上3。这样，5 + 2 + 3 = 10。也满足第二个条件，这就是一个解

上面说的说的就是题目的意思，解决的方案各异，我的解决方案是：拼凑。基本跟上面的思路一样，只是用了一个struct，里面有一个int dist[4]的数组，记录了这张牌与其他四张牌的距离，如果花色不一，就记为0，否则记为两者的距离（1-13轮回，即1和13的距离是1，因为13+1 = 1）

代码如下，比较乱，估计看不懂

#include<iostream>
#include<string>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
#include<map>
using namespace std;

map<string, int> dict;
map<int, string> dict_reverse;


void init_dict()
{
	dict.insert(make_pair("A", 1));
	dict.insert(make_pair("2", 2));
	dict.insert(make_pair("3", 3));
	dict.insert(make_pair("4", 4));
	dict.insert(make_pair("5", 5));
	dict.insert(make_pair("6", 6));
	dict.insert(make_pair("7", 7));
	dict.insert(make_pair("8", 8));
	dict.insert(make_pair("9", 9));
	dict.insert(make_pair("10", 10));
	dict.insert(make_pair("J", 11));
	dict.insert(make_pair("Q", 12));
	dict.insert(make_pair("K", 13));

	dict_reverse.insert(make_pair(1, "A"));
	dict_reverse.insert(make_pair(2, "2"));
	dict_reverse.insert(make_pair(3, "3"));
	dict_reverse.insert(make_pair(4, "4"));
	dict_reverse.insert(make_pair(5, "5"));
	dict_reverse.insert(make_pair(6, "6"));
	dict_reverse.insert(make_pair(7, "7"));
	dict_reverse.insert(make_pair(8, "8"));
	dict_reverse.insert(make_pair(9, "9"));
	dict_reverse.insert(make_pair(10, "10"));
	dict_reverse.insert(make_pair(11, "J"));
	dict_reverse.insert(make_pair(12, "Q"));
	dict_reverse.insert(make_pair(13, "K"));
}

struct Card
{
	int value;
	char suit;
	int dist[5];
	Card(string str)
	{
		this->suit = str[str.length() - 1];
		string sub = str.substr(0, str.length() - 1);
		this->value = dict[sub];
		memset(this->dist, 0, sizeof(this->dist));
	}
	Card(int value, char suit)
	{
		this->value = value;
		this->suit = suit;
		memset(this->dist, 0, sizeof(this->dist));
	}

	friend bool operator<(Card c1, Card c2)
	{
		if (c1.value != c2.value)
			return c1.value < c2.value;
		return c1.suit < c2.suit;
	}
};

int dcmp(int a, int b)
{
	if (a - b < 0)
		return -1;
	if (a - b > 0)
		return 1;
	return 0;
}

int get_dist(Card c1, Card c2)
{
	if (c1.suit != c2.suit)
		return 0;
	int v1 = c1.value, v2 = c2.value;
	if (v1 - v2 <= -7 || v1 - v2 >= 7)
	{
		return (min(v1, v2) + 13 - max(v1, v2)) * dcmp(v1, v2);
	}
	else
	{
		return v2 - v1;
	}
}

void adjust(vector<Card> &deck)
{
	for (int i = 0; i < 5; i++)
	{
		for (int j = 1; j < 5; j++)
		{
			deck[i].dist[j] = get_dist(deck[i], deck[(i + j) % 5]);
		}
	}
}


void play_games(vector<Card> &deck, vector<Card> &ans)
{
	vector<Card> tmp;
	for (int i = 0; i < deck.size(); i++)
	{
		for (int j = 1; j < 5; j++)
		{
			if (deck[i].dist[j] >= 1 && deck[i].dist[j] <= 6)
			{
				ans.push_back(Card(deck[(i + j) % 5].value, deck[(i + j) % 5].suit));
				ans.push_back(Card(deck[i].value, deck[i].suit));
				for (int z = 0; z < deck.size(); z++)
				{
					if (z != i && z != ((i + j) % 5))
						tmp.push_back(Card(deck[z].value, deck[z].suit));
				}
				sort(tmp.begin(), tmp.end());
				switch (deck[i].dist[j])
				{
				case 1:
					ans.push_back(Card(tmp[0].value, tmp[0].suit));
					ans.push_back(Card(tmp[1].value, tmp[1].suit));
					ans.push_back(Card(tmp[2].value, tmp[2].suit));
					return;
					break;
				case 2:
					ans.push_back(Card(tmp[1].value, tmp[1].suit));
					ans.push_back(Card(tmp[0].value, tmp[0].suit));
					ans.push_back(Card(tmp[2].value, tmp[2].suit));
					return;
					break;
				case 3:
					ans.push_back(Card(tmp[1].value, tmp[1].suit));
					ans.push_back(Card(tmp[2].value, tmp[2].suit));
					ans.push_back(Card(tmp[0].value, tmp[0].suit));
					return;
					break;
				case 4:
					ans.push_back(Card(tmp[0].value, tmp[0].suit));
					ans.push_back(Card(tmp[2].value, tmp[2].suit));
					ans.push_back(Card(tmp[1].value, tmp[1].suit));
					return;
					break;
				case 5:
					ans.push_back(Card(tmp[2].value, tmp[2].suit));
					ans.push_back(Card(tmp[0].value, tmp[0].suit));
					ans.push_back(Card(tmp[1].value, tmp[1].suit));
					return;
					break;
				case 6:
					ans.push_back(Card(tmp[2].value, tmp[2].suit));
					ans.push_back(Card(tmp[1].value, tmp[1].suit));
					ans.push_back(Card(tmp[0].value, tmp[0].suit));
					return;
					break;
				default:
					break;
				}
			}
		}
	}
}


int main()
{
	int n, count = 0;
	string str;
	vector<Card> deck, ans;
	cin >> n;
	init_dict();
	while (n--)
	{
		count++;
		for (int i = 0; i < 5; i++)
		{
			cin >> str;
			deck.push_back(Card(str));
		}

		adjust(deck);

		play_games(deck, ans);


		cout << "Problem " << count << ":";
		for (vector<Card>::iterator iter = ans.begin(); iter != ans.end(); iter++)
			cout << " " << dict_reverse[iter->value] << iter->suit;
		cout << endl;

		deck.clear();
		ans.clear();
	}
	//system("pause");
	return 0;
}