洛谷P1631序列合并(二分答案经典好题，或优先队列堆+数学优化，或有序表一一顺序比较)

题目链解：https://www.luogu.org/problemnew/show/P1631

二分枚举判断答案几乎是无敌的存在几十秒求出有m次操作的最值问题！

这题刚看完有点蒙，两个for循环的话不但爆空间，也爆时间啊！

看了大佬解释后，发现有3种做法，二分答案或优先队列(堆)，还有一种类似数据结构的归并排序从前往后一一比较的思想每次选出前面几个最小的。个人倾向于二分答案。

想到二分答案并不容易，有3点关键：

1.题目给的是有序的！（有序，单调一般都能二分）

2.从小达到排,找到最大的停止!(最大值!关键二分)

3.这是一个范围问题,最小范围和最大范围上限已知!(明显二分!)

（选n个数，也就是n次，和移动石头m一样的。。）

（二分枚举判断答案本质：只要有m次操作的最值问题都可用） 

另外需要注意的是，第一个for循环枚举答案的时候，完全可以找到一个点跳出达到很大的剪枝优化！（后面肯定不会有更小的了就退出完成）

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1e6;
int a[maxn],b[maxn];
int c[maxn];//结果数组要开大,因为可能有重复
int n;

int judge(int x)
{
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        if(cnt>n) break;//数选够了退出
        if(a[i]+b[1]>x) break;//这个优化很重要(整个循环退出),不用枚举到底了,如果第i个数+b第一个都比x大后面(包括下一轮)肯定所有更大!
                              //这个>和j循环里的>意义不同更重大,j循环里的>退出,下一轮可能还有更小的!但第一个>退出就代表下一轮也不可能更小了!
        for(int j=1;j<=n;j++)
        {
            if(a[i]+b[j]<x)//选了这个数,数的个数+1
            {
                cnt++;
                if(cnt>n) break;
            }
            else if(a[i]+b[j]>x) break;//＞这一轮退出(因为下一轮可能有更小的)
        }
    }
    
    return cnt;
}

int main()
{
    ios::sync_with_stdio(false); cin.tie(0);
    
    cin>>n;
    for(int i=1;i<=n;++i) cin>>a[i];
    for(int i=1;i<=n;++i) cin>>b[i];

    int l=a[1]+b[1],r=a[n]+b[n];
    int ans=0;
    while(l<=r)
    {
        int mid=(l+r)/2;
        
        int t=judge(mid);
        if(t<=n)
        {
            l=mid+1;
            ans=mid;
        }
        else r=mid-1;
    }
    
    int p=0;
    for(int i=1;i<=n;++i)
    {
        if(a[i]+b[1]>ans) break;//和judge里优化一样不再重述
        for(int j=1;j<=n;++j)
        {
            if(a[i]+b[j]<=ans)
            {
                c[++p]=a[i]+b[j];
            }
            else break;
        }
    }
    sort(c+1,c+1+p);

    for(int i=1;i<=n-1;i++) cout<<c[i]<<" ";
    cout<<c[n]<<endl;
    
    return 0;
}

数学优化，前i*j个小的元素下表绝对不会超过i*j，即下标超过i*j的都必定是第n大元素之后的！

#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
const int maxn=1e6;
int a[maxn],b[maxn];
int n;
struct px
{
    int x;
    bool operator<(const px &a) const
    {
        return x>a.x;
    }
    px(){};
    px(int X):x(X){};
};
priority_queue<px> que;

int main()
{
    ios::sync_with_stdio(false); cin.tie(0);

    cin>>n;
    for(int i=1;i<=n;++i) cin>>a[i];
    for(int i=1;i<=n;++i) cin>>b[i];

    for(int i=1;i<=n;i++)
    {
        for(int j=1;j*i<=n;j++)
        {
            que.push(px(a[i]+b[j]));
        }
    }

    for(int i=1;i<=n-1;i++)
    {
        cout<<que.top().x<<' ';
        que.pop();
    }
    cout<<que.top().x<<endl;

    return 0;
}

