hdu 1421 1159 1087 1160 5366 1257 light OJ 1110 uva 562 简单dp

最新推荐文章于 2022-03-16 02:42:45 发布
最新推荐文章于 2022-03-16 02:42:45 发布
阅读量590 收藏 1
点赞数
文章标签： 简单dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24667639/article/details/47292807
版权

hdu 1421

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <stack>
#include <set>
#include <map>
#include <vector>

using namespace std;
#define INF 0x2fffffff
#define LL long long
#define MAX(a,b) ((a)>(b))?(a):(b)
#define MIN(a,b) ((a)<(b))?(a):(b)
int a[2005];
int dp[2005][10005];

int main(){
    int n,m;
    while(cin >> n >> m){

        for(int i = 1;i <= n;i++){
            scanf("%d",&a[i]);
        }
        sort(a+1,a+n+1);

        for(int i = 0;i <= m;i++){
            dp[0][i] = INF;
            dp[1][i] = INF; 
        }
        for(int i = 0;i <= n;i++){
            dp[i][0] = 0;
        }
        for(int i = 2;i <= n;i++){
            for(int j = 1;j <= m;j++){
                if(i < 2*j){
                    dp[i][j] = INF;
                }   
                else{
                    dp[i][j] = min(dp[i-2][j-1]+(a[i-1]-a[i])*(a[i-1]-a[i]),dp[i-1][j]);
                }
            }
        }
        printf("%d\n",dp[n][m]);
    } 
    return 0;
}

hdu 1159

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <stack>
#include <set>
#include <map>
#include <vector>

using namespace std;
#define INF 0x2fffffff
#define LL long long
#define MAX(a,b) ((a)>(b))?(a):(b)
#define MIN(a,b) ((a)<(b))?(a):(b)
char a[1005];
char b[1005];
int dp[1005][1005];

