蓝桥杯每日一题----区间dp

前言

暂时没啥好说的,直接进入正题吧

引入

涂色PAINT

蓝桥杯每日一题----区间dp_第1张图片
读题发现要求的是使一段区间满足要求的最小操作次数,考虑用动态规划去做。
第一步:考虑缩小规模,这里的规模其实就是区间长度,那么dp数组应该可以表示某个区间,所以到这里dp数组至少是二维的,也就是dp[i][j],表示让区间[i,j]合法的最小操作次数。
第二步:考虑限制,这里暂时看不出来有啥限制,那就先不管。
第三步:根据写出来的dp数组推转移方程,dp[i][j]可以从三个地方转移dp[i-1][j],dp[i][j-1],dp[i-1][j-1],考虑这三个转移有什么特点,假设我现在已经求出了dp[i-1][j-1]的染色次数,那么当s[i]=s[j]时,我只需要在对dp[i-1][j-1]染色之前,把区间[i,j]进行一次涂色,涂成s[i]的颜色,这样再执行dp[i-1][j-1]得到的就是对区间[i,j]染成了要求的颜色,那么染色次数dp[i][j]=dp[i-1][j-1]+1;假设我现在已经求出了dp[i-1][j]的染色次数,那么当s[i]=s[j]时,我只需要在对第j个木板进行染色时同时捎带着把第i个木板染了就行,那么染色次数dp[i][j]=dp[i-1][j];假设我现在已经求出了dp[i][j-1]的染色次数,那么当s[i]=s[j]时,我只需要在对第i个木板进行染色时同时捎带着把第j个木板染了就行,那么染色次数dp[i][j]=dp[i][j-1];可以考虑三者取最小值。
综上,当s[i]=s[j]时,dp[i][j]=min(dp[i-1][j-1]+1,dp[i][j-1],dp[i-1][j])
那么当s[i]!=s[j]时,没有办法直接求这个大区间,那么就从小区间考虑,即断开区间。假设断点是k,分别求dp[i][k]和dp[k+1][j],再加起来即可,对于不同的断点取最小值。
第四步:考虑要写代码了,这里要注意一下dp数组如何初始化,我们可以明确的知道,区间长度为1时,所需要的操作次数就是1,所以初始化区间长度为1的值。我们要求的是最小值,其它位置上的值可以初始化为一个较大的值,也可以直接是0,但是在求解过程中要特判一下。
第五步:考虑区间dp的板子,区间dp一般三层for循环,第一层遍历区间长度,一般由2开始。
第二层遍历区间左端点,根据区间左端点和区间长度,区间右端点也就出来了。
第三层遍历区间断点。
这道题目就分析完了,还是给了两个版本的代码,一个是我初学时写的,一个是现在写的,都能AC,但是现在写的更规范一点

package java动态规划;

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

public class ok涂色 {
public static void main(String[] args) {
	Scanner scanner = new Scanner(System.in);
	char s[] = (" "+scanner.next()).toCharArray();
	int n = s.length-1;
	int dp[][] = new int[n+1][n+1];
	for(int i = 0;i <= n;i++) Arrays.fill(dp[i], Integer.MAX_VALUE/2);
	for(int i = 0;i <= n;i++) dp[i][i] = 1;
	for(int len = 2;len <= n;len++) {
		for(int l = 1;l+len-1<=n;l++) {
			int r = len+l-1;
			if(s[l]==s[r]) dp[l][r] = Math.min(dp[l+1][r], dp[l][r-1]);
			else {
				for(int k = l;k < r;k++)
					dp[l][r] = Math.min(dp[l][r], dp[l][k]+dp[k+1][r]);
			}
		}
	}
	System.out.println(dp[1][n]);
}
}
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String string = scanner.next();
		char[] s = string.toCharArray();
		int[][] dp = new int[string.length()][string.length()];
		// 初始化
		for (int i = 0; i < dp.length; i++) {
			dp[i][i] = 1;
		}

		for (int i = 1; i < string.length(); i++) {
			for (int j = 0; j + i < string.length(); j++) {
				int l = j;
				int r = j + i;
				if (s[l] == s[r]) {
					dp[l][r] = Math.min(dp[l + 1][r], dp[l][r - 1]);
				} else {
					for (int k = l; k < r; k++) {
						if (dp[l][r] != 0) {
							dp[l][r] = Math.min(dp[l][k] + dp[k + 1][r], dp[l][r]);
						} else {
							dp[l][r] = dp[l][k] + dp[k + 1][r];
						}
					}
				}
			}
		}
		System.out.println(dp[0][string.length() - 1]);
	}
}

