1 4 3 4 5
r y b b r
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

3
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

1 2 3 4
r y b l
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

1
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

# 输入获取
values = input().split()  # 读取牌的值
shades = input().split()  # 读取牌的花色

# 定义牌的类，每张牌有 "值" 和 "花色"
class Card:
    def __init__(self, val, shd):
        self.val = val  # 牌的值
        self.shd = shd  # 牌的花色

# 递归搜索最长的合法牌链
def search(sequence, visited, previous, depth, max_depth):
    # 更新当前最长链的深度
    max_depth[0] = max(max_depth[0], depth)

    # 遍历所有牌，尝试加入当前链
    for idx in range(len(sequence)):
        if visited[idx]:  # 如果该牌已被使用，则跳过
            continue

        current = sequence[idx]
        
        # 如果有前一张牌，检查是否符合连续条件 (值相同 或 花色相同)
        if previous and previous.val != current.val and previous.shd != current.shd:
            continue  # 如果不符合，跳过该牌

        # 选择该牌，并继续搜索
        visited[idx] = True
        search(sequence, visited, current, depth + 1, max_depth)
        visited[idx] = False  # 回溯，撤销选择

# 计算最长合法牌链的函数
def calculate_max_chain():
    total = len(values)  # 牌的总数

    # 生成牌的列表，每张牌是一个 Card 对象
    deck = [Card(values[i], shades[i]) for i in range(total)]

    max_depth = [0]  # 记录最长链的长度
    visited = [False] * total  # 记录哪些牌已经使用

    # 开始深度优先搜索，查找最长牌链
    search(deck, visited, None, 0, max_depth)

    return max_depth[0]  # 返回最长链的长度

# 输出最长合法牌链的长度
print(calculate_max_chain())

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49

java解法

• 解题思路
• 该程序的目的是计算最长的连续牌链，其中：

每张牌包含值 (val) 和 颜色 (col)。
牌链的规则：
相邻的牌，必须满足值相同或颜色相同。
解题步骤
读取输入

第一行输入为整数数组 vals，代表所有牌的值。
第二行输入为字符串数组 cols，代表所有牌的颜色。
创建 Tile 类

Tile 类存储每张牌的值和颜色。
回溯搜索 (DFS)

采用**回溯 + 深度优先搜索（DFS）**遍历所有可能的排列，计算最长合法链的长度。
变量说明：
vis[]：布尔数组，标记当前牌是否被使用。
prev：表示当前牌链中的上一张牌。
maxChain[0]：存储最长牌链的长度。
递归 search() 方法

遍历所有牌，尝试加入牌链：
如果当前牌 cur 和上一张牌 prev 不符合值或颜色相同的规则，则跳过。
标记 vis[i] = true，递归搜索下一张牌。
回溯 (vis[i] = false)，撤销选择，继续搜索其他可能路径。
最终返回 maxChain[0] 作为最长合法牌链的长度

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 读取第一行输入（牌的值）并转换为整数数组
        int[] vals = Arrays.stream(sc.nextLine().split(" "))
                           .mapToInt(Integer::parseInt)
                           .toArray();

        // 读取第二行输入（牌的颜色）并存储为字符串数组
        String[] cols = sc.nextLine().split(" ");

        // 计算最长合法牌链
        System.out.println(calc(vals, cols));
    }

    // 定义Tile类，表示每张牌
    static class Tile {
        int val; // 牌的值
        char col; // 牌的颜色（用字符表示）

        public Tile(int val, String col) {
            this.val = val;
            this.col = col.charAt(0); // 取颜色字符串的第一个字符
        }
    }

    // 计算最长合法牌链
    public static int calc(int[] vals, String[] cols) {
        int len = vals.length;
        Tile[] tiles = new Tile[len];

        // 创建牌的数组，每张牌由值和颜色组成
        for (int i = 0; i < len; i++) {
            tiles[i] = new Tile(vals[i], cols[i]);
        }

        int[] maxChain = {0}; // 存储最长牌链长度
        boolean[] vis = new boolean[len]; // 记录哪些牌已经使用

        // 进行深度优先搜索（DFS）
        search(tiles, vis, null, 0, maxChain);

        return maxChain[0]; // 返回最长牌链的长度
    }

    // 递归搜索最长的合法牌链
    public static void search(Tile[] tiles, boolean[] vis, Tile prev, int len, int[] maxChain) {
        // 更新最长牌链长度
        maxChain[0] = Math.max(maxChain[0], len);

        // 遍历所有牌，尝试加入牌链
        for (int i = 0; i < tiles.length; i++) {
            if (vis[i]) continue; // 如果该牌已被使用，则跳过

            Tile cur = tiles[i];

            // 如果前一张牌存在，检查是否符合连续条件 (值相同 或 颜色相同)
            if (prev != null && prev.val != cur.val && prev.col != cur.col) continue;

            // 选择该牌，并继续搜索
            vis[i] = true;
            search(tiles, vis, cur, len + 1, maxChain);
            vis[i] = false; // 回溯，撤销选择
        }
    }
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">