int main(){
    while(scanf("%s %s",a+1,b+1)!=EOF){
        int len1 = strlen(a+1);
        int len2 = strlen(b+1);
        memset(dp,0,sizeof(dp));
        for(int i = 1;i <= len1;i++){
            for(int j = 1;j <= len2;j++){
                if(a[i] == b[j]){
                    dp[i][j] = dp[i-1][j-1]+1;
                }
                else{
                    dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        printf("%d\n",dp[len1][len2]);
    }     
    return 0;
}

hdu 1087

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <stack>
#include <set>
#include <map>
#include <vector>

using namespace std;
#define INF 0x2fffffff
#define LL long long
#define MAX(a,b) ((a)>(b))?(a):(b)
#define MIN(a,b) ((a)<(b))?(a):(b)
int a[1005];
LL dp[1005];

int main(){
    int t;
    while(cin >>t ,t){
        for(int i = 0;i < t;i++){
            scanf("%d",&a[i]);
        }
        memset(dp,0,sizeof(dp));
        dp[0] = a[0];
        LL  ans = a[0];
        for(int i = 0;i < t;i++){
            dp[i] = a[i];
            for(int j = 0;j < i;j++){
                if(a[i] > a[j]){
                    dp[i] = MAX(dp[i],dp[j]+a[i]);
                }
            }
            ans = MAX(dp[i],ans);
        }
        printf("%I64d\n",ans);
    }
    return 0;
}

hdu 1160

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <stack>
#include <set>
#include <map>
#include <vector>

using namespace std;
#define INF 0x2fffffff
#define LL long long
#define MAX(a,b) ((a)>(b))?(a):(b)
#define MIN(a,b) ((a)<(b))?(a):(b)
struct node{
    int x,y,i;
    bool operator < (const node& a)const{
        return x < a.x;
    }
};
node a[100000];
int dp[100000];
void dfs(int now,int d){
    for(int i = now-1;i >= 0;i--){
        if(dp[i] == d-1 && a[i].x < a[now].x  && a[i].y > a[now].y){
            dfs(i,d-1);
            break;
        }
    }
    printf("%d\n",a[now].i);
}
int main(){
    int n = 0;
    while(scanf("%d%d",&a[n].x,&a[n].y)!=EOF) a[n].i = n+1,n++;
    sort(a,a+n);
    for(int i = 0;i < n;i++){
        dp[i] = 1;
    }
    int ma = 0;
    int ss ;
    for(int i = 0;i < n;i++){
        for(int j = 0;j < i;j++){
            if(a[i].y < a[j].y && a[i].x > a[j].x){
                dp[i] = max(dp[i],dp[j]+1);
            }
        }
        if(ma < dp[i]){
            ma = dp[i];
            ss = i;
        }
    }
    printf("%d\n",ma);
    dfs(ss,ma);
    return 0;
}

hdu 1231

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <stack>
#include <set>
#include <map>
#include <vector>

using namespace std;
#define INF 0x2fffffff
#define LL long long
#define MAX(a,b) ((a)>(b))?(a):(b)
#define MIN(a,b) ((a)<(b))?(a):(b)
int a[10005];
int dp[10005];
int l[10005];

int main(){
    int n;
    while(scanf("%d",&n)!=EOF&&n){
        int now = 0;
        int ans = 0;
        int flag = 0; 
        for(int i = 0;i < n;i++){
            scanf("%d",&a[i]);
            if(a[i] >= 0){
                flag = 1;
            }
        }
        int loc = 0;
        for(int i = 0;i < n;i++){
            if(a[i] > 0){
                now += a[i];
            }
            else{
                if(now + a[i] >= 0){
                    now += a[i]; 
                }
                else{
                    now = 0;
                    loc = i+1;
                }
            }
            ans = max(ans,now);
            dp[i] = ans;
            l[i] = loc;
        }
        printf("%d ",ans);
        if(flag == 0){
            printf("%d %d\n",a[0],a[n-1]);
        }
        else{
            int i = 0;
            if(ans!=0)
                for(i = 0;i < n;i++){
                    if(dp[i] == ans ){
                        break;
                    }
                }
            else{
                for(i = 0;i < n;i++){
                    if(a[i] == 0) break;
                }
            }
            printf("%d %d\n",a[l[i]],a[i]);                     
        }
    }
    return 0;

}

：另附一份简短的代码

#include <iostream>
#include <cstdio>
#include <climits>
#include <cstring>

using namespace std;

int a[11000],s,M,L,l,R,N;

int main()
{
    while (scanf("%d",&N),N){
        s=0; M=INT_MIN; L=1; l=1;
        for (int j=1;j<=N;j++){
            scanf("%d",&a[j]);
            s+=a[j];
            if (s>M) L=l,M=s,R=j;   
            if (s<0) s=0,l=j+1;      
        }
        if (M<0){
            M=0; L=1; R=N;
        }
        printf("%d %d %d\n",M,a[L],a[R]);
    }
}

hdu 5366

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <stack>
#include <set>
#include <map>
#include <vector>

using namespace std;
#define INF 0x2fffffff
#define LL long long
#define MAX(a,b) ((a)>(b))?(a):(b)
#define MIN(a,b) ((a)<(b))?(a):(b)

unsigned long long  f[100];

int main(){
    int n;
    f[1] = 1;
    f[2] = 2;
    f[3] = 3;
    f[4] = 5;
    f[5] = 8;
    for(int i = 6;i <= 60;i++){
        f[i] = f[i-3] + f[i-4] + f[i-5] + 3 + f[i-3];
    }
    while(cin >> n){
        cout << f[n] << endl;
    }
    return 0;

}

light OJ 1110

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <stack>
#include <set>
#include <map>
#include <vector>

using namespace std;
#define INF 0x2fffffff
#define LL long long
#define MAX(a,b) ((a)>(b))?(a):(b)
#define MIN(a,b) ((a)<(b))?(a):(b)
char a[1000];
char b[1000];
int dp[105][105];
string ans[105][105];
int main(){
    int t;
    cin >> t;
    int T = 1;
    while(t--){
        scanf("%s%s",a+1,b+1);
        int lena = strlen(a+1);
        int lenb = strlen(b+1);
        memset(dp,0,sizeof(dp));
        for(int i = 0;i <= lena ;i++){
            for(int j = 0;j <= lenb;j++){
                ans[i][j] = "";
            }
        }
        for(int i = 1;i <= lena;i++){
            for(int j = 1;j <= lenb;j++){
                if(a[i] == b[j]){
                    dp[i][j] = dp[i-1][j-1]+ 1;
                    ans[i][j] = ans[i-1][j-1] + a[i];
                }
                else{
                    if(dp[i-1][j] == dp[i][j-1]){
                        ans[i][j] = min(ans[i-1][j],ans[i][j-1]); 
                    }
                    else if(dp[i-1][j] > dp[i][j-1]){
                        ans[i][j] = ans[i-1][j]; 
                    }
                    else{
                        ans[i][j] = ans[i][j-1]; 
                    }
                    dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        if(ans[lena][lenb].length()!=0)
            cout << "Case " << T++ <<": " << ans[lena][lenb] << endl;
        else
            cout << "Case " << T++ <<": " << ":(" << endl; 
    } 
    return 0;
}

hdu 1257

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <stack>
#include <set>
#include <map>
#include <vector>

using namespace std;
#define INF 0x2fffffff
#define LL long long
#define MAX(a,b) ((a)>(b))?(a):(b)
#define MIN(a,b) ((a)<(b))?(a):(b)

int main(){
    int t;
    while(cin >> t){
        vector<int> vec;
        for(int i = 0;i < t;i++){
            int x;
            scanf("%d",&x);
            int flag  = 0;
            int mi = INF;
            for(int j = 0;j < vec.size();j++){
                if(vec[j] >= x){
                    vec[j] = x;
                    flag = 1;
                    break;
                }               
            }
            if(!flag){
                vec.push_back(x);
            }
        }
        printf("%d\n",vec.size());
    }
    return 0;
}

uva 562

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
using namespace std;
int a[105];
int dp[105][50005];

int main()
{
    int t;
    cin >> t;
    while(t--)
    {
        int n;
        int num = 0,sum = 0;
        scanf("%d",&n);
        for(int i = 1;i <= n;i++)
        {
            scanf("%d",&a[i]);
            sum += a[i];
        }
        num = sum / 2; 
        memset(dp,0,sizeof(dp));
        for(int i = 0; i <= n; i++)
        {
            dp[i][0] = 1;
        }
        for(int i = 1 ; i <= n;i++)
        {

            for(int j = 1; j <= num; j++)
            {
                if(j >= a[i])
                {

                    dp[i][j] = dp[i-1][j] | dp[i-1][j-a[i]];
                }
                else
                {
                    dp[i][j] = dp[i-1][j];
                }

            }
        }
        for(int i = num; i >= 0; i --)
        {
            if(dp[n][i])
            {
                printf("%d\n",sum - 2 * i);
                break;
            }
        }

    }
    return 0;
}
点羽染墨
关注
各大OJ题目分类
linleiqin
05-31 3973
<br /> <br />-----------------------------最优化问题------------------------------------- <br />----------------------常规动态规划  <br />SOJ1162 I-Keyboard  <br />SOJ2096 Maximum Submatrix  <br />SOJ2111 littleken bg <br />SOJ2142 Cow Exhibition  <br />SOJ2505 The C
HDU DP 题集
04-24
动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时，...
树形dp 题目清单
qq_39898877的博客
08-27 353
树上的动态规划 树的最大独立集 #include&lt;bits/stdc++.h&gt; using namespace std; #define maxn 100 vector&lt;int&gt; v[maxn]; int d[maxn], s[maxn], gs[maxn]; int dfs(int n, int fa) { for(int i = 0; i &lt; v[n...
省选＋NOI 第一部分 动态规划DP
青少年趣味编程
03-16 575
期望概率DP 【整理】简单的数学期望和概率DP 【整理】简单的数学期望和概率DP - nimphy - 博客园 期望&概率dp总结 期望&amp;概率dp总结_十分残念的博客-CSDN博客 期望&amp;概率dp总结_十分残念的博客-CSDN博客 概率dp+期望dp 题目列表（一） 概率dp+期望dp 题目列表（一） - 知る奇迹に - 博客园 概率DP/期望DP http://www.cyzuo.cn/index.php/archives/63/..
博弈类题目小结（HDU,POJ,ZOJ）
AC0.0的专栏
02-03 509
首先当然要献上一些非常好的学习资料： 基础博弈的小结：http://blog.csdn.net/acm_cxlove/article/details/7854530 经典翻硬币游戏小结：http://blog.csdn.net/acm_cxlove/article/details/7854534 经典的删边游戏小结：http://blog.csdn.net/acm_cxlove/
数位DP题目汇总
weixin_34198881的博客
02-11 123
Google Code Jam 2014 Round 1B Problem B hdu 2089 hdu 3555 uestc 250 (原1307) hdu 3652 hdu 3709 Light OJ 1140 Light OJ 1032 Codeforces 55D poj 3252 Light OJ 1068 转载于:https://www.cnblogs.com/ra...
DP题集
马德里小铁匠的铁匠铺
03-25 947
转自：点击打开链接 以前按照那个上面刷了好多 有一部分没刷 现在整理起来 继续刷 一、区间DP 1、Zoj 3537 Cake  2、Light oj 1422 Halloween Costumes   3、poj 2955 Brackets  4、CF 149 D Coloring Brackets 5、1651 Multiplication Puzzle 6、Zoj 34
各大OJ题目归类
稻草人
06-19 1564
各大OJ题目归类 Posted on 2012 年 8 月 8 日 by admin 要时常听时常想时常进修，才是人生真正的生活生计体式格式。什么事也不抱，什么事也不学的人，没有生活生计的资格。  —————————–最优化题目————————————- ———————-动态规划 SOJ1162 I-Keyboard SOJ2096 Maximum Submatrix
soj题目分类
u013048514的专栏
11-09 1153
-----------------------------最优化问题-------------------------------------  ----------------------常规动态规划   SOJ1162 I-Keyboard   SOJ1685 Chopsticks  SOJ1679 Gangsters  SOJ2096 Maximum Submatrix  
hdu.rar_HDU 1089.cpp_OJ题求和_hdu_horsekw5_杭电obj
09-24
【标题】"hdu.rar_HDU 1089.cpp_OJ题求和_hdu_horsekw5_杭电obj" 提供的信息是关于一个压缩文件，其中包含了一个名为 "HDU 1089.cpp" 的源代码文件，这个文件是为了解决杭州电子科技大学（Hangzhou Dianzi ...
hdu-page-11-answer.rar_hdu_hdu oj第十一页_page_搜题_杭电oj
09-14
《杭电OJ第十一页题目题解：基础算法与ACM入门》 在计算机科学的世界里，算法是解决问题的关键，而ACM（国际大学生程序设计竞赛）则为学生们提供了磨炼算法技能的绝佳平台。杭州电子科技大学（简称“杭电”）的在线...
DP.rar_DP_hdu_动态规划_动态规划 C++
09-20
标题中的“DP.rar”表明这是一个关于动态规划的资料压缩包，而“DP_hdu”暗示了这些题目可能来自杭州电子科技大学（HDU）的在线编程平台。动态规划通常用于解决那些可以通过子问题的最优解来构建原问题最优解的问题...
hdu oj poj 题目代码与详解
09-08
【题目代码与详解】是针对在线编程竞赛平台HDU（杭州电子科技大学在线评测系统）和POJ（普林斯顿大学在线判题系统）中的经典题目所编写的解决方案和解析的集合。这些平台是程序员和计算机科学学生提升算法技能、熟悉...
MiniGui业务开发基础培训-htk
最新发布
11-11
MiniGui业务开发基础培训-htk
com.harmonyos.exception.DiskReadWriteException(解决方案).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
网络分析-Wireshark数据包筛选技巧详解及应用实例
11-11
内容概要：本文档详细介绍了Wireshark软件中各种数据包筛选规则，主要包括协议、IP地址、端口号、包长以及MAC地址等多个维度的具体筛选方法。同时提供了大量实用案例供读者学习，涵盖HTTP协议相关命令和逻辑条件的综合使用方式。 适合人群：对网络安全或数据分析有一定兴趣的研究者，熟悉基本网络概念和技术的专业人士。 使用场景及目标：适用于需要快速准确捕获特定类型网络流量的情况；如网络安全检测、性能优化分析、教学演示等多种实际应用场景。 阅读建议：本资料侧重于实操技能提升，在学习时最好配合实际操作练习效果更佳。注意掌握不同类型条件组合的高级用法，增强问题解决能力。
com.harmonyos.exception.BatteryOverheatException(解决方案).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
com.harmonyos.exception.ServiceUnavailableException(解决方案).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值