SRM589

250:

给一个串S，可以做这样的操作，可以将串中的一种字母变成另一种字母，代价是该种字母的数量。求解的问题是，最小的代价将串S变成回文串。

根据回文关系，我们可以形成等价对应关系，a与b等价对应说明a和b必须是同种字母，根据这个关系，我们可以得到一个图，每个连通块表示要变成一种相同的字母，而这个操作的最小代价就是将连通块中除出现次数最多的字母全部都转变成出现次数最多的字母。

#include <iostream>
#include <vector>
#include <string>
#include <cstring>
using namespace std;

bool mm[256][256];
int cnt[256];
bool used[256];

class GooseTattarrattatDiv1 {
public:
    int getmin(string S) {
        memset(cnt, 0, sizeof(cnt));
        memset(mm, false, sizeof(mm));
        memset(used, false, sizeof(used));
        int n = S.size();
        for (int i = 0; i < n; i++) {
            mm[S[i]][S[n - 1 - i]] = true;
            mm[S[n - 1 - i]][S[i]] = true;
            cnt[S[i]]++;
        }
        int res = 0;
        for (int i = 0; i < 256; i++) {
            int sum = 0, max = 0;
            
            dfs(i, sum, max);
            res += (sum - max);
        }
        return res;
    }
    void dfs(int i, int& sum, int& max) {
        used[i] = true;
        sum += cnt[i];
        if (cnt[i] > max) max = cnt[i];
        
        for (int j = 0; j < 256; j++) {
            if (mm[i][j] && used[j] == false) {
                dfs(j, sum, max);
            }
        }
    }
};

500:

有R,G,B三种齿轮，不同颜色齿轮之间不会相接，相接的关系通过graph给出，同种颜色齿轮旋转方向相同，旋转方向一共有两种：顺时针与逆时针。求解如何去掉最少的齿轮使得该graph能相容，即可以找到某种旋转顺序使得不会发生矛盾（矛盾指相接的两个齿轮旋转方向相同）。

同种颜色的点归于一个集合，因此我们有三个集合，R，G，B，集合内的点不会有边，这个图由三个二分图组成，因为有3个集合，枚举一下齿轮的旋转方向，一共有三种情况：RG同向，GB同向，BR同向。于是问题转换成这三种情况中旋转最小值，对于每个情况，去掉最少的齿轮使其不矛盾便是一个最小点覆盖问题，二分图的最小点覆盖可以转变成二分图的最大匹配问题。

#include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

class GearsDiv1 {
private:
    vector<int> left, right;
    vector<string> G;
    bool s[55];
    int link[55];
public:
    int getmin(string color, vector <string> graph) {
        vector<int> r, g, b;
        for (int i = 0; i < color.length(); i++) {
            if (color[i] == 'R') r.push_back(i);
            else if (color[i] == 'G') g.push_back(i);
            else if (color[i] == 'B') b.push_back(i);
        }
        int rg = max_bimatch(r, g, graph);
        int gb = max_bimatch(g, b, graph);
        int br = max_bimatch(b, r, graph);
        return min(rg, min(gb, br));
    }
    int max_bimatch(vector<int> l, vector<int> r, vector<string> graph) {
        //
        left = l; right = r; G = graph;
        
        int res = 0;
        memset(link, -1, sizeof(link));
        for (int i = 0; i < left.size(); i++) {
            memset(s, false, sizeof(s));
            if (dfs(i)) res++;
        }
        
        return res;
    }
    bool dfs(int i) {
        for (int j = 0; j < right.size(); j++) {
            if (G[left[i]][right[j]] == 'Y' && s[right[j]] == false) {
                s[right[j]] = true;
                if (link[right[j]] == -1 || dfs(link[right[j]])) {
                    link[right[j]] = i;
                    return true;
                }
            }
        }
        return false;
    }
};