OJ《程序设计基础II》实验6——动态规划

最新推荐文章于 2022-10-06 21:04:42 发布
最新推荐文章于 2022-10-06 21:04:42 发布
阅读量580 收藏 6
点赞数 2
分类专栏： 山东理工大学 OJ 小白 文章标签： 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sky_kin/article/details/124032605
版权

6-1 A - 递归的函数

#include <stdio.h>
int p[31][31][31];
int f(int a,int b,int c)
{
    if(a<=0||b<=0||c<=0) return 1;//返回值为1的是单独的一个判断程序
    if(p[a][b][c]>0) return p[a][b][c];//从这里开始，是返回值为函数值的判断程序,如果p[a][b][c]>0,意味着已经判断过一次，直接返回就行，不需要再判断了，这样就不会超时了
    else if(a>20||b>20||c>20) return p[a][b][c]=f(20,20,20);
    else if(a<b&&b<c) return p[a][b][c]=f(a,b,c-1)+f(a,b-1,c-1)-f(a,b-1,c);
    else return p[a][b][c]=f(a-1,b,c)+f(a-1,b-1,c)+f(a-1,b,c-1)-f(a-1,b-1,c-1);
}
int main()
{
    int a,b,c;
    while(~scanf("%d %d %d",&a,&b,&c))
    {
        printf("%d\n",f(a,b,c));
    }
    return 0;
}

6-2 B - 数字三角形问题

#include <stdio.h>
int max(int a,int b)
{
    return a>b?a:b;//判断大小函数，如果a>b,输出a，否则输出b 
}
int a[101][101];
int ans[101][101];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=i;j++)
        {
            scanf("%d",&a[i][j]);
        }
    }
    for(int i=1;i<=n;i++)
    {
        ans[n][i]=a[n][i];
	}//将ans的最后一行赋值 
    for(int i=n-1;i>=1;i--)
    {
        for(int j=1; j<=i; j++)
        {
            ans[i][j]=max(ans[i+1][j],ans[i+1][j+1])+a[i][j];//只能向下或者向右下走，所以判断下或者右下哪个大就好 
        }
    }
    printf("%d\n",ans[1][1]);
    return 0;
}

6-3 C - 小鑫去爬山

#include <stdio.h>
int min(int a,int b)//构造函数筛选最小值 
{
    return a<b?a:b;
}
int a[101][101];
int ans[101][101];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=i; j++)
            {
                scanf("%d",&a[i][j]);
            }
        }
        for(int i=1; i<=n; i++)
        {
            ans[n][i]=a[n][i];//将第n行赋值，方便后面选择 
        }
        for(int i=n-1; i>=1; i--)//相当于一行一行往上走 
        {
            for(int j=1; j<=i; j++)
            {
                ans[i][j]=min(ans[i+1][j],ans[i+1][j+1])+a[i][j];//选择下一行的j和j+1列中较小的一个进行相加 
            }
        }//与上题差不多 
        printf("%d\n",ans[1][1]);
    }
    return 0;
}

 6-4 D - 最长公共子序列问题

#include <stdio.h>
#include <string.h>
int max(int a,int b)//构造max函数，筛选最大值 
{
    return a>b?a:b;
}
int main()
{
    char s1[501],s2[501];
    int n1,n2,a[501][501];
    while(~scanf("%s %s",s1,s2))
    {
        n1=strlen(s1);
        n2=strlen(s2);
        for(int i=0;i<=n1;i++)
        {
            a[i][0]=0;
        }
        for(int i=0;i<=n2;i++)
        {
            a[0][i]=0;
        }//以s1+1的长度为行，s2+1的长度位列，赋值矩阵 首行首列为0 
        for(int i=1;i<=n1;i++)
        {
            for(int j=1;j<=n2;j++)
            {
                if(s1[i-1]==s2[j-1])
                {
                  a[i][j]=a[i-1][j-1]+1;
                }
                else
                a[i][j]=max(a[i-1][j],a[i][j-1]);
            }
        }
            printf("%d\n",a[n1][n2]);
    }
    return 0;
}

