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("");
}
}