多路归并总结

1.鱼塘钓鱼

1262. 鱼塘钓鱼 - AcWing题库

多路归并的模型。

对于每个鱼塘构成的等差数列，我们每次在数列最头部进行选择，选完后再顺延到下一个数即可。我们可以通过维护一个包含所有等差序列首元素的大根堆，使每次可以很容易地选出最大的数。

这里还有一点点贪心，我们要知道，当人到达某个鱼塘时，一次性钓完需要钓的所有鱼，这种情况一定比折返钓鱼的情况更优。

我们枚举人最远走到哪个鱼塘，则钓鱼的总时间是t-路上的时间，在固定的时间和鱼塘范围内来进行多路归并。

#include<iostream>
#include<queue>
using namespace std;
const int N=110;
typedef pair<int,int> PII;
#define x first
#define y second
int n,t;
int a[N],b[N],c[N];
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(int i=1;i<=n;i++) scanf("%d",&b[i]);
    for(int i=2;i<=n;i++) 
    {
        scanf("%d",&c[i]);
        c[i]+=c[i-1];
    }
    scanf("%d",&t);
    int res=0;
    for(int i=1;i<=n;i++)
    {
        int tt=t-c[i];
        priority_queue<PII> heap;
        for(int j=1;j<=i;j++)
        {
            heap.push({a[j],j});
        }
        int fish=0;
        while(heap.size()&&tt>0)
        {
            int val=heap.top().x;
            fish+=val;
            tt--;
            int p=heap.top().y;
            heap.pop();
             heap.push({max(val-b[p],0),p});
        }
        res=max(res,fish);
    }
    printf("%d",res);
}

2.序列

146. 序列 - AcWing题库

首先思考最暴力的情况，是将个值全算出来，sort一遍，然后取前n个最小值。暴力的时间复杂度和空间复杂度显然都超了，我们继续思考优化的方法。

第一步优化，我们可以选择每次合并两个序列，共合并m-1次，每次合并时后将结果排序，只保留前n个最小值，这样的时间复杂度就降到了。

第二步优化，我们可以将序列分为n组，每组中有n个数，并且保证每组中的n个数是从小到大排序的。我们先将a数组从小到大排列，就可以达到这样的目的，分组方式如下图：

在这n组数中，最前面的数一定是本组中最小的数，因此，每次合并时，我们只需要进行n次选择，每次在这n组数的最前面选择一个数，就可以得到最后的结果。而这个选择过程，可以通过维护一个大小为n的小根堆来实现。在最开始，我们将每组的第一个数存入小根堆中，每次选择时取出堆顶元素，再将同组的下一个元素插入小根堆即可。这样一来，时间复杂度就变为了。

在这里也顺便复习了一下STL的堆写法。

建堆：

//大根堆
priority_queue<int> heap;
//小根堆
priority_queue<int,vector<int>,greater<int>> heap;

操作：

//插入
heap.push();
//删除堆顶元素
heap.pop();
//查看堆顶元素
heap.top();

ac代码如下：

#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
typedef pair<int,int> PII;
#define x first
#define y second
const int M=1010,N=2010;
int T;
int a[N],b[N];
int n,m;
void merge()
{
    priority_queue<PII,vector<PII>,greater<PII>> heap;
    for(int i=1;i<=n;i++) heap.push({a[1]+b[i],1});
    int c[N];
    for(int i=1;i<=n;i++)
    {
        c[i]=heap.top().x;
        int p=heap.top().y;
        heap.pop();
        heap.push({c[i]-a[p]+a[p+1],p+1});
    }
    for(int i=1;i<=n;i++) a[i]=c[i];
}
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        int heap[N];
        scanf("%d%d",&m,&n);
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        sort(a+1,a+1+n);
        for(int i=1;i<=m-1;i++)
        {
            for(int j=1;j<=n;j++) scanf("%d",&b[j]);
            merge();
        }
        for(int i=1;i<=n;i++) printf("%d ",a[i]);
        printf("\n");
    }
}

也可以自己手写堆来实现：

手写堆的板子可以看这条博客。

