HIT研究生算法作业4

1、答：
定义：$maxSu{m}_i为A[1,...i]连续子数组的最大和;su{m}_i为当前连续子数组的和$，则有

递推方程：

$$\begin{gathered} su{m}_i=A[i]ifi=1或su{m}_{i-1}<0 \\ su{m}_i=su{m}_{i-1}+A[i]ifsu{m}_{i-1}>=0 \\ maxSu{m}_i=A[i]ifi=1 \\ maxSu{m}_i=Max(maxSu{m}_{i-1},su{m}_i) \end{gathered}$$

算法伪代码：

• 输入：$数组A[1,2....n]$
• 输出：连续子数组的最大和

maxSubArray(A)
	maxSum <- A[1];
	sum <- A[1];
	for i <- 2 to n
		if sum < 0 Then
			sum <- A[i];
		else
			sum <- sum + A[i];
		maxSum = Max(maxSum, sum);
	return maxSum; 

时间复杂度分析：

• 输入规模：$n$
• 复杂度：$O(n)$

2、答：
定义：$d{p}_i为爬到第i阶台阶的方法数$，则有

递推方程：

$$\begin{gathered} d{p}_1=1d{p}_2=2 \\ d{p}_i=d{p}_{i-1}+d{p}_{i-2} \end{gathered}$$

算法伪代码：

• 输入：台阶阶数$n$
• 输出：爬到$n$阶的方法数

climbStairs(n)
	if n == 1 Then return 1;
	if n == 2 Then return 2;
	dp_i_1 <- 2;
	dp_i_2 <- 1;
	for i <- 3 to n
		dp_i <- dp_i_1 + dp_i_2;
		dp_i_2 = dp_i_1;
		dp_i_1 = dp_i;
	return dp_i;
		 

时间复杂度分析：

• 输入规模：$\log n$
• 复杂度：$O(2^{\log n})$

3、答：
定义：$dp[i][j]记录字符串S中s_i{s}_{i+1}...s_j子串是否为回文的$，则有

递推方程：

$$\begin{gathered} dp[i][i]=True \\ dp[i][i+1]=Trueif{s}_i=s_{i+1} \\ dp[i][j]=Trueifdp[i+1][j-1]=True且s_i=s_j \end{gathered}$$

算法伪代码：

• 输入：字符串$S$
• 输出：最长回文子串$S^{\prime }$

longestPalindrome(S)
	n <- S.length;
	dp <- new boolean[n][n]
	start <- 1;
	maxL <- 1;
	if n <= 1 Then return S;
	for i <-1 to n
		dp[i][i] <- True;
	for i <-1 to n - 1
		if S[i] = S[i + 1] Then 
			dp[i][i + 1] <- True;
			start <- i;
			maxL <- 2;
	for gap <- 2 to n - 1
		for i <- 1 to n - gap - i
			j <- i + gap;
			if dp[i + 1][j - 1] && S[i] = S[j] Then
				dp[i][j] <- True;
				start <- i;
				maxL <- gap + 1;
	return S.subString(start, start + gap);

时间复杂度分析：

• 输入规模：$n$
• 复杂度：$O(n^2)$

4、答：
定义：$dp[i][j]记录到达网格A第i行第j列，最短路径$，则有

递推方程：

$$\begin{gathered} dp[i][j]=A[i][j]ifi=1且j=1 \\ dp[i][j]=dp[i-1][j]+A[i][j]ifj=1且i>=2 \\ dp[i][j]=dp[i][j-1]+A[i][j]ifi=1且j>=2 \\ dp[i][j]=Min(dp[i-1][j],dp[i][j-1])+A[i][j] \end{gathered}$$

算法伪代码：

• 输入：网格$A[1...m][1...n]$
• 输出：到达网格第m行第n列的最短路径

findPath(A, m, n)
	dp <- new int[m][n];
	dp[1][1] <- A[1][1];
	path <- new Stack()
	for i <- 2 to m
		dp[i][1] <- dp[i - 1][1] + A[i][1];
	for j <- 2 to n
		dp[1][j] <- dp[1][j - 1] + A[1][j];
	for i <- 2 to m
		for j <- 2 to n
			dp[i][j] <- Min(dp[i - 1][j],dp[i][j - 1]) + A[i][j];
	i <- m; j <- n;
	while i >= 1 && j >= 1
		d <- dp[i][j] - A[i][j]
		if i > 1 && dp[i - 1][j] == d Then
			path.push(DOWN);
		else
			path.push(RIGHT);
	return path;

时间复杂度分析：

• 输入规模：$mn$
• 复杂度：$O(mn)$

5、答：
定义：$dp[i][j]为i时刻j位置可以收到得最多馅饼数$

递推方程：
$$\begin{gathered} dp[i][j]=P[i][j]ifi=1且j=4,5,6 \\ dp[i][j]=Max(dp[i-1][j],dp[i-1][j-1],dp[i-1][j+1])+P[i][j] \end{gathered}$$

算法伪代码：

• 输入：$数组P，P[i][j]表示i时刻j位置落下得馅饼数$
• 输出：可以获得最多得馅饼数

getPie(P)
	t <- P.length;
	dp <- new int[13];
	dp[-1] <- 0; dp[11] <- 0; 
	dp[4] <- P[1][4];dp[5] <- P[1][5];dp[6] <- P[1][6];
	start <- 3;
	end <- 7;
	for i <- 2 to t
		start <- Max(--start, 0);
		end <- Min(++end, 10);
		for j <- start to end
			dp[j] <- Max(dp[j],dp[j - 1], dp[j + 1]) + P[i][j];
	return Max(dp);

时间复杂度分析：

• 输入规模：$11n$
• 复杂度：$O(n)$