华为OD机试 - 最长的顺子 - 感谢@禁止你发言提供的更简便算法（Java 2023 B卷 200分）
目录
-
- 专栏导读
- 一、题目描述
- 二、输入描述
- 三、输出描述
- 四、解题思路
- 五、Java算法源码
- 六、感谢@禁止你发言提供的更简单、更优质的算法
-
- 解题思路
- 优质算法源码
- 七、效果展示
-
- 1、输入
- 2、输出
- 3、说明
华为OD机试 2023B卷题库疯狂收录中，刷题点这里
专栏导读
本专栏收录于《华为OD机试（JAVA）真题（A卷+B卷）》。
刷的越多，抽中的概率越大，每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。
一、题目描述
斗地主起源于湖北十堰房县，据说是一位叫吴修全的年轻人根据当地流行的扑克玩法”跑得快”改编的，如今已风靡整个中国，并流行于互联网上。
牌型:单顺，又称顺子，最少5张牌，最多12张牌(3…A)不能有2，也不能有大小王，不计花色。
例:3-4-5-6-7-8，7-8-9-10-J-Q，3-4-5-6-7-8-9-10-J-Q-K-A可用的牌3<4<5<6<7<8<9<10 1、输入 2、输出 对手可能构成的最长的顺子(如果有相同长度的顺子，输出牌面最大的那一个) 如果无法构成顺子，则输出NO-CHAIN 输入的第一行为当前手中的牌 输入的第二行为已经出过的牌 最长的顺子 1、获取输入：当前手中的牌 + 已经出过的牌，并合并字符串，分割为数组； 2、定义char2int map，进行JQKA的映射转换，便于排序; 3、定义reverseMap，int转回JQKA，方便最后打印顺子； 4、定义数组theirPokers表示对手的牌，遍历前述的合并牌数组（当前手中的牌 + 已经出过的牌），每遍历到一张牌，对手的牌对应的数组元素 - 1。 注意: 5、动态规划获取最长的顺子，以当前牌结尾的顺子长度只与以前一个牌结尾的顺子长度和当前牌是否可用有关。 注意这里有个优化技巧，由于当前牌的顺子长度只与前一个牌的顺子长度和当前牌是否可用有关，因此我们不需要定义dp数组 存储空间降低，但可读性差了点。 6、如果符合条件（顺子长度不小于5），则按格式输出 7、如果不符合，则输出NO-CHAIN 3-3-4-4-5-A-5-6-2-8-3-9-10-Q-7-K-J-10-B 9-10-J-Q-K-A 下一篇：华为OD机试 - 荒岛求生 - 栈Stack（Java 2023 B卷 100分） 本文收录于，华为OD机试（JAVA）真题（A卷+B卷） 刷的越多，抽中的概率越大，每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。
二、输入描述
三、输出描述
输入
输出
说明
3-3-3-3-4-4-5-5-6-7-8-9-10-J-Q-K-A
A-4-5-6-7-8-8-89-10-J-Q-K-A
四、解题思路
五、Java算法源码
private static Map<String, Integer> jqkaMap = new HashMap<>();
private static Map<Integer, String> reverseMap = new HashMap<>();
// B(小王)C(大王)
private static String specialStr = "2BC";
static {
jqkaMap.put("J", 11);
jqkaMap.put("Q", 12);
jqkaMap.put("K", 13);
jqkaMap.put("A", 14);
reverseMap.put(11, "J");
reverseMap.put(12, "Q");
reverseMap.put(13, "K");
reverseMap.put(14, "A");
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 当前手中的牌
List<Integer> line1 = Arrays.asList(sc.nextLine().split("-")).stream().filter(x->!specialStr.contains(x)).map(x -> {
if (jqkaMap.containsKey(x)) {
return String.valueOf(jqkaMap.get(x));
}
return x;
}).mapToInt(Integer::parseInt).boxed().collect(Collectors.toList());
// 已经出过的牌
List<Integer> line2 = Arrays.asList(sc.nextLine().split("-")).stream().filter(x->!specialStr.contains(x)).map(x -> {
if (jqkaMap.containsKey(x)) {
return String.valueOf(jqkaMap.get(x));
}
return x;
}).mapToInt(Integer::parseInt).boxed().collect(Collectors.toList());
// 当前手中的牌 + 已经出过的牌
List<Integer> list = new ArrayList<>();
list.addAll(line1);
list.addAll(line2);
System.out.println(list);
/**
* 对手的牌 = 全部牌 - 当前手中的牌 - 已经出过的牌
*
* key：3-A，value：每张牌的数量
*/
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < list.size(); i++) {
Integer s = list.get(i);
s = jqkaMap.getOrDefault(s, s);
Integer sum = map.getOrDefault(s, 4);
map.put(s, --sum);
}
System.out.println(map);
// 获取最大的龙
List<Integer> dragonList = getDragonList(map);
// 如果能获取到的最大的龙，不符合斗地主要求，直接返回NO-CHAIN
if(dragonList.size() < 5){
System.out.println("NO-CHAIN");
return;
}
// 按指定格式输出
StringJoiner stringJoiner = new StringJoiner("-");
dragonList.stream().sorted((o1, o2) -> {
return o1.compareTo(o2);
}).map(x -> {
if (reverseMap.containsKey(x)) {
String temp = String.valueOf(reverseMap.get(x));
stringJoiner.add(temp);
return temp;
}
stringJoiner.add(String.valueOf(x));
return x;
}).collect(Collectors.toList());
System.out.println(stringJoiner);
}
/**
* 获取最大的龙
* @param map 对手的牌 key：3-A，value：每张牌的数量
* @return 最大的龙
*/
private static List<Integer> getDragonList(Map<Integer, Integer> map){
// 获取符合要求的最大的龙
List<Integer> dragonList = new ArrayList<>();
// map倒序遍历，获取符合要求的最大的龙
ListIterator<Map.Entry<Integer, Integer>> mapList = new ArrayList<>(map.entrySet()).listIterator(map.size());
while (mapList.hasPrevious()) {
Map.Entry<Integer, Integer> previousMap = mapList.previous();
// 有剩余牌时，拼接龙
if (previousMap.getValue() > 0) {
dragonList.add(previousMap.getKey());
} else if (previousMap.getValue() == 0) {// 当没有牌时，表示能获取到的最大的龙
// 如果获取的龙，符合斗地主要求，则直接返回，否则清空dragonList，重新计算
if(dragonList.size()>=5){
break;
}else {
dragonList = new ArrayList<>();
}
}
}
System.out.println(dragonList);
return dragonList;
}
六、感谢@禁止你发言提供的更简单、更优质的算法
解题思路
可优化为：int prev = theirPokers[0] > -4 ? 1 : 0;
int current;
int max = Integer.MIN_VALUE;
//记录最长顺子的起始牌
int start = 1;
for (int i = 1; i < theirPokers.length; i++) {
//有剩余牌时，拼接顺子
if (theirPokers[i] > -4) {
current = prev + 1;
if (current > max) {
max = current;
start = i + 3 - max + 1; //注意这里+3，是由于数组下标和扑克牌之间差了3
}
// 无剩余牌，顺子长度置为0
} else {
current = 0;
}
prev = current;
}
优质算法源码
public static void main(String[] args) {
//获取输入：当前手中的牌 + 已经出过的牌， 并合并
Scanner scanner = new Scanner(System.in);
String myPokers = scanner.next();
String alreadyPokers = scanner.next();
String[] mergePokers = myPokers.concat("-").concat(alreadyPokers).split("-");
//为方便后续判断顺子，将JQKA转为int, reverse为供后续打印顺子使用
Map<Character, Integer> char2int = new HashMap<>();
char2int.put('J', 11);
char2int.put('Q', 12);
char2int.put('K', 13);
char2int.put('A', 14);
Map<Integer, Character> reverseMap = char2int.entrySet().stream()
.collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
// 定义数组表示对手的牌，遍历前面合并牌数组（当前手中的牌 + 已经出过的牌），每遍历到一张牌，对手的牌对应的数组元素 - 1
// 注意: 数组长度由来：有题目可知，顺子有效的牌为3-14，所以长度为14 - 3 + 1
// 注意：为什么-3：有效的顺子牌从3开始，而数组下标需要从0开始
int[] theirPokers = new int[14 - 3 + 1];
for (String poker : mergePokers) {
if (poker.length() > 1) { // 10
theirPokers[Integer.parseInt(poker) - 3]--;
} else if (char2int.containsKey(poker.charAt(0))) { //JQKA
theirPokers[char2int.get(poker.charAt(0)) - 3]--;
} else if (poker.charAt(0) != '2' && poker.charAt(0) != 'B' && poker.charAt(0) != 'C') {
theirPokers[Integer.parseInt(poker) - 3]--;
}
}
// 动态规划获取最长的顺子，当前牌的顺子长度只与前一个牌的顺子长度和当前牌是否可用有关
//如果对方的牌含有3，则初始值设置为1，否则为0
int prev = theirPokers[0] > -4 ? 1 : 0;
int current;
int max = Integer.MIN_VALUE;
//记录最长顺子的起始牌
int start = 1;
for (int i = 1; i < theirPokers.length; i++) {
//有剩余牌时，拼接顺子
if (theirPokers[i] > -4) {
current = prev + 1;
if (current > max) {
max = current;
// 注意这里+3，是由于数组下标和扑克牌之间差了3
start = i + 3 - max + 1;
}
// 无剩余牌，顺子长度置为0
} else {
current = 0;
}
prev = current;
}
// 符合条件
if (max >= 5) {
String straight = IntStream.range(start, start + max)
.mapToObj(poker -> poker > 10 ? reverseMap.get(poker) : poker)
.map(String::valueOf).collect(Collectors.joining("-"));
System.out.println(straight);
//长度小于5， 输出NO-CHAIN
} else {
System.out.println("NO-CHAIN");
}
}
七、效果展示
1、输入
A-4-5-8-8-10-C-6-7-82、输出
3、说明