#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
typedef pair<int,int> PII;
#define x first
#define y second
const int M=1010,N=2010;
int T;
int a[N],b[N];
int n,m;
void down(int u,PII heap[],int idx)
{
    int t=u;
    if(2*u<=idx&&heap[t].x>heap[2*u].x) t=2*u;
    if(2*u+1<=idx&&heap[t].x>heap[2*u+1].x) t=2*u+1;
    if(t!=u) 
    {
        swap(heap[t],heap[u]);
        down(t,heap,idx);
    }
}
void up(int u,PII heap[],int idx)
{
    while(u/2&&heap[u/2].x>heap[u].x) 
    {
        swap(heap[u/2],heap[u]) ;
        u/=2;
    }
}
void merge()
{
    PII heap[N];
    int idx=0;
    for(int i=1;i<=n;i++) 
    {
        heap[++idx]={a[1]+b[i],1};
        up(idx,heap,idx);
    }
    int c[N];
    for(int i=1;i<=n;i++)
    {
        c[i]=heap[1].x;
        int p=heap[1].y;
        swap(heap[1],heap[idx--]);
        down(1,heap,idx);
        heap[++idx]={c[i]-a[p]+a[p+1],p+1};
        up(idx,heap,idx);
    }
    for(int i=1;i<=n;i++) a[i]=c[i];
}
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        int heap[N];
        scanf("%d%d",&m,&n);
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        sort(a+1,a+1+n);
        for(int i=1;i<=m-1;i++)
        {
            for(int j=1;j<=n;j++) scanf("%d",&b[j]);
            merge();
        }
        for(int i=1;i<=n;i++) printf("%d ",a[i]);
        printf("\n");
    }
}

3.技能升级

找不到页面 - AcWing

和鱼塘钓鱼是完全相同的模型，但是数据范围大了很多，需要进一步优化。可以看到，这题中的m很大，我们要尽可能地想办法让时间复杂度不受m的影响或者是logm。

在多路归并后，如果将结果输出为一个序列，我们会发现这个序列一定是单调的（在本题中是单调递增），而且，我们可以找到序列中最小的数，当每一路中的数小于这个数时，这一路的数都不可能再选了。

由此想到二分，我们可以二分一个x，使得>=x的数有>=m个，>=x+1的数有<m个。而且，由于等差数列的性质，我们可以很轻易地求出所有路中>=x的数的个数。

#include<iostream>
using namespace std;
const int N=1e5+10;
typedef long long ll;
int n,m;
int a[N],b[N];
bool check(int u)
{
    ll res=0;
    for(int i=1;i<=n;i++)
    {
        if(a[i]>=u) res+=(a[i]-u)/b[i]+1;
    }
    if(res>=m) return true;
    else return false;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d%d",&a[i],&b[i]);
    int l=0,r=1e6;
    while(l<r)
    {
        int mid=(l+r+1)>>1;
        if(check(mid)) l=mid;
        else r=mid-1;
    }
    ll res=0;
    ll cnt=0;
    for(int i=1;i<=n;i++)
    {
        if(a[i]>=l)
        {
            int xiangshu=(a[i]-l)/b[i]+1;
            int moxiang=a[i]-(xiangshu-1)*b[i];
            res+=(ll)(a[i]+moxiang)*xiangshu/2;
            cnt+=xiangshu;
        }
    }
    printf("%lld",res-(cnt-m)*l);
}

4.丑数

62. 丑数 - AcWing题库

我们先列出一些丑数，寻找它们的规律：

可以发现，总集s是s2、s3和s5的并集。于是，我们只需要对s2、s3和s5进行多路归并+判重。

#include<vector>
class Solution {
public:
    int getUglyNumber(int n) {
        vector<int> q;
        q.push_back(1);
        int i=0,j=0,k=0;
        for(int l=2;l<=n;l++)
        {
            int t=min(q[i]*2,min(q[j]*3,q[k]*5));
            q.push_back(t);
            if(q[i]*2==t) i++;
            if(q[j]*3==t) j++;
            if(q[k]*5==t) k++;
        }
        return q.back();
    }
};