2017-2018 ACM-ICPC, NEERC, Southern Subregional Contest

最新推荐文章于 2019-08-20 16:32:13 发布

编程熊

最新推荐文章于 2019-08-20 16:32:13 发布

阅读量431

点赞数 2

CC 4.0 BY-SA版权

分类专栏： gym 文章标签： codeforces gym

本文链接：https://blog.youkuaiyun.com/qq_36779545/article/details/78464110

gym 专栏收录该内容

1 篇文章

订阅专栏

本文通过两个具体问题介绍了如何运用二分查找与动态规划（DP）解决复杂问题。第一个问题是关于寻找最优分割策略来最小化最大差值，第二个问题则是关于调整数列使其相邻元素差值不超过1的最大可能总和。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

I题：

题意：将一个升序排好的数列切成若干段，要求每段的长度，对每一段中最大值与最小值的差取个最大值，问这个最大值最小是多少

思路：很容易想到二分答案然后check一下是否满足条件， check的方法，一开始想的是贪心取，发现尽可能多的取，会造成最后一段不够k，以及分界点（切下去的点）变化，造成不满足，实际上合理选择分界点是可以的， check的正确方法是dp记忆化一下，d[i]表示[1..d[i]]一段可以按上述要求进行切割，且d[i]是i及其之前最靠近i的位置（即从头开始到i位置处最远可以切割到的位置），

则若有d[n]==n，则意味着一整段都可以进行切割。

若[d[i-k]+1,i]一段能被切割，则[1,i]一整段就能被切割，于是有d[i]==i；

否则d[i]继承上次跑到的最远位置last.

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<vector>
#include<set>
#include<map>
#include<stack>
#include<queue>
#include<time.h>
#include<unordered_map>
#include<unordered_set>
#define ll long long
using namespace std;
#define mp make_pair
#define pb push_back
#define lson l,mid,pos<<1
#define rson mid+1,r,pos<<1|1
const double PI=acos(-1);
const int maxm=2000+5;
const int maxn=3e5+5;
const int mod=1e9+7;
const int inf=0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3fLL;
const double eps=1e-8;
//int dir[4][2]={0,1,1,0,0,-1,-1,0};
//ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
//ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
//ll inv(ll b){if(b==1)return 1; return (mod-mod/b)*inv(mod%b)%mod;}
//ll fpow(ll n,ll k){ll r=1;for(;k;k>>=1){if(k&1)r=r*n%mod;n=n*n%mod;}return r;}

int n, k;
int a[maxn];
int dp[maxn];

bool check(int answer)
{
     int id = 0;
     for(int i = k; i <= n; i++)
     {
         int point = dp[i-k];
         if((a[i]-a[dp[i-k]+1]) <= answer) id = i; /// 此处为dp[i-k]+1] 而非 dp[i-k+1]， 理解：dp[i] 表示1到i”可以“切得最远位置
         dp[i] = id;
     }
     if(dp[n] == n)
        return true;
     else
        return false;
}

int  main()
{
    scanf("%d%d", &n, &k);
    for(int i = 1; i <= n;i++)
    {

        scanf("%d", &a[i]);
    }
    sort(a+1,a+n+1);
    int l = 0, r = 1000000000;
    while(l < r)
    {
        int mid = (l+r)/2;
        if(check(mid))
        {
            r = mid;
        }
        else
        {
            l = mid+1;
        }
    }
    printf("%d\n", l);
    return 0;
}

k题：

题意：

给定一个数列a，每个元素初始值为s[i]，可以加上g[i]的变化量，要求最终得到的数列中相邻两数的绝对值之差. 问总共最多能加的值是多少。输出总和及各点变化后的量。

思路:

这道题如果比较了解两个区间的关系，可以很快有思路吧。（六种情况）

一开始就想到一种比较难处理的栗子，只需要正着和反着扫一遍，贪心维护一下就好，

从前往后扫的时候维护处最大和最小的值，便可以check出是否有可行解。

从后往前就贪心的取每一个值，即可。

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

const int maxn = 2e5 + 5;

int n;
int a[maxn], g[maxn], xmax[maxn], xmin[maxn];
int now[maxn];

int main()
{
    scanf("%d", &n);
    long long sum = 0, ans = 0;
    for(int i = 1; i <= n; i++)
    {
        scanf("%d%d", &a[i], &g[i]);
        g[i] = a[i]+g[i];
    }
    xmax[1] = g[1];
    xmin[1] = a[1];
    for(int i = 2; i <= n; i++)
    {
        xmax[i] = min(g[i], xmax[i-1]+1);
        xmin[i] = max(a[i], xmin[i-1]-1);
        if(xmax[i] < xmin[i])
        {
            printf("-1\n");
            return 0;
        }
    }
    sum += xmax[n] - a[n];
    ans = xmax[n];
    now[n] = xmax[n];
    for(int i = n-1; i >= 1; i--)
    {
        if(ans+1 <= xmax[i])
          ans = ans+1;
        else if(ans<=xmax[i])
          ans =ans;
          else
            ans = ans -1;
         now[i]=ans;
        sum += ans-a[i];

    }
    printf("%I64d\n", sum);
    for(int i = 1; i <= n; i++)
    printf("%d%c", now[i],i==n?'\n':' ');
    return 0;
}