HDU 5740

题意：

　　　　给出已0 1染色的无向图(不一定联通)，一次操作为一对相邻点颜色互换.  

　　　　问使任意相邻点颜色不同，最少需要多少次操作

分析：

　　　　交换两点的代价即为两点间最短路.

　　　　故用BFS找出所有点到任意点的最短距离，并记录路径.
   

　　　　对于每个连通块，按照相邻点颜色不同重新染色一遍，若发现已给的01数目与染色需要01数目不符，则不可能   

　　　　不然 ，则根据已给的01数目与染色需要01数目，确定匹配的点集.
   

　　　　最后KM算法算出最小权值匹配即可   

　　　　确定匹配后，分析下同一路上的交换顺序，确定交换步骤

　　　　不算难，就是麻烦

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <vector>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAXN=505;
const int MAXM = 505*505;

int map[MAXN][MAXN];//二分图描述 
int linker[MAXN],lx[MAXN],ly[MAXN];
int slack[MAXN];
int nx,ny;
bool visx[MAXN],visy[MAXN];

bool DFS(int x)
{
    int y;
    visx[x] = 1;
    for(y = 0;y < ny; ++y)
    {
        if(visy[y]) continue;
        int tmp = lx[x] + ly[y] - map[x][y];
        if(tmp == 0)
        {
            visy[y] = 1;
            if(linker[y] == -1 || DFS(linker[y]))
            {
                linker[y] = x;
                return 1;
            }
        }
        else if(slack[y] > tmp)
            slack[y] = tmp;
    } 
    return 0;
}
int KM()
{
    for(int i = 0;i < nx; ++i) linker[i] = -1,ly[i] = 0;
    for(int i = 0;i < nx; ++i)
    {
        lx[i] = -INF;
        for(int j = 0;j < ny; ++j)
            if(map[i][j] > lx[i]) 
                lx[i] = map[i][j];
    }
    for(int x = 0;x < nx; ++x)
    {
        for(int i = 0;i < ny; ++i) slack[i] = INF;
        while(1)
        {
            for(int i = 0;i < nx; ++i) visx[i] = 0;
            for(int i = 0;i < ny; ++i) visy[i] = 0;
            if(DFS(x)) break;
            int d = INF;
            for(int i = 0;i < ny; ++i)
                if(!visy[i] && d > slack[i])
                    d = slack[i];
            for(int i = 0;i < nx; ++i)
                if(visx[i])
                    lx[i] -= d;
            for(int i = 0;i < ny; ++i)
                if(visy[i]) ly[i] += d;
                else slack[i] -= d;
        }
    }
    int res = 0;
    for(int i = 0;i < ny;++i)
        if(linker[i] != -1)
            res += map[ linker[i] ][i];
    return res;
}

int g[MAXN][MAXN],col[MAXN];
vector<int> X,Y,Left,Right;//X 1 Y 0 
char s[MAXN];
int n,m,ans;
queue<int> p;
vector<int> G[MAXN];

bool BFS(int x,int c)//染色 
{
    while(!p.empty()) p.pop();
    col[x] = c;
    if(c) X.push_back(x);
    else Y.push_back(x);
    p.push(x);
    int size,i;
    while(!p.empty())
    {
        x = p.front(); p.pop();
        size = G[x].size();
        for(i = 0; i < size; ++i)
        {
            if(col[ G[x][i] ] == col[x] ) return 0;
            else if(col[ G[x][i] ] == -1)
            {
                col[ G[x][i] ] = col[x]^1;
                if( col[ G[x][i] ] ) X.push_back( G[x][i] );//1 
                else Y.push_back( G[x][i] );//0 
                p.push( G[x][i] );
            }
        }
    }
    return 1;
}
vector<int> path[MAXN][MAXN];
int vis[MAXN],Pair1[MAXN],Pair2[MAXN],*Pair;
pair<int,int> Ans[MAXM];//答案 

