POJ3181 完全背包+高精度数模板

最新推荐文章于 2018-10-17 22:18:57 发布
最新推荐文章于 2018-10-17 22:18:57 发布
阅读量460 收藏 1
点赞数
分类专栏： ACM_DP ACM_POJ ACM_白书学习 文章标签： poj dp 完全背包 高精度模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luke2834/article/details/49452077
版权
ACM_DP 同时被 3 个专栏收录
50 篇文章 1 订阅
订阅专栏
ACM_POJ
27 篇文章 0 订阅
订阅专栏
ACM_白书学习
22 篇文章 0 订阅
订阅专栏

题意

  • 有1~k，这k个数，每种数可以用任意多次，问你组成n的方案数
  • N<=1000，k<=100

思路

  • 就是完全背包，把k种物品，第i种重量为i，重量限制为N的方案数，只要把原本的max改为sum即可
  • 由于k，n比较小，我就没优化的写了一个，将将过。。之后重写了一个优化后的，就都贴出来了
  • 注意要用高精度数

实现

没优化的

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

const int MAXSIZE = 50;

struct BigInt{
public:
    int a[MAXSIZE];
    int length;
public:
    BigInt():length(0){memset(a,0,sizeof(a));}
    BigInt(string s);
    BigInt(int b);
    BigInt(const BigInt& c);
    BigInt operator=(int b);
    BigInt operator=(string s); 
};
////////////////////////////////////////////////////////
////////////////////////////////////////////////////////

BigInt::BigInt(string s)
{
    memset(a,0,sizeof(a));
    *this = s;
}
BigInt::BigInt(int b)
{
    memset(a,0,sizeof(a));
    *this = b;
}
BigInt::BigInt(const BigInt& c)
{
    int i;
    memset(a,0,sizeof(a));  
    length = c.length;
    memset(a,0,sizeof(a));
    for(i=0;i<length;i++)
    {
        a[i] = c.a[i];
    }
}


BigInt BigInt::operator=(int b)
{
    memset(a,0,sizeof(a));
    if(b==0)
    {
        a[0] = 0;
        length = 1;
        return *this;
    }
    if(b<0)
    {
        b = -b;
    }
    for(length=0;b>0;length++)
    {
        a[length] = b%10;
        b /= 10;
    }
    return *this;
}

BigInt BigInt::operator=(string s)
{
    int i;
    length = s.length();
    memset(a,0,sizeof(a));
    for(i=0;i<length;i++)
    {
        a[length-i-1] = (int)(s[i] - '0');
    }
    return *this;
}


BigInt operator+(const BigInt& d,const BigInt& b)
{
    int i;
    int jinWei = 0;
    BigInt sum;
    int max_length = (d.length<b.length)?b.length:d.length;
    for(i=0;i<max_length;i++)
    {
        jinWei = d.a[i]+b.a[i]+jinWei;
        sum.a[i] = jinWei%10;
        jinWei/=10;
    }
    sum.length = i;                //sum.length 易忘赋值 
    if(jinWei!=0) 
    {
        sum.a[i] = jinWei; //加上最高位进位
        sum.length++; 
    }
    return sum;
}
BigInt operator-(const BigInt& d,const BigInt& b)   //适宜d>b时 
{
    int i,j;
    int tuiWei = 0;
    BigInt sum;
    int max_length = (d.length<b.length)?b.length:d.length;
    for(i=0;i<max_length;i++)
    {
        tuiWei = d.a[i]-b.a[i]-tuiWei;
        if(tuiWei>=0)
        {
            sum.a[i] = tuiWei;
            tuiWei = 0;
        }
        else
        {
            sum.a[i] = 10+tuiWei;
            tuiWei = 1;
        }
    }
    sum.length = i;                //sum.length 易忘赋值
    for(j=i-1;sum.a[j]==0&&j>0;j--)
        sum.length--;
    return sum;
}

