大一acmer日常记录day17

洛谷p1478：方法1：贪心，方法2：动态规划

 贪心：每次取耗费体力最小的

动态规划：背包

​
洛谷p1478：方法1：贪心，方法2：动态规划


 贪心：每次取耗费体力最小的
代码：

# include <bits/stdc++.h>
using namespace std;
struct man
{
    int x;
    int y;
}apple[5005];
bool cmp(man a,man b)
{
    if(a.y<b.y)return 1;
    return 0;
}
int main ()
{
    int n,s,a,b;
    cin>>n>>s>>a>>b;
    int h=a+b;
    for(int i=1;i<=n;i++)
    {
        cin>>apple[i].x>>apple[i].y;
    }
    int ans=0;
    sort(apple+1,apple+n+1,cmp);
    for(int i=1;i<=n;i++)
    {

        if(h>=apple[i].x&&s>=apple[i].y)
        {
            s-=apple[i].y;
            ans++;
        }
    }
    printf("%d",ans);
    return 0;
}

​

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

int x[5005],y[5005];
int dp[5005][1005];int a,b,n,s;
int main ()
{

    cin>>n>>s>>a>>b;
    for(int i=1;i<=n;i++)
    {
        cin>>x[i]>>y[i];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=s;j++)
        {
            dp[i][j]=dp[i-1][j];
            if(j>=y[i]&&(a+b)>=x[i])dp[i][j]=max(dp[i][j],dp[i-1][j-y[i]]+1);
        }
    }
    cout<<dp[n][s];
    return 0;
}

   洛谷p5019：贪心

 思路：贪心策略：对相邻两块路考虑如果后一块深度大于前一块，则天数等于当前天数+后-前

代码：

​
# include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,p,l,ans;
int main ()
{
    cin>>n;

    for(ll i=1;i<=n;i++)
    {
       ll p;
       cin>>p;
        if(p>l)ans+=(p-l);
         l=p;
    }
    printf("%lld",ans);

    return 0;
}

​

 洛谷p1094：贪心

 思路：贪心策略：先由小到大排序，对第一个和最后一个考虑，如果之和大于w，则ans++，考虑第一个和最后一个位置减一，如果之和小于等于w，ans++，第一个位置+1，最后一个位置减一

代码

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


int main ()
{
    int w,n,p[30005];
    cin>>w>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>p[i];
    }
    sort(p+1,p+n+1);
    int l=1,r=n;
    int ans=0;
    while(l<=r)
    {
        if(p[l]+p[r]<=w)
        {
            ans++;
            l++;
            r--;
        }
        else
        {
            r--;
            ans++;
        }
    }
    cout<<ans;
    return 0;
}

洛谷p4995：贪心

 思路：贪心策略：先排序，跳到最高的石头上，在从最高跳到第一个，然后第一个跳到倒数第二个，依次类推

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main ()
{
    ll n,h[305];
    cin>>n;
    for(ll i=1;i<=n;i++)
    {
        cin>>h[i];
    }
    sort(h+1,h+1+n);
    ll l=1,r=n;
    ll ans=h[r]*h[r];
    int total=1;
    while(r-l>=1)
    {
        ans+=(h[r]-h[l])*(h[r]-h[l]);
        if(total%2==1)
        {

        total++;
        r--;
        }
        else
        {
            l++;
            total++;
        }
    }
    cout<<ans;
    return 0;
}

洛谷p4447：队列

 思路：

把每一个组看成一个队列。我们只要关心的是队尾每次插入的元素是什么就行。

将n个数排序，从头到尾扫一遍，每次扫到一个数，就看一看现有的组（队列）中有没有末尾是该数-1的，有就插入进去，该组数量+1。直到扫完，输出最小组数的长度。

没了？

不。每次选队列时，也许有很多符合要求的，但是选哪一个呢？不好好考虑这个会40的！

当然是加给最短的那个啦！挺高平均水平嘛！（手动滑稽） 如果没有符合要求的，新开一个队列。

代码：

# include <bits/stdc++.h>
using namespace std;
int n,a[100005];
struct node
{
    int num;
    int b;
}ans[100005];
int l=0;
int main ()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    sort(a+1,a+1+n);
    for(int i=1;i<=n;i++)
    {
        bool ok=false;
        for(int j=l;j>=0;j--)
        {
            if(ans[j].b==a[i]-1)
            {
                ok=true;
                ans[j].num++;
                ans[j].b++;
                break;
            }
        }
        if(!ok)
        {
            l++;
            ans[l].b=a[i];
            ans[l].num++;
        }
    }
    int ans1=ans[1].num;
    for(int i=2;i<=l;i++)
    {
        ans1=min(ans1,ans[i].num);
    }
    printf("%d",ans1);
    return 0;
}