作业比赛编号 : 1271 - 2022年春季学期《算法分析与设计》练习9

最新推荐文章于 2022-09-27 15:03:43 发布

AllenCRQ

最新推荐文章于 2022-09-27 15:03:43 发布

阅读量272

点赞数

分类专栏： OJ 文章标签：蓝桥杯职场和发展

本文链接：https://blog.csdn.net/weixin_51250562/article/details/125036170

版权

OJ 专栏收录该内容

17 篇文章 1 订阅

订阅专栏

最大子段和

题目描述

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

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;

int dp(int a[], int n)
{
    int* dp = new int[n + 1];
    int m = 0;
    dp[1] = a[1];
    for (int i = 2; i <= n; i++)
    {
        dp[i] = max(dp[i - 1] + a[i], a[i]);
        if (dp[i] > m)
        {
            m = dp[i];
        }
    }
    return m;

}
int main()
{
    int n;
    int a[1005];
    while (cin >> n)
    {
        for (int i = 1; i <= n; i++)
        {
            cin >> a[i];
        }
        cout << dp(a, n) << endl;

    }
}

最大子段和升级版

题目描述

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

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
int b[100];
 
void fun(int a[], int n)
{
    b[0] = a[0];
    int max = b[0];
    for (int i = 1; i < n; i++) {
        if (b[i - 1] >= 0) {
            b[i] = a[i] + b[i - 1];
        }
        else {
            b[i] = a[i];
        }
        if (b[i] > max) {
            max = b[i];
        }
    }
    int maxx = max;
    int flag, flag1, k;
    
    for (k = n - 1; k >= 0; k--) {
        if (b[k] == maxx) {
            flag1 = k;
            break;
        }
 
    }
    for (int j = k; j >= 0; j--) {
        maxx = maxx - a[j];
        if (maxx == 0) {
            flag = j;
            break;
        }
    }
    printf("%d %d %d", max, flag + 1, flag1 + 1);
}
 
int main()
{
    int n;
    while (~scanf("%d", &n))
    {
        int a[n];
        for (int i = 0; i < n; i++) {
            scanf("%d", &a[i]);
        }
        fun(a, n);
        printf("\n");
    }
    return 0;
}

斜线最大最小值

题目描述

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

#include<iostream>
#include<algorithm>
using namespace std;
int a[100][100];

int main()
{
    int n;
    while (cin >> n)
    {
        int ma;
        int mi;
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                cin >> a[i][j];
            }
        }
        for (int r = 1; r <= n; r++)
        {
            ma = a[0][r - 1];
            mi = a[0][r - 1];

            for (int i = 0; i < n - r + 1; i++)
            {
                int j = i + r - 1;
                if (a[i][j] > ma)
                {
                    ma = a[i][j];
                }
                if (a[i][j] < mi)
                {
                    mi = a[i][j];
                }
            }

            cout << "L" << r << "=" << ma << "," << " " << "S" << r << "=" << mi << endl;

        }

    }
}

石子合并问题

题目描述

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

输入

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

输出

输出最小花费。

样例输入 Copy
5
1 2 3 4 5

样例输出 Copy
33

#include <iostream>
using namespace std;
void f();
#define MAX 999999999 //定义一个最大值，方便数据写进表中
int dp[1001][1001]={0};//初始化表格中最小花费
int num[1001];
int sum[1001][1001];//石子数
int n;

int main()
{
 cin>>n;
 for(int i=1;i<=n;i++)
 {
  cin>>num[i];
 }  
 f();
 return 0;
}

void f()
{
 int i,j,min1,t,k;//min1为最小值
 for( i=1;i<=n;i++)
 {
  sum[i][i]=num[i];//写入石子数
  for( j=i+1;j<=n;j++)
  {
   sum[i][j]=sum[i][j-1]+num[j];
  }
 }
 //遍历所有情况进行比较，读入最小花费值
 for( j=2;j<=n;j++)
 {
  for( i=j-1;i>0;i--)
  {
   min1=MAX;
   dp[i][j]=MAX;
   for( k=i;k<j;k++)
   {
    t=dp[i][k]+dp[k+1][j]+sum[i][j];//最小花费的和加上棋子数
    if(t<min1)
    min1=t;
   }
  dp[i][j]=min1;
  }
 }
 cout<<dp[1][n];
}

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

