uva1625 Color Length 线性动态规划

UVA 1625: Color Length 问题解析与状态转移方程
本文详细解释了UVA 1625问题的解决策略,通过引入状态转移方程,实现最优解的求解。重点讨论了如何高效地记录和计算每种颜色的起始和结束位置,以及如何利用这些信息来最小化合并后的颜色序列中各颜色跨度的总和。
// uva1625 Color Length
// 这是好久之前在紫书(page 276)上看到的题目了
// 题目的意思是,给你两个长度分别为n和m的颜色序列(n,m<=5000)
// 都是由大写字母组成,要求按照顺序合并成同一个序列,即每次
// 可以把一个序列开头的颜色放在新序列的尾部
// 比如两个序列:GGBY 和 YRRGB至少有两种合并结果:
// GBYBRYRGB 和 YRRGGBBYB 对于每一种颜色c,跨度L(c)是最大位置和
// 最小位置之差,
// 问题是: 找一种合并的方式使得L(c)的总和最小。
//
// 首先,要换一种思维,每种颜色分别记录最小位置和最大位置,这个是不会有错的
// 之后,我们不是每种颜色单独去统计每次出现这种颜色时,他的最开始的位置,然
// 后再去加上此时的长度,而是所有颜色一起统计在第一个串i的位置和在第二个串j
// 的位置未结束但是已经开始的颜色的总数,因为最后统计的总的sigema(L)的时候
// 这些位置都是要算进去的
// 则:状态d(i,j)表示第一个串剩下i和第二个串剩下j时所得到的sigma(L)的最小值
// 则状态转移为:d(i,j) = min(d(i+1,j),d(i,j+1))+res(i,j);
// d(i+1,j)表示从第一个串拿走一个
// d(i,j+1)表示从第二个串拿走一个
// res(i,j)表示当前第一个串i,第二个串j位置时未结束但是已经开始的颜色的总数
//
//
//
// 感悟:
// 这道题真的看了很久很久,想了很久很久,看着书上的记录开始和结束的位置
// 我还能懂,之后计数的环节我就不太懂了,书上的代码我也没有看懂
// 目前只会这种状态的定义,而且细节部分还要多多的考究,会把紫书上的状态
// 再仔细的研习的,也望各位能够给予指点,小子实在是感激不尽
// 哎,继续练吧。。。
// 
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define ceil(a,b) (((a)+(b)-1)/(b))
#define endl '\n'
#define gcd __gcd
#define highBit(x) (1ULL<<(63-__builtin_clzll(x)))
#define popCount __builtin_popcountll
typedef long long ll;
using namespace std;
const int MOD = 1000000007;
const long double PI = acos(-1.L);

template<class T> inline T lcm(const T& a, const T& b) { return a/gcd(a, b)*b; }
template<class T> inline T lowBit(const T& x) { return x&-x; }
template<class T> inline T maximize(T& a, const T& b) { return a=a<b?b:a; }
template<class T> inline T minimize(T& a, const T& b) { return a=a<b?a:b; }

const int maxn = 5010;
int d[maxn][maxn];
char p[maxn],q[maxn];
int len1,len2;
int start[27][2];
int end[27][2];
int res[maxn][maxn];
const int inf = 0x3f3f3f3f;

void print(){
	for (int i=0;i<len1;i++){
		for (int j=0;j<len2;j++)
			printf("%d ",d[i][j]);
		puts("");
	}
}
void init(){
	scanf("%s",p);
	scanf("%s",q);
	len1 = strlen(p);
	len2 = strlen(q);
	for (int i=0;i<=len1;i++)
		for (int j=0;j<=len2;j++)
			d[i][j] = inf;
	memset(start,0x3f,sizeof(start));
	memset(end,-1,sizeof(end));
	for (int i=0;i<len1;i++){
		p[i] -= 'A';
	}
	for (int i=0;i<len2;i++)
		q[i] -= 'A';
	for (int i=0;i<len1;i++){
		if (start[p[i]][0] == inf)
			start[p[i]][0] = i;
		end[p[i]][0] = i;
	}
	for (int i=0;i<len2;i++){
		if (start[q[i]][1] == inf)
			start[q[i]][1] = i;
		end[q[i]][1] = i;
	}
	for (int i=0;i<=len1;i++)
		for (int j=0;j<=len2;j++){
			int cnt = 0;
			for (int k=0;k<26;k++){
				if (start[k][0]==inf&&start[k][1]==inf)	continue;
				if (start[k][0]>i-1&&start[k][1]>j-1)	continue;
				if (end[k][0]<i&&end[k][1]<j)	continue;
				cnt++;
			}
			res[i][j] = cnt;
		}
}


