UVa 1627 - Team them up!——[0-1背包]

Your task is to divide a number of persons into two teams, in such a way, that:

• everyone belongs to one of the teams;
• every team has at least one member;
• every person in the team knows every other person in his team;
• teams are as close in their sizes as possible.

This task may have many solutions. You are to find and output any solution, or to report that the solution does not exist.

Input

The input begins with a single positive integer on a line by itself indicating the number of the cases following, each of them as described below. This line is followed by a blank line, and there is also a blank line between two consecutive inputs.

For simplicity, all persons are assigned a unique integer identifier from 1 to N.

The first line in the input file contains a single integer number N (2 ≤ N ≤ 100) - the total number of persons to divide into teams, followed by N lines - one line per person in ascending order of their identifiers. Each line contains the list of distinct numbers A_ij (1 ≤ A_ij ≤ N, A_ij ≠ i) separated by spaces. The list represents identifiers of persons that i^th person knows. The list is terminated by 0.

Output

For each test case, the output must follow the description below. The outputs of two consecutive cases will be separated by a blank line.

If the solution to the problem does not exist, then write a single message "No solution" (without quotes) to the output file. Otherwise write a solution on two lines. On the first line of the output file write the number of persons in the first team, followed by the identifiers of persons in the first team, placing one space before each identifier. On the second line describe the second team in the same way. You may write teams and identifiers of persons in a team in any order.

Sample Input

2

5
3 4 5 0
1 3 5 0
2 1 4 5 0
2 3 5 0
1 2 3 4 0

5
2 3 5 0
1 4 5 3 0
1 2 5 0
1 2 3 0
4 3 2 1 0

Sample Output

No solution

3 1 3 5
2 2 4

题意分析：
　　以“不相互认识关系”建无向图，每个连通块都可以分成两队，如果存在已经分成一队的两个人互相不认识，说明无解，表现在图中就是存在环，用bfs求连通块即可。
将每个连通块中必须分到不同队的两组人分别记录下来team0，team1，接下来对求出的各个连通块动态规划，两队人数之差 dt＝team0-team1，则要选择将每个连通块适当分组使dt最接近0。
　　以d（i，j）表示已经选择前i个连通块，且dt=j时的最优解。
　　状态转移方程为 d（i，j）＝min｛d（i－1，j－dt［i］）＋dt［i］，d（i－1，j+dt［i］－dt［i］）｝，其中dt［i］是指第i个连通块的两队人数差。
　　用b（i，j）记录当前状态应该分组的方式，0表示将连通块的team0部分分到0组，1则表示将team0部分分到1组。
代码如下：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #include <algorithm>
 #include <vector>
 using namespace std;
 const int maxn=;
 #define INF 100000000
 int know[maxn][maxn];
 int unknow[maxn][maxn];
 int team[maxn];
 int n;
 vector<int> block[maxn][];
 int num;
 int d[maxn][*maxn];
 int b[maxn][*maxn];
 bool dfs(int i,int t,vector<int> *b){
     team[i]=t;
     b[t].push_back(i);
     bool ok=true;
     for(int j=;j<=n;j++){
         if(unknow[i][j]){
             if(team[j]==-) {
                 if(!dfs(j,!t,b)){
                     ok=false;
                     break;
                 }
             }
             else if(team[j]!=t) continue;
             else{
                 ok=false;
                 break;
             }
         }
     }
     return ok;
 }
 bool blocks(){
     for(int i=;i<maxn;i++)
         for(int j=;j<;j++)
             block[i][j].clear();
     num=;
     for(int i=;i<=n;i++)
         if(team[i]==-)
             if(!dfs(i,,block[num++]))
                 return false;
     return true;
 }
 void dp(){
     memset(d, , sizeof d);
     memset(b,,sizeof b);
     for(int i=;i<=num;i++){
         for(int j=;j<*maxn;j++){
             if(i==){
                 d[i][j]=INF;
                 if(j==maxn)
                 d[i][j]=;
                 continue;
             }
             d[i][j]=INF;
             int deta=block[i-][].size()-block[i-][].size();
             if(j-deta>=&&j-deta<*maxn&&d[i-][j-deta]!=INF){
                 if(abs(d[i][j])>abs(d[i-][j-deta]+deta)){
                     d[i][j]=d[i-][j-deta]+deta;
                     b[i][j]=;
                 }
             }
             if(j+deta>=&&j+deta<*maxn&&d[i-][j+deta]!=INF){
                 if(abs(d[i][j])>abs(d[i-][j+deta]-deta)){
                     d[i][j]=d[i-][j+deta]-deta;
                     b[i][j]=;
                 }
             }

         }
     }
 }
 void print(){
     int ans=INF,p=;
     for(int k=;k<*maxn;k++){
         if(abs(ans)>abs(d[num][k])){
             ans=d[num][k];
             p=k;
         }
     }
     vector<int> team[];
     for(int i=num,j=p;i>=;i--){
         int dt=block[i-][].size()-block[i-][].size();
         int t=b[i][j];
         if(t==){
             for(int k=;k<block[i-][].size();k++)
                 team[].push_back(block[i-][][k]);
             for(int k=;k<block[i-][].size();k++)
                 team[].push_back(block[i-][][k]);
             j-=dt;
         }
         else{
             for(int k=;k<block[i-][].size();k++)
                 team[].push_back(block[i-][][k]);
             for(int k=;k<block[i-][].size();k++)
                 team[].push_back(block[i-][][k]);
             j+=dt;
         }
     }
     printf("%d",int(team[].size()));
     for(int i=;i<team[].size();i++){
         printf(" %d",team[][i]);
     }
     printf("\n");
     printf("%d",int(team[].size()));
     for(int i=;i<team[].size();i++){
         printf(" %d",team[][i]);
     }
     printf("\n");
    }
 int main(int argc, const char * argv[]) {
     int tt;
     scanf("%d",&tt);
     int cas=;
     while(tt--){
         memset(know,,sizeof know);
         memset(unknow,,sizeof know);
         memset(team,-,sizeof team);

         scanf("%d",&n);
         for(int i=;i<=n;i++){
             int j;
             while(scanf("%d",&j)&&j){
                 know[i][j]=;
             }
         }

         for(int j=;j<=n;j++){
             for(int i=;i<=n;i++){
                 if(i==j)
                     continue;
                 if(!know[i][j]){
                     unknow[i][j]=unknow[j][i]=;
                 }
             }
         }

         if(!blocks()){
             printf("No solution\n");
             if(tt) printf("\n");
             continue;
         }
         dp();
         print();
         if(tt) printf("\n");
     }

     return ;
 }