和上图差不多的，需要理解，不好讲；

6-5 E - 最长上升子序列

#include <stdio.h>
#include <string.h>
int max(int a,int b)//max函数，筛选最大值 
{
    return a>b?a:b;
}
int main()
{
    int n,a[1001],b[1001];
    scanf("%d",&n);
    for(int i=0; i<n; i++)
    {
        scanf("%d",&a[i]);
        b[0]=1;//初始化边界条件，以a[0]结尾的最长上升子序列长度为1 
    }
    for(int i=1;i<n;i++)//让i从1开始，计算以a[i]结尾的最长上升子序列长度 
    {
        int Max=0;//j<i时最长上升子序列长度 
        for(int j=0;j<i;j++)
        {
            if(a[i]>a[j]&&b[j]>Max)//若a[j]<a[i]且Max小于以a[j]为结尾的最长上升子序列 
                Max=b[j];//则为Max赋新值 
        }
        b[i]=Max+1;//则以b[i]结尾的最长上升子序列为以b[j]结尾的最长上升子序列+1 
    }
    int ans=-1;
    for(int i=0;i<n;i++)
    {
        ans=max(ans,b[i]);//筛选以b[i]结尾的最长上升子序列的长度的最大值 
    }
    printf("%d",ans);
    return 0;
}

6-6 F - 上升子序列

#include <stdio.h>
#include <string.h>
int max(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    int n,a[1001],b[1001];
    while(~scanf("%d",&n))
    {
        for(int i=0; i<n; i++)
    {
        scanf("%d",&a[i]);
    }
    b[0]=a[0];//以b[0]结尾的最大上升子序列和为a[0] 
    for(int i=1;i<n;i++)//下面和上题几乎一模一样，不做过多赘述 
    {
        int Max=0;
        for(int j=0;j<i;j++)
        {
            if(a[i]>a[j]&&b[j]>Max)
                Max=b[j];
        }
        b[i]=Max+a[i];
    }
    int ans=-1;
    for(int i=0; i<n; i++)
        ans=max(ans,b[i]);
    printf("%d\n",ans);
    }
 
    return 0;
}

6-7 G - 最长公共子序列

不懂，直接放学长大佬的

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
char a[110][110];
int dp[30000 + 10];
int len[110];
int n;
int DP( int *x )//x记录每个字符串的动态长度，即每个状态对应的每个字符串长度，这里需要一定理解，每个状态可以想成把一部分字符串丢掉，即长度减少
{
    int i, j, index, ret;
    for( i = 1; i <= n; i++ )//如果有一个字符串的长度为0，那么最长公共子序列必定为0
    {
        if( x[i] == 0 )
        {
            return 0;
        }
    }
    for( index = x[n] - 1, i = n - 1; i >= 1; i-- )
    {
        index = index * len[i] + x[i] - 1; //转化为一维数组，这里可以自己推导一下，上面分享的博客里有解释
    }
    if( dp[index] >= 0 )//如果之前求过这个状态直接返回，减少重复计算，dp的核心思想
    {
        return dp[index];
    }
    //从每个字符串的末尾开始匹配
    for( i = 2; i <= n; i++ )
    {
        if( a[1][x[1] - 1] != a[i][x[i] - 1] )
        {
            break;
        }
    }
    if( i > n )//如果都相等则把字符串长度都-1，答案就行-1后字符串求dp的答案+1
    {
        for( j = 1; j <= n; j++ )
        {
            x[j]--;
        }
        ret = DP(x) + 1;//dp求得长度-1的字符串状态的最长+1
        for( j = 1; j <= n; j++ )
        {
            x[j]++;
        }
    }
    else
    {
        ret = 0;
        int t;
        //开始枚举每一种情况，取最大值保留
        for( j = 1; j <= n; j++ )
        {
            x[j]--;
            t = DP( x );
            ret = max( ret, t );
            x[j]++;
        }
    }
    dp[index] = ret;//记忆化
    return ret;
}
int main()
{
    int T;
    int L[110];
    scanf("%d", &T);
    while( T-- )
    {
        scanf("%d", &n);
        for( int i = 1; i <= n; i++ )
        {
            scanf("%s",a[i] );
            len[i] = L[i] = strlen( a[i] );
        }
        memset( dp, -1, sizeof(dp) );
        printf("%d\n", DP( L ) );
    }
    return 0;
}

