【01背包问题】从小数据到大数据

1、普通01背包

for i=1:n
    for j=0:W

if(j<w[i])
    dp[i][j]=dp[i-1][j];
else
    dp[i][j]=max(dp[i][j],dp[i][j-w[i]]+w[i];

2、01背包问题之2

题目特征：背包重量太大，开不了那么大的数组。普通01背包中的时间复杂度O（nW），现在就不够用了。

解决方案：价值的范围较小，试着改变dp的方向。之前的方法中，针对不同的重量限制计算最大的价值，现在针对不同的价值计算最小的重量。

状态定义：dp[i][j] 前i个物品中挑选出价值总和为j时总重量的最小值（不存在时是一个充分大的INF），初始值dp[0][0]=0,dp[0][j]=INF。

状态转移：

最终答案：的最大（时间复杂度）

hdu 6495冰水挑战

思路：背包载荷是c,每个物品的重量是ai,每个物品的价值是1。一般来说，会想到针对不同的体力计算最大的挑战个数，也就是dp[i][j]代表考虑j点体力最多能挑战多少个，这样的话j的数据量到达1e9，时空复杂度都hold不住，相对的针对挑战个数考虑体力的最小值的话（针对价值考虑重量），挑战个数的最大值是n,1e3，时间复杂度就是1e3*1e3

dp[i][j]前i个物品价值为j所消耗的最小空间

针对挑战个数考虑体力的最小值的话----->为了方便处理本题（因为在问题讨论过程中需要用到剩余体力），改成求剩余体力的最大值，dp[i][j]考虑前i个挑战，选择了j个挑战剩余的最大体力，dp[n][i]>0的最大的i就是答案

 

注意不管咋样，他都是个01背包，按照不选和选两种情况分类讨论即可

不选它：参考普通01背包中的dp[i][j]=dp[i-1][j]---> dp[i][j]=dp[i-1][j]+c[i] 本题额外判断它是否能从dp[i-1][j]转移过来，即dp[i-1][j]>0

选它：参考01背包中的额dp[i][j]=max(dp[i][j],dp[i][j-w[i]]+v[i])---> dp[i][j]=max(dp[i][j],挑战它之前的体力-a[i]+c[i])，注意由于选它dp[i][j]一定是由dp[i-1][j-1]转移过来的，所以挑战它之前的体力=min(dp[i-1][j-1],b[i]),要判断是否能成功转移

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long LL;
const int N=1e3+10;
LL a[N],b[N],c[N];
LL dp[N][N];           //最多能完成n个挑战   总价值最大是n4
//减少的体力最小-->剩下的体力最大
//写二维的时候感觉还是正着写比较酥服

int n;
LL C;
const int INF=1e9;
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        cin>>n>>C;
        for(int i=1;i<=n;++i)
            cin>>a[i]>>b[i]>>c[i];
        memset(dp,-INF,sizeof(dp));
        dp[0][0]=C;
        for(int i=1;i<=n;++i)       //要得到体力消耗的最小值
        {
            for(int j=0;j<=n;++j)
            {
        
                if(dp[i-1][j]>0)
                    dp[i][j]=max(dp[i][j],dp[i-1][j]+c[i]);
                if(j)
                {
                    int tmp=min(dp[i-1][j-1],b[i]);
                    if(tmp>a[i])                //考虑选它
                    {
                        dp[i][j]=max(dp[i][j],tmp-a[i]+c[i]); //c[i]写外面了可真是该死
                    }
                }

            }

        }

        int ans;
        for(int i=n;i>=0;--i)
        {
            if(dp[n][i]>0)
            {
                ans=i;
                break;
            }
        }
        cout<<ans<<endl;
    }

}

3、超大背包问题

hdu5887 && nyoj 1901 将下面代码t开成long long即可

题意：第一行两个数，草药个数n和总时间t，接下来n行，每行代表草药处理时间和价值，就价值的最大值。

特征：除了种类其他都是1e9

优秀博客！强烈推荐看！

博主：一般V，W很大，n很小，是搜索，因为搜索复杂度为2^n，只与n有关。当n上百的时候，就是dp

