[LG4890]Never·island DP

～～～题面～～～

题解：

　　感到此题非常的神奇。。。看了大佬的题解才懂的。

　　首先建模：

　　先把所有队伍的出去回来时间都放在一个数组里，然后排序，从左到右扫一边，给每个队伍都建一个带权点，进行如下操作：

　　（s表示出发，t表示回家， len表示两个点之间的时间差）　　

　　1，对于s --- > t的情况，如果两者属于一个队伍，那么给这个队伍加上len，表示如果给这个队伍钥匙可以获得的贡献。

　　　　如果两者不属于同一个队伍，那么在这两个队伍之间连一条边权为len的边，表示如果同时给这2个队伍钥匙可以获得的贡献。

　　2，对于s ---> s的情况，给左边的队伍加上len，表示如果给左边队伍钥匙可以获得的贡献。

　　3，对于t ---> t的情况，给右边队伍加上len，表示如果给右边队伍钥匙可以获得的贡献。

　　4，对于t ---> s的情况，直接给ans += len，因为不需要钥匙就可以获得这个贡献。

　　然后考虑如何DP。

　　我们观察到每个点最多只有一条入边，最多只有一条出边，因此这些点和边构成了由一堆链组成的图。而这些链两两不相交（不互相干扰）

　　因此我们只需要保证在DP时，一条链中的点都按顺序放在一起即可。所以我们对整张图做一个拓扑排序，最后得到的DP顺序应该是类似这样的：（可能有点单独成链）

　　相当于把所有链一一放好，然后DP。

　　那么如何转移呢？

　　设f[i][j][0/1]表示DP到i位，当前选了j个点，当前点选or不选的贡献。

　　那么对于不相连的点，直接更新即可，

　　对于相连的点，如果用f[i - 1][j - 1][1]更新f[i][j][1]，那么还需要加上两点之间边的边权，表示两个点同时选带来的多余贡献。

　　最后的答案等于ans = d[n * 2] - d[1] - ans - max(f[i][j][1], f[i][j][0]);

　　d[n * 2] - d[1]是在获取整个线段的长度，减去ans是在减掉一开始就有的贡献（无需钥匙的），max(f[i][j][0], f[i][j][1])是给钥匙带来的贡献，相减后剩下的就是开门的天数。

　　（一遍A，感到非常愉悦，而且速度还可以）

 #include<bits/stdc++.h>
 using namespace std;
 #define R register int
 #define AC 2100
 #define ac 5000
 #define LL long long 

 int n, k, cnt, ans;
 int power[AC], Next[AC], last[AC];
 int in[AC], d[AC], tot;//存下DP序列
 LL s[AC], f[AC][AC][];
 bool z[AC];
 //DP到i位，选了j个点，当前点选与不选,s是当前点的向后的边的边权
 struct node{
     int x, id;
     bool z;
 }p[ac];

 inline int read()
 {
     int x = ;char c = getchar();
     while(c > '' || c < '') c = getchar();
     while(c >= '' && c <= '') x = x *  + c - '', c = getchar();
     return x;
 }

 inline bool cmp(node a, node b)
 {
     return a.x < b.x;
 }

 inline void upmax(int &a, int b)
 {
     if(b > a) a = b;
 }

 void dfs(int x)
 {
     d[++tot] = x, z[x] = true;
     while(Next[x]) d[++tot] = Next[x], x = Next[x], z[x] = true;
 }

 void pre()
 {
     n = read(), k = read();
     for(R i = ; i <= n; i ++)
     {
         p[++cnt] = (node){read(), i, };
         p[++cnt] = (node){read(), i, };
     }
     sort(p + , p + cnt + , cmp);
     int b =  * n;
     for(R i = ; i < b; i ++)
     {
         int len = p[i + ].x - p[i].x, x = p[i].id, y = p[i + ].id;
         if(!p[i].z && p[i + ].z)
         {
             if(x == y) power[p[i].id] += len;
             else Next[x] = y, last[y] = x, s[x] = len, ++ in[y];
         }
         else if(!p[i].z && !p[i + ].z) power[x] += len;
         else if(p[i].z && p[i + ].z) power[y] += len;
         else ans += len;
     }
 }

 void work()
 {
     int b =  * n;
     for(R i = ; i < b; i ++) //类似于拓扑排序，要没有入度才行
         if(!z[p[i].id] && !in[p[i].id]) dfs(p[i].id);
     for(R i = ; i <= n; i ++)//枚举点
     {
         for(R j = ; j <= k; j ++)
         {
             f[i][j][] = max(f[i - ][j][], f[i - ][j][]);
             if(last[d[i]]) f[i][j][] = max(f[i - ][j - ][], f[i - ][j - ][] + s[last[d[i]]]) + power[d[i]];
             else f[i][j][] = max(f[i - ][j - ][], f[i - ][j - ][]) + power[d[i]];
         }
     }
     printf("%lld\n", p[n * ].x - ans - p[].x - max(f[n][k][], f[n][k][]));
 }

 int main()
 {
     freopen("in.in", "r", stdin);
     pre();
     work();
     fclose(stdin);
     return ;
 }