codevs 2241 排序二叉树

/*
WTF
 写了好久了 开始的时候题目读错了 建图建错了
 搜索写的也不好 感觉会T
 总之 第一次写的很low
 贴一下吧
*/
#include<iostream>
#include<cstdio>
#include<cstring>
#define N 40
#define M 40
using namespace std;
int n,g[N*N][N*N],a[][M*M];
int num[],ans,maxx,f[N*N][N*N];
struct node
{
    int c[],data;
    int x[],y[];
}p[N*N][N*N];
int Get_place(int x,int y)
{
    if(x<=n)return ;
    if(y>(x-n)*-&&y<=*n)return ;
    if(y<=(x-n)*-)return ;
    return ;
}
int Dfs(int x,int y)
{
    int sum=;
    for(int i=;i<=;i++)
      for(int j=;j<=;j++)
        {
          if(p[x][y].c[i]<p[x][y].data&&p[x][y].c[j]>p[x][y].data
          &&f[p[x][y].x[i]][p[x][y].y[i]]==&&f[p[x][y].x[j]][p[x][y].y[j]]==)
            {
              f[p[x][y].x[i]][p[x][y].y[i]]=;f[p[x][y].x[j]][p[x][y].y[j]]=;
              sum=max(sum,Dfs(p[x][y].x[i],p[x][y].y[i])+Dfs(p[x][y].x[j],p[x][y].y[j]));
              f[p[x][y].x[i]][p[x][y].y[i]]=;f[p[x][y].x[j]][p[x][y].y[j]]=;
            }
        }
    for(int i=;i<=;i++)
      {
          if(f[p[x][y].x[i]][p[x][y].y[i]]==)
            {
              f[p[x][y].x[i]][p[x][y].y[i]]=;
              sum=max(sum,Dfs(p[x][y].x[i],p[x][y].y[i]));
              f[p[x][y].x[i]][p[x][y].y[i]]=;
            }
      }
    return sum;
}
int main()
{
    scanf("%d",&n);
    for(int k=;k<=;k++)
      for(int i=;i<=n*n;i++)
        scanf("%d",&a[k][i]);
    num[]=n*n;
    for(int i=;i<=n*;i++)
      for(int j=;j<=*i-;j++)
        {
          int pi=Get_place(i,j);
          if(pi==)g[i][j]=a[pi][num[pi]--];
          else g[i][j]=a[pi][++num[pi]];
        }
    for(int i=;i<=n*;i++)
      for(int j=;j<=i*-;j++)
        {
          if(j&)
            {
              p[i][j].c[]=g[i][j-];
              p[i][j].c[]=g[i][j+];
              p[i][j].c[]=g[i+][j+];
              p[i][j].data=g[i][j];
              p[i][j].x[]=i;p[i][j].y[]=j-;
              p[i][j].x[]=i;p[i][j].y[]=j+;
              p[i][j].x[]=i+;p[i][j].y[]=j+;
            }
          else
            {
              p[i][j].c[]=g[i][j-];
              p[i][j].c[]=g[i][j+];
              p[i][j].c[]=g[i-][j-];
              p[i][j].data=g[i][j];
              p[i][j].x[]=i;p[i][j].y[]=j-;
              p[i][j].x[]=i;p[i][j].y[]=j+;
              p[i][j].x[]=i-;p[i][j].y[]=j-;
            }
          if(j==)
            {
              p[i][j].c[]=g[*n+-i][j];
              p[i][j].x[]=*n+-i;
              p[i][j].y[]=*n-*i+;
            }
          if(j==i*-)
            {
              p[i][j].c[]=g[*n+-i][*n-*i+];
              p[i][j].x[]=*n+-i;
              p[i][j].y[]=*n-*i+;
            }
          if(i==*n&&(j&))
            {
              p[i][j].c[]=g[i][*n-j];
              p[i][j].x[]=i;
              p[i][j].y[]=*n-j;
            }
        }
    //int xi,yi;
    //while(~scanf("%d%d",&xi,&yi))
    //printf("%d\n%d %d %d\n",p[xi][yi].data,p[xi][yi].c[1],p[xi][yi].c[2],p[xi][yi].c[3]);
    for(int i=;i<=n*;i++)
      for(int j=;j<=i*-;j++)
        {
          memset(f,,sizeof(f));
          f[i][j]=;ans=max(Dfs(i,j),ans);
        }
    printf("%d\n",ans);
    return ;
}

