CodeForces 567F DP Mausoleum

本着只贴代码不写分析的题解是在耍流氓的原则，还是决定写点分析。

思路很清晰，参考的官方题解，一下文字仅对题解做一个简要翻译。

题意：

有1~n这n个数，每个数用两次。构成一个长为2n的序列，而且要求序列满足先递增后递减(都是非严格的递增递减)。

再给出k个约束，每个约束形如1 >= 3这种，表示序列的第一个数要不小于第三个数。

问满足约束的合法序列有多少种。

分析：

首先先不考虑这些约束条件，考虑如何构造出这种序列。

考虑两个1放置的位置，因为序列是两边小中间大，所以这两个1要么放在前面两个位置，或者后面两个位置，要么一前一后，而且只有这三种放法。

事实上，不考虑约束条件的话，n个数能得到的合法的序列的个数为3ⁿ

因此这些数是1~n从两边往中间放的。

设d(L, R)表示[L, R]这个区间还没放数，满足约束条件的序列个数，则答案为d(1, 2n)

下面考虑如何处理这些不等式：

计算d(L, R)时，比如要放在L和L+1这两个格子，那么就考虑所有和L相关的不等式，以及和L+1相关的不等式。

为了更清楚起见，画一个图看看：

绿色表示已经放好数的区间，黄色表示正要放的两个格子，红色是还未放数的区间。

那么有大小关系：绿色的数 < 黄色的数 < 红色的数，两个黄色格子的数是相等的。

比如有不等式L >= v

如果a[L] == a[v]，那么v应该等于L + 1，表示L和v两个位置放同一个数；

如果a[L] > a[v]，那么v应该在绿色的区间表示之前已经放过数了，这样放在L的数才能比放在v的数大。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#define MP make_pair
using namespace std;

typedef long long LL;

const int maxn = 80;

int n, k;

vector<int> G[maxn], req[maxn];

LL d[maxn][maxn];

bool check(int L, int R, int l, int r)
{
    for(int i = 0; i < G[l].size(); i++)
    {
        int v = G[l][i], t = req[l][i];
        if(t == -2)
        {
            if(v < L || v > R || v == r) return false;
        }
        else if(t == -1)
        {
            if(v < L || v > R) return false;
        }
        else if(!t)
        {
            if(v != r) return false;
        }
        else if(t == 1)
        {
            if(v >= L && v <= R && v != r) return false;
        }
        else
        {
            if(v >= L && v <= R) return false;
        }
    }

    for(int i = 0; i < G[r].size(); i++)
    {
        int v = G[r][i], t = req[r][i];
        if(t == -2)
        {
            if(v < L || v > R || v == l) return false;
        }
        else if(t == -1)
        {
            if(v < L || v > R) return false;
        }
        else if(!t)
        {
            if(v != l) return false;
        }
        else if(t == 1)
        {
            if(v >= L && v <= R && v != l) return false;
        }
        else
        {
            if(v >= L && v <= R) return false;
        }
    }

    return true;
}

LL dp(int L, int R)
{
    LL& ans = d[L][R];
    if(ans >= 0) return d[L][R];
    if(L + 1 == R)
    {
        if(check(L, R, L, R)) return 1LL;
        return 0;
    }

    ans = 0;

    if(check(L, R, L, L + 1))
        ans += dp(L + 2, R);
    if(check(L, R, L, R))
        ans += dp(L + 1, R - 1);
    if(check(L, R, R - 1, R))
        ans += dp(L, R - 2);

    return ans;
}

int main()
{
    scanf("%d%d", &n, &k);
    char eq[10];
    while(k--)
    {
        int u, v;
        scanf("%d", &u);
        scanf("%s", eq);
        scanf("%d", &v);

        int t;
        if(strcmp(eq, "<") == 0) t = -2;
        else if(strcmp(eq, "<=") == 0) t = -1;
        else if(strcmp(eq, "=") == 0) t = 0;
        else if(strcmp(eq, ">=") == 0) t = 1;
        else if(strcmp(eq, ">") == 0) t = 2;
        else exit(1234);

        if(u == v)
        {
            if(abs(t) <= 1) continue;
            else { puts("0"); exit(0); }
        }

        req[u].push_back(t); req[v].push_back(-t);
        G[u].push_back(v); G[v].push_back(u);
    }

    memset(d, -1, sizeof(d));

    printf("%I64d
", dp(1, n * 2));

    return 0;
}