2017-7-17/18 背包dp cf round 417 div2

　　poj3624

　0-1背包 裸 

#include<iostream>
#include<cstdio>

using namespace std;
const int maxn=15000;
int w[maxn];
int v[maxn];
int cost;
int main()
{
    int n,m;
    scanf("%d%d",&n,&cost);
    for(int i=0;i<n;i++)
    {
        scanf("%d%d",&w[i],&v[i]);
    }
    int dp[maxn];
    memset(dp,0,sizeof(dp));
    for(int i=0;i<n;i++)
    {
        for(int j=cost;j>=w[i];j--)
        {
            dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
        }
    }
    cout<<dp[cost]<<endl;
}

 　　poj3628

2^20 枚举即可

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<vector>

using namespace std;

int a[22];
int n,m;


int cal(int x)
{
    int i=0;
    int sum=0;
    while(x)
    {
        if(x&1) sum+=a[i];
        x>>=1;
        i++;
    }
    return sum;
}


int main()
{
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++)
        scanf("%d",&a[i]);

    int num=2e9;

    for(int i=0;i<=(1<<n)-1;i++)
    {
        int d=cal(i);
        if(d<num&&d>=m) num=d;
    }
    printf("%d
",num-m);
}

方法2:　　0-1背包 用所有cow的高度和作为背包体积V，最后找到最小的但是大于m的即可，背包体积从小到大枚举找到ans

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<vector>

using namespace std;

int dp[20000005];
int a[22];

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    int sum=0;
    for(int i=0;i<n;i++)
        scanf("%d",&a[i]),sum+=a[i];
    dp[0]=0;
    for(int i=0;i<n;i++)
    {
        for(int j=sum;j>=a[i];j--)
            dp[j]=max(dp[j],dp[j-a[i]]+a[i]);
    }
    for(int i=0;i<=sum;i++)
    {
        if(dp[i]>=m) {printf("%d
",dp[i]-m);break;}
    }
    
}

 poj 1837 

题意：背包变形，在一个天平上有一些挂钩 一些砝码，将所有砝码挂上去，问使得天平平衡的方案数是多少？

思路：类似背包 这里使用7500作平衡点，另外dp[i][j]表示前i个砝码都放上去，平衡度为j时的方案数目，引入平衡度的概念。那么dp[i][j]=sigma(dp[i-1][j-c[k]*w[i]]),0<=k<n, ans=dp[m][7500];

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

using namespace std;

int n,m;

int w[50];
int c[50];
int dp[22][15010];

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&c[i]);
    for(int i=1;i<=m;i++) scanf("%d",&w[i]);
    memset(dp,0,sizeof(dp));
    dp[0][7500]=1;

    for(int i=1;i<=m;i++)
    {
        for(int j=0;j<=15000;j++)
        {
            for(int k=1;k<=n;k++)
            {
                dp[i][j]+=dp[i-1][j-c[k]*w[i]];
                //dp[i][j+c[k]*w[i]]+=dp[i-1][j];
            }
        }
    }


    printf("%d
",dp[m][7500]);
}

 hdu 2548 饭卡

思路：如果余额小于5元，就直接输出余额，如果余额大于五元就直接留出来买最贵的那个，然后去掉五元之外的钱，用来做0-1背包，买其他的物品

#include<bits/stdc++.h>

using namespace std;

int w[1010];
int dp[50000+100];
int t;
int cost;
int n;