/*
 换一种建图方式 这样很机智啊 然而我并没有想到
 保留原来的三个4个三角形 然后建图 而不是搞到一个大的三角形里再建图
 具体看代码吧
 我们得到了每个点相邻的三个点的权值以后 需要枚举根 然后扩展结点 统计最大值
 对于每一个点 我们并不需要分开考虑左右都选还是直选左或者直选右
 我们左右都扩展一遍然后取大并做和就ok
 但是介于二叉搜索树的要求 如果我们扩展节点时只要求他和相邻父亲比较大小的话
 不能满足左子树的每个节点都小于根 所以我们扩展的时候再维护一下边界 这样的话就使得树满足性质了
 然而时间复杂度会很大 需要记忆化
 再然而我们这个状态不好表示 只能用3维 f[i][j][k] 表示从j到i 边界是k(不管是左还是右)以i为根的最优解
 再再然而我们又发现这个状态爆空间了-- 降维的话 如果把第三维降掉显然会有重复
 其实我们的j到i是很浪费的 我们可以压缩第二维 把到从j改为从i的第几个相邻的点到的
 这样我们就能存下了 然后就是细节问题了
 开始存小三角形用的5*20*20 n<=18 RE到死....忘记存的三角形不是矩形了.....WTF
*/
#include<iostream>
#include<cstdio>
#include<cstring>
#define N 40//数组开大保平安
#define M 20*20*4
using namespace std;
int n,g[][N][N],s[M][],ans;
bool vis[M][M];
int f[M][][M];
void Init()
{
    cin>>n;
    for(int k=;k<=;k++)
      for(int i=;i<=n;i++)
        for(int j=;j<=i*-;j++)
          cin>>g[k][i][j];
}
void Add(int x,int y)
{
    if(vis[x][y]==)
      {
          vis[x][y]=;
          s[x][++s[x][]]=y;
      }
    if(vis[y][x]==)
      {
          vis[y][x]=;
          s[y][++s[y][]]=x;
      }
}
void Build_tree()
{
    for(int k=;k<=;k++)//内部点
      for(int i=;i<=n-;i++)
        for(int j=;j<*i-;j++)
          if(j&)
            {
                Add(g[k][i][j],g[k][i][j+]);
                Add(g[k][i][j],g[k][i][j-]);
                Add(g[k][i][j],g[k][i+][j+]);
            }
          else
            {
              Add(g[k][i][j],g[k][i][j+]);
                Add(g[k][i][j],g[k][i][j-]);
                Add(g[k][i][j],g[k][i-][j-]);
            }
    for(int k=;k<=;k++)//底边界偶数点
      for(int i=;i<=n*-;i+=)
        {
          Add(g[k][n][i],g[k][n][i+]);
          Add(g[k][n][i],g[k][n][i-]);
          Add(g[k][n][i],g[k][n-][i-]);
        }
    for(int i=;i<=n;i++)//侧边界点
      {
          Add(g[][i][*i-],g[][i][]);
          Add(g[][i][*i-],g[][i][]);
          Add(g[][i][*i-],g[][i][]);
      }
    for(int i=;i<=n*-;i+=)//底边界奇数点
      {
          Add(g[][n][i],g[][n-(i/)][]);
        Add(g[][n][i],g[][i/+][(i/+)*-]);
        Add(g[][n][i],g[][n][*n-i]);
      }
}
int DP(int i,int l1,int l2)//因为要用到i来自哪 所以左右边界可能颠倒
{
    int from=;
    while(s[i][from]!=l2)from++;//i是从i的第几个相邻的点连过来的
    if(f[i][from][l1]>)return f[i][from][l1];//记忆化
    int l,r,lmax=,rmax=;
    if(l1>l2)l=l2+,r=l1;//修正左右边界
    else l=l1,r=l2-;
    for(int j=;j<=;j++)
      if(j!=from&&l<=s[i][j]&&r>=s[i][j])
        {
          if(s[i][j]<i)lmax=max(lmax,DP(s[i][j],l,i));
          else rmax=max(rmax,DP(s[i][j],r,i));
        }
    f[i][from][l1]=lmax+rmax+;
    return f[i][from][l1];
}
void Dfs()
{
    for(int i=;i<=n*n*;i++)//枚举根节点
      {
          int lmax=,rmax=;
        for(int j=;j<=;j++)
          if(s[i][j]<i)lmax=max(lmax,DP(s[i][j],,i));//左子树的所有数在1-i-1之间
          else rmax=max(rmax,DP(s[i][j],n*n*,i));//右子树的所有数在i+1-n*n*4之间
        ans=max(ans,+lmax+rmax);
      }
}
int main()
{
    //freopen("bstree.in","r",stdin);
    //freopen("bstree.out","w",stdout);
    Init();
    Build_tree();
    Dfs();
    cout<<ans<<endl;
    return ;
}