• hihocoder 1038 01背包


    #1038 : 01背包

    时间限制:20000ms
    单点时限:1000ms
    内存限制:256MB

    描述

    且说上一周的故事里,小Hi和小Ho费劲心思终于拿到了茫茫多的奖券!而现在,终于到了小Ho领取奖励的时刻了!

    小Ho现在手上有M张奖券,而奖品区有N件奖品,分别标号为1到N,其中第i件奖品需要need(i)张奖券进行兑换,同时也只能兑换一次,为了使得辛苦得到的奖券不白白浪费,小Ho给每件奖品都评了分,其中第i件奖品的评分值为value(i),表示他对这件奖品的喜好值。现在他想知道,凭借他手上的这些奖券,可以换到哪些奖品,使得这些奖品的喜好值之和能够最大。

    提示一:合理抽象问题、定义状态是动态规划最关键的一步

    提示二:说过了减少时间消耗,我们再来看看如何减少空间消耗

    输入

    每个测试点(输入文件)有且仅有一组测试数据。

    每组测试数据的第一行为两个正整数N和M,表示奖品的个数,以及小Ho手中的奖券数。

    接下来的n行描述每一行描述一个奖品,其中第i行为两个整数need(i)和value(i),意义如前文所述。

    测试数据保证

    对于100%的数据,N的值不超过500,M的值不超过10^5

    对于100%的数据,need(i)不超过2*10^5, value(i)不超过10^3

    输出

    对于每组测试数据,输出一个整数Ans,表示小Ho可以获得的总喜好值。

    样例输入
    5 1000
    144 990
    487 436
    210 673
    567 58
    1056 897
    样例输出
    2099


    【思路】:0-1背包。一维滚动数组优化空间

    /* 有N件物品和一个容量为V的背包。第i件物品的费用是c[i],价值是w[i],求解将哪些物品放入背包可使价值总和最大 特点: 每一件物品仅有一件,能够选择放或者不放。 定义状态:F[i][v]:表示前i件物品恰好放入一个容量为v的背包能够获得的最大的价值 转移方程:F[i][v]=max(F[i-1][v],F[i-1][v-c[i]]+w[i]]); 优化空间复杂度: 以上求法时间和空间复杂度均为O(V*N),时间复杂度不能在优化了,然而空间复杂度能够进一步优化我们这样考虑:仅仅用一个数组F[0..V],保证第i次循环结束结束后F[v]表示的是就是定义的状态F[i][v] 伪代码: for i<--1 to N     do for v<--V to 0     do F[v]=max(F[v],F[v-c[i]]+w[i]); */

     1 #include<iostream>
     2 #include <string>
     3 #include <algorithm>
     4 #include <fstream>
     5 using namespace std;
     6 int f[100001] = {0};
     7 int need[501], value[501];
     8 int main(){
     9     int n, m, w, v;
    10 //ifstream cin("aaa.txt");
    11     cin >> n >> m;
    12     for (int i = 1; i <= n; i++) {
    13         cin >> need[i] >> value[i];
    14     }
    15     for(int i = 1; i <= n; i++){
    16         //cin >> w >> v;
    17         for(int j = m; j >= need[i]; j--){
    18             f[j] = max(f[j], f[j - need[i]] + value[i]);
    19         }
    20     }
    21     cout << f[m] << endl;
    22 
    23     //system("pause");
    24     return 0;
    25 }
    View Code
     1 #include <stdio.h>
     2 #include <string.h>
     3 
     4 int dp[100010];
     5 
     6 int main()
     7 {
     8     int n,m,v,w;
     9     int i,j,k;
    10     memset(dp,0,sizeof(dp));
    11     scanf("%d%d",&n,&m);
    12     for(i=0;i<n;i++)
    13     {
    14         scanf("%d%d",&w,&v);
    15         for(j=m;j>=w;j--)
    16         {
    17             if(dp[j]<dp[j-w]+v)
    18             dp[j] = dp[j-w]+v;
    19         }
    20     }
    21     printf("%d
    ",dp[m]);
    22     return 0;
    23 }
    View Code
     1 # include <iostream>
     2 # include <string.h>
     3 using namespace std;
     4 int dp[100010];
     5 int main()
     6 {
     7     int n,m,w,v,i,j;
     8     while(cin>>n>>m)
     9     {
    10         memset(dp,0,sizeof(dp));
    11         for(i=1;i<=n;i++)
    12         {
    13             cin>>w>>v;
    14             for(j=m;j>=w;j--)
    15                 dp[j]=dp[j]>dp[j-w]+v?dp[j]:dp[j-w]+v;
    16         }
    17         cout<<dp[m];
    18     }
    19     return 0;
    20 }
    View Code
    越努力,越幸运
  • 相关阅读:
    返回值与返回引用的问题
    C内存之指针传递
    Elasticsearch-Java中文搜索器(下)
    Elasticsearch-Java中文搜索器(中)
    Elasticsearch-Java中文搜索器(上)
    Redis和Memcache对比及选择
    Java + Tomcat + Memcached + Nginx 实现负载均衡~下
    Java + Tomcat + Memcached + Ecs 实现负载均衡~上
    Java -- 偏向锁、轻量级锁、自旋锁、重量级锁
    Java 锁与对象头
  • 原文地址:https://www.cnblogs.com/qinduanyinghua/p/5489028.html
Copyright © 2020-2023  润新知