UVAlive 4100 - Sharif Super Computer （2SAT）

Description





SSC is a super computer designed in Sharif University having 2 ``master" and n ``slave" processors. It can run softwares in parallel: One of the master processors loads the
software on the slave processors such that the memory and CPU usage among them are balanced, while the other master is used for monitoring the system.
Because of the dependencies between different parts of the software, many messages should be exchanged between processors. A very fast network is needed to minimize the message passing overhead. To optimize
the network, a clique structure will be constructed in which there is a direct communication cable between each pair of processors.
There are two different cables: blue cables which can transmit up to 100 Megabits per second and red cables which can transmit up to 1 Gigabits per second. Each pair of slave processors will be connected by
one blue cable. Due to the higher communication volume on master processors, the two masters are connected by one red cable and also each master is connected to each slave by another red cable.
SSC is thus made of n + 2 motherboards, each containing exactly one processor, the needed memory, and also n + 1 similar network sockets
installed as a horizontal array. The motherboards are put in a vertical rack box, each in one horizontal shelf. So, each motherboard is uniquely identified by its height in the rack.
The cooling system has forced us to put the two master motherboards in the lowest and highest shelves of the rack. We assume that the master in the bottom has height 0, and the heights of the other motherboards
are integers higher than 0. You, as a computer engineer, are asked to do the final assembly of SSC. You are given the empty rack box, the ready motherboards, and your job is to determine whether you can put the boards in the rack that satisfy the constraints
and cable lengths.
There are exactly 2n + 1 red cables available with the given sizes. However the blue cables are available in m different sizes, and we have
unlimited number of cables in each size. You are so careful to keep the cabling between processors tidy and tight, so you want to install the motherboards in the heights such that the size of cable used between each pair of motherboards is exactly equal to
the difference between the heights of two boards.

Input

There are multiple test cases in the input. The first line of each test case contains two numbers n(1

n

100) and m(1

m

1000) .
The second line contains 2n + 1 integers, which are the sizes of Gigabit Ethernet cables. The third line contains m integers which are the sizes of Megabit Ethernet cable groups. The last
line of the input contains two zero numbers.

Output

For each data set you should write n + 1 integers as the heights of the motherboards in SSC rack box. The first number represents the height of the top master processor, and
the remaining n integers are the positions of the slaves in an increasing order. In the case of having multiple solutions write the one with the minimum alphabetical order. If there is no solution write `` Impossible".

Sample Input

3 3 
3 7 7 10 10 14 17 
3 4 7 
3 3 
3 7 7 10 10 14 17 
3 4 8 
0 0

Sample Output

17 3 7 10 
Impossible

直接按照书上的思路写的。要注意的细节是，最开始2*n条边不能两两配对则false。
输出答案前记得先排序。

#include<cstdio>
#include<map>
#include<queue>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<list>
#include<set>
#include<cmath>
using namespace std;
const int maxn = 1e3 + 5;
const int INF = 1e9;
const double eps = 1e-6;
typedef unsigned long long ULL;
typedef long long LL;
typedef pair<int, int> P;
#define fi first
#define se second

int blue[maxn];
map<int, int> M;

struct TwoSAT{
    int n;
    vector<int> G[maxn*2];
    bool mark[maxn*2];
    int S[maxn*2], c;

    bool dfs(int x){
        if(mark[x^1]) return false;
        if(mark[x]) return true;
        mark[x] = true;
        S[c++] = x;
        for(int i = 0;i < G[x].size();i++){
            if(!dfs(G[x][i])) return false;
        }
        return true;
    }

    void init(int n){
        this -> n = n;
        for(int i = 0;i < n*2;i++) G[i].clear();
        memset(mark, 0, sizeof mark);
    }

    bool solve(){
        for(int i = 0;i < n*2;i += 2)
        if(!mark[i] && !mark[i+1]){
            c = 0;
            if(!dfs(i)){
                while(c > 0) mark[S[--c]] = false;
                if(!dfs(i+1)) return false;
            }
        }
        return true;
    }
};

TwoSAT solver;

P pos[maxn];

int abs(int x){
    return x<0?-x:x;
}

vector<int> ans;

int main(){
    int n, m;
    while(cin >> n >> m){
        if(n == 0 && m == 0)
            break;
        for(int i = 0;i < 2*n+1;i++){
            cin >> blue[i];
        }
        sort(blue, blue+2*n+1);
        bool ok = true;
        for(int i = 0;i < n;i++){
            pos[i] = P(blue[i], blue[2*n-i-1]);
            if(blue[i]+blue[2*n-i-1] != blue[2*n])
                ok = false;
        }
        M.clear();
        for(int i = 0;i < m;i++){
            int x;
            cin >> x;
            M[x] = 1;
        }

        solver.init(n);
        for(int i = 0;i < n;i++){
            int x1 = pos[i].fi;
            int y1 = pos[i].se;
            for(int j = i+1;j < n;j++){
                int x2 = pos[j].fi;
                int y2 = pos[j].se;
                if(M.count(abs(x1-x2))==0 && M.count(abs(x1-y2))==0){
                    solver.G[2*i].push_back(2*i+1);
                    solver.G[2*i+1].push_back(2*i);
                }
                else if(M.count(abs(x1-x2))==0)
                    solver.G[2*i].push_back(2*j+1);
                else if(M.count(abs(x1-y2))==0)
                    solver.G[2*i].push_back(2*j);

                if(M.count(abs(y1-x2))==0 && M.count(abs(y1-y2))==0){
                    solver.G[2*i].push_back(2*i+1);
                    solver.G[2*i+1].push_back(2*i);
                }
                else if(M.count(abs(y1-x2))==0)
                    solver.G[2*i+1].push_back(2*j+1);
                else if(M.count(abs(y1-y2))==0)
                    solver.G[2*i+1].push_back(2*j);
            }
        }
        if(ok && solver.solve()){
            cout << blue[2*n] << ' ';
            ans.clear();
            for(int i = 0;i < n;i++){
                if(solver.mark[2*i])
                    ans.push_back(pos[i].fi);
                else
                    ans.push_back(pos[i].se);
            }
            sort(ans.begin(), ans.end());
            for(int i = 0;i < ans.size();i++)
                cout << ans[i] << ' ';
            puts("");
        }
        else
            puts("Impossible");
    }
    return 0;
}