2019 Multi-University Training Contest 3

9 篇文章 0 订阅
8 篇文章 0 订阅

hdu6611:K Subsequence

theme:给定一个含n个元素的序列,可以选择k轮,每轮选出非降子序列求和,选过的元素不能再选,求k轮后最大能得到的和。

solution:最长非降子序列与dp、线段树、网络流联系紧密。每个数字有次数限制,所以考虑费用流。增加一个源点与汇点,再在源点之后与汇点之前增加一个点,分别于源/汇点相连,出/进的流量为k(限制k轮),费用为0。这两点都与每一个元素相连。其他节点按<=关系相连,流量都为0(因为一个元素只能被选一次),由于我们是求最大和,而用的算法是最小费用最大流,所以我们把边的费用设为-ai,最终结果为跑一遍最小费用最大流取-即可。

这里用dijkstra优化费用流

#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
const int maxn = 1e4;
const int inf = 0x3f3f3f3f;
struct edge {//网络的边
    int to, cap, cost, rev;
    edge() {}
    edge(int to, int _cap, int _cost, int _rev) :to(to), cap(_cap), cost(_cost), rev(_rev) {}
};
int V, H[maxn + 5], dis[maxn + 5], PreV[maxn + 5], PreE[maxn + 5];
vector<edge> G[maxn + 5];//点

void init(int n) {
    V = n;
    for (int i = 0; i <= V; ++i)G[i].clear();
}
//建边与反向边
void AddEdge(int from, int to, int cap, int cost) {
    G[from].push_back(edge(to, cap, cost, G[to].size()));
    G[to].push_back(edge(from, 0, -cost, G[from].size() - 1));
}
//MCMF
int Min_cost_max_flow(int s, int t, int f, int& flow) {
    int res = 0; fill(H, H + 1 + V, 0);
    while (f) {
        priority_queue <pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>> > q;
        fill(dis, dis + 1 + V, inf);
        dis[s] = 0; q.push(pair<int, int>(0, s));
        while (!q.empty()) {
            pair<int, int> now = q.top(); q.pop();
            int v = now.second;
            if (dis[v] < now.first)continue;
            for (int i = 0; i < G[v].size(); ++i) {
                edge& e = G[v][i];
                if (e.cap > 0 && dis[e.to] > dis[v] + e.cost + H[v] - H[e.to]) {
                    dis[e.to] = dis[v] + e.cost + H[v] - H[e.to];
                    PreV[e.to] = v;
                    PreE[e.to] = i;
                    q.push(pair<int, int>(dis[e.to], e.to));
                }
            }
        }
        if (dis[t] == inf)break;
        for (int i = 0; i <= V; ++i)H[i] += dis[i];
        int d = f;
        for (int v = t; v != s; v = PreV[v])d = min(d, G[PreV[v]][PreE[v]].cap);
        f -= d; flow += d; res += d*H[t];
        for (int v = t; v != s; v = PreV[v]) {
            edge& e = G[PreV[v]][PreE[v]];
            e.cap -= d;
            G[v][e.rev].cap += d;
        }
    }
    return res;
}

int a[maxn];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,k;
        scanf("%d%d",&n,&k);
        for(register int i=1;i<=n;++i) scanf("%d",&a[i]);
        int ss=0,s=1,t=2*n+2,tt=2*n+3;//ss为源点,tt为汇点
        init(tt+1);//清空vector
        AddEdge(ss,s,k,0);//建边同时建反向边
        AddEdge(t,tt,k,0);
        for(register int i=1;i<=n;++i)
        {
            AddEdge(s,i+1,1,0);
            AddEdge(i+1+n,t,1,0);
            AddEdge(i+1,i+1+n,1,-a[i]);
            for(register int j=i+1;j<=n;++j)
            {
                if(a[j]>=a[i])
                {
                    AddEdge(1+i+n,1+j,1,0);
                }
            }
        }
        int ans=0;
        printf("%d\n",-Min_cost_max_flow(ss,tt,inf,ans));
    }
    return 0;
}

Find the answer

theme:n个元素,现给定m,对每个元素i,求至少从i之前i-1个元素取出几个赋值为0使得a1+a2+…+ai<=m?

solution:由贪心肯定是优先取出最大的数才能使得数目最小,但对每个元素都求前几大就算用优先队列也会超时。

反过来,考虑从i-1个数中最多选几个使得和<=m-ai,这样就可以用线段树来维护。建权值线段树sum,cnt分别维护和与个数,先离散化,第一个元素明显答案为0,所以从第1元素开始插入求i+1元素答案(用lower_bound可以获取元素i离散后的位置,即线段树中的结点区间l=r),这时对于i+1个元素,在线段树中查询sum<=m的最大区间,所以从左子树开始查。注意,可能结点l处cnt[l]>1,这时不是全舍,而是取出一部分,所以l=r时返回min(cnt[l],res/v[l-1])

#include<bits/stdc++.h>
#include<vector>
#include<algorithm>
using namespace std;
#define far(i,t,n) for(int i=t;i<n;++i)
#define pk(a) push_back(a)
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

ll a[200020];
vector<ll>v;
ll sum[200020<<2];
int cnt[200020<<2];

void update(int pos,int l,int r,int rt)
{
    if(l==r)
    {
        cnt[rt]++;
        sum[rt]+=v[l-1];
        return;
    }
    int mid=(l+r)>>1;
    if(pos<=mid)
        update(pos,l,mid,rt<<1);
    else
        update(pos,mid+1,r,rt<<1|1);
    cnt[rt]=cnt[rt<<1]+cnt[rt<<1|1];
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}
int query(int l,int r,int rt,ll res)//从左往右找最大的sum<=res
{
    if(l==r)
    {
        return min((ll)cnt[rt],res/v[l-1]);
    }
    int mid=(l+r)>>1;
    if(sum[rt<<1]>=res)
        return query(l,mid,rt<<1,res);
    else
        return cnt[rt<<1]+query(mid+1,r,rt<<1|1,res-sum[rt<<1]);
}

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        memset(cnt,0,sizeof(cnt));
        memset(sum,0,sizeof(sum));
        int n;
        ll m;
        scanf("%d%lld",&n,&m);
        v.clear();
        far(i,1,n+1)
            scanf("%lld",&a[i]),v.push_back(a[i]);
        sort(v.begin(),v.end());
        int e=unique(v.begin(),v.end())-v.begin();
        printf("0 ");
        for(int i=1;i<n;++i)//用a[i]算a[i+1]
        {
            ll x=lower_bound(v.begin(),v.begin()+e,a[i])-v.begin()+1;
            update(x,1,n,1);
            ll res=m-a[i+1];
            int ans=query(1,n,1,res);
            printf("%d ",i-ans);
        }
        puts("");
    }
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值