bzoj4059 [Cerc2012]Non-boring sequences && bzoj5200 [NWERC2017]Factor-Free Tree

https://konnyakuxzy.github.io/BZPRO/JudgeOnline/4059.html

https://cn.vjudge.net/problem/Gym-100624D

根本不会。。。

似乎有很高妙的分治做法啊！https://www.cnblogs.com/forever97/p/bzoj4059.html

就是说，如果当前区间为[l,r]，存在一个i满足pre[i]<l&&nxt[i]>r，那么任意一个[l,r]的子区间，只要包含i点就不无聊，因此只需要再检验[l,i-1]和[i+1,r]即可

复杂度n*log就是因为倒过来就是启发式合并的过程。。。

以前代码很奇怪不知道怎么回事也A掉了。。。

if(i==j)    break;
i++;
if(pre[i]<l&&nxt[i]>r)    return solve(l,i-)&&solve(i+,r);
if(i==j)    break;
j--;
if(pre[j]<l&&nxt[j]>r)    return solve(l,j-)&&solve(j+,r);

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 #include<map>
 using namespace std;
 #define fi first
 #define se second
 #define mp make_pair
 #define pb push_back
 typedef long long ll;
 typedef unsigned long long ull;
 typedef pair<int,int> pii;
 int n,T,a[];
 int pre[],nxt[];
 map<int,int> ma;
 bool solve(int l,int r)
 {
     if(l>=r)    return ;
     int i,j;
     for(i=l,j=r;;)
     {
         if(pre[i]<l&&nxt[i]>r)    return solve(l,i-)&&solve(i+,r);
         i++;
         if(i>j)    break;
         if(pre[j]<l&&nxt[j]>r)    return solve(l,j-)&&solve(j+,r);
         j--;
         if(i>j)    break;
     }
     return ;
 }
 int main()
 {
     int i;
     scanf("%d",&T);
     while(T--)
     {
         scanf("%d",&n);
         for(i=;i<=n;i++)    scanf("%d",&a[i]);
         ma.clear();
         for(i=;i<=n;i++)
         {
             pre[i]=ma.count(a[i])?ma[a[i]]:;
             ma[a[i]]=i;
         }
         ma.clear();
         for(i=n;i>=;i--)
         {
             nxt[i]=ma.count(a[i])?ma[a[i]]:n+;
             ma[a[i]]=i;
         }
         puts(solve(,n)?"non-boring":"boring");
     }
     return ;
 }

也有很高妙的扫描线做法啊！https://blog.csdn.net/PoPoQQQ/article/details/46380617

---

https://konnyakuxzy.github.io/BZPRO/JudgeOnline/5200.html

https://cn.vjudge.net/problem/Gym-101623F

做法跟上面那题几乎是一样的

仍然不会。。。

做法是类似的，卡在”区间内有多个可作为根的位置时，如何选择“上了

上网查了一下，发现怎样选择并不会影响答案。。。

证明很简单：假设已经得到了区间内一组以a为根的合法解，b也是一个合法根，直接把这棵树的根改为b，那么显然只有a到b的链上的所有边的两个端点的父亲-祖先关系反了一下，显然这条链上端点的值两两互质，因此这样子换根之后也是合法解

还有一点：我自己想的是每次分治直接分解质因数然后怎么怎么样，很慢，可能被卡常（质因数分解n^(1/4)吧？）

然而，可以直接线筛出1e7内每个数的最小质因子。。。然后分解质因子复杂度只要一个log

而且，只需要预处理每个数的上一个和下一个与其不互质的数位置即可。。。感觉常数要小不少啊

错误记录：

1.已经发现了需要单独记录f[t]，然后while才能除以的是同一个数（就是需要69行），但是只改了一半（没改81行）

2.LA上有多组数据，但是我没有完整地清空（WA了很多发，包括61行，87行（需要fa[..]=0））

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 #include<map>
 using namespace std;
 #define fi first
 #define se second
 #define mp make_pair
 #define pb push_back
 typedef long long ll;
 typedef unsigned long long ull;
 typedef pair<int,int> pii;
 bool nprime[];
 int prime[],len,f[];
 int n,a[];
 int pre[],nxt[];
 map<int,int> ma;
 bool fl;
 int fa[];
 int solve(int l,int r)
 {
     if(l>r)    return ;
     if(l==r)    return l;
     int i,j;
     for(i=l,j=r;;)
     {
         if(pre[i]<l&&nxt[i]>r)
         {
             fa[solve(l,i-)]=i;
             fa[solve(i+,r)]=i;
             return i;
         }
         i++;
         if(i>j)    break;
         if(pre[j]<l&&nxt[j]>r)
         {
             fa[solve(l,j-)]=j;
             fa[solve(j+,r)]=j;
             return j;
         }
         j--;
         if(i>j)    break;
     }
     fl=;
     return ;
 }
 int main()
 {
     int i,j,t,q;
     for(i=;i<=;i++)
     {
         if(!nprime[i])    prime[++len]=i,f[i]=i;
         for(j=;j<=len&&i*prime[j]<=;j++)
         {
             nprime[i*prime[j]]=;f[i*prime[j]]=prime[j];
             if(i%prime[j]==)    break;
         }
     }
     while(scanf("%d",&n)==){
     fl=;
     for(i=;i<=n;i++)    scanf("%d",&a[i]);
     ma.clear();
     for(i=;i<=n;i++)
     {
         t=a[i];pre[i]=;
         while(t!=)
         {
             q=f[t];
             pre[i]=max(pre[i],ma.count(q)?ma[q]:);
             ma[q]=i;
             while(t%q==)    t/=q;
         }
     }
     ma.clear();
     for(i=n;i>=;i--)
     {
         t=a[i];nxt[i]=n+;
         while(t!=)
         {
             q=f[t];
             nxt[i]=min(nxt[i],ma.count(q)?ma[q]:n+);
             ma[q]=i;
             while(t%q==)    t/=q;
         }
     }
     fa[solve(,n)]=;
     if(fl)    puts("impossible");
     else
     {
         for(i=;i<=n;i++)
         {
             printf("%d",fa[i]);
             if(i!=n)    putchar(' ');
         }
         puts("");
     }}
     return ;
 }