uva1627 Team them up!

注意这题要求互相认识
不认识的人之间连一条线
一个人在组1，那么不认识（互相认识）的人就在组0；同时这些人不认识的人就在组1.每个联通分量都可以独立推导，遇到矛盾则无解
一个联通分量有一个核心，其他的点是分支
我感觉紫书写的样例又是有点问题，应该是4在0，那么135在1，反正则反；而不是1在0,345在1
然后一个联通分量的核心在一组，分支就在另一组；
设0组比1组多d，就对应d加一个或者减一个值
相当于背包

矛盾状况就是任意个联通分量不能二分染色

#include<cstdio>
#include<cstring>
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

const int maxn =  + ;

int n, G[maxn][maxn], color[maxn], diff[maxn], cc;
vector<int> team[maxn][]; // team[cc][c] is the list of people in connected-component cc, color c

// returns false if not bipartite graph
bool dfs(int u, int c) {
  color[u] = c;
  team[cc][c-].push_back(u);
  for(int v = ; v < n; v++) {
    if(u != v && !(G[u][v] && G[v][u])) { // u and v 不互相认识
      if(color[v] >  && color[v] == color[u]) return false;
      if(!color[v] && !dfs(v, -c)) return false;
    }
  }
  return true;
}

bool build_graph() {
  memset(color, , sizeof(color));
  cc = ; // current connected-component
  for(int i = ; i < n; i++)
    if(!color[i]) {
      team[cc][].clear();  //存染成1的
      team[cc][].clear();  //染成2的
      if(!dfs(i, ))
        return false;
      diff[cc] = team[cc][].size() - team[cc][].size();
      cc++;
    }

  return true;
}

// d[i][j+n] = 1 iff we can arrange first i cc so that team 1 has j more people than team 2.
int d[maxn][maxn*], teamno[maxn];

void print(int ans) {
  vector<int> team1, team2;
  for(int i = cc-; i >= ; i--) {
    int t;
    if(d[i][ans-diff[i]+n]) {
            t = ;
            ans -= diff[i];
    }
    else {
    t = ;
    ans += diff[i];
    }
    for(int j = ; j < team[i][t].size(); j++)
      team1.push_back(team[i][t][j]);
    for(int j = ; j < team[i][^t].size(); j++)
      team2.push_back(team[i][^t][j]);
  }

  printf("%d", team1.size());
  for(int i = ; i < team1.size(); i++)
    printf(" %d", team1[i]+);
  printf("\n");
  printf("%d", team2.size());
  for(int i = ; i < team2.size(); i++)
    printf(" %d", team2[i]+);
  printf("\n");
}

void dp() {
  memset(d, , sizeof(d));
  d[][+n] = ;
  for(int i = ; i < cc; i++)
    for(int j = -n; j <= n; j++) if(d[i][j+n]) {
      d[i+][j+diff[i]+n] = ;
      d[i+][j-diff[i]+n] = ;
    }
  for(int ans = ; ans <= n; ans++) {              //差的绝对值尽量小即可
    if(d[cc][ans+n]) { print(ans); return; }
    if(d[cc][-ans+n]) { print(-ans); return; }
  }
}

int main() {
  int T;
  cin >> T;
  while(T--) {
    cin >> n;
    memset(G, , sizeof(G));
    for(int u = ; u < n; u++) {
      int v;
      while(cin >> v && v) G[u][v-] = ;   //认识
    }

    if(n ==  || !build_graph())
        cout << "No solution\n";
    else
        dp();
        cout << "\n";
  }
  return ;
}