1718. 构建字典序最大的可行序列-深度优先遍历+回溯法

1718. 构建字典序最大的可行序列

给你一个整数 n ，请你找到满足下面条件的一个序列：

整数 1 在序列中只出现一次。
2 到 n 之间每个整数都恰好出现两次。
对于每个 2 到 n 之间的整数 i ，两个 i 之间出现的距离恰好为 i 。

序列里面两个数 a[i] 和 a[j] 之间的 距离 ，我们定义为它们下标绝对值之差 |j - i| 。

请你返回满足上述条件中 字典序最大 的序列。题目保证在给定限制条件下，一定存在解。

一个序列 a 被认为比序列 b （两者长度相同）字典序更大的条件是： a 和 b 中第一个不一样的数字处，a 序列的数字比 b 序列的数字大。比方说，[0,1,9,0] 比 [0,1,5,6] 字典序更大，因为第一个不同的位置是第三个数字，且 9 比 5 大。

示例 1：

输入：n = 3
输出：[3,1,2,3,2]
解释：[2,3,2,1,3] 也是一个可行的序列，但是 [3,1,2,3,2] 是字典序最大的序列。

示例 2：

输入：n = 5
输出：[5,3,1,4,3,5,2,4,2]
这题，一开始没有优化，时间不能通过，优化后的代码如下，时间开销 100%，解题代码如下：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
 int find;
 void dfs(int n,int now,int *r,int *re){
     if(find==0){
          if(now==n*2-1){
            
            
              find=1;
             }
             else{
                 if(re[now]==-1){
                    for(int i=n-1;i>=0;i--){
                        if(find==0){
                            if(i!=0){
                                  if(r[i]==-1&&now+i+1<2*n-1&&re[now+i+1]==-1){
                            
                                        re[now]=i+1;
                                    
                                        re[now+i+1]=i+1;
                                        r[i]=now;
                                    
                                        dfs(n,now+1,r,re);
                                        r[i]=-1;
                                        if(find==0){
                                            re[now]=-1;
                                        re[now+i+1]=-1;

                                        }
                                        
                                        

                                    }

                            }
                            else{
                                if(r[i]==-1){
                                    re[now]=1;
                                    r[i]=now;
                                     dfs(n,now+1,r,re);
                                     r[i]=-1;
                                     if(find==0){
                                         re[now]=-1;
                                     }

                                }
                            }
                        

                        }

                        
                       
                        
                    }
                 }
                 else{
                      dfs(n,now+1,r,re);

                 }
                 


             }

     }
    
 }
int* constructDistancedSequence(int n, int* returnSize){
    int *r=(int **)malloc(sizeof(int)*n);
     int *re=(int *)malloc(sizeof(int)*(n*2-1));
    for(int i=0;i<n;i++){
       r[i]=-1;
    }
    for(int i=0;i<n*2-1;i++){
        re[i]=-1;
    }
    find=0;
     for(int i=n-1;i>=0;i--){
         printf("dfas");
         if(find==0){
             if(i!=0){
                   r[i]=0;
            re[i+1]=i+1;
            re[0]=i+1;
           dfs(n,1,r,re);
            r[i]=-1;
              if(find==0){
                   re[0]=-1;
                  re[0+i+1]=-1;

           }

             }
             else{
                 r[0]=0;
                 re[0]=1;
                 dfs(n,1,r,re);
                 r[0]=-1;
                    if(find==0){
                        re[0]=-1;
                    }

             }
            

         }
        

     }
     *returnSize=n*2-1;
     return re;
    

}