BigInt operator*(const BigInt& d,const BigInt& b)
{
    int i,j,k;
    int jinWei=0;
    BigInt temp = 0;
    BigInt fuck = 0;
    if(b.a[0]==0&&b.length == 1||d.a[0]==0&&d.length == 1)
    {
        return b;
    }
    for(i=0;i<b.length;i++)   //b作为乘数 
    {
        jinWei = 0;
        temp = 0; 
        for(j=0;j<d.length;j++) //a*b[i] 
        {
            jinWei = d.a[j]*b.a[i] + jinWei;
            temp.a[j] = jinWei%10;
            jinWei /= 10;
        }
        temp.length = j;
        if(jinWei!=0)
        {
            temp.a[j] = jinWei; 
            temp.length++;
        }
        if(i!=0)
        {
            for(k=temp.length-1;k>=0;k--)  //左移i位 
            {
                temp.a[k+i] = temp.a[k];
                temp.a[k] = 0;
            }
            temp.length += i;
        }
        fuck = fuck+temp;
    }
    return fuck;
}
bool operator<(const BigInt& d,const BigInt& b)
{
    if(d.length<b.length)
        return true;
    if(d.length>b.length)
        return false;
    for(int i=b.length-1;i>=0;i--)
    {
        if(d.a[i]>b.a[i])
            return false;
        if(d.a[i]<b.a[i])
            return true;
    }
    return false;
}
bool operator==(const BigInt& d,const BigInt& b)
{
    if(d.length!=b.length)
        return false;
    for(int i=b.length-1;i>=0;i--)
    {
        if(d.a[i]!=b.a[i])
            return true;
    }
    return true;
}
bool operator!=(const BigInt& d,const BigInt& b)
{
    return !(d==b);
}
bool operator>(const BigInt& d,const BigInt& b)
{
    return !(d==b||d<b);
}
bool operator<=(const BigInt& d,const BigInt& b)
{
    return !(d>b);
}
bool operator>=(const BigInt& d,const BigInt& b)
{
    return !(d<b);
}

/////////////////////////////////////////////
/////////////////////////////////////////////
char* toString(BigInt a)
{
    int i;
    //注意static
    static char s[MAXSIZE];
    for(i=a.length-1;i>=0;i--)
    {
        s[a.length-i-1] = (char)(a.a[i]+'0');
    }
    s[a.length] =  '\0';
    return s;
}


int n,k;
BigInt dp[2][1005];
int main(){
    cin>>n>>k;

    dp[0][0] = BigInt(1);
    for (int i=1;i<=k;i++){
        for (int j=0;j<=n;j++){
            dp[i&1][j] = BigInt(0);
            for (int k=0;k*i <= j;k++){
                dp[i&1][j] = dp[i&1][j] + dp[(i-1)&1][j-k*i];
            }
        }
    }
    cout <<toString(dp[k&1][n] )<<'\n';

    return 0;
}

优化后的

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

const int MAXSIZE = 50;

struct BigInt{
public:
    int a[MAXSIZE];
    int length;
public:
    BigInt():length(0){memset(a,0,sizeof(a));}
    BigInt(string s);
    BigInt(int b);
    BigInt(const BigInt& c);
    BigInt operator=(int b);
    BigInt operator=(string s); 
};
////////////////////////////////////////////////////////
////////////////////////////////////////////////////////

BigInt::BigInt(string s)
{
    memset(a,0,sizeof(a));
    *this = s;
}
BigInt::BigInt(int b)
{
    memset(a,0,sizeof(a));
    *this = b;
}
BigInt::BigInt(const BigInt& c)
{
    int i;
    memset(a,0,sizeof(a));  
    length = c.length;
    memset(a,0,sizeof(a));
    for(i=0;i<length;i++)
    {
        a[i] = c.a[i];
    }
}


BigInt BigInt::operator=(int b)
{
    memset(a,0,sizeof(a));
    if(b==0)
    {
        a[0] = 0;
        length = 1;
        return *this;
    }
    if(b<0)
    {
        b = -b;
    }
    for(length=0;b>0;length++)
    {
        a[length] = b%10;
        b /= 10;
    }
    return *this;
}

BigInt BigInt::operator=(string s)
{
    int i;
    length = s.length();
    memset(a,0,sizeof(a));
    for(i=0;i<length;i++)
    {
        a[length-i-1] = (int)(s[i] - '0');
    }
    return *this;
}


