[蓝桥杯 2023 省 B] 接龙数列

题目来自洛谷：

思路：

题目要求我们求最少删除多少个数，可以使剩下的序列是接龙序列。也就是说，我们要求合法的最长的接龙序列。接龙序列：“例如 12,23,35,56,61,11 是接龙数列；12,23,34,56 不是接龙数列，因为 56 的首位数字不等于 34 的末位数字。所有长度为 1 的整数数列都是接龙数列。”

我们可以“选和不选”的思想，来解决这道题目。先枚举所有的合法的方案，然后在返回时，返回最大那个分支。

记忆化搜索：

#include<bits/stdc++.h>
#define int long long 
using namespace std;
const int N = 1e5+20;

int n;
int arr[N];
int mem[N][11];  // 修改1：第二维改为11

int get_final(int x) {
    return x % 10;
}

int get_first(int x) {
    while (x >= 10) x /= 10;
    return x;
}

int dfs(int x, int final) {  // final：-1表示前面没有保留的数字
    if (x > n) return 0;
    
    // 修改2：将final偏移+1避免负数索引
    if (mem[x][final + 1] != -1) return mem[x][final + 1];
    
    int s = get_first(arr[x]);
    int e = get_final(arr[x]);
    
    // 修改3：处理初始状态（final=-1的情况）
    if (final == -1) {
        int keep = dfs(x + 1, e);        // 保留当前数字
        int skip = dfs(x + 1, -1) + 1;   // 跳过当前数字
        return mem[x][final + 1] = min(keep, skip);
    }
    
    if (s != final) {  // 只能跳过
        return mem[x][final + 1] = dfs(x + 1, final) + 1;
    }
    
    // 可以选择保留或跳过
    int keep = dfs(x + 1, e);
    int skip = dfs(x + 1, final) + 1;
    return mem[x][final + 1] = min(keep, skip);
}

signed main() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> arr[i];
    memset(mem, -1, sizeof mem);
    cout << dfs(1, -1) << endl;  // 修改4：初始状态设置为-1
    return 0;
}

递推代码：

#include<bits/stdc++.h>
#define int long long 
using namespace std;
const int N = 1e5+20;

int n;
int arr[N];//存数据
int f[N][15];

//得到数字的尾项
int get_final(int x){
    return x%10;
}
//①得到数字的首位容易错误 没考虑到个位数的存在
int get_first(int x){
    while(x >= 10){
        x= x/ 10;
    }
    return x;
}

signed main(){
    cin >> n;
    for(int i = 1; i <= n; i++) cin >> arr[i];
    
    int final = get_final(arr[1]);
    f[1][final] = 1;
    //从上往下递推
    //求的是最长子序列
    for(int i = 2; i <= n; i++){
        
        int s = get_first(arr[i]);
        int e = get_final(arr[i]);
        
        //不选 没有记录前面数字的最后一个数字
        //因此 for 循环遍历一下 把最后一个数字传下来
        for(int j = 0; j<=9; j++){
            f[i][j] = f[i-1][j];
        }
        //选择
        //返回的是f[i-1][s] +1话，代表能够构成最长子序列
        //返回的是f[i][e] 代表不选
        f[i][e] = max(f[i][e], f[i-1][s] +1);
        
    }
    //因为是从上往下递归的，所以要遍历一下第n层的点，找到最长接龙序列
    int ans = 0;
    for(int i = 0; i <= 9; i++){
        ans = max(ans, f[n][i]);
    }
    
    cout << n-ans << endl;
    return 0;
}