DAG最小可重路径覆盖or最长反链的一种做法
zrO xtx Orz
感觉就是抄了一遍https://zybuluo.com/AntiLeaf/note/804022
不得不说，这个做法非常强。
由于博主水平有限，有可能有一些纯感性理解的东西．
首先，最长反链这个说法似乎有一些问题，这里的反链是指互不包含的点集。
最小可重路径覆盖指边和点都可以重复．
最小不可重路径覆盖指点不重复．
这样根据dilworth定理，这个东西对应最小链剖分，也就是求出传递闭包并连边后的DAG的最小不可重路径覆盖。
最小不可重路径覆盖还是比较简单的．
他有一个经典做法，拆点建二分图，原点向左边的点连边，容量为1，左边的点向右边的点连原图的边，容量为1，右边的点向汇点连边，容量为1．
考虑一个匹配的含义就是原来的\(n\)个路径中的两个结合了．
那么答案就是点数减最大匹配数．
最小可重路径覆盖，第一种做法是求出传递闭包，然后转化为不可重，但是点数较多时并不能求出传递闭包．
另一种做法考虑优化建图，原来的边的含义是直接或间接到达，现在的边只有直接到达的含义，那么为了可以让间接到达存在，每个点的入点向出点连Inf边，并且原图的边连Inf．
如果这个问题的最长反链是一个点集的呢？
只需要源点只向该点集连边，只有该点集向汇点连边即可，因为考虑其他的边和点都是维护是否可达关系的辅助边和点．
一个用到这个的题的代码
#include <bits/stdc++.h>
using namespace std;
const int N=100005;
char ss[N];
int fa[N];
int len[N];
int trans[N][26],la,tot=1;
int s,t;
int aa[N];
int val[N];
int getfail(char *s,int x,int r){
while (s[r]!=s[r-len[x]-1]){
x=fa[x];
//cerr<<x<<" "<<len[x]<<endl;
}
return x;
}
void init(){
len[0]=0;
len[1]=-1;
fa[0]=1;
}
void build(char *s,int l,int r){
//cerr<<"BBBB"<<" "<<la<<endl;
char c=s[r]-'a';
int cur=getfail(s,la,r);
//cerr<<"cur"<<cur<<endl;
if (!trans[cur][c]){
++tot;
len[tot]=len[cur]+2;
fa[tot]=trans[getfail(s,fa[cur],r)][c];
//cerr<<"tot"<<tot<<" "<<fa[tot]<<" "<<cur<<endl;
trans[cur][c]=tot;
}
la=trans[cur][c];
val[la]=max(val[la],aa[r]);
//cerr<<"build"<<l<<" "<<r<<endl;
}
struct edge{
int y,cap,op;
};
int pp=0;
vector<edge> g[N+N];
void add(int x,int y,int z){
//cerr<<"add"<<x<<" "<<y<<" "<<z<<" "<<++pp<<endl;
g[x].push_back({y,z,g[y].size()});
g[y].push_back({x,0,g[x].size()-1});
}
int cur[N+N],d[N+N];
bool bfs(){
queue<int> q;
q.push(s);
for (int i=s; i<=t; ++i) cur[i]=d[i]=0;
d[s]=233;
while (!q.empty()){
int x=q.front(); q.pop();
//cerr<<"XXXXXXXXXXXX"<<x<<" "<<g[x].size()<<endl;
for (auto j:g[x]){
//cerr<<"cap"<<j.cap<<endl;
if (j.cap&&!d[j.y]){
//cerr<<j.y<<endl;
d[j.y]=d[x]+1;
q.push(j.y);
}
}
}
//cerr<<d[t]<<endl;
return d[t];
}
int dfs(int x,int fl){
if (x==t) return fl;
//cerr<<"dfs"<<x<<" "<<fl<<endl;
int orz=fl;
for (int &j=cur[x]; j<g[x].size(); ++j){
edge &e=g[x][j];
int t=0;
if (e.cap&&d[e.y]==d[x]+1&&(t=dfs(e.y,min(fl,e.cap)))){
//cerr<<"init"<<endl;
e.cap-=t;
g[e.y][e.op].cap+=t;
fl-=t;
if (!fl) return orz;
}
}
return orz-fl;
}
int maxflow(){
int ans=0;
while (bfs()){
//cerr<<"BFS"<<endl;
//for (int i=s; i<=t; ++i) cerr<<d[i]<<" ";
//cerr<<endl;
//getchar();
ans+=dfs(s,2333333);
}
//cerr<<"ans"<<ans<<endl;
return ans;
}
int calc(int lim){
//cerr<<"calc"<<lim<<endl;
s=0;
t=tot*2+1;
int bbbb=0;
for (int i=s; i<=t; ++i) g[i].clear();
for (int i=2; i<=tot; ++i){
//cerr<<"IIIII"<<i<<endl;
if (val[i]>=lim){
++bbbb;
add(s,i*2-1,1);
add(i*2,t,1);
}
add(i*2,i*2-1,23333333);
}
//cerr<<"___________"<<endl;
//cerr<<"tot"<<tot<<endl;
for (int i=2; i<=tot; ++i)
for (int c=0; c<26; ++c){
if (trans[i][c]){
add(i*2-1,trans[i][c]*2,233333);
}
}
for (int i=2; i<=tot; ++i)
if (fa[i]>1) add(fa[i]*2-1,i*2,2333333);
return bbbb-maxflow();
}
void update(){
for (int i=tot; i>=2; --i) val[fa[i]]=max(val[fa[i]],val[i]);
}
int n,k;
int main(){
scanf("%d%d",&n,&k);
scanf("%s",ss+1);
vector<int> v;
for (int i=1; i<=n; ++i) scanf("%d",&aa[i]),v.push_back(aa[i]);
//cerr<<"!!!!!"<<endl;
init();
for (int i=1; i<=n; ++i) build(ss,1,i);
// for (int i=1; i<=tot; ++i) cerr<<val[i]<<" ";
update();
//cerr<<"????"<<endl;
//cerr<<"tpt:"<<tot<<endl;
sort(v.begin(),v.end());
//for (int i=1; i<=tot; ++i) cerr<<fa[i]<<" ";
//cerr<<endl;
//for (int i=1; i<=tot; ++i) cerr<<val[i]<<" ";
//calc(3);
//return 0;
int ret=-1;
for (int l=0,r=v.size()-1,mid=(l+r)>>1; l<=r; mid=(l+r)>>1)
if (calc(v[mid])>=k) ret=v[mid],l=mid+1; else r=mid-1;
if (ret==-1) cout<<"NEGATIVE"<<endl;
else cout<<ret<<endl;
}
