[TC2016BeijingDiv1] DarkMatterParticles（并查集，01背包）

Problem Statement

    	
Maya has n volatiel dark matter particles in her research facility (particles are numbered as 0, 1, 2, ..., n-1). They are all kept in one giant jar as some particles, if separated far away, would explode.



Maya recently received a huge research grant, and built a new research facility on another planet. Maya wishes to transport exactly k of the particles to the new facility for further experiments. Maya needs to figure out which k particles she can safely transport to the new facility so that no particle would explode.



Maya has a list of pairs described by x and y such that if the two particles x[i] and y[i] are separated, they would explode (assume x[i] is not equal to y[i] for all i). In particular, if Maya transports only one of x[i] and y[i] to the new facility (thereby the other one remaining in the current facility), they would explode. Therefore Maya needs to keep both particles x[i] and y[i] in her current facility or to transport both particles to the new facility (for every i).

Given this information, please help Maya by determining whether it is possible to transport exactly k particles to the new facility without resulting in any explosion. If it is possible, return "Possible"; otherwise return "Impossible" (all quotes for clarity).

Definition

    	
Class:	DarkMatterParticles
Method:	SplitParticles
Parameters:	int, int, vector <int>, vector <int>
Returns:	string
Method signature:	string SplitParticles(int n, int k, vector <int> x, vector <int> y)
(be sure your method is public)
Limits

    	
Time limit (s):	2.000
Memory limit (MB):	256
Constraints

-	n will be between 2 and 1,000, inclusive.
-	k will be between 1 and 1,000, inclusive.
-	x will contain between 1 and 2,500 elements, inclusive.
-	x and y will contain the same number of elements.
-	Each element in x will be between 0 and n-1, inclusive.
-	Each element in y will be between 0 and n-1, inclusive.
-	For each valid i, x[i] != y[i].
Examples

0)	
    	
4
2
{0,1,2,3}
{1,2,3,0}
Returns: "Impossible"
1)	
    	
4
4
{0,1,2,3}
{1,2,3,0}
Returns: "Possible"
2)	
    	
4
2
{0,1,2,3}
{2,3,0,1}
Returns: "Possible"
3)	
    	
4
3
{0,1,2,3}
{2,3,0,1}
Returns: "Impossible"
4)	
    	
3
3
{0,1,2}
{1,2,0}
Returns: "Possible"
5)	
    	
3
2
{0,1,2}
{1,2,0}
Returns: "Impossible"
6)	
    	
6
1
{0,1,4}
{1,2,5}
Returns: "Possible"
7)	
    	
6
2
{0,1,4}
{1,2,5}
Returns: "Possible"
8)	
    	
6
3
{0,1,4}
{1,2,5}
Returns: "Possible"
9)	
    	
6
6
{0,1,4}
{1,2,5}
Returns: "Possible"

一共有n个点，有一些点必须一起被装在背包里，现在给了好多点，问背包能不能装恰好k个点。

用并查集维护各个堆，然后每一堆做一个物品的重量，做01背包即可。

// BEGIN CUT HERE

// END CUT HERE
#line 5 "DarkMatterParticles.cpp"
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <sstream>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <fstream>
#include <numeric>
#include <iomanip>
#include <bitset>
#include <list>
#include <stdexcept>
#include <functional>
#include <utility>
#include <ctime>
using namespace std;

