2022年春季学期《算法分析与设计》练习9

君临๑

于 2022-10-04 21:22:24 发布

阅读量187

点赞数 1

分类专栏：算法设计与分析文章标签：算法 java

本文链接：https://blog.csdn.net/m0_53653948/article/details/127166499

版权

算法设计与分析专栏收录该内容

17 篇文章 3 订阅

订阅专栏

1458: 最大子段和

题目描述

给定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

import java.util.Scanner;
import static java.lang.Math.max;
public class Main{
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        while(scan.hasNext()){
        int n=scan.nextInt();
        int a[]=new int[n];
        for(int i=0;i<n;i++){
            a[i]=scan.nextInt();
        }
        int MAX;
        int dp[]=new int[1001];
        dp[0]=a[0];
        MAX=dp[0];
        for(int i=1;i<a.length;i++){
            dp[i]=max(dp[i-1]+a[i],a[i]);
            MAX=max(MAX,dp[i]);
        }
        System.out.println(MAX);
    }}
}

1993: 最大子段和升级版

题目描述

使用动态规划算法求整数数组（可能包含负整数）的最大子段和，以及和最大子段的起始位置和结束位置：
例如：输入数组(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

import java.util.Scanner;
 
public class Main{
    private static void solve(int a[]) {
        int dp[]=new int[1001];
        int MAX,s,e;
        s=0;
        e=0;
        dp[0]=a[0];
        MAX=dp[0];
        for(int j=1;j<a.length;j++){
            if(dp[j-1]>0){
                dp[j]=dp[j-1]+a[j];
            }
            else{
                dp[j]=a[j];
            }
            if(dp[j]>MAX){
                MAX=dp[j];
                e=j;
            }
            int maxSum2=MAX;
            for(int i=e;i>=0;i--){
                maxSum2=maxSum2-a[i];
                if(maxSum2==0)
                    s=i;
            }
        }
        System.out.println(MAX+" "+(s+1)+" "+(e+1));
    }
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
       while(scan.hasNext()){
           int n= scan.nextInt();
        int a[]=new int[n];
        for(int i=0;i<n;i++){
            a[i]=scan.nextInt();
        }
        solve(a);
 
       }
    }
}

1455: 斜线最大最小值

题目描述

求如图所示一个上三角矩阵中每一条斜线中的最大元素(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

import java.util.Scanner;
 
import static java.lang.Math.max;
import static java.lang.Math.min;
 
public class Main{
    public static void main(String[] args) {
        int a[][]=new int[1001][1001];
        Scanner scan=new Scanner(System.in);
            while(scan.hasNext())
            {
                int n=scan.nextInt();
                for(int i=0; i<n; i++)
                {
                    for(int j=0; j<n; j++)
                    {
                        a[i][j]=scan.nextInt();
                    }
                }
                int minn=0,maxx=0;
                for(int r=1; r<=n; r++)
                {
                    maxx=a[0][r-1];
                    minn=a[0][r-1];
                    for(int i=1; i<n-r+1; i++)
                    {
                        int j=i+r-1;
                        maxx=max(maxx,a[i][j]);
                        minn=min(minn,a[i][j]);
                    }
                    System.out.printf("L%d=%d, S%d=%d\n",r,maxx,r,minn);
                }
            }
        }
 
 
    }

1992: 矩阵连乘问题-备忘录法求最优值

题目描述

使用备忘录法求解矩阵连乘问题，输出最少乘法次数。

输入

每组数据包括两行，第一行为数组长度n，第二行为存储矩阵维数的一维数组。

输出

矩阵连乘最优计算次数。

样例输入 Copy

7
30 35 15 5 10 20 25

样例输出 Copy

import java.util.Scanner;
 
public class Main{
    private static int solve(int[] a, int[][] b,int i, int j) {
        if(b[i][j]>0) return b[i][j];
        if(i==j) return 0;
        int u=solve(a,b,i,i)+solve(a,b,i+1,j)+a[i-1]*a[i]*a[j];
        for(int k=i+1;k<j;k++)
        {
            int t=solve(a,b,i,k)+solve(a,b,k+1,j)+a[i-1]*a[k]*a[j];
            if(t<u)
                u=t;
        }
        b[i][j]=u;
        return u;
    }
    public static void main(String[] args) {
        int b[][]=new int[2000][2000];
        int a[]=new int[1000];
 
        Scanner scan=new Scanner(System.in);
        while(scan.hasNext()){
            int n= scan.nextInt();
            for(int i=0;i<n;i++){
                a[i]= scan.nextInt();
            }
            int z=solve(a,b,1,n-1);
            System.out.println(z);
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++)
                    b[i][j]=0;
            }
        }
    }
}

1470: 矩阵连乘问题-动态规划求最优值

题目描述

使用动态规划算法求解矩阵连乘问题，输出最少乘法次数。

输入

每组数据包括两行，第一行为数组长度n，第二行为存储矩阵维数的一维数组。

输出

矩阵连乘最优计算次数。

样例输入 Copy

7
30 35 15 5 10 20 25

样例输出 Copy

import java.util.Scanner;
 
