分组[测试点分支+二分图判定]

题意大概是给你一个序列，让你把这个序列划分成几个连续的小组，每个小组又可以分成两份，要求使所分小组数最小，且满足每个小组内部的每个小团体都不能有任意两个数相加为

整数的平方......

1.首先一个很重要的点，数据范围是1<<17，2*（1<<17）=1<<18;而sqrt(1<<18)=1<<9=512;所以枚举判断是否合法，即可只枚举512次而避免了O(N^2)复杂度;

2.要求字典序最小的答案，而咱们又要贪心，所以从后往前转移.....

3.其实依题，判断每个小组是否合法，因为每个小组内只有且仅有2个小团体，所以，就可以是看成是二分图判断问题，如果判断可以构成二分图，就继续往下搜;

我们先来回忆一下二分图;

二分图的定义是：把一组点分成两组，且每组内部的点没有连边联系，而两组之间可以有连边;

这样考虑的话

我们可以把每个数与其敌对数（当然是同组内的）先建边，这样建成的边像（关押罪犯）一样可以是看成仇恨边，而在这道题里，有仇恨的数不能放在同一个集合里，，同一集合的

数是不可有仇恨连边的，而两组之间可以有仇恨边，仔细读一下，和二分图定义是一样的;

好我们就可以把这个题转化成二分图判断题;

而从后枚举，就是让你目前的二分图尽可能长，所以就是去每次添加一个点，然后把这个点加入二分图，看是否仍能符合二分图的性质;

然后就到了如何去判断二分图;

一.交叉染色法判断二分图

bool judge=0;
void dfs(int x,int fa,int cols){
      col[x]=cols;
      if(judge)return ;
    for(int i=fir[x],y;i;i=edge[i].nxt){
          y=edge[i].to;
          if(judge)return ;
          if(y==fa)continue;
          if(cols+col[y]==3)continue;//颜色编号为1和二
          if(cols==col[y])return judge=1,void();
          if(!col[y])dfs(y,x,3-cols);
    }    
}
//其实就是你和与你连边的点是敌对的，你不能和你敌对的点有相同的颜色即同一集合，又因为//和你连边的都是对立点，所以你就把和你连边的点染成异色，只要不是和你对立的点还和你有//相同的颜色（在同一个集合）就可以了;

二.并查集牛逼法（弓主任（交线牛逼法））