BigInt operator+(const BigInt& d,const BigInt& b)
{
    int i;
    int jinWei = 0;
    BigInt sum;
    int max_length = (d.length<b.length)?b.length:d.length;
    for(i=0;i<max_length;i++)
    {
        jinWei = d.a[i]+b.a[i]+jinWei;
        sum.a[i] = jinWei%10;
        jinWei/=10;
    }
    sum.length = i;                //sum.length 易忘赋值 
    if(jinWei!=0) 
    {
        sum.a[i] = jinWei; //加上最高位进位
        sum.length++; 
    }
    return sum;
}
BigInt operator-(const BigInt& d,const BigInt& b)   //适宜d>b时 
{
    int i,j;
    int tuiWei = 0;
    BigInt sum;
    int max_length = (d.length<b.length)?b.length:d.length;
    for(i=0;i<max_length;i++)
    {
        tuiWei = d.a[i]-b.a[i]-tuiWei;
        if(tuiWei>=0)
        {
            sum.a[i] = tuiWei;
            tuiWei = 0;
        }
        else
        {
            sum.a[i] = 10+tuiWei;
            tuiWei = 1;
        }
    }
    sum.length = i;                //sum.length 易忘赋值
    for(j=i-1;sum.a[j]==0&&j>0;j--)
        sum.length--;
    return sum;
}

BigInt operator*(const BigInt& d,const BigInt& b)
{
    int i,j,k;
    int jinWei=0;
    BigInt temp = 0;
    BigInt fuck = 0;
    if(b.a[0]==0&&b.length == 1||d.a[0]==0&&d.length == 1)
    {
        return b;
    }
    for(i=0;i<b.length;i++)   //b作为乘数 
    {
        jinWei = 0;
        temp = 0; 
        for(j=0;j<d.length;j++) //a*b[i] 
        {
            jinWei = d.a[j]*b.a[i] + jinWei;
            temp.a[j] = jinWei%10;
            jinWei /= 10;
        }
        temp.length = j;
        if(jinWei!=0)
        {
            temp.a[j] = jinWei; 
            temp.length++;
        }
        if(i!=0)
        {
            for(k=temp.length-1;k>=0;k--)  //左移i位 
            {
                temp.a[k+i] = temp.a[k];
                temp.a[k] = 0;
            }
            temp.length += i;
        }
        fuck = fuck+temp;
    }
    return fuck;
}
bool operator<(const BigInt& d,const BigInt& b)
{
    if(d.length<b.length)
        return true;
    if(d.length>b.length)
        return false;
    for(int i=b.length-1;i>=0;i--)
    {
        if(d.a[i]>b.a[i])
            return false;
        if(d.a[i]<b.a[i])
            return true;
    }
    return false;
}
bool operator==(const BigInt& d,const BigInt& b)
{
    if(d.length!=b.length)
        return false;
    for(int i=b.length-1;i>=0;i--)
    {
        if(d.a[i]!=b.a[i])
            return true;
    }
    return true;
}
bool operator!=(const BigInt& d,const BigInt& b)
{
    return !(d==b);
}
bool operator>(const BigInt& d,const BigInt& b)
{
    return !(d==b||d<b);
}
bool operator<=(const BigInt& d,const BigInt& b)
{
    return !(d>b);
}
bool operator>=(const BigInt& d,const BigInt& b)
{
    return !(d<b);
}

/////////////////////////////////////////////
/////////////////////////////////////////////
char* toString(BigInt a)
{
    int i;
    //注意static
    static char s[MAXSIZE];
    for(i=a.length-1;i>=0;i--)
    {
        s[a.length-i-1] = (char)(a.a[i]+'0');
    }
    s[a.length] =  '\0';
    return s;
}


