牛客题解 | [CQOI2007]涂色PAINT

合集 - 牛客笔试必刷101题单题解(34)

1.牛客题解 | N皇后问题02-21

2.牛客题解 | [CQOI2007]涂色PAINT02-21

3.牛客题解 | [NOIP2001]装箱问题02-214.牛客题解 | [NOIP2002 普及组] 过河卒02-215.牛客题解 | [ZJOI2010]COUNT 数字计数02-216.牛客题解 | abb02-217.牛客题解 | ranko的手表02-218.牛客题解 | 【模板】01背包02-219.牛客题解 | 【模板】二维前缀和02-2110.牛客题解 | 【模板】二维差分02-2111.牛客题解 | 【模板】前缀和02-2112.牛客题解 | 【模板】单源最短路102-2113.牛客题解 | 【模板】哈夫曼编码02-2114.牛客题解 | 【模板】完全背包02-2115.牛客题解 | 【模板】差分02-2116.牛客题解 | 【模板】循环队列02-2117.牛客题解 | 【模板】链表02-2118.牛客题解 | 三角形最小路径和02-2119.牛客题解 | 不相邻取数02-2120.牛客题解 | 串02-2121.牛客题解 | 乘积为正数的最长连续子数组02-2122.牛客题解 | 买卖股票的最好时机(一)02-2123.牛客题解 | 买卖股票的最好时机(三)02-2124.牛客题解 | 买卖股票的最好时机(二)02-2125.牛客题解 | 买卖股票的最好时机(四)02-2126.牛客题解 | 二分查找-I02-2127.牛客题解 | 二叉树中的最大路径和02-2128.牛客题解 | 从中序与后序遍历序列构造二叉树02-2129.牛客题解 | 信封嵌套02-2130.牛客题解 | 兑换零钱02-2131.牛客题解 | 分割等和子集02-2132.牛客题解 | 删除相邻数字的最大分数02-2133.牛客题解 | 删除链表的节点02-2134.牛客题解 | 反转链表02-21

收起

题目

题目链接

解题思路

1. 状态定义：

   • $dp[i][j]$ 表示区间 $[i,j]$ 染色需要的最少次数

2. 转移方程：

   • 当 $s[i] == s[j]$ 时：$dp[i][j] = \min(dp[i+1][j], dp[i][j-1])$
   • 当 $s[i] != s[j]$ 时：$dp[i][j] = \min(dp[i][j], dp[i][k] + dp[k+1][j])$

3. 实现要点：

   • 字符串下标从 $1$ 开始，方便处理
   • 初始化 $dp$ 数组为较大值
   • 长度为 $1$ 的区间初始化为 $1$

---

代码

#include <bits/stdc++.h>
using namespace std;

int dp[51][51];

int main() {
    string s;
    cin >> s;
    int n = s.size();
    
    // 将字符串下标从1开始
    s = " " + s;
    
    // 初始化dp数组为较大值
    memset(dp, 0x3f, sizeof dp);
    
    // 初始化长度为1的区间
    for(int i = 1; i <= n; i++) {
        dp[i][i] = 1;
    }
    
    // 枚举区间长度
    for(int len = 2; len <= n; len++) {
        // 枚举左端点
        for(int i = 1; i + len - 1 <= n; i++) {
            int j = i + len - 1;  // 右端点
            
            // 如果区间两端颜色相同
            if(s[i] == s[j]) {
                dp[i][j] = min(dp[i+1][j], dp[i][j-1]);
            } else {
                // 枚举分割点
                for(int k = i; k < j; k++) {
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j]);
                }
            }
        }
    }
    
    cout << dp[1][n];
    return 0;
}

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

public class Main {
    static int[][] dp = new int[51][51];
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        int n = s.length();
        
        // 将字符串下标从1开始
        s = " " + s;
        
        // 初始化dp数组为较大值
        for(int[] row : dp) {
            Arrays.fill(row, 0x3f3f3f3f);
        }
        
        // 初始化长度为1的区间
        for(int i = 1; i <= n; i++) {
            dp[i][i] = 1;
        }
        
        // 枚举区间长度
        for(int len = 2; len <= n; len++) {
            // 枚举左端点
            for(int i = 1; i + len - 1 <= n; i++) {
                int j = i + len - 1;  // 右端点
                
                // 如果区间两端颜色相同
                if(s.charAt(i) == s.charAt(j)) {
                    dp[i][j] = Math.min(dp[i+1][j], dp[i][j-1]);
                } else {
                    // 枚举分割点
                    for(int k = i; k < j; k++) {
                        dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k+1][j]);
                    }
                }
            }
        }
        
        System.out.println(dp[1][n]);
        sc.close();
    }
}

def solve(s: str) -> int:
    n = len(s)
    # 将字符串下标从1开始
    s = " " + s
    
    # 初始化dp数组
    dp = [[float('inf')] * (n + 1) for _ in range(n + 1)]
    
    # 初始化长度为1的区间
    for i in range(1, n + 1):
        dp[i][i] = 1
    
    # 枚举区间长度
    for length in range(2, n + 1):
        # 枚举左端点
        for i in range(1, n - length + 2):
            j = i + length - 1  # 右端点
            
            # 如果区间两端颜色相同
            if s[i] == s[j]:
                dp[i][j] = min(dp[i+1][j], dp[i][j-1])
            else:
                # 枚举分割点
                for k in range(i, j):
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j])
    
    return dp[1][n]

def main():
    s = input().strip()
    print(solve(s))

if __name__ == "__main__":
    main()

---

算法及复杂度

• 算法：区间动态规划
• 时间复杂度：$\mathcal{O}(n^3)$，其中 $n$ 是字符串长度
• 空间复杂度：$\mathcal{O}(n^2)$，用于存储 $dp$ 数组