#define MAXN 100050
#define mat(x) (x+N)
//虚点～
inline int find(int x){
    return (x==fa[x])?x:fa[x]=find(fa[x]);
}
int fa[MAXN],N;
vector<int>ans;
int main()
{
    int M=(N<<1);
    for(int i=1;i<=M;i+=5){
        fa[i]=i;
        if(i+1<=M)fa[i+1]=i+1;
        if(i+2<=M)fa[i+2]=i+2;
        if(i+3<=M)fa[i+3]=i+3;//卡常一下
        if(i+4<=M)fa[i+4]=i+4;
    }//并查集要用到拓展域和虚点
    //虚点的作用是为了让与和你对立的点不再和你连边而和你的虚点连边
    //而你的虚点就可以设为（i+N）
    bool judge=0;
    for(int i=N;i>=1;--i){
        judge=0;
        for(int j=0,y;j<to[i].size();++j){
            y=to[i][j];
            fa[find(i)]=fa[find(mat(y)];
            fa[find(y)]=fa[find(mat(i))];
            if(fa[i]==fa[y]){//其实也一样，就是你把和你敌对的点连在了你的虚点上，
                        //然后你的虚点不能和你连便，因为你不能和你自己敌对
                        //用并查集维护就是可以加快你判断与你对立的点是否和你在同一个集合里
                        //用交叉染色法判一次O(N),他判一次差不多O(1);
                        // 所以还是这个比较好    
                judge=1;break;
            }    
        }
        if(judge){
            //清零数组一大堆懒得写了反正是思路;
            ans.push_back(i);
        }
    }
    
}

差不多这个题最重要的就是判断二分图;

模板好题提醒(关押罪犯)应该先做;

#include<bits/stdc++.h>
using namespace std;
int N,K;
int col[331079],fir[331079];
bool v[331079];
int h[331707];
int c[331079];
vector<int>ans;
int has[331079];
vector<vector<int> >to(331079),num(331107);
struct ct{int st,ed,nxt;}lian[10011007];int tot=0;

inline int max(int a,int b){return a>b?a:b;}

inline void add(int x,int y){
    lian[++tot].st=x;
    lian[tot].ed=y;
    lian[tot].nxt=fir[x];
    fir[x]=tot;
}
int maxn=0;
bool judge=0;
void dfs(int x,int fa,int cs){
    c[x]=cs;register int y;
    if(judge)return ;
    for(int i=fir[x];i;i=lian[i].nxt){
        y=lian[i].ed;
        if(judge)return ;
        if(!v[y])continue;
        if(y==fa)continue;
        if(c[y]+cs==3)continue;
        if(c[y]==cs)return judge=1,void();
        if(!c[y])dfs(y,x,3-cs);
    }
}

int main()
{
    scanf("%d%d",&N,&K);
    for(int i=1;i<=N;++i){
        scanf("%d",&col[i]);
    }
    int lim=512;
   if(K==1){ for(int i=N;i>=1;--i){
        for(int j=lim;j*j>=col[i];--j){
            if(v[j*j-col[i]]){
                for(int k=1;k<=has[0];++k)
                    v[has[k]]=0;
                has[0]=0;ans.push_back(i);
                break;
            }
        }
        v[col[i]]=1;has[++has[0]]=col[i];
        }
    }

   else
    {
    register int deta=1<<17;
        for(int i=N;i>=1;--i){
            judge=0;
            lim=sqrt(maxn+col[i])+1;
            for(int j=lim;j*j>=col[i];--j)
            if(j*j-col[i]<=(deta)){
                    for(int k=0;k<h[j*j-col[i]];++k){
                        register int p=num[j*j-col[i]][k];
                        if(p!=i){
                            add(p,i);
                            add(i,p);
                        }
                    }
            }
            v[i]=1;
            dfs(i,i,1);
            //for(int is=0;is<=131072;++is)c[is]=0;
            if(judge){
                has[++has[0]]=i;
                ans.push_back(i);//c[i]=0;
                for(register int j=1;j<=has[0];j+=4){
                v[has[j]]=0,c[has[j]]=0,fir[has[j]]=0,h[col[j]]=0,num[col[j]].clear();
                if(j+1<=has[0]){v[has[j+1]]=0,c[has[j+1]]=0,fir[has[j+1]]=0,h[col[j+1]]=0,num[col[j+1]].clear();}
                if(j+2<=has[0]){v[has[j+2]]=0,c[has[j+2]]=0,fir[has[j+2]]=0,h[col[j+2]]=0,num[col[j+2]].clear();}
                if(j+3<=has[0]){v[has[j+3]]=0,c[has[j+3]]=0,fir[has[j+3]]=0,h[col[j+3]]=0,num[col[j+3]].clear();}
                }
                tot=0;
                has[0]=0;
                maxn=col[i];
            }
            v[i]=1;
            has[++has[0]]=i;
            h[col[i]]++;
            maxn=max(maxn,col[i]);
            num[col[i]].push_back(i);
            for(register int j=1;j<=has[0];j+=5){
            c[has[j]]=0;
            if(j+1<=has[0])c[has[j+1]]=0;
            if(j+2<=has[0])c[has[j+2]]=0;
            if(j+3<=has[0])c[has[j+3]]=0;
            if(j+4<=has[0])c[has[j+4]]=0;
            }
        }
       }
       printf("%d
",(ans.size())+1);
       for(int i=ans.size()-1;i>=0;--i){
           printf("%d ",ans[i]);
        }
        printf("
");
}