int main()
{
    while(~scanf("%d",&n)&&n)
    {
        for(int i=0;i<n;i++) scanf("%d",&w[i]);
        scanf("%d",&cost);
        if(cost<5) {printf("%d
",cost);continue;}
        sort(w,w+n);
        cost-=5;
        memset(dp,0,sizeof(dp));
        for(int i=0;i<n-1;i++)
        {
            for(int j=cost;j>=w[i];j--)
                dp[j]=max(dp[j],dp[j-w[i]]+w[i]);
        }
        printf("%d
",cost-dp[cost]+5-w[n-1]);
    }
    return 0;
}

  poj 3903  nlog(n)求最长递增子序列LIS

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

int n;
const int maxn=100010;
const int inf=0x7fffffff;
int dp[maxn];
int a[maxn];

int main()
{
    while(~scanf("%d",&n))
    {
        for(int i=0;i<n;i++) scanf("%d",&a[i]);

        fill(dp,dp+n,inf);

        for(int i=0;i<n;i++)
            *lower_bound(dp,dp+n,a[i])=a[i];
        int ans=lower_bound(dp,dp+n,inf)-dp;
        printf("%d
",ans);
    }
}

 hdu 1203 0-1背包变形

题意：qn要去申请n所学校，但是只有cost前，每所学校都有申请费用以及录取概率，求qn有学上的最大概率

#include<bits/stdc++.h>

using namespace std;

double dp[10010];
int w[10010];
double p[10010];
int n,cost;

double cal(double x,double y)
{
    double c=1.0-(1-x)*(1-y);
    return c;
}

int main()
{
    while(~scanf("%d%d",&cost,&n)&&(cost||n))
    {
        for(int i=0;i<n;i++)
            scanf("%d%lf",&w[i],&p[i]);
        memset(dp,0,sizeof(dp));
        for(int i=0;i<n;i++)
        {
            for(int j=cost;j>=w[i];j--)
                dp[j]=max(dp[j],cal(dp[j-w[i]],p[i]));
        }
        printf("%.1f%%
",dp[cost]*100);
    }
}

 hdu 2955 

题目大意：rob计划要抢银行，一共有n个银行，给定逃跑概率上限值lim（安全概率），对每个银行都有一个可以抢的钱数以及被抓的概率，问你在保证安全情况下，最多抢到多少钱？

思路：这题从被抓概率考虑，我们肯定要求最小的，这样就违背了背包的原理，我们反过来，从逃跑概率出发，也就是说求逃跑概率最大值满足条件，我们把抢到的钱看做体积，逃跑概率看做价值，这样背包之后，再从末尾往前查满足条件的即可，需要注意的是边界要进行初始化，0的时候 就是不抢 概率为1 ，同时还要注意一定要恰好装满背包 需要重复查一次

#include<bits/stdc++.h>
using namespace std;

int t;
int n;
int cost;
double lim;
int w[110];
double p[110];

double dp[10010];

double cal(double x,double y)
{
    return x*y;
}
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        cost=0;
        scanf("%lf%d",&lim,&n);
        lim=1-lim;
        for(int i=0;i<n;i++)
            scanf("%d%lf",&w[i],&p[i]),cost+=w[i],p[i]=1-p[i];
        memset(dp,0,sizeof(dp));
        dp[0]=1;

        for(int i=0;i<n;i++)
        {
            for(int j=cost;j>=w[i];j--)
            {
                dp[j]=max(dp[j],cal(dp[j-w[i]],p[i]));
            }
        }

        int ans;
        for(int i=cost;i>=0;i--)
        {
            if(dp[i]>=lim) {
                ans=i;
                break;
            }
        }
        int pos=0;
        for(int i=ans;i>=1;i--)
        {
            if(dp[i]!=dp[i-1]){
                pos=i;
                break;
            }
        }

        printf("%d
",pos);
    }
}

poj  1948   Triangular Pastures 子集和问题

题目大意：有n个木棒，给出每个木棒的长度，将所有三角形都用上，求所能构成的三角形的最大面积，最后结果乘以100   向下取整，若不能构成三角形 输出-1；

题目思路，dp[i][j][k]表示前i个木棒能不能拼成两条边的长度分别为j和k，那么第三条边就可以减法求出来

　　dp[i][j][k]=(dp[i-1][j][k]|dp[i-1][j-w[i]][k]|dp[i-1][j][k-w[i]]); 由于内存限制，优化掉第一层，滚动数组

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cmath>

using namespace std;

int n;
int w[50];
bool dp[1610][1610];

double cal(double p,int a,int b,int c)
{
    return sqrt(double(p*1.0*(p-a)*(p-b)*(p-c)));
}



int main()
{
    scanf("%d",&n);
    int sum=0;
    for(int i=0;i<n;i++)
        scanf("%d",&w[i]),sum+=w[i];
    memset(dp,0,sizeof(dp));
    dp[w[0]][0]=dp[0][w[0]]=1;

    double ans=0;

    int flag=0;

    for(int i=1;i<n;i++)
    {
        for(int j=sum;j>=0;j--)
        {
            for(int k=sum;k>=0;k--)
            {
                if(j-w[i]>=0) dp[j][k]|=dp[j-w[i]][k];
                if(k-w[i]>=0) dp[j][k]|=dp[j][k-w[i]];
                int c=sum-j-k;
                if(dp[j][k]&&j+k>c&&j+c>k&&k+c>j){
                    ans=max(ans,cal(sum/2.0,j,k,c));
                    flag=1;
                }
            }
        }
    }
    if(flag)
        printf("%d
",int(ans*100));
    else puts("-1");

}

A 

题目大意：有一个十字路口的交通灯，给出各种左转，右转，直行，人行横道，判断是否会撞到人行横道

思路：分别对直行、左转、右转进行判断即可

#include<bits/stdc++.h>
using namespace std;

int l[4];
int s[4];
int r[4];
int p[4];

int main()
{
    for(int i=0;i<4;i++)
        cin>>l[i]>>s[i]>>r[i]>>p[i];
    for(int i=0;i<4;i++)
    {
        if((l[i]||r[i]||s[i])&&p[i]){
            cout<<"YES";return 0;
        }
    }
    for(int i=0;i<4;i++)
    {
        if(r[i]&&p[(i+1)%4]){
            cout<<"YES";return 0;
        }
    }
    for(int i=0;i<4;i++)
    {
        if(l[i]&&p[(i+4-1)%4]){
            cout<<"YES";return 0;
        }
    }
    for(int i=0;i<4;i++)
    {
        if(s[i]&&p[(i+2)%4])
        {
            cout<<"YES";return 0;
        }
    }
    cout<<"NO";
    return 0;
}

B

题目大意：一个矩阵，最左右两列表示楼梯，中间的m列表示灯，走一步需要1min，每次关完本层的灯，再去关上层的灯，从左下角出发，求关完所有的灯需要的时间

思路：

预处理一下，对每一层从左边或者右边出发 需要花费多少时间，进行二进制枚举每一层从左边走还是右边走，用pre保存下一层从左边走的还是从右边走的，然后进行枚举求最小值，

注意两个地方：

一是注意预处理一下需要走上第几层，二是不需要向上走时，就不用再动了，二进制枚举右移次数有限制

#include<bits/stdc++.h>
using namespace std;

int n,m;
int ma[20][110];
int l[20];
int r[20];
const int inf=0x7fffffff;


int main()
{
    memset(l,0,sizeof(l));
    memset(r,0,sizeof(r));
    char c;
    cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m+2;j++)
        {
            cin>>c;
            ma[i][j]=c-'0';
        }
    }
    for(int i=n-1;i>=0;i--)
    {
        for(int j=0;j<m+2;j++)
        {
            if(ma[i][j]==1){
                l[i]=max(l[i],j);
                r[i]=max(r[i],m+1-j);
            }
        }
    }

    int flag=n-1;
    for(int i=0;i<n;i++)
    {
        if(l[i]) {flag=i;break;}
    }

    int ans=inf;
    for(int i=0;i<=(1<<(n-1))-1;i++)
    {
        int p=i;
        int sum=0;
        int pre=0;
        for(int j=n-2,k=0;j>=0&&k<n-1-flag;j--,k++)
        {
            if(p&1){
                if(pre){
                    sum+=r[j+1]+r[j];
                    pre=1;
                }
                else {
                    sum+=(m+1-l[j+1])+r[j];
                    pre=1;
                }
            }
            else{
                if(pre){
                    sum+=(m+1-r[j+1])+l[j];
                    pre=0;
                }
                else {
                    sum+=l[j+1]+l[j];
                    pre=0;
                }
            }
            p>>=1;
        }
        sum+=l[n-1];
        sum+=n-1-flag;

        ans=min(ans,sum);
    }
    cout<<ans;
}

　　C 

简单二分，

#include<bits/stdc++.h>
using namespace std;

typedef long long LL;

int n,cost;
struct node
{
    int v;
    int ord;
    LL cal;
}a[100000+100];
const int inf=0x7fffffff;
LL num=inf;

int cmp(node u,node v)
{
    if(u.cal<v.cal) return 1;
    else return 0;
}

int check(int x)
{
    LL sum=0;
    for(int i=1;i<=n;i++)
    {
        a[i].cal=a[i].ord*1LL*x+a[i].v;
    }
    sort(a+1,a+n+1,cmp);
    for(int i=1;i<=x;i++)
    {
        sum+=a[i].cal;
        if(sum>cost*1LL) return 0;
    }



    num=sum;

    return 1;
}


int main()
{
    scanf("%d%d",&n,&cost);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i].v);
        a[i].ord=i;
    }
    int l=0,r=n;
    int ans=0;
    while(l<=r)
    {

        int mid=(l+r)/2;
        if(check(mid)) {
            ans=mid;
            l=mid+1;
        }
        else {
            r=mid-1;
        }
    }
    printf("%d %I64d
",ans,num);
}