ural1156. Two Rounds(二分染色+dfs)-优快云博客

本文探讨了一种通过裸爆搜解决特定问题的方法，并介绍了如何通过连通分量分类来优化算法效率，从而避免了时间限制错误(TLE)。通过实例分析，展示了在编程竞赛或实际应用中，对问题进行合理分类的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

好久没有写过题了，有点生疏啊，这题坑了好久......写了个裸的爆搜TLE了，然后将他分类后，只对有2个点以上的连通分量爆搜就过了，只含一个点的连通分量可以随便在两个round里选，所以可以不搜，最后随便放就行。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <cstring>
using namespace std;
#define N 105
#define M 210
struct node
{
    int to,next;
} e[M];
int head[N],esum;
int n,m;
inline void init()
{
    memset(head,-1,sizeof(head));
    esum=0;
}
inline void addedge(int u,int v)
{
    e[esum].to=v,e[esum].next=head[u],head[u]=esum++;
}
int belong[N],cnt;
bool err,vis[N];
vector<int>lst[N][2];
vector<int>::iterator it;
void dfs(int id,int flag)
{
    if(err) return ;
    if(!belong[id])
    {
        belong[id]=flag;
        lst[cnt/2][flag%2].push_back(id);
    }
    else if(belong[id]!=flag)
    {
        err=1;
        return ;
    }
    int col=1-(flag-cnt)+cnt;
    for(int i=head[id]; ~i; i=e[i].next)
    {
        int to=e[i].to;
        if(!belong[to])
            dfs(to,col);
        else if(belong[to]!=col)
        {
            err=1;
            return ;
        }
    }
}
bool havFind;
bool ans[N];
int sum;
void findAns(int id,int s1,int s2)
{
    if(havFind) return ;
    if(s1>n||s2>n) return ;
    if(id==cnt/2)
    {
        havFind=1;
        sum=s1;
        return ;
    }
    if(lst[id][0].size()+lst[id][1].size()>1)
    {
        ans[id]=0;
        findAns(id+1,s1+lst[id][0].size(),s2+lst[id][1].size());
        if(havFind) return ;
        ans[id]=1;
        findAns(id+1,s1+lst[id][1].size(),s2+lst[id][0].size());
        if(havFind) return ;
    }
    else findAns(id+1,s1,s2);
}
int main()
{
    int a,b;
    while(~scanf("%d%d",&n,&m))
    {
        init();
        for(int i=0; i<m; i++)
        {
            scanf("%d%d",&a,&b);
            addedge(a,b);
            addedge(b,a);
        }
        memset(belong,0,sizeof(belong));
        err=0,cnt=1;
        for(int i=1; i<=2*n; i++)
            if(!belong[i])
            {
                lst[cnt/2][0].clear();
                lst[cnt/2][1].clear();
                dfs(i,cnt);
                if(err) break;
                cnt+=2;
            }
        if(err) puts("IMPOSSIBLE");
        else
        {
            havFind=0;
            findAns(0,0,0);
            if(havFind)
            {
                int rest=n-sum;
                for(int i=0; i<cnt/2; i++)
                {
                    if(lst[i][0].size()+lst[i][1].size()==1)
                    {
                        if(rest) ans[i]=1,rest--;
                        else ans[i]=0;
                    }
                }
                for(int i=0; i<cnt/2; i++)
                    for(it=lst[i][ans[i]].begin(); it!=lst[i][ans[i]].end(); it++)
                        printf("%d ",*it);
                puts("");
                for(int i=0; i<cnt/2; i++)
                    for(it=lst[i][!ans[i]].begin(); it!=lst[i][!ans[i]].end(); it++)
                        printf("%d ",*it);
                puts("");
            }
            else puts("IMPOSSIBLE");
        }
    }
    return 0;
}