const int maxn = 1010;
int pre[maxn], sz[maxn], dp[maxn];
vector<int> v;
int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); }
void unite(int x, int y) { pre[find(x)] = find(y); }
class DarkMatterParticles
{
    public:
    string SplitParticles(int n, int k, vector <int> x, vector <int> y)
    {
        if(n == k) return "Possible";
        if(n < k) return "Impossible";
        for(int i = 0; i < maxn; i++) pre[i] = i;
        memset(sz, 0, sizeof(sz));
        memset(dp, 0, sizeof(dp));
        dp[0] = 1; v.clear();
        for(int i = 0; i < x.size(); i++) unite(x[i], y[i]);
        for(int i = 0; i < n; i++) sz[find(i)]++;
        for(int i = 0; i < n; i++) if(sz[i]) v.push_back(sz[i]);
        for(int i = 0; i < v.size(); i++) {
            for(int j = k; j >= v[i]; j--) {
                dp[j] |= dp[j-v[i]];
            }
        }
        return dp[k] ? "Possible" : "Impossible";
    }
    
// BEGIN CUT HERE
    public:
    void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); if ((Case == -1) || (Case == 6)) test_case_6(); if ((Case == -1) || (Case == 7)) test_case_7(); if ((Case == -1) || (Case == 8)) test_case_8(); if ((Case == -1) || (Case == 9)) test_case_9(); if ((Case == -1) || (Case == 10)) test_case_10(); }
    private:
    template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '"' << *iter << "","; os << " }"; return os.str(); }
    void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "	Expected: "" << Expected << '"' << endl; cerr << "	Received: "" << Received << '"' << endl; } }
    void test_case_0() { int Arg0 = 4; int Arg1 = 2; int Arr2[] = {0,1,2,3}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {1,2,3,0}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); string Arg4 = "Impossible"; verify_case(0, Arg4, SplitParticles(Arg0, Arg1, Arg2, Arg3)); }
    void test_case_1() { int Arg0 = 4; int Arg1 = 4; int Arr2[] = {0,1,2,3}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {1,2,3,0}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); string Arg4 = "Possible"; verify_case(1, Arg4, SplitParticles(Arg0, Arg1, Arg2, Arg3)); }
    void test_case_2() { int Arg0 = 4; int Arg1 = 2; int Arr2[] = {0,1,2,3}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {2,3,0,1}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); string Arg4 = "Possible"; verify_case(2, Arg4, SplitParticles(Arg0, Arg1, Arg2, Arg3)); }
    void test_case_3() { int Arg0 = 4; int Arg1 = 3; int Arr2[] = {0,1,2,3}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {2,3,0,1}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); string Arg4 = "Impossible"; verify_case(3, Arg4, SplitParticles(Arg0, Arg1, Arg2, Arg3)); }
    void test_case_4() { int Arg0 = 3; int Arg1 = 3; int Arr2[] = {0,1,2}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {1,2,0}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); string Arg4 = "Possible"; verify_case(4, Arg4, SplitParticles(Arg0, Arg1, Arg2, Arg3)); }
    void test_case_5() { int Arg0 = 3; int Arg1 = 2; int Arr2[] = {0,1,2}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {1,2,0}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); string Arg4 = "Impossible"; verify_case(5, Arg4, SplitParticles(Arg0, Arg1, Arg2, Arg3)); }
    void test_case_6() { int Arg0 = 6; int Arg1 = 1; int Arr2[] = {0,1,4}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {1,2,5}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); string Arg4 = "Possible"; verify_case(6, Arg4, SplitParticles(Arg0, Arg1, Arg2, Arg3)); }
    void test_case_7() { int Arg0 = 6; int Arg1 = 2; int Arr2[] = {0,1,4}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {1,2,5}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); string Arg4 = "Possible"; verify_case(7, Arg4, SplitParticles(Arg0, Arg1, Arg2, Arg3)); }
    void test_case_8() { int Arg0 = 6; int Arg1 = 3; int Arr2[] = {0,1,4}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {1,2,5}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); string Arg4 = "Possible"; verify_case(8, Arg4, SplitParticles(Arg0, Arg1, Arg2, Arg3)); }
    void test_case_9() { int Arg0 = 6; int Arg1 = 6; int Arr2[] = {0,1,4}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {1,2,5}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); string Arg4 = "Possible"; verify_case(9, Arg4, SplitParticles(Arg0, Arg1, Arg2, Arg3)); }
    void test_case_10() { int Arg0 = 6; int Arg1 = 6; int Arr2[] = {1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {2}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); string Arg4 = "Possible"; verify_case(10, Arg4, SplitParticles(Arg0, Arg1, Arg2, Arg3)); }

// END CUT HERE

};

// BEGIN CUT HERE
int main()
{
    DarkMatterParticles ___test;
    ___test.run_test(-1);
    return 0;
}
// END CUT HERE