The Seven-Sparkling-Star Card Game

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 的卡牌数量和初始血量以及每回合所用的卡牌，其中 $I l l u m i n a_$ 为先手，你需要求出这次游戏的结果，每回合对战时会有多种关于主战斗区和辅助战斗区之间的安排，由于回合间互不影响，双方都会选择总攻击力最大的方案。

注1：如果牌局在某一回合结束，后续所有回合和将要使用的卡牌全部作废。

注2：牌型不可叠加计算，若同时满足多种牌型，取倍数高的计算。

注3：对于诸如“同花两对”、“同花一对”之类的牌型，仅需满足其对子或三条的部分为同花，剩余的牌可为任意牌。

注4：对于同花葫芦只要构成”同花葫芦“的”同花三条“和”同花一对“内部同花即可。

Input

第一行两个整数 $n, h$ 为双方各自的卡牌数量和血量（即双方都有 $n$ 张卡牌且双方血量都相同）

接下来 $n$ 行，每一行包含 $I l l u m i n a_$ 的一张卡牌，第 $2$ 至 $8$ 行为他第一回合使用的卡牌，第 $9$ 至 $15$ 行为他第二回合使用的卡牌（如果有第二回合的话），以此类推。

每张卡牌的第一行包含 2 个正整数和一个字符(点数10用T表示,A,K,Q,J正常输入）, $a_{i}, c_{i}, e_{i}$

再接下来 $n$ 行，每一行包含 $S p a r k l e_7$ 的一张卡牌，格式同上。

Output

输出按以下几类处理：

若在某名玩家结束行动后，使得对方血量降至 $0$ 或以下，则输出该玩家的名字 ( Illumina_ 或 Sparkle_7 )，再接着输出一个正整数（与名字间有一个空格），表示这次行动在第几回合。

若所有 $n$ 张卡牌全部打完后需比较剩余血量，则输出剩余血量更大的玩家的名字( Illumina_ 或 Sparkle_7 )，再接着输出一个不带引号的 $“final"$ （与名字间有一个空格）。

否则，输出 $“Tie"$ 代表平局（不含引号）。

Sample

Input 1

Output 1

Sparkle_7 1

Input 2

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;
}

posted @ 2022-11-13 11:27 ereoth 阅读(48) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· [arc059] F - Unhappy Hacking

· CF187D BRT Contract

· 2025.1.24——1400

· CF1739 C. Card Game

· P8836 [传智杯 #3 决赛] 打牌题解

阅读排行：
· 地球OL攻略 —— 某应届生求职总结
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 提示词工程——AI应用必不可少的技术
· .NET周刊【3月第1期 2025-03-02】

ereoth

ereoth's blog

The Seven-Sparkling-Star Card Game

Problem

基本游戏规则：

胜负判定规则：

Input

Output

Sample

Input 1

Output 1

Input 2

Output 2

Solution

Code

公告

常用链接

最新随笔

积分与排名

随笔分类

相册

阅读排行榜

评论排行榜

推荐排行榜

最新评论