Problem
The Seven-Sparkling-Star Card Game(七星卡牌)游戏是 Illumina_ 矿业无限游戏公司的最新力作。
基本游戏规则：
对战双方各持 \(n\) 张卡牌，其中 \(n\) 是 \(7\) 的倍数，且其为回合制游戏，每回合先手行动结束后手才能行动。在每回合行动时，双方选手选用恰好 \(7\) 张牌与对方进行对战，其中玩家需要将 \(7\) 张牌安排为 \(5\) 张牌组成的主战斗区和 \(2\) 张牌组成的辅助战斗区，该回合结束后，双方玩家于这回合使用的 张卡牌全置，直至卡牌用完。
胜负判定规则：
若在某一回合中，某一玩家行动完，对方血量小于等于 \(0\)，则判定该玩家胜利。
若双方的 \(n\) 张卡牌均用完，则剩余血量大的玩家获胜，若此时两名玩家剩余血量相同，则判平局。
卡牌介绍：
每张卡牌的属性（对解题有用的）有：攻击力 \(a\)，花色 \(c\)，和点数 \(e\)，其中花色和点数的取值范围是普通扑克牌（除去大小王后的52张牌）且可以重复。
7张卡牌的攻击力结算：
自玩家选出了七张卡牌并分出主战斗区和辅助战斗区后，还需计算主战斗区中 \(5\) 张卡牌的牌型加成：
1.同花五条，若 \(5\) 张牌的花色和点数全部相同，则称其构成“同花五条”，使得主战斗区和辅助战斗区的所有卡牌攻击力变为原来的 \(7777\) 倍。
2.皇家同花顺，若 \(5\) 张牌的花色全部相同且点数恰好为 A,K,Q,J,T(10) 各一张则称其构成“皇家同花顺”，使得主战斗区和辅助战斗区的所有卡牌攻击力变为原来的 \(2000\) 倍。
3.五条, 若 \(5\) 张牌的点数全部相同，则称其构成“五条”，且不满足“同花五条”，使得主战斗区和辅助战斗区的所有卡牌攻击力变为原来的 \(1000\) 倍。
4.同花顺，若 \(5\) 张牌不构成皇家同花顺且 张牌的花色全部相同且点数连续（连续定义为取K为13，Q为12，J为11，A为1，点数为数字的牌按数字计，且 \(5\) 张牌经过重新排序可构成公差为 \(1\) 的等差数列），则称其构成“同花顺”，使得主战斗区和辅助战斗区的所有卡牌攻击力变为原来的 \(888\) 倍。
5.同花四条，若 \(5\) 张牌中有任意四张花色和点数全部相同，剩下 \(1\) 张点数不与前 \(4\) 张相同，则称其为“同花四条”，使得主战斗区和辅助战斗区的所有卡牌攻击力变为原来的 \(777\) 倍。
6.同花葫芦，若 \(5\) 张牌中有 \(3\) 张花色和点数全部相同，剩下 \(2\) 张点数和花色全部相同但点数不与前 \(3\) 张相同，则称其为“同花葫芦”，使得主战斗区和辅助战斗区的所有卡牌攻击力变为原来的 \(666\) 倍。
7.四条，若 \(5\) 张牌中有任意四张点数全部相同，剩下 \(1\) 张点数不与前 \(4\) 张相同，且不满足“同花四条”，则称其为“四条”，使得主战斗区和辅助战斗区的所有卡牌攻击力变为原来的 \(500\) 倍。
8.葫芦，若 \(5\) 张牌中有 \(3\) 张点数全部相同，剩下 \(2\) 张点数全部相同且点数不与前 \(3\) 张相同，且不满足“同花葫芦”，则称其为“葫芦”，使得主战斗区和辅助战斗区的所有卡牌攻击力变为原来的 \(343\) 倍。
9.同花三条，若 \(5\) 张牌中有 \(3\) 张花色和点数全部相同且不满足“同花五条”、“同花四条”、“同花葫芦”、“五条”、“四条”和“葫芦”，则称其为“同花三条”，使得主战斗区和辅助战斗区的所有卡牌攻击力变为原来的 \(200\) 倍。
10.顺子，若 \(5\) 张牌的点数恰好为A,K,Q,J,10各一张或点数连续（“连续”的定义同上），且不满足“皇家同花顺”和“同花顺”，则称其为“顺子”，使得主战斗区的所有卡牌攻击力变为原来的 \(100\) 倍。
11.同花，若 \(5\) 张牌的花色全部相同且不满足上述任何牌型，则称其为“同花”，使得主战斗区的所有卡牌攻击力变为原来的 \(50\) 倍。
12.同花两对，若 \(5\) 张牌中有两个同花对子（“同花对子”定义为点数和花色都一样的两张牌），且不满足“同花五条”和“同花四条”和“同花葫芦”，则称其为“同花两对”，使得主战斗区的所有卡牌攻击力变为原来的 \(20\) 倍。
13.三条，若 \(5\) 张牌中有 \(3\) 张牌的点数全部相同，且不满足“同花五条”、“同花四条”、“同花葫芦”、“同花三条”，“五条”、“四条”和“葫芦”，则称其为“三条”，使得主战斗区的所有卡牌攻击力变为原来的 \(10\) 倍。
14.两对，若 \(5\) 张牌中有两个对子（“对子”定义为点数一样的两张牌）且不满足“同花五条”、“同花四条”、“同花葫芦”、“同花三条”，“五条”、“四条”和“葫芦”,则称其为“两对”，使得主战斗区的所有卡牌攻击力变为原来的 \(7\) 倍。
15.同花一对，若 \(5\) 张牌中有一个同花对子（“同花对子”的定义同上），且不满足上述任何牌型，则称其为“同花一对”，使得主战斗区的所有卡牌攻击力变为原来的 \(5\) 倍。
16.一对，若 \(5\) 张牌中有一个对子（“对子”的定义同上），且不满足上述任何牌型，则称其为“一对”，使得主战斗区的所有卡牌攻击力变为原来的 \(2\) 倍。
17.高牌，若这 \(5\) 张牌不满足上述任何牌型，则称其为“高牌”，无任何增益。
最后，记 \(S\) 为主战斗区和辅助战斗区的所有卡牌攻击力之和，即为本回合一名玩家对对手造成的全部攻击力，在下回合，所有增益全部重置。
你的任务是给定两名玩家 Illumina_ 和 Sparkle_7 的卡牌数量 和初始血量 以及每回合所用的卡牌，其中 \(Illumina\_\) 为先手，你需要求出这次游戏的结果，每回合对战时会有多种关于主战斗区和辅助战斗区之间的安排，由于回合间互不影响，双方都会选择总攻击力 最大的方案。
注1：如果牌局在某一回合结束，后续所有回合和将要使用的卡牌全部作废。
注2：牌型不可叠加计算，若同时满足多种牌型，取倍数高的计算。
注3：对于诸如“同花两对”、“同花一对”之类的牌型，仅需满足其对子或三条的部分为同花，剩余的牌可为任意牌。
注4：对于同花葫芦只要构成”同花葫芦“的”同花三条“和”同花一对“内部同花即可。
Input
第一行两个整数 \(n,h\) 为双方各自的卡牌数量和血量（即双方都有 \(n\) 张卡牌且双方血量都相同）
接下来 \(n\) 行，每一行包含 \(Illumina\_\) 的一张卡牌，第 \(2\) 至 \(8\) 行为他第一回合使用的卡牌，第 \(9\) 至 \(15\) 行为他第二回合使用的卡牌（如果有第二回合的话），以此类推。
每张卡牌的第一行包含 2 个正整数和一个字符(点数10用T表示,A,K,Q,J正常输入）, \(a_i, c_i, e_i\)
再接下来 \(n\) 行，每一行包含 \(Sparkle\_7\) 的一张卡牌，格式同上。
Output
输出按以下几类处理：
若在某名玩家结束行动后，使得对方血量降至 \(0\) 或以下，则输出该玩家的名字 ( Illumina_ 或 Sparkle_7 )，再接着输出一个正整数（与名字间有一个空格），表示这次行动在第几回合。
若所有 \(n\) 张卡牌全部打完后需比较剩余血量，则输出剩余血量更大的玩家的名字( Illumina_ 或 Sparkle_7 )，再接着输出一个不带引号的 \(\text{“final"}\)（与名字间有一个空格）。
否则，输出 \(\text{“Tie"}\) 代表平局（不含引号）。
Sample
Input 1
7 1261
23 2 4
21 2 Q
81 1 8
55 1 5
63 4 9
82 3 K
57 4 J
16 1 6
73 4 4
49 2 4
28 1 A
86 1 K
15 4 A
35 1 A
Output 1
Sparkle_7 1
Input 2
7 15555
0 1 A
0 1 A
0 1 A
0 1 A
0 1 A
1 2 4
1 6 8
57 1 7
44 3 T
15 3 4
22 3 2
16 1 6
46 4 J
88 3 J
Output 2
Illumina_ final
Solution
大模拟，有点恶心
思维难度不大，根据题意的情况依此判就行，主要是考代码功底
写的时候注意一些坑点：
1.有些情况所带来的增益是对于所有卡牌的，而有些只是对于主战区的卡牌增益
2.若同时满足多种牌型，取倍数高的计算，而不是选择总增益的最大的牌型。
Code
代码很长，但应该比较容易理解
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int kmax = 103;
struct Card {
int a, c, e;
};
struct Contest {
Card p[7];
} a[kmax], b[kmax];
int n, num[15][5];
long long ct;
int o[15];
long long al, bl, tot, tott;
char ch;
bool Check1(Contest c) {
sort(c.p, c.p + 7, [](Card p, Card q) { return p.e < q.e || p.e == q.e && p.c < q.c; });
for (int i = 0, j = 4; j < 7; i++, j++) {
bool b = 1;
for (int k = i + 1; k <= j; k++) {
b &= (c.p[k].c == c.p[k - 1].c);
b &= (c.p[k].e == c.p[k - 1].e);
}
if (b) return 1;
}
return 0;
}
bool Check2(Contest c) {
memset(num, 0, sizeof(num));
for (int i = 0; i < 7; i++) {
num[c.p[i].e][c.p[i].c]++;
}
for (int i = 1; i <= 4; i++) {
if (num[1][i] && num[10][i] && num[11][i] && num[12][i] && num[13][i]) return 1;
}
return 0;
}
bool Check3(Contest c) {
sort(c.p, c.p + 7, [](Card p, Card q) { return p.e < q.e || p.e == q.e && p.c < q.c; });
for (int i = 0, j = 4; j < 7; i++, j++) {
bool b = 1;
for (int k = i + 1; k <= j; k++) {
b &= (c.p[k].e == c.p[k - 1].e);
}
if (b) return 1;
}
return 0;
}
bool Check4(Contest c) {
memset(num, 0, sizeof(num));
for (int i = 0; i < 7; i++) {
num[c.p[i].e][c.p[i].c]++;
}
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= 13; j++) {
if (num[j][i] && num[j % 13 + 1][i] && num[(j + 1) % 13 + 1][i] && num[(j + 2) % 13 + 1][i] && num[(j + 3) % 13 + 1][i]) return 1;
}
}
return 0;
}
bool Check5(Contest c) {
sort(c.p, c.p + 7, [](Card p, Card q) { return p.e < q.e || p.e == q.e && p.c < q.c; });
for (int i = 0, j = 3; j < 7; i++, j++) {
bool b = 1;
for (int k = i + 1; k <= j; k++) {
b &= (c.p[k].c == c.p[k - 1].c);
b &= (c.p[k].e == c.p[k - 1].e);
}
if (b) return 1;
}
return 0;
}
bool Check6(Contest c) {
memset(num, 0, sizeof(num));
for (int i = 0; i < 7; i++) {
num[c.p[i].e][c.p[i].c]++;
}
bool b = 0, bb = 0;
for (int i = 1; i <= 13; i++) {
for (int j = 1; j <= 4; j++) {
if (num[i][j] >= 3) {
b = 1;
break;
}
if (num[i][j] >= 2) {
bb = 1;
break;
}
}
}
return b && bb;
}
bool Check7(Contest c) {
sort(c.p, c.p + 7, [](Card p, Card q) { return p.e < q.e || p.e == q.e && p.c < q.c; });
for (int i = 0, j = 3; j < 7; i++, j++) {
bool b = 1;
for (int k = i + 1; k <= j; k++) {
b &= (c.p[k].e == c.p[k - 1].e);
}
if (b) return 1;
}
return 0;
}
bool Check8(Contest c) {
memset(num, 0, sizeof(num));
for (int i = 0; i < 7; i++) {
num[c.p[i].e][0]++;
}
bool b = 0, bb = 0;
for (int i = 1; i <= 13; i++) {
if (num[i][0] >= 3) {
b = 1;
continue;
}
if (num[i][0] >= 2) {
bb = 1;
continue;
}
}
return b && bb;
}
bool Check9(Contest c) {
sort(c.p, c.p + 7, [](Card p, Card q) { return p.e < q.e || p.e == q.e && p.c < q.c; });
for (int i = 0, j = 2; j < 7; i++, j++) {
bool b = 1;
for (int k = i + 1; k <= j; k++) {
b &= (c.p[k].c == c.p[k - 1].c);
b &= (c.p[k].e == c.p[k - 1].e);
}
if (b) return 1;
}
return 0;
}
bool Check10(Contest c) {
tott = 0;
bool hhh = 0;
for (int i = 0; i < 7; i++) {
for (int j = i + 1; j < 7; j++) {
ct = 0;
memset(o, 0, sizeof(o));
for (int k = 0; k < 7; k++) {
if (i == k || j == k) continue;
o[c.p[k].e] = 1;
ct += c.p[k].a;
}
bool bb = 0;
for (int k = 1; k <= 13; k++) {
if (o[k] && o[k % 13 + 1] && o[(k + 1) % 13 + 1] && o[(k + 2) % 13 + 1] && o[(k + 3) % 13 + 1]) {
bb = 1;
}
}
if (bb) {
tott = max(tott, ct);
hhh = 1;
}
}
}
return hhh;
}
bool Check11(Contest c) {
tott = 0;
bool hhh = 0;
for (int i = 0; i < 7; i++) {
for (int j = i + 1; j < 7; j++) {
ct = 0;
memset(o, 0, sizeof(o));
for (int k = 0; k < 7; k++) {
if (i == k || j == k) continue;
o[c.p[k].c]++;
ct += c.p[k].a;
}
bool bb = 0;
for (int k = 1; k <= 4; k++) {
if (o[k] == 5) {
bb = 1;
}
}
if (bb) {
tott = max(tott, ct);
hhh = 1;
}
}
}
return hhh;
}
bool Check12(Contest c) {
tott = 0;
bool hhh = 0;
for (int i = 0; i < 7; i++) {
for (int j = i + 1; j < 7; j++) {
ct = 0;
memset(num, 0, sizeof(num));
for (int k = 0; k < 7; k++) {
if (i == k || j == k) continue;
num[c.p[k].e][c.p[k].c]++;
ct += c.p[k].a;
}
int b = 0;
for (int i = 1; i <= 13; i++) {
for (int j = 1; j <= 4; j++) {
if (num[i][j] >= 2) {
b++;
}
}
}
if (b >= 2) {
tott = max(tott, ct);
hhh = 1;
}
}
}
return hhh;
}
bool Check13(Contest c) {
tott = 0;
bool hhh = 0;
for (int i = 0; i < 7; i++) {
for (int j = i + 1; j < 7; j++) {
ct = 0;
memset(o, 0, sizeof(o));
for (int k = 0; k < 7; k++) {
if (i == k || j == k) continue;
o[c.p[k].e]++;
ct += c.p[k].a;
}
bool bb = 0;
for (int k = 1; k <= 13; k++) {
if (o[k] >= 3) {
bb = 1;
}
}
if (bb) {
tott = max(tott, ct);
hhh = 1;
}
}
}
return hhh;
}
bool Check14(Contest c) {
tott = 0;
bool hhh = 0;
for (int i = 0; i < 7; i++) {
for (int j = i + 1; j < 7; j++) {
ct = 0;
memset(num, 0, sizeof(num));
for (int k = 0; k < 7; k++) {
if (i == k || j == k) continue;
num[c.p[k].e][0]++;
ct += c.p[k].a;
}
int b = 0;
for (int i = 1; i <= 13; i++) {
if (num[i][0] >= 2) {
b++;
}
}
if (b >= 2) {
tott = max(tott, ct);
hhh = 1;
}
}
}
return hhh;
}
bool Check15(Contest c) {
tott = 0;
bool hhh = 0;
for (int i = 0; i < 7; i++) {
for (int j = i + 1; j < 7; j++) {
ct = 0;
memset(num, 0, sizeof(num));
for (int k = 0; k < 7; k++) {
if (i == k || j == k) continue;
num[c.p[k].e][c.p[k].c]++;
ct += c.p[k].a;
}
int b = 0;
for (int i = 1; i <= 13; i++) {
for (int j = 1; j <= 4; j++) {
if (num[i][j] >= 2) {
b++;
}
}
}
if (b >= 1) {
tott = max(tott, ct);
hhh = 1;
}
}
}
return hhh;
}
bool Check16(Contest c) {
tott = 0;
bool hhh = 0;
for (int i = 0; i < 7; i++) {
for (int j = i + 1; j < 7; j++) {
ct = 0;
memset(num, 0, sizeof(num));
for (int k = 0; k < 7; k++) {
if (i == k || j == k) continue;
num[c.p[k].e][0]++;
ct += c.p[k].a;
}
int b = 0;
for (int i = 1; i <= 13; i++) {
if (num[i][0] >= 2) {
b++;
}
}
if (b >= 1) {
tott = max(tott, ct);
hhh = 1;
}
}
}
return hhh;
}
void Solve(Contest c, long long &h) {
tot = tott = 0;
for (int i = 0; i < 7; i++) {
tot += c.p[i].a;
}
if (Check1(c)) {
h -= tot * 7777;
} else if (Check2(c)) {
h -= tot * 2000;
} else if (Check3(c)) {
h -= tot * 1000;
} else if (Check4(c)) {
h -= tot * 888;
} else if (Check5(c)) {
h -= tot * 777;
} else if (Check6(c)) {
h -= tot * 666;
} else if (Check7(c)) {
h -= tot * 500;
} else if (Check8(c)) {
h -= tot * 343;
} else if (Check9(c)) {
h -= tot * 200;
} else if (Check10(c)) {
h -= tott * 100 - (tot - tott);
} else if (Check11(c)) {
h -= tott * 50 - (tot - tott);
} else if (Check12(c)) {
h -= tott * 20 - (tot - tott);
} else if (Check13(c)) {
h -= tott * 10 - (tot - tott);
} else if (Check14(c)) {
h -= tott * 7 - (tot - tott);
} else if (Check15(c)) {
h -= tott * 5 - (tot - tott);
} else if (Check16(c)) {
h -= tott * 2 - (tot - tott);
} else {
h -= tot;
}
}
int main() {
// freopen("illumina.in", "r", stdin);
// freopen("illumina.out", "w", stdout);
scanf("%d%lld", &n, &al);
bl = al;
for (int i = 1; i <= n / 7; i++) {
for (int j = 0; j < 7; j++) {
scanf("%d %d %c", &a[i].p[j].a, &a[i].p[j].c, &ch);
if (ch == 'A') a[i].p[j].e = 1;
if (ch == 'T') a[i].p[j].e = 10;
if (ch == 'J') a[i].p[j].e = 11;
if (ch == 'Q') a[i].p[j].e = 12;
if (ch == 'K') a[i].p[j].e = 13;
if (ch >= '2' && ch <= '9') a[i].p[j].e = ch - '0';
}
}
for (int i = 1; i <= n / 7; i++) {
for (int j = 0; j < 7; j++) {
scanf("%d %d %c", &b[i].p[j].a, &b[i].p[j].c, &ch);
if (ch == 'A') b[i].p[j].e = 1;
if (ch == 'T') b[i].p[j].e = 10;
if (ch == 'J') b[i].p[j].e = 11;
if (ch == 'Q') b[i].p[j].e = 12;
if (ch == 'K') b[i].p[j].e = 13;
if (ch >= '2' && ch <= '9') b[i].p[j].e = ch - '0';
}
}
for (int i = 1; i <= n / 7; i++) {
Solve(a[i], bl);
if (bl <= 0) {
printf("Illumina_ ");
printf("%d\n", i);
return 0;
}
Solve(b[i], al);
if (al <= 0) {
printf("Sparkle_7 ");
printf("%d\n", i);
return 0;
}
}
if (al < bl) printf("Sparkle_7 final");
if (al == bl) printf("Tie");
if (al > bl) printf("Illumina_ final");
return 0;
}