problem1 link
最后剩下的是中间的一个矩形．所以可以直接枚举这个矩形，如果它含有的硬币个数等于$K$，则再计算移动的最少次数，更新答案．
problem2 link
首先，每个节点发送每种消息最多只发送一次；其次，在得到消息之后一定是马上发送而不是等待一会儿再发送；最后一点是，如果第$i$天发送了一种消息，一定可以在第$i+1$天发送另外一种消息．
现在的问题是，一个节点同时有两种消息时，应该首先发送哪一种．这个可以$2^{n}$枚举第一次发送的消息类型，然后模拟即可．在模拟过程中可能会出现先来的消息不是枚举的第一次发送的类型．这个可以直接结束这种情况，因为一定会枚举到一种情况，其他节点都一样，而这个节点是先发送另一种状态．
problem3 link
首先，如果将给出的矩阵看作是$n$个顶点的有向图，那么交换$i,j$行列得到的新图相当于两个顶点交换标号，即顶点$i$变为$j$，顶点$j$变为$i$．
那么题目就是要对给出的图重新标号，使得与目标图匹配．
对于$n=8$来说，如果画出目标图，是下面的样子：
设$p_{i}$表示目标图的第$i$个顶点是原图的第$p_{i}$个顶点．那么对于$n=8$来说，确定了$p_{0},p_{1},p_{n-1}$后，与$p_{1}$相连且不与$p_{n-1}$相连的就是$p_{2}$，同时与$p_{1}$和$p_{n-1}$相连的是$p_{6}$．
也就是说由$p_{1},p_{7}$可找到$p_{2},p_{6}$．同理，由$p_{2},p_{6}$可找到$p_{3},p_{5}$，最后就是$p_{4}$.查找的过程如下图所示（第一幅图找到$p_{2},p_{6}$，第二幅图找到$p_{3},p_{5}$）
最后一个问题就是如果有了这个数组$p$，求最少的交换次数．$p$中的数组组成了若干个环，对于每个环$C$，需要的交换次数为$|C|-1$
code for problem1
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
class DropCoins {
public:
int getMinimum(vector <string> board, int K) {
const int n = (int)board.size();
const int m = (int)board[0].size();
int result = -1;
vector<vector<int>> f(n + 1, vector<int>(m + 1, 0));
for (int i = 1; i <= n; ++ i) {
for (int j = 1; j <= m; ++ j) {
f[i][j] = f[i - 1][j] + f[i][j - 1] - f[i - 1][j - 1];
if (board[i - 1][j - 1] == 'o') {
++ f[i][j];
}
}
}
for (int left = 1; left <= m; ++ left) {
for (int right = left; right <= m; ++ right) {
for (int up = 1; up <= n; ++ up) {
for (int down = up; down <= n; ++ down) {
int cnt = f[down][right] - f[down][left - 1] - f[up - 1][right]
+ f[up - 1][left - 1];
if (cnt == K) {
int cost = Cost(left - 1, m - right) + Cost(up - 1, n - down);
if (result == -1 || result > cost) {
result = cost;
}
}
}
}
}
}
return result;
}
private:
int Cost(int x, int y) {
return std::min(x + x + y, x + y + y);
}
};
code for problem2
#include <iostream>
#include <string>
#include <vector>
using namespace std;
class Rumor {
public:
int getMinimum(string knowledge, vector<string> graph)
{
const int n = (int)graph.size();
int result = -1;
for (int mask = 0; mask < (1 << n); ++ mask) {
int cost = calculate(mask, knowledge, graph);
if (cost != -1 && (result == -1 || result > cost)) {
result = cost;
}
}
return result;
}
private:
int getFirstType(int mask, int i) {
return (mask & (1 << i)) ? 2 : 1;
}
int getSecondType(int mask, int i) {
return (mask & (1 << i)) ? 1 : 2;
}
int calculate(const int mask, const string& knowledge,
const vector<string>& graph) {
const int n = (int)knowledge.size();
long long preGetMessageState = 0;
long long currentKnowMessageState = 0;
int preBroadcastMask = 0;
int day = 0;
for (int i = 0; i < n; ++ i) {
if (knowledge[i] == 'Y') {
preGetMessageState |= 3ll << (i << 1);
}
}
int sendedMessageMask = 0;
currentKnowMessageState = preGetMessageState;
const long long finalState = (1ll << (n + n)) - 1;
while (currentKnowMessageState != finalState) {
++ day;
int nowBroadcastState = 0;
long long nowGetMessageState = 0;
for (int i = 0; i < n; ++ i) {
int type = -1;
if (preBroadcastMask & (1 << i)) {
type = getSecondType(mask, i);
}
else if (!(sendedMessageMask & (1 << i))) {
int t = (preGetMessageState >> (i + i)) & 3;
if (t != 0) {
if (t & getFirstType(mask, i)) {
type = getFirstType(mask, i);
}
else {
return -1;
}
}
}
if (type == -1) {
continue;
}
for (int j = 0; j < n; ++ j) {
if (graph[i][j] == 'Y') {
nowGetMessageState |= ((long long)type) << (j + j);
}
}
if (type == getSecondType(mask, i)) {
sendedMessageMask |= 1 << i;
}
else {
nowBroadcastState |= 1 << i;
}
}
long long currentAll = currentKnowMessageState | nowGetMessageState;
if (currentAll == currentKnowMessageState) {
return -1;
}
currentKnowMessageState = currentAll;
preGetMessageState = nowGetMessageState;
preBroadcastMask = nowBroadcastState;
}
return day;
}
};
code for problem３
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
class MonochromePuzzle {
public:
int getMinimum(vector <string> board) {
const int n = (int)board.size();
for (int i = 0; i < n; ++ i) {
int cnt = 0;
for (int j = 0; j < n; ++ j) {
if (board[i][j] == '#') {
++ cnt;
}
}
if (cnt != 3) {
return -1;
}
}
int result = -1;
for (int i = 0; i < n; ++ i) {
for (int j = 0; j < n; ++ j) {
if (i == j) {
continue;
}
for (int k = 0; k < n; ++ k) {
if (k == i || k == j) {
continue;
}
if (board[i][j] != '#' || board[i][k] != '#') {
continue;
}
int tmp = calculate(i, j, k, board);
if (tmp != -1 && (result == -1 || result > tmp)) {
result = tmp;
}
}
}
}
return result;
}
private:
int calculate(const int p0, const int p1, const int p2,
const vector<string>& board) {
const int n = (int)board.size();
vector<int> p(n, 0);
vector<int> used(n, 0);
p[0] = p0;
p[1] = p1;
p[n - 1] = p2;
used[p0] = used[p1] = used[p2] = 1;
int x = 1, y = n - 1;
int a = 2, b = n - 2;
while (a < b) {
int ta = -1, tb = -1;
for (int i = 0; i < n; ++ i) {
if (used[i] == 0 && board[p[x]][i] == '#') {
if (board[p[y]][i] == '#') {
tb = i;
}
else {
ta = i;
}
}
}
if (ta == -1 || tb == -1) {
return -1;
}
p[a] = ta;
p[b] = tb;
used[ta] = used[tb] = 1;
x = a ++;
y = b --;
}
for (int i = 0; i < n; ++ i) {
if (used[i] == 0 && board[p[x]][i] == '#' &&
board[p[y]][i] == '#' && board[p[n - 1]][i] == '#') {
p[a] = i;
return getCost(p);
}
}
return -1;
}
int getCost(const vector<int>& p) {
const int n = (int)p.size();
vector<int> visited(n, 0);
int result = n;
for (int i = 0; i < n; ++ i) {
if (visited[i]) {
continue;
}
int current = i;
while (visited[current] == 0) {
visited[current] = 1;
current = p[current];
}
result -= 1;
}
return result;
}
};