int n,k;
BigInt dp[1005]; 
int main(){
    cin>>n>>k;

    dp[0] = BigInt(1);
    for (int i=1;i<=k;i++){
        for (int j=0;j<=n;j++){
            if (j >= i)
                dp[j] = dp[j-i] + dp[j];
        }
    }
    cout <<toString(dp[n] )<<'\n';

    return 0;
}
luke2834
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【POJ3260】The Fewest Coins 多重背包+完全背包
辗转山河弋流歌
09-22 1812
O（n）的多重背包优化！
极角排序:POJ 1696(叉积+深搜）
04-15
在POJ 1696这个编程题目中，很可能需要解决与极角排序相关的问题。POJ（Problem Online Judge）是一个在线的编程竞赛平台，它提供了许多编程题目供参赛者解决，以提升编程能力和算法理解。 描述中提到的“叉积+深搜...
POJ 3181完全背包（+高精）
SiriusRen的博客
10-23 191
思路： f[i]表示还剩i空间的方案数套个高精 （网上有人把它拆成了两个long long） 其实这道题的高精并不难写…..//By SiriusRen #include <cstdio> using namespace std; int n,k,f[1111][53],flag; int main(){ scanf("%d%d",&n,&k); f[n][0]=1;
poj3181 Dollar Dayz (DP+大数)
苏苏爱自由
05-30 3782
Dollar Dayz Crawling in process... Crawling failed Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u Submit Status Practice POJ 3181 Appoint description:
poj3181 Dollar Dayz dp
671coder的专栏
05-15 2402
题目链接：here 题目大意：         n 块钱 如何由  1-k 块钱组合起来的方法。。 分析：         完全背包。。但是注意高精度。。 代码： java： import java.math.BigInteger; import java.util.Arrays; import java.util.Scanner; public class poj3181dp
POJ 3181 Dollar Dayz(完全背包+简单高精度加法)
code
10-26 1411
POJ 3181 Dollar Dayz(完全背包+简单高精度加法) http://poj.org/problem?id=3181 题意:        给你K种硬币,每种硬币分别是1美元,2美元…K美元且可以无限使用,问你用上面K种硬币构成n美元的话有多少种方法? 分析:        本题是一道明显的完全背包问题, 不过本题还可以换一种方法来看: 整数n由前K个自然数构造, 一共有多
poj3181（高精度完全背包dp）
林伏案的博客
09-05 1391
点击打开链接 /* translation: 给你一定金额n的硬币，再给出k件商品，第i件商品的价格为i。用n金额有多少种购买方案？ solution: 完全背包，状态以及转移方程均类似 note: 1：一开始按照完全背包的写法，是错误的。但方法没错，原因在于数据问题，输入边界值1000 100， 输出的是无用的数据。明显发生了数据溢出问题。所以按照网上题解的思路，将其分成两个数组，
POJ3181：Dollar Dayz(完全背包)
ACM！荣耀之路！
07-24 4909
Description Farmer John goes to Dollar Days at The Cow Store and discovers an unlimited number of tools on sale. During his first visit, the tools are selling variously for $1, $2, and $3. Farmer Joh
poj1787 Charlie's Change 完全背包
671coder的专栏
05-16 3376
题目链接：here 题目大意：         分硬币，有1，5，10，25四种硬币，给定每种硬币的数量，给定要组合成的价值，问刚好达到价值时用的硬币最多的情况。 分析：         感觉上是多重背包，实际上用完全背包的思路来做很快！         dp[j] 表示 j 块钱最多由多少块硬币组成， path[j] 表示 上一次最多有多少块构成的 j 块钱， used[j] 表示 j
POJ 3181 Dollar Dayz（划分数详解+高精度）
热门推荐
光明~~~
04-10 2万+
划分数详解，多种划分数。 　　1. 将n划分成若干正整数之和的划分数。 　　2. 将n划分成k个正整数之和的划分数。 　　3. 将n划分成最大数不超过k的划分数。 　　4. 将n划分成若干奇正整数之和的划分数。 　　5. 将n划分成若干不同整数之和的划分数。
POJ 1267 多重背包问题
JustNo
10-17 2243
背包问题分为三种 0-1 背包问题         每种物品只有一个。 完全背包问题        每种物品无限个。 多重背包问题        每种物品有限个但不止一个。 多重背包问题分为两种解法： 依据0-1 背包性质，我们将有限个的同种物品认为不同，然后按照0-1背包问题解决，这种解法这题超时。 第二种解法，多重背包二进制优化解决。二进制优化解释 背包问题详解：01背包、完全背包、...
poj2488.rar_poj24_poj2488_方向模板法
最新发布
09-14
标题中的“poj2488.rar_poj24_poj2488_方向模板法”指的是一个解决编程竞赛问题POJ2488的压缩文件，其中可能包含了解决该问题的代码示例。POJ是Programming Online Judge的缩写，是一个在线的编程竞赛平台，参与者...
POJ1014-Dividing【DFS】【多重背包+二进制优化】
08-04
在给出的文件列表中，“POJ1014-Dividing【多重背包+二进制优化】.cpp”和“POJ1014-Dividing【DFS】.cpp”很可能是两份不同的C++代码实现，分别展示了如何结合多重背包和二进制优化以及如何利用DFS来解决问题。...
POJ1207-The 3n + 1 problem
07-29
《POJ1207-The 3n + 1 problem》是北京大学在线编程平台POJ上的一道经典算法题目，其主要涉及的知识点是数论和动态规划。本题目的核心是解决著名的“Collatz Conjecture”问题，也被称为“3n+1猜想”。 3n+1猜想是...
poj部分题目代码（可以做模板用）
09-17
【标题】"poj部分题目代码（可以做模板用）" 涉及的知识点主要集中在编程和算法解决实际问题的应用上。POJ（Problem-OrientedJudge）是中国的一个在线编程竞赛平台，它提供了大量的算法题目供程序员进行训练，提升...
Leetcode 741. Cherry Pickup DP
luke2834的专栏
02-24 2727
题意 一个n*n矩阵A，矩阵包含-1, 1, 0，其中-1不能通行，从矩阵左上角走到右下角，再走回左上角，第一次遇到1收益+1，第二次则不加，问你最大收益。 思路 这个题困扰我好久，网上题解包括discussion感觉都不是特别直观，现在终于完全想通了。。这里记录一下，希望能对大家有帮助。 这个题如果没有反复，那么显然可以用一个普通二维dp，直接求解 那么首先，我们想到的肯定是一个...
POJ3046 多重集组合数 dp+前缀和优化+滚动数组 （包含类似优化的小总结）
luke2834的专栏
10-27 1545
题意 T种数，每种有a[t]个，总共有A个数。问你取其中X个数作为子集，有多少种这样的子集。计算L<=X<=H的子集数之和，结果mod 1000000 1<=T<=1000, 1<=a[t] <= 100，即1 <= A <= 100000, L<=H<=A 思路 基本想法：可以类比为把求max改为求sum的多重背包，所以基本的递推关系很好写，dp(i,j) = sum dp(i-1)(j-k) 其
UVa1025 DP （还要再看看~）
luke2834的专栏
03-16 1468
题意 请参考紫书描述~ 思路 状态开始没有定好，还是参考了下紫书..     dp[i][j] 表示在第i秒，第j个站上，一共的最少等待时间             初始条件dp[T][n] = 0,其它赋值为inf             转移：（1）在该站等一分钟 （2）若有向左走的车，则可以乘上 （3）若有向右走的车，则可以乘上   更新顺序：时间i倒着遍历   注意：数组要
hihoCoder1044 简单状压DP
luke2834的专栏
03-12 1308
题意 1到n的序列，每个位置wi个垃圾，一个人打扫，但连续m个位置最多有q个位置被打扫，问你最多打扫多少垃圾 思路 由于m较小，所以可以使用状压dp（当然本来这题就是专门练状压dp的...）。 总体思路不难，但有一些地方卡了我一下的这里说一下，一是连续m个位置看起来比较复杂不好处理，但是仔细一下可以发现，如果当看到第i个位置时，只需要考虑它和它前面m-1个位置就可以了，它后面的由后续工
POJ题目标签与算法分类总结
- 背包问题：经典的动态规划问题，如POJ1837和POJ1276。 - 表型动态规划：包括基于状态转移方程的DP问题，如POJ3267、POJ1836等。 - 最长公共子序列：利用二维数组求解，如POJ3176。 以上就是对POJ题目分类中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值