void GetPath(int u)//找到最短路并记录路径 
{
    int i, t, v;
    for(i = 0; i <= n; ++i) vis[i] = 0; 
    while(!p.empty()) p.pop();
    p.push(u); 
    path[u][u].push_back(u);
    vis[u] = 1;
    g[u][u] = 0; 
    while(!p.empty())
    {
        t = p.front(); p.pop();
        for(i = 0; i < G[t].size(); ++i)
        {
            v = G[t][i];
            if( !vis[v] )
            {
                vis[v] = 1;
                g[u][v] = g[u][t] + 1;
                path[u][v] = path[u][t];
                path[u][v].push_back(v);
                p.push(v);
            }
        }
    }
}
int GetSum(vector<int> &X,vector<int> &Y,int Pair[])//匹配 
{
    int i,j;
    Left.clear(); Right.clear(); 
    for( i = 0; i < X.size(); ++i)
    {
        if(s[ X[i] ] == '0') Left.push_back( X[i] );
    }
    for( i = 0; i < Y.size(); ++i)
    {
        if(s[ Y[i] ] == '1') Right.push_back( Y[i] );
    }
    nx = Left.size();
    ny = Right.size();
    for( i = 0; i< nx; ++i)
    {
        for( j = 0;j< ny; ++j)
        {
            int x = Left[i],y = Right[j];
            map[i][j] = -g[x][y];
        }
    }
    int sum = KM();
    for(i = 0; i < nx; ++i)
    {
        int v = Right[i] ;
        int u = Left[ linker[i] ];
        Pair[u] = v; Pair[v] = u;//1 0
    }
    return -sum;
}
void GetAns(int u,int v)
{
    int i, j, k;
    if(s[u] != '0') swap( u, v);
    vector<int> &p = path[u][v];
    for(i = 0; i < p.size(); i = j)
    {
        for(j = i; j<p.size() && s[ p[j] ] == '0'; ++j); //路上第一个'1'
        if(j == p.size()) break;
        for(k = j; k > i; --k)
        {
            Ans[ans++] = make_pair(p[k], p[k - 1]);
            swap(s[ p[k] ],s[ p[k-1] ]);
        }
    }
}
int solve(int st)//当前连通分支 
{
    int i, zero = 0, col0 = 0;
    X.clear(); Y.clear();
    if(!BFS(st, 0)) return 0;//染色 
    for(i = 0; i < X.size(); ++i)
    {
        if(s[X[i]] == '0') ++zero;
    }
    for(i = 0; i < Y.size(); ++i)
    {
        if(s[Y[i]] == '0') ++zero; 
    }
    int sum1=INF,sum2=INF;
    if(zero == Y.size() )// '0' 与 0 的数目相等，X中'0'与Y中'1'对换 
    {
        sum1 = GetSum(X, Y, Pair1);
    }
    if(zero == X.size() )// '0' 与 1 的数目相等，X中'1'与Y中'0'对换 
    {
        sum2 = GetSum(Y, X, Pair2);
    }
    if(sum1 == INF && sum2 == INF) return 0;
    if(sum1 < sum2) Pair = Pair1;
    else Pair = Pair2;
    for(i=0;i<X.size(); ++i)
    {
        if(Pair[ X[i] ] != -1)  GetAns(X[i], Pair[ X[i] ]);
    }
    return 1;
}
int main()
{
    int i,j,t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d%s", &n, &m, s+1);
        for(i = 1; i <= n; ++i) G[i].clear();
        for(i = 1; i <= n; ++i)
        {
            for(j = 1; j <= n; ++j)
            {
                g[i][j] = INF;
            }
        }
        for(i = 1;i <= m; ++i)
        {
            int x,y;
            scanf("%d%d", &x, &y);
            G[x].push_back(y);
            G[y].push_back(x);
        }
        for(i = 1; i <= n; ++i)
            for(j = 1; j <= n; ++j) 
                path[i][j].clear();
        for(i = 1; i <= n; ++i) GetPath(i);//最短路 
        for(i = 1; i <= n; ++i) 
        {
            Pair1[i] = Pair2[i] = col[i] = -1;
        }
        bool flag=1;
        ans = 0;
        for(i = 1;i <= n; ++i)//对每个连通分支 
        {
            if(col[i]==-1&&!solve(i))
            {
                flag = 0; break;
            }
        }
        if(!flag)
        {
            puts("-1"); continue;
        }
        printf("%d
",ans);
        for(i = 0; i< ans ;++i)
            printf("%d %d
",Ans[i].first, Ans[i].second);
    }
    return 0;
}