例题2

合并回文子串
蓝桥杯每日一题----区间dp_第2张图片
这道题稍微难一点,关键在于要想到用区间dp去做,并且明确区间是谁。我们要合并字符串A和B,那么可以考虑一点一点的合并,比如A的某个区间和B的某个区间进行合并。
第一步:考虑规模,这里的规模就是要合并的两个字符串,那么其实也就是有两个区间,字符串A的区间和字符串B的区间,那么dp数组就是四维的,dp[i][j][k][l]表示将字符串Ai-Aj与字符串Bk-Bl是否能形成回文串,如果可以那么回文串的长度就是(j-i+1)+(l-k+1).
第二步:考虑限制,限制就是不能更改原串字符的相对顺序,但是这里不知道怎么加在dp数组中,暂时一放。
第三步:推状态转移方程
对于dp[i][j][k][l],考虑一下如果怎么变成回文,i和j可以是对应的回文,j和k也可以是对应的回文,i和l可以是对应的回文,k和l可以是对应的回文。
那么考虑i和k可以是对应的回文吗?若可以,那么位置k必然是在l的右边,这样就打乱了数组B的原始顺序,所以是不可以的,其它非法方案也是类似。
若A[i]=A[j],则dp[i][j][k][l]可以从dp[i-1][j-1][k][l]转移过来,我只是想判断这种情况是否是回文,若是则为1,否则则为0,所以转移的时候可以直接用或运算转移,即dp[i][j][k][l]|=dp[i-1][j-1][k][l]。其他情况类似,于是有这样的转移方程,
若A[i]=A[j],则dp[i][j][k][l]|=dp[i+1][j-1][k][l]
若A[j]=A[k],则dp[i][j][k][l]|=dp[i][j][k+1][l-1]
若A[i]=A[l],则dp[i][j][k][l]|=dp[i+1][j][k][l-1]
若A[k]=A[j],则dp[i][j][k][l]|=dp[i][j+1][k-1][l]
当相等的情况不满足时,其实也就是无法构成回文,不必考虑。
第四步:考虑写代码,这里有两个区间,所以前两个for循环分别表示两个区间的长度,后两个for循环分别表示区间的左端点,因为这里没有断开区间操作,所以不用遍历断点。这里在写的时候注意是从区间长度为0开始遍历的,当总区间长度小于等于1时必然是回文,也就是len1+len2<=1时,直接是dp[i][j][k][l]=1。当然也可以预处理出来总长度为1的情况,但是不要漏处理了。

参考代码

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt();
        while (t > 0) {
            t--;
            String a = scanner.next();
            String b = scanner.next();
            int n1 = a.length();
            int n2 = b.length();
            int dp[][][][] = new int[n1 + 5][n1 + 5][n2 + 5][n2 + 5];
            a = " " + a + " ";
            b = " " + b + " ";
            int res = 0;
            for (int len1 = 0; len1 < n1 + 1 ; len1++) {
                for (int len2 = 0; len2 < n2 + 1; len2++) {
                    for (int l1 = 1, r1 = len1 + l1 - 1; r1 < n1 + 1; l1++, r1++) {
                        for (int l2 = 1, r2 = len2 + l2 - 1; r2 < n2 + 1; l2++, r2++) {
//                      int r1 = len1+l1-1;
//                      int r2 = len2+l2-1;
                            if (len1 + len2 <= 1) {
                                dp[l1][r1][l2][r2] = 1;
                            } else {
                                if (r2 > 0 && a.charAt(l1) == b.charAt(r2))
                                    dp[l1][r1][l2][r2] |= dp[l1 + 1][r1][l2][r2 - 1];
                                if (r1 > 0 && a.charAt(r1) == b.charAt(l2))
                                    dp[l1][r1][l2][r2] |= dp[l1][r1 - 1][l2 + 1][r2];
                                if (r1 > 0 && a.charAt(l1) == a.charAt(r1))
                                    dp[l1][r1][l2][r2] |= dp[l1 + 1][r1 - 1][l2][r2];
                                if (r2 > 0 && b.charAt(l2) == b.charAt(r2))
                                    dp[l1][r1][l2][r2] |= dp[l1][r1][l2 + 1][r2 - 1];

                                if (dp[l1][r1][l2][r2] == 1) {
                                    res = Math.max(res, len1 + len2);
                                }
                            }

                        }
                    }
                }
            }
            System.out.println(res);
        }
    }
}

你可能感兴趣的:(蓝桥杯,职场和发展)