POJ1636 动态规划+并查集

POJ1636

问题重述：

两个监狱中各有m个囚犯，欲对这两个监狱中的囚犯进行等数量的交换。已知某些囚犯不能关押在同一个监狱，求解可以交换人数的最大值k (k < m/2)。

分析：

假设监狱1中的囚犯a与监狱2中的囚犯b不能共存。那么假如对a进行交换，也必须对b进行交换。因此，根据互斥关系建立的连通集两边的成员必须同时进行交换。

求解步骤：

1）  根据已知的互斥关系，采用并查集建立连通集，分别记录每个连通集在两个监狱中的成员数目，记为v1, v2。

2）  采用动态规划算法，用布尔变量dp[i][j]表示监狱1中i个囚犯与监狱2中的j个囚犯进行交换的可行性。则有dp[i][j] = dp[i – v1[k]][j – v2[k]]

3）  满足dp[i][i] = 1, i < m/2的i的最大值即所求的解。

 //Memory: 580K        Time: 63MS
 #include <iostream>
 #include <cstring>
 #include <cstdio>

 using namespace std;

 ;
 int m, r;
 bool g[maxn][maxn];
 int f[maxn];
 int nl[maxn];
 int nr[maxn];
 bool vis[maxn];
 int v1[maxn], v2[maxn];
 int cnt;
 bool dp[maxn][maxn];

 void makeset()
 {
     memset(f, , sizeof(f));
     memset(nl, , sizeof(nl));
     memset(nr, , sizeof(nr));
     ; i <=  * m; i++)
         f[i] = i;
     ; i <= m; i++) {
         nl[i] = ;
         nr[i] = ;
     }
      + m; i <= m * ; i++) {
         nr[i] = ;
         nl[i] = ;
     }
 }

 int find(int a) {
     if (f[a] == a) return a;
     f[a] = find(f[a]);
     return f[a];
 }

 void uni(int a, int b) {
     int sa = find(a);
     int sb = find(b);
     if (sa != sb) {
         f[sa] = sb;
         nl[sb] += nl[sa];
         nr[sb] += nr[sa];
     }
 }

 void init()
 {
     makeset();
     ; i <= m; i++) {
         ; j <= m * ; j++) if (g[i][j]) {
             uni(i, j);
         }
     }
     cnt = ;
     ; i <= m * ; i++) {
         int s = find(i);
         if (s == i) {
             v1[cnt] = nl[s];
             v2[cnt++] = nr[s];
         }
     }
 }

 int main()
 {
     int cas;
     cin >> cas;
     while (cas--) {
         memset(g, , sizeof(g));
         scanf("%d%d", &m, &r);
         int a, b;
         ; i < r; i++) {
             scanf("%d%d", &a, &b);
             g[a][b + m] = ;
         }
         init();

         memset(dp, , sizeof(dp));
         dp[][] = ;
         ; i < cnt; i++) {
             ; j >= ; j--)  ////此处必须进行倒序循环：每次循环的dp都由上一轮循环后序号较小的dp确定，倒序循环避免提前更新序号较小的dp
                 ; k >= ; k--) {  //同上
                      && k + v2[i] <= m/)
                         dp[j + v1[i]][k + v2[i]] = ;
                 }
         }

         ; i >= ; i--) {
             if (dp[i][i]) {
                 cout << i <<endl;
                 break;
             }
         }
     }
     ;
 }