public class Main{
    private static int solve(int[] a, int[][] b,int i, int j) {
        if(b[i][j]>0) return b[i][j];
        if(i==j) return 0;
        int u=solve(a,b,i,i)+solve(a,b,i+1,j)+a[i-1]*a[i]*a[j];
        for(int k=i+1;k<j;k++)
        {
            int t=solve(a,b,i,k)+solve(a,b,k+1,j)+a[i-1]*a[k]*a[j];
            if(t<u)
                u=t;
        }
        b[i][j]=u;
        return u;
    }
    public static void main(String[] args) {
        int b[][]=new int[2000][2000];
        int a[]=new int[1000];
 
        Scanner scan=new Scanner(System.in);
        while(scan.hasNext()){
            int n= scan.nextInt();
            for(int i=0;i<n;i++){
                a[i]= scan.nextInt();
            }
            int z=solve(a,b,1,n-1);
            System.out.println(z);
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++)
                    b[i][j]=0;
            }
        }
    }
}

1456: 矩阵连乘问题-构造最优解

题目描述

使用动态规划算法求解矩阵连乘问题。

输入

每组数据包括两行，第一行为数组长度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]

#include <bits/stdc++.h>
using namespace std;
void checkk(int x,int *p,int **dp,int **s)
{
    int n=x-1;
    for(int i=1; i<=n; i++)
    {
        dp[i][i]=0;
    }
    for(int r=2; r<=n; r++)
    {
        for(int i=1; i<=n-r+1; i++)
        {
            int j=r+i-1;
            dp[i][j]=dp[i+1][j]+p[i-1]*p[i]*p[j];
            s[i][j]=i;
            for(int k=i+1; k<j; k++)
            {
                int t=dp[i][k]+dp[k+1][j]+p[i-1]*p[k]*p[j];
                if(t<dp[i][j])
                {
                    dp[i][j]=t;
                    s[i][j]=k;
                }
            }
        }
    }
}
void checkkkprint(int **s,int i,int j){
    if(i==j){
        return ;
    }
    checkkkprint(s,i,s[i][j]);
    checkkkprint(s,s[i][j]+1,j);
    printf("A[%d:%d] * A[%d:%d]\n",i,s[i][j],s[i][j]+1,j);
}
int main()
{
    int n;
    while(cin>>n)
    {
        int p[105];
        for(int i=0; i<n; i++)
        {
            cin>>p[i];
        }
        int **dp = new int *[n + 1];
        int **s = new int *[n + 1];
        for (int i = 1; i <= n; i++)
        {
            dp[i] = new int[n + 1];
            s[i] = new int[n + 1];
        }
        checkk(n,p,dp,s);
        checkkkprint(s,1,n-1);
    }
    return 0;
}

1459: 石子合并问题

题目描述

在一条直线上有n堆石子，每堆有一定的数量，每次可以将两堆相邻的石子合并，合并后放在两堆的中间位置，合并的费用为两堆石子的总数。求把所有石子合并成一堆的最小花费。例如：输入{1，2，3，4，5}，输出33。【3+6+9+15=33】

输入

本题应该处理到文件尾，每组输入包括两行，第一行为石子堆的个数n，第二行则为每堆石子的个数。

输出

输出最小花费。

样例输入 Copy

5
1 2 3 4 5

样例输出 Copy

import java.util.Scanner;
 
public class Main{
    public static void main(String[] args) {
 
 
        int a[]=new int[200];
 
        Scanner scan=new Scanner(System.in);
            while(scan.hasNext()){
            int n= scan.nextInt();
                for(int i=0;i<n;i++)
                    a[i]=scan.nextInt();
                int z=solve(n,a);
                System.out.println(z);
            }
        }
 
       public static int solve(int n,int a[]){
           int tb[][]=new int[200][200];
           int sum[][]=new int[200][200];
            for(int i=1;i<=n;i++)
                tb[i][i]=0;
 
 
            for(int i=1;i<=n;i++)
                sum[i][i]=a[i-1];
 
            for(int i=1;i<n;i++){
                for(int j=i+1;j<=n;j++)
                    sum[i][j]=sum[i][j-1]+a[j-1];
                }
 
 
 
            for(int r=2;r<=n;r++){
 
                for(int i=1;i<=n-r+1;i++) {
 
                    int j = i + r - 1;
 
                    tb[i][j] = tb[i][i] + tb[i + 1][j] + sum[i][j];
 
                    for (int k = i + 1; k < j; k++) {
 
                        int t = tb[i][k] + tb[k + 1][j] + sum[i][j];
 
                        if (tb[i][j] > t)
 
                            tb[i][j] = t;
 
                    }
                }
                }
 
            return tb[1][n];
        }
    }

君临๑

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
2022年春季学期《算法分析与设计》练习9

在一条直线上有n堆石子，每堆有一定的数量，每次可以将两堆相邻的石子合并，合并后放在两堆的中间位置，合并的费用为两堆石子的总数。例如：输入{1，2，3，4，5}，输出33。例如：输入数组(6,-1,5,4,-7)，输出14, 1, 4，其中14表示最大子段和，1表示和最大的子段从第1个数字开始，4表示和最大的子段到第4个数字结束，即(6, -1 , 5, 4)。每一个对角线输出一行，每行包括Lx=Max, Sx=Min，其中x为斜线序号（序号从1开始），Max为该斜线上的最大值，Min为该斜线上的最小值。
复制链接

扫一扫