Codeforces567F. Mausoleum(DP)

最新推荐文章于 2021-09-30 13:20:15 发布

原创最新推荐文章于 2021-09-30 13:20:15 发布 · 1.2k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#dp #codeforces #567F #Mausoleum

codeforces 同时被 2 个专栏收录

13 篇文章

订阅专栏

6 篇文章

订阅专栏

本文探讨了一个利用记忆化搜索解决序列排列问题的方法，通过动态规划和限制条件的考虑，有效地解决了从大到小放置数字的问题，并在特定条件下进行优化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

//考虑从大到小向序列中放置数字(两个两个的放)，小的数字肯定在大的数字两旁。
//比如当前放置i 有三种情况，两左，一左一右，两右。
//令dp[l][r]表示l~r的放置种数（从n开始放置，放了(r-l+1)/2 个数字(每次放两个)）
//那么转移方程实际上就是dp[l][r]=(A)dp[l-2][r]+(B)dp[l+1][r-1]+(C)dp[l][r-2];
//这三种情况都会更新到[l,r];
//对于k个限制条件，我们只要在A\B\C加入对应的限制条件即可。
//两左可以放置的条件是，这两个位置可以相等且可以小于区间[l-2,r]的值
//类似的一左一右，两右都是一样的。
//因为只有2*n个位置，我们只要暴力枚举出是否符合条件即可。
//用记忆化搜索比较好写，终止条件是r==l+1（可以理解成放置n，两个n一定放在一起）

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int N=100;
long long dp[N][N];
char dic[5][5]={"<",">","<=",">=","="};
vector<int>rela[N][5];
int n;
int find(char *s){
    for(int i=0;i<5;i++){
        if(strcmp(dic[i],s)==0)return i;
    }
    return -1;
}
int input(){
    int k,bad=0;
    char ss[5];
    int a,b;
    scanf("%d%d",&n,&k);
    for(int i=0;i<k;i++){
        scanf("%d%s%d",&a,ss,&b);
        int eq=find(ss);
        if(a==b&&(eq==0||eq==1)){
            bad=1;
        }
        if(eq==4){
            rela[a][4].push_back(b);
            rela[b][4].push_back(a);
        }
        else{
            rela[a][eq].push_back(b);
            rela[b][eq^1].push_back(a);
        }
    }
    return bad;
}
bool okequal(int x,int y){
    for(int i=0;i<2;i++){
        for(int j=0;j<rela[x][i].size();j++){
            if(rela[x][i][j]==y){
                return false;
            }
        }
        for(int j=0;j<rela[y][i].size();j++){
            if(rela[y][i][j]==x){
                return false;
            }
        }
    }
    return true;
}
bool okless(int x,int l,int r){
    for(int j=0;j<rela[x][1].size();j++){
        if(rela[x][1][j]>=l&&rela[x][1][j]<=r){
            return false;
        }
    }
    for(int j=0;j<rela[x][3].size();j++){
        if(rela[x][3][j]>=l&&rela[x][3][j]<=r){
            return false;
        }
    }
    for(int j=0;j<rela[x][4].size();j++){
        if(rela[x][4][j]>=l&&rela[x][4][j]<=r){
            return false;
        }
    }
    return true;
}
void DP(int l,int r){
    if(r<=l)return;
    if(l==r-1||dp[l][r])return;
    if(okequal(l,l+1)&&okless(l+1, l+2, r)&&okless(l, l+2, r)){
        DP(l+2,r);
        dp[l][r]+=dp[l+2][r];
    }
    if(okequal(r, r-1)&&okless(r, l, r-2)&&okless(r-1,l,r-2)){
        DP(l,r-2);
        dp[l][r]+=dp[l][r-2];
    }
    if(okequal(l, r)&&okless(l, l+1, r-1)&&okless(r, l+1, r-1)){
        DP(l+1,r-1);
        dp[l][r]+=dp[l+1][r-1];
    }
}
int main(){
    int bad=input();
    if(bad==1){
        printf("0\n");
    }
    else{
        for(int i=1;i<2*n;i++){
            if(okequal(i,i+1))
                dp[i][i+1]=1;
        }
        DP(1,2*n);
        printf("%lld\n",dp[1][2*n]);
    }
    return 0;
}