6-8 H - 取数字问题

#include <stdio.h>
int max(int a,int b)
{
    return a>b?a:b;
}
int n,m;
int ans=0x3f3f3f3f,a[11][11];//ans设为int范围的最大值，用于下面验证。
void dp(int i,int j,int sum)//i，j表示现在在哪个点，sum表示从原点到(i,j)的和
{
    sum=sum+a[i][j];
    if(i<m-1)//如果没到最下边，则继续往下走，i+1表示向下一行的意思
        dp(i+1,j,sum);
    if(j<n-1)//如果没到最右边，则继续向右走
        dp(i,j+1,sum);
    if(i==m-1&&j==n-1&&sum>0&&sum<ans)//到达右下角了，判断这条路是否满足正数最小
        ans=sum;
}
int main()
{
    scanf("%d %d",&m,&n);
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            scanf("%d",&a[i][j]);
        }
    }
    dp(0,0,0);//从原点开始
    if(ans==0x3f3f3f3f)//如果ans值不变，意味着不能得到正整数 
        printf("-1");
    else
    printf("%d",ans);
    return 0;
}

6-9 I - 免费馅饼

#include<stdio.h>
#include<string.h>
int max(int a,int b)
{
    return a>b?a:b;
}
int dp[100001][15];
int main()
{
    int n;
    while(~scanf("%d",&n)&&n!=0)
    {
        int t1=0;
        memset(dp,0,sizeof(dp));
        for(int i=0;i<n;i++)
        {
            int x,t;
            scanf("%d %d",&x,&t);
            t1=max(t1,t);
            dp[t][x]++;
        }
        for(int i=t1-1;i>=0; i--)
        {
            dp[i][0]=dp[i][0]+max(dp[i+1][0],dp[i+1][1]);
            for(int j=1;j<=10;j++)
            {
                dp[i][j]=dp[i][j]+max(max(dp[i+1][j-1],dp[i+1][j]),dp[i+1][j+1]);
            }
        }
        printf("%d\n",dp[0][5]);
    }
    return 0;
}

6-10 J - 走迷宫

不怎么明白就不乱解释了，放学长大佬代码

#include<stdio.h>
#include<string.h>
struct node
{
    int x, y;
} ls[1000];
int dx[] = {0,-1,0,1}, dy[] = {-1,0,1,0};
int bj[16][16], map[16][16];
int m, n, step, sum = 0, xz, yz;
void dfs(int x1, int y1)
{
    int i;
    if(x1 == xz && y1 == yz)
    {
        sum++;
        for(i = 0; i < step; i++)
        {
            printf("(%d,%d)",ls[i].x,ls[i].y);
            if(i < step - 1)
                printf("->");
        }
        printf("\n");
    }
    else
    {
        int kx, ky;
        for(i = 0; i < 4; i++)
        {
            kx  = x1 + dx[i];
            ky =  y1 + dy[i];
            if(kx >= 1 && ky >= 1 && kx <= n && ky <= m && !bj[kx][ky] && map[kx][ky])
            {
                ls[step].x = kx;
                ls[step].y = ky;
                step++;
                bj[kx][ky] = 1;
                dfs(kx,ky);
                bj[kx][ky] = 0;
                step--;
            }
        }
    }
}
int main()
{
    int i, j,xq,yq;
    while(~scanf("%d%d",&n,&m))
    {
        memset(bj,0,sizeof(bj));
        memset(ls,0,sizeof(ls));
        for(i = 1; i <= n; i++)
            for(j = 1; j <= m; j++)
                scanf("%d",&map[i][j]);
        scanf("%d%d%d%d",&xq,&yq,&xz,&yz);
        ls[0].x = xq;
        ls[0].y = yq;
        sum = 0;
        step = 1;
        bj[xq][yq] = 1;
        dfs(xq,yq);
        if(sum == 0)
            printf("-1\n");
    }
    return 0;
}

