可以修建的缆车总数不超过n，于是可以先通过$O(n^2)$的枚举求出所有可以修建的缆车。
对于一个缆车，若它仅连接i和i+1，那么它不受k的限制，把这种缆车额外取出，从大到小排序。
剩下的缆车两两之间要么是包含关系，要么没有任何交集，按照包含关系可以建出一棵树。
设f[i][j][k]表示以i为根的子树中修建了j个缆车，且该区间内所有点上面的缆车数的最大值为k的最优解。
则对于x的孩子i，通过枚举a,b,c,d，可以得到：
f'[x][a+c][max(b,d)]=max(f'[x][a+c][max(b,d)],f[x][a][b]+f[i][c][d])
可以通过讨论b和d的大小关系，维护两个前缀最大值来省去d的枚举。
如果把a的枚举上界定为x之前部分的子树大小，c的枚举上界定为i的子树大小，那么对于树上的两个点，只会在它们的lca处被DP到，所以这个树形DP的时间复杂度为$O(kn^2)$。
最后统计答案时，只要枚举修建的受k限制的缆车数和不受k限制的缆车数，取个最大值即可。
#include<cstdio>
#include<algorithm>
#define rep(i,l,n) for(int i=l;i<=n;i++)
#define dep(i,n,l) for(int i=n;i>=l;i--)
using namespace std;
const int N=210,inf=~0U>>2;
int T,n,m,i,j,k,flag,x[N],y[N],cnt,one,b[N],g[N],nxt[N],ans;
int size[N],f[N][N][10],t[N][10];
struct P{int l,r,w;P(){}P(int _l,int _r,int _w){l=_l,r=_r,w=_w;}}a[N];
inline bool cmp(int x,int y){return x>y;}
inline void up(int&a,int b){if(a<b)a=b;}
void dfs(int x){
rep(a,0,m)rep(b,0,k)f[x][a][b]=-inf;f[x][0][0]=0;
for(int i=g[x];i;i=nxt[i]){
dfs(i);
dep(a,min(size[x]+size[i],m),0)rep(b,0,k)t[a][b]=f[x][a][b];
dep(a,min(size[x],m),0)dep(c,min(size[i],m-a),0){
int t1=-inf,t2=-inf;
rep(b,0,k){
up(t1,f[i][c][b]);
up(t2,f[x][a][b]);
up(t[a+c][b],max(f[x][a][b]+t1,f[i][c][b]+t2));
}
}
size[x]+=size[i];
dep(a,min(size[x],m),0)rep(b,0,k)f[x][a][b]=t[a][b];
}
if(!x)return;
size[x]++;
dep(a,min(size[x],m-1),0)dep(b,k-1,0)up(f[x][a+1][b+1],f[x][a][b]+::a[x].w);
}
int main(){
while(~scanf("%d%d%d",&n,&m,&k)){
k--;
rep(i,1,n)scanf("%d%d",&x[i],&y[i]);
rep(i,1,n)rep(j,i+1,n)if(y[i]==y[j]){
flag=1;
rep(k,i+1,j-1)if(y[k]>=y[i]){flag=0;break;}
if(flag){
if(i+1==j){
b[++one]=x[j]-x[i];
}else{
a[++cnt]=P(i+1,j-1,x[j]-x[i]);
}
}
}
if(one>1)sort(b+1,b+one+1,cmp);
rep(i,2,one)b[i]+=b[i-1];
rep(i,1,cnt){
j=0;
rep(k,1,cnt)if(a[k].l<a[i].l&&a[k].r>a[i].r)if(!j||a[k].w<a[j].w)j=k;
nxt[i]=g[j],g[j]=i;
}
dfs(0);
ans=-1;
rep(i,m-one,m)rep(j,0,k)up(ans,f[0][i][j]+b[m-i]);
printf("Case %d: %d
",++T,ans);
rep(i,0,cnt)g[i]=size[i]=0;
cnt=one=0;
}
return 0;
}