Poj 1112 Team Them Up!

1、题目给出的是一个有向图，即如果有A认识B，但不一定有B认识A。但是在所分配的组里面，任意两个人都要互相认识，所以对于答案单向边是无效的，只有双向边才有用， 先读入数据建立有向图，然后对这个有向图进行处理，如果两个点之间的边是单向边，就认为两个点之间无边，对于两个点间的双向边，即建立一条无向边（这两个人互相认识），这样就可以把一个有向图转化为一个无向图。

2、 将这个无向图转化为它的补图。1，2步在实现时可以一次完成，详见代码。（因为图比较小，用邻接矩阵可以更加方便地建立补图）

3、 对转换后的补图求出所有的连通分量（连通块）。可以看到在补图中的不同的连通分量中的两个人都是互相认识的，那些一个连通分量中相邻的点一定是不互相认识的（有可能单一认识，但是单一认识无效）。
（此图来自网络）

4、 在做DFS求连通分量的时候，同时对连通分量中的点染色（0或1），如果一个点颜色为0，那么所有和它相邻的点与它的颜色应该不同（标记为1），因为补图中相邻的两个人都是不认识的。这样DFS结束后，就可以根据颜色把所有的连通分量中的点分成两个集合s0和s1，在不同集合的人是不可能分到一个team内的。到这里要做一个特判，对于s0或s1组里的任意两个人p,q，如果补图中存在一条边(p,q)，说明无解，输出"No solution"。

5、 求出了所有的连通分量，对于第 i 个连通分量 都把其节点分为两个集合 s0i 和 s0i。在此用背包DP了，确认最终可以分配到的状态，dp[ i ][ j ]表示将 第 i 个连通分量加入team的时候，team1 中共有 j 个人， 值为bool型，表示可否到达

状态转移方程：

dp[ i ][ j ] =true ( if dp[ i-1 ][ j-s0i ] == true
dp[ i ][ j ] =true ( if dp[ i-1 ][ j-s1i ] == true

这时要做的就是把所有的s0i和s1i分配到team1和team2中去，使team1的总和与team2的总和差值最小。
最后在dp[cnt][i]（cnt是最后一个连通块数）中找出值为true的最小 2*i - n 值。输出答案。

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#define CLR(x,y) memset(x,y,sizeof(x))
#define eps 1e-9
#define INF 0x3f3f3f3f

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1;
    char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------

const int MAXN=110;

int n,cnt;
bool g[MAXN][MAXN],r[MAXN][MAXN];
bool vis[MAXN],dp[MAXN][MAXN];
int ans[MAXN][MAXN];

struct Node
{
    int a[2];       //该连通区该颜色的人数 
    int s[2][MAXN]; //该连通区该颜色的人数 
} p[MAXN];

void dfs(int v,int color,int num)
{
    vis[v]=true;
    p[num].s[color][++p[num].a[color]]=v;
    for(int i=1; i<=n; i++)
        if(!vis[i] && r[v][i])
            dfs(i,color^1,num);
}

bool fit()
{
    for(int i=1; i<=cnt; i++)
        for(int t=0; t<2; t++)
            for(int j=1; j<=p[i].a[t]; j++)
                for(int k=j+1; k<=p[i].a[t]; k++)
                    if(r[p[i].s[t][j]][p[i].s[t][k]])  //同一联通快内，同颜色不认识的话有矛盾
                        return false;

    return true;
}

int main()
{
    while(read(n))
    {
        CLR(g,0);CLR(r,0);
        for(int i=1,j; i<=n; i++)
            while(read(j)&&j)
                g[i][j]=1;			// µ¥Ïò±ß
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                if(!g[i][j] || !g[j][i])
                    r[i][j]=r[j][i]=1;	//建无向反图
        CLR(vis,0);
        cnt=0;
        for(int i=1; i<=n; i++)  //对每一个连通区间 染色 
            if(!vis[i])
            {
                cnt++;
                p[cnt].a[0]=p[cnt].a[1]=0;
                dfs(i,0,cnt);
            }

        if(!fit())
        {
            puts("No solution");
            continue;
        }
        int ans1[MAXN],ans2[MAXN];
        CLR(dp,0);CLR(ans,0);
        dp[0][0]=true;
        for(int i=1; i<=cnt; i++) //简单背包，每个连通分量每种颜色必须进一个小队  
        {
            for(int j=p[i].a[0]; j<=n; j++)
                if(!dp[i][j]&&dp[i-1][j-p[i].a[0]])
                    dp[i][j]=true,ans[i][j]=0;
            for(int j=p[i].a[1]; j<=n; j++)
                if(!dp[i][j]&&dp[i-1][j-p[i].a[1]])
                    dp[i][j]=true,ans[i][j]=1;
        }
        int gap=n,temp1=0,temp2=0;
        for(int i=1; i<=n; i++)
            if(dp[cnt][i]&&abs(2*i-n)<gap) //求出 差值最小的 两支队伍数 
                gap=abs(2*i-n),temp1=i;
        temp2=n-temp1;
        if(!temp1 || !temp2)
            puts("No solution");
        else
        {
            int t=0,k=0;
            for(int i=cnt; i>=1; i--)
            {
                if(ans[i][temp1])
                {
                    for(int j=1; j<=p[i].a[1]; j++)
                        ans1[t++]=p[i].s[1][j];
                    for(int j=1; j<=p[i].a[0]; j++)
                        ans2[k++]=p[i].s[0][j];
                    temp1-=p[i].a[1];
                }
                else
                {
                    for(int j=1; j<=p[i].a[0]; j++)
                        ans1[t++]=p[i].s[0][j];
                    for(int j=1; j<=p[i].a[1]; j++)
                        ans2[k++]=p[i].s[1][j];
                    temp1-=p[i].a[0];
                }
            }
            write(k);
            for(int i=0;i<k;i++)
                putchar(' '),write(ans2[i]);
            putchar('\n');
            write(t);
            for(int i=0;i<t;i++)
                putchar(' '),write(ans1[i]);
            putchar('\n');
        }
    }
    return 0;
}