本文探讨了如何使用动态规划解决一系列与矩阵相关的问题，包括最大子段和、子段和的起止位置、斜线最大最小值、矩阵连乘次数优化、最优路径和最小花费等。通过实例和代码展示了如何应用备忘录法、递归和状态转移方程求解这些问题。
A最大子段和
该问题的先设置一个循环，从第一个元素开始遍历数组a的所有元素，并且用b数组记录从第0个元素到第i个元素的最大和。用if语句判断元素的前一个值是否大于0.若大于0，则b[i]=b[i-1]+a[i],若小于0，则b[i]=a[i],重新开始记录最大子段和.
题目描述
给定n个整数（可能是负数）组成的序列a[1], a[2], a[3], …, a[n]，求该序列的子段和如a[i]+a[i+1]+…+a[j]的最大值。
输入
每组输入包括两行，第一行为序列长度n，第二行为序列。
输出
输出字段和的最大值。
样例输入 Copy
5 -1 0 1 2 3
样例输出 Copy
6
import java.util.Scanner;
public class Main {
public static int[] a;
public static int[] b;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
int n=scan.nextInt();
a=new int[n];
b=new int[n];
for(int i=0;i<n;i++)
a[i]=scan.nextInt();
slove();
}
}
public static void slove(){
b[0]=a[0];
int max=b[0];
for(int i=1;i<a.length;i++){
if(b[i-1]>0)
b[i]=b[i-1]+a[i];
else
b[i]=a[i];
if(b[i]>max)
max=b[i];
}
System.out.println(max);
}
}
B最大子段和升级版
题目描述
使用动态规划算法求整数数组（可能包含负整数）的最大子段和，以及和最大子段的起始位置和结束位置：
例如：输入数组(6,-1,5,4,-7)，输出14, 1, 4，其中14表示最大子段和，1表示和最大的子段从第1个数字开始，4表示和最大的子段到第4个数字结束，即(6, -1 , 5, 4)。
输入
每组输入两行，第1行为数组中包含的整数个数n，第2行为n个整数（可能包含负整数），两两之间用空格隔开。
输出
输出最大子段和，以及和最大子段的起始位置和结束位置，两两之间用空格隔开。
样例输入 Copy
5 6 -1 5 4 -7
样例输出 Copy
14 1 4
问题解析：在题目A的基础上添加记录起始位和末尾的元素。设置记录起始元素位的first为0，在记录max的同时记录下end的位置。设置循环，从end处开始，max一直减去当前元素，直到max=0，则找到了起始的位置。
import java.util.Scanner;
public class Main {
public static int[] a;
public static int[] b;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
int n=scan.nextInt();
a=new int[n];
b=new int[n];
for(int i=0;i<n;i++)
a[i]=scan.nextInt();
slove();
}
}
public static void slove(){
b[0]=a[0];
int max=b[0];
int first=0,end=0,max1=0;
for(int i=1;i<a.length;i++){
if(b[i-1]>0)
b[i]=b[i-1]+a[i];
else
b[i]=a[i];
if(b[i]>max){
max=b[i];
end=i;
}
max1=max;
}
for(int i=end;i>=0;i--){
max1=max1-a[i];
if(max1==0)
first=i;
}
System.out.println(max+" "+(first+1)+" "+(end+1));
}
}
问题 C: 斜线最大最小值
题目描述
求如图所示一个上三角矩阵中每一条斜线中的最大元素(L)和最小元素(S)。
输入
每组输入包括两部分，一部分为数字n，表示三角矩阵的行数。
第二部分即为三角矩阵。
输出
每一个对角线输出一行，每行包括Lx=Max, Sx=Min，其中x为斜线序号（序号从1开始），Max为该斜线上的最大值，Min为该斜线上的最小值。
样例输入 Copy
6 1 3 5 7 11 20 0 6 8 2 3 13 0 0 7 4 8 9 0 0 0 18 3 10 0 0 0 0 12 6 0 0 0 0 0 15
样例输出 Copy
L1=18, S1=1 L2=8, S2=3 L3=10, S3=2 L4=9, S4=3 L5=13, S5=11 L6=20, S6=20
问题解析：该问题关键在于行，列的表述。设置r为行，用循环遍历每一行。用i表示斜线的当前行，j表示斜线当前列。通过规律可以发现i=n-r+1,j=i+r-1。通过循环遍历可以找出每一斜线所对应的最值。
import java.util.Scanner;
public class Main {
public static int[][] a;
public static int[][] b;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
int n=scan.nextInt();
a=new int[n][n];
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
a[i][j]=scan.nextInt();
b=new int[n][n];
slove();
}
}
public static void slove(){
b[0][0]=a[0][0];
for(int i=1;i<a.length;i++)
b[0][i]=b[0][i-1]+a[0][i];
for(int r=1;r<=a.length;r++){
int l=a[0][r-1];
int s=a[0][r-1];
for(int i=0;i<a.length-r+1;i++){
int j=i+r-1;
l=Math.max(l, a[i][j]);
s=Math.min(s, a[i][j]);
}
System.out.println("L"+r+"="+l+", S"+r+"="+s);
}
}
}
问题 D: 矩阵连乘问题-备忘录法求最优值
题目描述
使用备忘录法求解矩阵连乘问题，输出最少乘法次数。
输入
每组数据包括两行，第一行为数组长度n，第二行为存储矩阵维数的一维数组。
输出
矩阵连乘最优计算次数。
样例输入 Copy
7 30 35 15 5 10 20 25
样例输出 Copy
15125
问题解析：根据备忘录法的特点，将问题拆分为多个子问题，存储每一个子问题的值，并且从其中选取子问题中值较小的组合为最终答案。
import java.util.Scanner;
public class Main {
public static int[] a;
public static int[][] b;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
int n=scan.nextInt();
a=new int[n];
for(int i=0;i<n;i++)
a[i]=scan.nextInt();
b=new int[n][n];
System.out.println(slove(1,n-1));
}
}
public static int slove(int i,int j){
if(b[i][j]>0)
return b[i][j];
if(i==j)
return 0;
int min=slove(i+1,j)+a[i-1]*a[i]*a[j];
for(int k=i+1;k<j;k++){
int t=slove(i,k)+slove(k+1,j)+a[i-1]*a[k]*a[j];
if(min>t)
min=t;
}
b[i][j]=min;
return min;
}
}
问题 E: 矩阵连乘问题-动态规划求最优值
题目描述
使用动态规划算法求解矩阵连乘问题，输出最少乘法次数。
输入
每组数据包括两行，第一行为数组长度n，第二行为存储矩阵维数的一维数组。
输出
矩阵连乘最优计算次数。
样例输入 Copy
7 30 35 15 5 10 20 25
样例输出 Copy
15125
代码分析：与上题的解法的不同之处在于增加了两个循环遍历，使得能找出最小的解
import java.util.Scanner;
public class Main {
public static int[] a;
public static int[][] b;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
int n=scan.nextInt();
a=new int[n];
for(int i=0;i<n;i++)
a[i]=scan.nextInt();
b=new int[n][n];
slove();
}
}
public static void slove(){
for(int r=2;r<=a.length;r++)
for(int i=1;i<a.length-r+1;i++){
int j=i+r-1;
b[i][j]=b[i+1][j]+a[i-1]*a[i]*a[j];
for(int k=i+1;k<j;k++){
int t=b[i][k]+b[k+1][j]+a[i-1]*a[k]*a[j];
if(b[i][j]>t)
b[i][j]=t;
}
}
System.out.println(b[1][a.length-1]);
}
}
问题 F: 矩阵连乘问题-构造最优解
题目描述
使用动态规划算法求解矩阵连乘问题。
输入
每组数据包括两行，第一行为数组长度n，第二行为存储矩阵维数的一维数组。
输出
矩阵连乘最优计算次序。
样例输入 Copy
7 30 35 15 5 10 20 25
样例输出 Copy
A[2:2] * A[3:3] A[1:1] * A[2:3] A[4:4] * A[5:5] A[4:5] * A[6:6] A[1:3] * A[4:6]
代码分析：添加了数组c,用于对于矩阵连乘的位置的确认；添加的find函数用于输出对应的位置的乘积顺序。
import java.util.Scanner;
public class Main {
public static int[] a;
public static int[][] b;
public static int[][] c;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
int n=scan.nextInt();
a=new int[n];
for(int i=0;i<n;i++)
a[i]=scan.nextInt();
b=new int[n][n];
c=new int[n][n];
slove();
find(1,n-1);
}
}
public static void slove(){
for(int r=2;r<=a.length;r++)
for(int i=1;i<a.length-r+1;i++){
int j=i+r-1;
b[i][j]=b[i+1][j]+a[i-1]*a[i]*a[j];
c[i][j]=i;
for(int k=i+1;k<j;k++){
int t=b[i][k]+b[k+1][j]+a[i-1]*a[k]*a[j];
if(b[i][j]>t){
b[i][j]=t;
c[i][j]=k;
}
}
}
}
public static void find(int i,int j){
if(i==j)
return;
find(i,c[i][j]);
int t=c[i][j]+1;
find(t,j);
System.out.println("A["+i+":"+c[i][j]+"] * "+"A["+t+":"+j+"]");
}
}
问题 G: 石子合并问题
题目描述
在一条直线上有n堆石子，每堆有一定的数量，每次可以将两堆相邻的石子合并，合并后放在两堆的中间位置，合并的费用为两堆石子的总数。求把所有石子合并成一堆的最小花费。例如：输入{1，2，3，4，5}，输出33。【3+6+9+15=33】
输入
本题应该处理到文件尾，每组输入包括两行，第一行为石子堆的个数n，第二行则为每堆石子的个数。
输出
输出最小花费。
样例输入 Copy
5 1 2 3 4 5
样例输出 Copy
33
问题分析：与矩阵连乘问题的思路大致相同。将乘积问题替换成相邻的两个数的和的问题。
import java.util.Scanner;
public class Main {
public static int n;
public static int[] a;
public static int[][] b;
public static int[][] c;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
n=scan.nextInt();
a=new int[n];
b=new int[n][n];
c=new int[n][n];
for(int i=0;i<n;i++)
a[i]=scan.nextInt();
for(int i=0;i<n;i++)
c[i][i]=a[i];
for(int i=0;i<n;i++)
for(int j=i+1;j<n;j++)
c[i][j]=c[i][j-1]+a[j];
slove();
}
}
public static void slove(){
for(int r=2;r<=n;r++)
for(int i=0;i<n-r+1;i++){
int j=i+r-1;
b[i][j]=b[i+1][j]+c[i][j];
for(int k=i+1;k<j;k++){
int t=b[i][k]+b[k+1][j]+c[i][j];
if(b[i][j]>t){
b[i][j]=t;
}
}
}
System.out.println(b[0][n-1]);
}
}
问题 H: XP的矩阵
题目描述
XP学长觉得矩阵很美，虽然他也不知道美在哪里，因此，他决定挖掘一下矩阵的美。现在给定一个m行n列的矩阵，从左上角开始每次只能向右或者向下移动，最后到达右下角的位置，将路径上的所有数字累加起来作为这条路径的路径和。XP学长决定编写一个程序来求所有路径和中的最小路径和。例如，下面矩阵中的路径1-3-1-0-6-1-0是所有路径中路径和最小的，返回结果是12。
1 3 5 9
8 1 3 4
5 0 6 1
8 8 4 0
输入
输入包含多组测试用例，第一行输入一个T表示测试数据组数，(1<=T<=15)
接下来有T组数据，每组先输入两个整数M,N接下来输入M*N的矩阵(1<=N,M<=1000)，且最终结果在int范围内。
输出
输出路径和的最小值。
样例输入 Copy
1 4 4 1 3 5 9 8 1 3 4 5 0 6 1 8 8 4 0
样例输出 Copy
12
问题分析：定义数组b来存储到达a[i][j]的最优路径，通过Math.min(a,b)函数来判断上方和左边的较小的元素来实现。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
int z=scan.nextInt();
for(int y=0;y<z;y++){
int m=scan.nextInt();
int n=scan.nextInt();
int[][] a=new int[m][n];
int[][] b=new int[m][n];
for(int i=0;i<m;i++)
for(int j=0;j<n;j++)
a[i][j]=scan.nextInt();
b[0][0]=a[0][0];
for(int i=1;i<n;i++)
b[0][i]=b[0][i-1]+a[0][i];
for(int i=1;i<m;i++)
b[i][0]=b[i-1][0]+a[i][0];
for(int i=1;i<a.length;i++)
for(int j=1;j<a[0].length;j++)
b[i][j]=Math.min(b[i-1][j],b[i][j-1])+a[i][j];
System.out.println(b[a.length-1][a[0].length-1]);
}
}
}
699
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