有序表合并的方法,类似数据结构的归并排序思想一个一个比较
因为A和B是递增的，所以最小的n个数肯定是A和B前几个数的组合

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
const int maxn=1e6+5;
int a[maxn],b[maxn];
int n;
struct px
{
    int x;
    bool operator<(const px &a) const
    {
        return x>a.x;
    }
    px(){};
    px(int X):x(X){};
};
priority_queue<px> que;

int main()
{
    ios::sync_with_stdio(false); cin.tie(0);

    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1;i<=n;i++) cin>>b[i];

    int A=1,B=1;//设置两个指针，各指向数组的开头，然后依次往后走！
    que.push(px(a[A]+b[B]));//这个肯定最小，放进堆里
    while(que.size()<n*3)//多选一些(多选多少可能要试几次,*2错误,*3就过了)，然后从堆里面输出最小的n个
    {
        if(a[A]<=b[B])//每次比较指针指向的数，小的那个指针向后移
        {
            A++;
            for(int i=1;i<=B;i++) que.push(px(a[A]+b[i]));//然后下一个指向的数与b的前B个数组合，扔进堆里
        }
        else
        {
            B++;
            for(int i=1;i<=A;i++) que.push(px(a[i]+b[B]));//同上
        }
    }
    for(int i=1;i<=n-1;i++)
    {
        cout<<que.top().x<<' ';
        que.pop();
    }
    cout<<que.top().x<<endl;

    return 0;
}

还有一道洛谷P2085跟上题几乎一样，有2种做法，二分答案和有序表合并思想从小到大一个一个比较。

二分90ms

#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=1e6;
ll a[maxn],b[maxn],c[maxn];
ll d[maxn];
int n,m;

int judge(ll x)
{
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        if(cnt>m) break;

        for(int j=1;j<=m;j++)
        {
            if(a[i]*j*j+b[i]*j+c[i]<x)
            {
                cnt++;
                if(cnt>m) break;
            }
            else if(a[i]*j*j+b[i]*j+c[i]>x) break;
        }
    }

    return cnt;
}

int main()
{
    ios::sync_with_stdio(false); cin.tie(0);

    cin>>n>>m;
    ll Min=1e10,Max=0;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i]>>b[i]>>c[i];

        Min=min(Min,a[i]+b[i]+c[i]);
        Max=max(Max,a[i]*m*m+b[i]*m+c[i]);
    }
    ll l=Min,r=Max;
    ll ans=0;
    while(l<=r)
    {
        ll mid=(l+r)/2;

        int t=judge(mid);
        if(t<=m)
        {
            l=mid+1;
            ans=mid;
        }
        else r=mid-1;
    }

    int p=0;
    for(int i=1;i<=n;i++)
    {
        if(p==m) break;
        for(int j=1;j<=m;j++)
        {
            ll t=a[i]*j*j+b[i]*j+c[i];
            if(t<=ans)
            {
                d[++p]=t;
            }
            else break;
        }
    }

    sort(d+1,d+1+p);

    for(int i=1;i<=m-1;i++) cout<<d[i]<<" ";
    cout<<d[m]<<endl;

    return 0;
}

有序表合并比较3000ms

#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
typedef long long ll;
const int maxn=1e6;
ll a[maxn],b[maxn],c[maxn];
ll d[maxn],e[maxn];
ll n,m;

int main()
{
    ios::sync_with_stdio(false); cin.tie(0);

    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i]>>b[i]>>c[i];
        d[i]=1;
    }

    for(int i=1;i<=n;i++)//m个数,保证每次取到的都是最小的!这个方法也可以不用优先队列普通数组存就可以!
    {
        ll ans=1e9,ansj=0;
        ll t=0;
        for(int j=1;j<=2;j++)
        {
            t=a[j]*d[j]*d[j]+b[j]*d[j]+c[j];
            if(t<ans)
            {
                ans=t;
                ansj=j;
            }
        }
        e[i]=ans;
        d[ansj]++;
    }

    for(int i=1;i<=m-1;i++)
    {
        cout<<e[i]<<' ';
    }
    cout<<e[n]<<endl;

    return 0;
}

可以看到，二分枚举判断答案几乎是无敌的存在几十秒求出有m次操作的最值问题！

完。