核心：性价比高的优先考虑+最优性剪枝

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=0x3f3f3f3f;
typedef long long LL;
struct node
{
    LL t,v;
    double r;
    node(){}
    node(LL t,LL v,double r):t(t),v(v),r(r){}
}h[105];
bool cmp(node x,node y)     //优先考虑性价比高的
{
    return x.r>y.r;
}
int n,t,k;
LL ans;
bool check(int x,LL now_t, LL now_v)    //最优性剪枝   若加上剩下所有物品的权值也无法得到比当前得到的最优解更优的解，则剪枝。
{
    for(int i=x;i<=k;++i)
    {
        if(t-now_t>=h[i].t)
        {
            now_t+=h[i].t;
            now_v+=h[i].v;
        }
        else
        {
            now_v+=h[i].r*(t-now_t);
            break;
        }
    }
    return now_v>ans;
}
void dfs(int x,LL now_t,LL now_v)
{
    ans=max(ans,now_v);
    if(x<=k&&check(x,now_t,now_v))
    {
        if(t-now_t>=h[x].t) dfs(x+1,now_t+h[x].t,now_v+h[x].v);
        dfs(x+1,now_t,now_v);                                       //习惯性地写了个else，wa了好一会，mmd
    }
}

int main()
{
    while(cin>>n>>t)
    {
        ans=0;
        k=0;
        for(int i=1;i<=n;++i)
        {
            LL tt,v;
            cin>>tt>>v;
            if(tt<=t)//这里不预处理也能A
                h[++k]=node(tt,v,1.0*v/tt);
            //h[i]=node(tt,v,1.0*v/tt);        
        }
        sort(h+1,h+1+k,cmp);
        dfs(1,0LL,0LL);
        cout<<ans<<endl;
    }

    return 0;



}

进阶版，搜索都不行，这时候就要折半搜索啦

codefroces Anya and Cubes

题意：n个数，选择其中的一些组成S，问有多少种方法，同时有k个sticker，使用一个可是数字变为其阶乘，一个数字只能使用一次。（sticker可用可不用）

思路：定义dp[i][j][k]为考虑前i个数字，使用了j个sticker，组成数字k的方案数

一个小套路：涉及到可用多少个的时候都会开一维表示用了几个~

情况1 不选择第i个数字 dp[i][j][k]+=dp[i-1][j][k]

情况2 选择第i个数字不使用sticker dp[i][j][k]+=dp[i-1][j][k-a[i]]

情况3 选择第i个数字且使用sticker dp[i][j][k]+=dp[i-1][j-1][k-fac[a[i]]]

直接用背包的话时间复杂度是n*k*S 且S开不下

直接搜索的话是3^n,因为每个数字对应着三种选择

这时候考虑双向DFS（折半搜索），时间复杂度为

参考博客

值得注意的一点是！不加判断直接用mp[num][sum]会T，特别迷，加了之后0.8s过，不加就T在test 91，难受

代码流程：先搜前一半，记录mp[num][sum] ，第一维是用了几个sticker，第二维是组成的和是多少

再搜后一半，ans+=mp[i][s-sum]  i+num<=k 

 

#include<iostream>
#include<cstring>
#include<algorithm>
#include<map>
#include<cstdio>
using namespace std;
typedef long long LL;
int n,k;
LL s;
LL fac[20];
map<LL,int> mp[30];     //mp[i]记录的是用了i次sticker
int cnt=0;
LL ans=0;
LL a[30];

void dfs1(int x,int num,LL sum)     //枚举前一半
{
    if(x==n/2+1)
    {
        if(mp[num].count(sum))      //直接mp[num][sum]会T
            mp[num][sum]++;
        else mp[num][sum]=1;
        return ;
    }
    dfs1(x+1,num,sum);      //不选
    if(sum+a[x]<=s)    dfs1(x+1,num,sum+a[x]); //不用sticker
    if(num+1<=k&&a[x]<=19&&sum+fac[a[x]]<=s) dfs1(x+1,num+1,sum+fac[a[x]]);
}
void dfs2(int x,int num,LL sum)
{
    if(x==n+1)
    {
        for(int i=0;i+num<=k;++i)
            if(mp[i].count(s-sum))    //直接mp[num][s-sum]会T
                ans+=mp[i][s-sum];
        return ;
    }
    dfs2(x+1,num,sum);      //不选
    if(sum+a[x]<=s)    dfs2(x+1,num,sum+a[x]); //不用sticker
    if(num+1<=k&&a[x]<=19&&sum+fac[a[x]]<=s) dfs2(x+1,num+1,sum+fac[a[x]]);

}

int main()
{
    fac[0]=1;
    for(int i=1;i<=19;++i)
        fac[i]=fac[i-1]*i;
    scanf("%d%d%lld",&n,&k,&s);

    for(int i=1;i<=n;++i)
        scanf("%lld",&a[i]);
    dfs1(1,0,0);
    dfs2(n/2+1,0,0);
    printf("%lld\n",ans);
    return 0;


}

 

https://blog.csdn.net/qq_24489717/article/details/49950027 DFS和折半枚举两种方案