「SDOI2014」Lis 解题报告

「SDOI2014」Lis

题目描述

给定序列 \(A\)，序列中的每一项 \(A_i\) 有删除代价 \(B_i\) 和附加属性 \(C_i\)。

请删除若干项，使得 \(A\) 的最长上升子序列长度减少至少 \(1\)，且付出的代价之和最小，并输出方案。

如果有多种方案，请输出将删去项的附加属性排序之后，字典序最小的一种。

\(T\le 5,1\le n\le 700,1\le A_i,B_i,C_i\le 10^9\)

---

上午想这个题的时候，有一种迷之直觉，让我去做网络流24题的最长不下降子序列那题，然后我就去了，然后建模果然是一样的，太神奇啦

按\(dp\)值把点分层，然后把入度为\(0\)的和\(s\)连，把出度为\(0\)的和\(t\)连，发现问题转化成割掉权值和最小的点，使\(s,t\)不连通，可以用拆点最小割做。

然后考虑如何做字典序最小，我们可以从小到大枚举\(C\)，看这条边可不可以成为最小割上的边。

一条边可以是割集上的边\((u,v)\)得在残余网络上满足

• 已经流满了
• \(u\)不可以通过残余网络到\(v\)

可以从\(s\)遍历一遍看看\(u,v\)是否都被遍历或者都没被遍历。

然而这个题在枚举这个边合法后得钦定它，所以得删了它重新建图重新跑，但这肯定不能搞。

考虑一个退流操作，如果在残余网络上删去边\((u,v)\)，可以先跑两边最大流\((t,v)\)和\((u,s)\)的，然后把这条边流量清空，这样复杂度就是对的了（

---

Code:

#include <cstdio>
#include <cctype>
#include <cstring>
#include <algorithm>
using std::min;
using std::max;
int read()
{
    int x=0;char c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)) x=x*10+c-'0',c=getchar();
    return x;
}
const int N=1500;
const int M=3e5;
const int inf=0x3f3f3f3f;
int head[N],to[M],Next[M],edge[M],cnt;
void add(int u,int v,int w)
{
    to[++cnt]=v,edge[cnt]=w,Next[cnt]=head[u],head[u]=cnt;
    to[++cnt]=u,edge[cnt]=0,Next[cnt]=head[v],head[v]=cnt;
}
int q[N],dep[N],l,r;
bool bfs(int s,int t)
{
    memset(dep,0,sizeof dep);
    dep[q[l=r=1]=s]=1;
    while(l<=r)
    {
        int now=q[l++];
        for(int v,i=head[now];i;i=Next[i])
            if(edge[i]&&!dep[v=to[i]])
            {
                dep[v]=dep[now]+1;
                if((q[++r]=v)==t) return true;
            }
    }
    return false;
}
int dfs(int now,int flow,int t)
{
    if(now==t) return flow;
    int res=flow,yuu;
    for(int v,i=head[now];i&&res;i=Next[i])
        if(edge[i]&&dep[v=to[i]]==dep[now]+1)
        {
            yuu=dfs(v,min(res,edge[i]),t);
            if(!yuu){dep[v]=0;continue;}
            edge[i]-=yuu,edge[i^1]+=yuu;
            res-=yuu;
        }
    return flow-res;
}
int Dinic(int s,int t)
{
    int ret=0,flow;
    while(bfs(s,t)) while(flow=dfs(s,inf,t)) ret+=flow;
    return ret;
}
int dp[N],sta[N],tot,a[N];
struct node
{
    int id,x;
    bool friend operator <(node a,node b){return a.x<b.x;}
}yuu[N];
void work()
{
    cnt=1;memset(head,0,sizeof head);
    int n=read(),ans=0;
    for(int i=1;i<=n;i++)
    {
        a[i]=read();
        yuu[i].id=i;
        dp[i]=1;
        for(int j=1;j<i;j++)
            if(a[j]<a[i])
                dp[i]=max(dp[i],dp[j]+1);
        ans=max(ans,dp[i]);
    }
    for(int i=1;i<=n;i++)
        add(i,i+n,read());
    int s=n<<1|1,t=s+1;
    for(int i=1;i<=n;i++)
    {
        yuu[i].x=read();
        if(dp[i]==1) add(s,i,inf);
        if(dp[i]==ans) add(i+n,t,inf);
        for(int j=1;j<i;j++)
            if(a[j]<a[i]&&dp[j]+1==dp[i])
                add(j+n,i,inf);
    }
    printf("%d ",Dinic(s,t));
    std::sort(yuu+1,yuu+1+n);
    for(int i=1;i<=n;i++)
    {
        int u=yuu[i].id;
        if(edge[u<<1]||bfs(u,u+n)) continue;
        sta[++tot]=u;
        Dinic(u,s),Dinic(t,u+n);
        edge[u<<1]=edge[u<<1|1]=0;
    }
    std::sort(sta+1,sta+1+tot);
    printf("%d\n",tot);
    for(int i=1;i<=tot;i++) printf("%d ",sta[i]);
}
int main()
{
    int T=read();
    while(T--) work();
    return 0;
}

---

2019.2.21

转载于:https://www.cnblogs.com/butterflydew/p/10413967.html