CSP4

思路：
区间DP问题，这道题我是用暴力模拟，其实可以用随机插入然后判断是不是可以组成二叉搜索树,插入可以用C++的全排列；
这是一种全排列的方法；当然也可以用C++中自带的STL
next_permutation实现升序，而prev_permutation实现降序，参数是数组的开始以及数组的末尾+1（数组的长度）
这样可使尝试所有排列的插入

#include <iostream>
using namespace std;
void swap(int &a,int &b){
    int temp=a;
    a=b;
    b=temp;
}
void perm(int list[],int low,int high){
    if(low==high){   //当low==high时,此时list就是其中一个排列,输出list
        for(int i=0;i<=low;i++)
            cout<<list[i];
        cout<<endl;
    }else{
        for(int i=low;i<=high;i++){//每个元素与第一个元素交换
            swap(list[i],list[low]); 
            perm(list,low+1,high); //交换后,得到子序列,用函数perm得到子序列的全排列
            swap(list[i],list[low]);//最后,将元素交换回来,复原,然后交换另一个元素
        }
    }
}
int main()
{
 
int list[]={1,2,3};
perm(list,0,2);
return 0;
}

shuzu[maxn][3];
cnt = 1;
bool insert(int k)
{
int n = 1;
	while(1)
	{
		if(k>shuzu[n][0])
		{
			if(shuzu[n][2]!=0)
			{
				if(gcd(shuzu[n][2],k))
				{
					cnt++;
					shuzu[n][2] = cnt;
					shuzu[cnt][0] = k;
					return true;
				}
				else{
					return false;
				}
			}
			else{
				n = shuzu[n][2];
				continue;
			}
		}
		if(k<shuzu[n][0])
		{
		...
		}
	}
}

二叉搜索树具有明显的子结构特性，这个题虽然要构成一个二叉树，但是给出的是一个区间，因此这个题还是要用区间dp来做的，树的结构不能丢，我们定义两个数组：l[i][j],r[i][j]l[i][j],r[i][j]l[i][j],r[i][j]分别表示以iii为根，向左到j可以作为i的左子树，向右到jjj可以作为iii的右子树。树结构非常重要，虽然是区间dp，但是这个结果要构成一个二叉搜索树，因此必须有这两个数组。
我们不能单纯的判断如果dp[i][j]可以成树然后dp[j][m]可以成树然后就判断dp[i][m]可以成树，因为数有一个很重要的性质就是根节点不可以丢弃，
所以我们用L[i][j]来表示，根节点为i，子节点从i~j的树，他是否能构成树，所以我们要知道dp[1][n]能否构成树，知需要知道，L[1][k]和R[k][n]是否构成树，如果构成树那么结果就是正确的。那么要知道L[i][j]是否能够成树，我们就要知道L[k][i-1]和R[k][j]是否都构成树，都构成树，证明dp[i-1][j]以k为根构成树，如果a[i]和a[k]满足gcd公式，那么就说明可以构成以i为根到j的左子树，那么这个结构就明显了，是一个由长度为1出发，到长度为N

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
using namespace std;
const int maxn=700+100;
int t,n,a[maxn];
bool dp[maxn][maxn],g[maxn][maxn],l[maxn][maxn],r[maxn][maxn];
int gcd(int _a,int _b) {return _b==0? _a: gcd(_b,_a%_b);}
void init(){
    memset(l,false,sizeof(l));
    memset(r,false,sizeof(r));
    memset(dp,false,sizeof(dp));
    for (int i=1; i<=n; i++) {
        l[i][i]=r[i][i]=dp[i][i]=true;
        for (int j=1; j<=n; j++)
        //用数组记录的原因是防止重复判断
            g[i][j]=gcd(a[i],a[j])>1;
    }
}
bool IsBinarySearchTree(){
    for (int len=1; len<=n; len++){
        for (int i=1; i<=n-len+1; i++){
        //判断dp[i][j],从长度为1开始，到长度为n,即最后，LR额长度从1到n
            int j=i+len-1;
            for (int k=i; k<=j; k++){
                if(l[k][i] && r[k][j]){
                //此时可以判断长度为len+1的l和r
                    dp[i][j]=true;
                    l[j+1][i]|=g[j+1][k];
                    r[i-1][j]|=g[i-1][k];
                }
            }
        }
    }
    return dp[1][n];
}
int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        for (int i=1; i<=n; i++) scanf("%d",&a[i]);
        init();
        if(IsBinarySearchTree()) printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}