#include<iostream>
#include<algorithm>
using namespace std;
int a[1005][1005]; 
int dp[1008][1005];
int fun(int m,int n)
{
	for (int i = 0; i < m; i++)
	{
		dp[i][0] = dp[i - 1][0] + a[i][0];
	}

	for (int i = 0; i < n; i++)
	{
		dp[0][i] = dp[0][i-1] + a[0][i];
	}
	for (int i = 1; i < m; i++)
	{
		for (int j = 1; j < n; j++)

		{
			dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + a[i][j];
		} 
	}
	return dp[m - 1][n - 1];
}
int main() {
	int T;
	int m;
	int n;
	cin >> T;
	while (T--)
	{
	
		cin >> m >> n;
		for (int i = 0; i < m; i++)
		{
			for (int j = 0; j < n; j++)
			{
				cin >> a[i][j];
			}
		}
		cout << fun(m, n) << endl;
	}

}

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

题目描述

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

输入

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

输出

矩阵连乘最优计算次数。

样例输入 Copy
7
30 35 15 5 10 20 25

样例输出 Copy
15125


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include<iostream>
using namespace std;
int m[100][100];

int lookupchain(int a[], int i, int j) {
    if (m[i][j] < 0) {
        if (i == j) m[i][j] = 0;
        else {
            int u = lookupchain(a, i + 1, j) + a[i - 1] * a[i] * a[j];

            for (int k = i + 1; k < j; k++) {
                int t = lookupchain(a, i, k) + lookupchain(a, k + 1, j) + a[i - 1] * a[k] * a[j];
                if (t < u)
                    u = t;
            }
            m[i][j] = u;
        }
    }
    return m[i][j];
}

int main()
{
    int n;
    while (cin >> n)
    {
        int a[1005];
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                m[i][j] = -1;
            }
        }
        cout << lookupchain(a, 1, n - 1) << endl;
    }
    return 0;
}

动态规划：


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include<iostream>
using namespace std;
int m[100][100];
int p[1005];
void lookupchain(int n) {
    for (int i = 1; i <= n-1; i++)
        m[i][i] = 0;
    for (int r = 2; r <= n-1; r++)
    {
        for (int i = 1; i <= n-r; i++)
        {
            int j = i + r - 1;
            m[i][j] = m[i + 1][j] + p[i - 1] * p[i] * p[j];
            for (int k = i + 1; k < j; k++)
            {
                int t = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
                if (t < m[i][j])
                {
                    m[i][j] = t;
                }
            }
        }

    }
}

int main()
{
    int n;
    while (cin >> n)
    {
        for (int i = 0; i < n; i++) {
            cin >> p[i];
        }
        lookupchain(n);
      
        cout << m[1][n - 1] << endl;
    }
    return 0;
}

构造最优解

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include<iostream>
using namespace std;
int m[100][100];
int s[100][100];
void traceback(int i, int j)
{
    if (i == j)
        return;
    traceback(i, s[i][j]);
    traceback(s[i][j] + 1, j);
    cout << "A" << "[" << i << ":" << s[i][j] << "]" << "*" << "A" << "[" << s[i][j] + 1 << ":" << j << "]" << endl;
}
void mchain(int p[],int n)
{
    int t = n - 1;//t矩阵个数 n为数组长度
    for (int i = 1; i <=t; i++)
        m[i][i] = 0;
    for (int r = 2; r <= t; r++)
    {
        for (int i = 1; i <= t - r + 1; i++)
        {
            int j = i + r - 1;
            m[i][j] = m[i + 1][j] + p[i - 1] * p[i] * p[j];
            s[i][j] = i;
            for (int k = i + 1; k < j; k++)
            {
                int t = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
                if (t < m[i][j])
                {
                    m[i][j] = t;
                    s[i][j] = k;
                }
            }
        }
    }
    traceback(1, t);
}
 
int main()
{
    int n;
    int p[1000];
    while (cin >> n)
    {
        for (int i = 0; i < n; i++)
        {
            cin >> p[i];
        }
        mchain(p, n);
         
     
    }
}

AllenCRQ

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
作业比赛编号 : 1271 - 2022年春季学期《算法分析与设计》练习9

最大子段和题目描述给定n个整数（可能是负数）组成的序列a[1], a[2], a[3], …, a[n]，求该序列的子段和如a[i]+a[i+1]+…+a[j]的最大值。输入每组输入包括两行，第一行为序列长度n，第二行为序列。输出输出字段和的最大值。样例输入Copy5-1 0 1 2 3样例输出Copy6#include<cstdio>#include<iostream>#include<alg...
复制链接

扫一扫

专栏目录