第五周 8.7-8.13

有做题 没空写博客。

8.8

CF 704 B - Ant Man

由于左右代价不一样，直接拆绝对值。

那么代价只和每个点的入边与出边是向左还是向右有关。

考虑dp[i][j][k][l]为前i个点，有j个剩一个出度一个入度的联通块，k个只有一个入度的联通块，l个只有出度的联通块。

对于每个点，枚举它的出边与入边是向左还是向右，一共四种情况。

需要注意以下几点：

1.第一维可以滚动；k和l最大只有1，即为s和e所在的联通块，3、4维压一起更好写。

2.s和e只有一条边，所以要单独考虑。

3.不能让前面的联通块自己成环封闭起来，所以每次dp只能用至少含有一条出边或者入边的状态。

4.每次加边要考虑各种情况，比如是加在含有一出一入的联通块上，还是加在只有一入的联通块上，当然得保证前面的状态含有这样的联通块才能加。

总之细节很多，调了好久都快弃了竟然过了感动哭了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;
const LL INF = 1e18;
LL dp[5005][4], cpy[5005][4];
LL x[5005], a[5005], b[5005], c[5005], d[5005];

int main(void)
{
    int n, s, e;
    scanf("%d %d %d", &n, &s, &e);
    for(int i = 1; i <= n; i++) scanf("%I64d", x + i);
    for(int i = 1; i <= n; i++) scanf("%I64d", a + i);
    for(int i = 1; i <= n; i++) scanf("%I64d", b + i);
    for(int i = 1; i <= n; i++) scanf("%I64d", c + i);
    for(int i = 1; i <= n; i++) scanf("%I64d", d + i);

    for(int i = 0; i <= n; i++)
    for(int j = 0; j < 4; j++) dp[i][j] = INF;
    dp[0][0] = 0;

    for(int i = 1; i <= n; i++)
    {
        memcpy(cpy, dp, sizeof(cpy));
        for(int j = 0; j <= n; j++)
        for(int k = 0; k < 4; k++) dp[j][k] = INF;

        for(int j = 0; j <= n; j++)
        for(int k = 0; k < 4; k++)
        {
            if(cpy[j][k] == INF) continue;
            if(i > 1 && !j && !k) continue;

            if(i == s)
            {
                dp[j][k^1] = min(dp[j][k^1], cpy[j][k] + d[i] - x[i]);
                if(k & 2) dp[j][k^2] = min(dp[j][k^2], cpy[j][k] + c[i] + x[i]);
                if(j) dp[j-1][k^1] = min(dp[j-1][k^1], cpy[j][k] + c[i] + x[i]);
            }

            else if(i == e)
            {
                dp[j][k^2] = min(dp[j][k^2], cpy[j][k] + b[i] - x[i]);
                if(k & 1) dp[j][k^1] = min(dp[j][k^1], cpy[j][k] + a[i] + x[i]);
                if(j) dp[j-1][k^2] = min(dp[j-1][k^2], cpy[j][k] + a[i] + x[i]);
            }

            else
            {
                dp[j+1][k] = min(dp[j+1][k], cpy[j][k] + b[i] + d[i] - x[i] - x[i]);
                if(j || (k & 1)) dp[j][k] = min(dp[j][k], cpy[j][k] + a[i] + d[i]);
                if(j || (k & 2)) dp[j][k] = min(dp[j][k], cpy[j][k] + b[i] + c[i]);
                if(j) dp[j-1][k] = min(dp[j-1][k], cpy[j][k] + a[i] + c[i] + x[i] + x[i]);
                if(k == 3) dp[j][k^3] = min(dp[j][k^3], cpy[j][k] + a[i] + c[i] + x[i] + x[i]);
            }
        }
    }
    printf("%I64d\n", dp[0][0]);
    return 0;
}