void solve(){
	d[len1][len2]=0;
	//print();
	for (int i=len1-1;i>=0;i--)
		d[i][len2] = d[i+1][len2]+res[i][len2];
	for (int j=len2-1;j>=0;j--)
		d[len1][j] = d[len1][j+1]+res[len1][j];
	for (int i=len1-1;i>=0;i--)
		for (int j=len2-1;j>=0;j--)
			d[i][j] = min(d[i+1][j],d[i][j+1])+res[i][j];
	printf("%d\n",d[0][0]);
//	print();
}

int main() {
	int t;
	//freopen("G:\\Code\\1.txt","r",stdin);
	scanf("%d",&t);
	while(t--){
		init();
		solve();
	}
	return 0;
}

### 关于UVa 307问题的动态规划解法 对于UVa 307 (Sticks),虽然通常采用深度优先搜索(DFS)+剪枝的方法来解决这个问题,但也可以尝试构建一种基于动态规划的思想去处理它。然而,在原描述中并未提及具体的动态规划解决方案[^3]。 #### 动态规划解题思路 考虑到本题的核心在于通过若干根木棍拼接成更少数量的新木棍,并使得这些新木棍尽可能接近给定的目标长度。为了应用动态规划技术,可以定义一个二维数组`dp[i][j]`表示从前i种不同类型的木棍中选取一些组合起来能否恰好组成总长度为j的情况: - 如果存在这样的组合,则`dp[i][j]=true`; - 否则`dp[i][j]=false`. 初始化时设置`dp[0][0]=true`, 表明没有任何木棍的情况下能够构成零长度。接着遍历每种类型的木棍以及所有可能达到的累积长度,更新对应的布尔值。最终检查是否存在某个k使得`sum/k * k == sum && dp[n][sum/k]`成立即可判断是否能成功分割。 这种转换方式利用了动态规划中的两个重要特性:最优化原理和重叠子问题属性。具体来说,每当考虑一根新的木棍加入现有集合时,只需要关注之前已经计算过的较短长度的结果,从而避免重复运算并提高效率[^1]. #### Python代码实现 下面给出一段Python伪代码用于说明上述逻辑: ```python def can_partition_sticks(stick_lengths, target_length): n = len(stick_lengths) # Initialize DP table with False values. dp = [[False]*(target_length + 1) for _ in range(n + 1)] # Base case initialization. dp[0][0] = True for i in range(1, n + 1): current_stick = stick_lengths[i - 1] for j in range(target_length + 1): if j >= current_stick: dp[i][j] |= dp[i - 1][j - current_stick] dp[i][j] |= dp[i - 1][j] return any(dp[-1][l] and l != 0 for l in range(target_length + 1)) # Example usage of the function defined above. stick_lengths_example = [...] # Input your data here as a list. total_sum = sum(stick_lengths_example) if total_sum % min(stick_lengths_example) == 0: result = can_partition_sticks(stick_lengths_example, int(total_sum / min(stick_lengths_example))) else: result = False print('Can partition sticks:', 'Yes' if result else 'No') ``` 需要注意的是,这段代码只是一个简化版本,实际比赛中还需要进一步调整参数以适应特定输入范围的要求。此外,由于题目本身允许有多余的小段剩余未被使用,所以在设计状态转移方程时也应适当放宽条件.
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值