加油加油加油！！！

动态规划--OJ题
m0_46795297的博客
04-28 505
动态规划–最长非连续子序列 题目描述： 在一个数字序列中，找到一个最长的非连续子序列，使得这个子序列是不下降（非递减）。现有序列A={1,2,3,-1,-2,7,9},则A的最长不下降子序列是{1,2,3,7,9}。如果有多个最长序列，只需选数字顺位靠后的序列从大到小输出。 [Accepted] OJ代码 #include<iostream> #include<windows...
OJ《程序设计基础II》实验2——链表
sky_kin的博客
03-30 1773
2-1 A - 数据结构实验之链表一：顺序建立链表 #include<stdio.h> #include<string.h> typedef struct Node//typedef使用后，下面的结构体可不用struct { int data; struct Node *next; }node; node *creat(int n) { node *head,*p,*tail; head=(node*)malloc(sizeof(node));//
OJ算法--动态规划
qq_42860218的博客
02-22 662
OJ算法–动态规划 算法概述 动态规划用于解决一定规模下的最优解问题，通过小规模最优解推导出大规模最优解，再由大规模最优解推导出更大规模最优解。以此类推最终得到问题答案，01背包问题就是最典型的动态规划问题。 例题 在刷牛客OJ时会遇到这样一道题： 算法原理 对于这样一个问题，影响问题规模的因素有两个，一个是需要凑出的邮票总价值，另一个是可用的邮票规模。当邮票总价值变小，或者可用邮票规模变小，亦或是两者同时变小时，问题都会变得更加简单。因此我们可以找出小规模问题和大规模问题中的某种递推公式，从而解决该题目
OJ题目8--动态规划问题
m0_62908071的博客
03-03 240
1，​​​​​​509. 斐波那契数 - 力扣（LeetCode） (leetcode-cn.com) 过去一直用递归法，但由于栈区空间的限制，当递归过深时容易发生栈溢出。 int fib(int n) { if(n==0) { return 0; } else if(n==1) { return 1; } else { return fib(n-1)+fib(n-2); } }
动态规划算法Oj题（一）
qq_61635026的博客
10-06 704
动态规划算法Oj题
hduoj 动态规划入门 数塔
小渣渣的博客
02-16 476
数塔 Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 64671    Accepted Submission(s): 37688   Problem Description 在讲述DP算法的时候，一个经典的例子就是数塔问题，它是这...
OJ《程序设计基础II》实验3——递推
sky_kin的博客
03-30 1955
3-1 A - 养兔子 #include<stdio.h> int main() { int n,i; scanf("%d",&n); long long a[111] = {0, 1, 2};//赋值，前几个自己可以算出来的值，然后找规律 for(i=3;i<=n;i++) { a[i]=a[i-1]+a[i-2];//找到规律后写 } printf("%lld",a[n]);//注意，上面用的long
OJ《程序设计基础II》 实验1- 结构体、共用体和枚举
sky_kin的博客
03-30 987
1-1 A - 检查宿舍卫生 #include<stdio.h> struct score { int a,b,c,d,e; }f[100];//结构体； int main() { int n,i,g[100],max=0,h=0; scanf("%d",&n); for(i=0;i<n;i++) { scanf("%d %d %d %d %d",&f[i].a,&f[i].b,&f[i].c,&f[i].d,&f[i].e
OJ 程序设计基础（B) I 实验一
m0_62582934的博客
12-12 1692
初学C语言
OJ《程序设计基础I 》实验4-for循环程序设计
sky_kin的博客
03-22 1096
1-1 A - A+B for Input-Output Practice (II) #include <stdio.h> int main() { int n,a,b,i; scanf("%d",&n); for(i=0;i<n;i++)\\for 循环，最好从0开始，因为后面学到数组都是从0开始。 { scanf("%d %d",&a,&b); printf("%d\n",a+b); }
OJ动态规划DP题目列表
01-06
OJ动态规划DP题目列表 POJ SOJ HDU 动态规划题目
ACM总结——动态规划
nameofcsdn的博客
05-29 3025
动态规划(dynamic programming)简称DP。 先看3个简单的问题： 1，斐波那契数列 1,1,2,3,5,8...... 求第n项 int fac(int n) { if(n<3)return 1; return fac(n-1)+fac(n-2); } 时间复杂度O (1.6 ^ n) 递归写法（备忘录法）： int ans[1000]={0}; int fac(int n) { if(n<3)return 1; if(ans
100道动态规划——40 CSUOJ 1889 Copying DNA 记忆化搜索 DP的感觉
Sion
04-28 1221
Description Evolution is a seemingly random process which works in a way which resembles certain approaches we use to get approximate solutions to hard combinatorial problems. You are now to do somet
OJ《程序设计基础I 》实验5-一维数组
sky_kin的博客
03-23 1526
1-1 A - C语言实验——最值 #include<stdio.h> int main() { int n,a[10],min,max,i,x,y,t,k; scanf("%d",&n); for(i=0;i<n;i++)//数组下标要从0开始，所以i=0； { scanf("%d",&a[i]); } max=a[0],min=a[0];//初始化max，min为a[0],方便比较； for(i
C语言循环结构程序设计
qq_45984789的博客
04-10 3389
内容详解 while语句 do—while语句 for语句 循环嵌套 break和continue语句 实例展示 热身小练：打印6行6列的 “ * ”矩阵，两个“ * ”之间用空格隔开 #include <stdio.h> int main() { for(int i=1;i<=6;i++) { for(int j=1;j<=6;j++) { prin...
ACM模块解析之 动态规划
popcjz的博客
04-17 1634
动态规划一.简介在ACM中，动态规划是一种将一个复杂问题分为多个简单的小问题的思想。在使用动态规划时，原问题须满足重叠子问题和最优子结构这个性质。运用动态规划思想设计的算法一般比朴素的算法高效很多。因为在计算某个状态的时候，已经被计算的子问题将不需要重复计算，而是调用之前存储下的结果。这样就减少了大量的重复计算。动态规划思想的本质是在一个有向无环图中，求一个函数的最优值，也可以看做是一个加入了“记...
《动态规划》— ACM 动态规划例题详解
69小石头的博客
08-19 1491
描述 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 (图1) 图1给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和。 注意：路径上的每一步只能从一个数走到下一层上和它最近的左边的那个数或者右边的那个数。 输入 输入的是一行是一个整数N (1 &...
C语言程序设计第五章循环结构程序设计总结
weixin_61961378的博客
12-04 684
例5.1 #include<stdio.h> #include<math.h> int main() { int n = 13, year; double number, rate = 0.02; for (year = 1; year <= 10; year++) { number = n * pow((1 + rate), year); printf("%2d年后,人数为:%.2f亿\n", year, number); } return 0; }
如何将二维数组转化为一维数组
热门推荐
weixin_43332220的博客
03-05 2万+
今天碰到一道面试题，如何将二维数组转化为一维 数组 问题是这样子的：[[0, 1], [2, 3], [4, 5]] 如何转化为 [0, 1, 2, 3, 4, 5]？ 方法一：使用ES5的reduce reduce() 方法接收一个函数作为累加器（accumulator），数组中的每个值（从左到右）开始缩减，最终为一个值。 arr.reduce(callback,[initialValue])...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CRAEN

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值