topcoder srm 685 div1
problem1 link
依次枚举每个元素$x$，作为$S$中开始选择的第一个元素。对于当前$S$中任意两个元素$i,j$，若$T[i][j]$不在$S$中，则将其加入$S$，然后继续扩展；若所有的$T[i][j]$都在$S$中，则结束扩展。每次扩展结束之后保存$|S|$的最小值。
problem2 link
总的思路是搜索，分别枚举每一条边是在哪个集合中，进行如下的优化：
（1）使用并查集，当其中两个集合都联通时结束；当有一个集合联通时，直接判断剩下所有的边加入另一个集合能否使得另一个集合联通；
（2）如果当前剩下所有的边都加入到其中一个集合都不能使其联通时，结束搜索返回；
（3）当前边加入第一个集合使其联通分量减少时才进行加入的操作，否则不再继续搜索下去，而将其直接加入另一个集合。
problem3 link
随即生成1000个点数为12个图，然后计算最小生成树的个数。假设可以从中选出四个（可能是相同的）然后串联起来，那么答案就是$A_{1}*A_{2}*A_{3}*A_{4}$。$A_{i}$为选出的第$i$个图的最小生成树的个数。
code for problem1
#include <algorithm>
#include <vector>
class MultiplicationTable2 {
public:
int minimalGoodSet(const std::vector<int> &a) {
int n2 = static_cast<int>(a.size());
int n = 1;
while (n * n != n2) {
++n;
}
std::vector<std::vector<int>> g(n, std::vector<int>(n));
auto Compute = [&](int x) {
if (g[x][x] == x) {
return 1;
}
std::vector<int> s;
std::vector<bool> h(n);
s.push_back(x);
h[x] = true;
while (true) {
bool ok = true;
std::vector<int> ns = s;
for (size_t i = 0; i < s.size(); ++i) {
for (size_t j = 0; j < s.size(); ++j) {
int k = g[s[i]][s[j]];
if (!h[k]) {
h[k] = true;
ns.push_back(k);
ok = false;
}
}
}
if (ok) {
break;
}
s = ns;
}
return static_cast<int>(s.size());
};
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
g[i][j] = a[i * n + j];
}
}
int result = n;
for (int i = 0; i < n; ++i) {
result = std::min(result, Compute(i));
}
return result;
}
};
code for problem2
#include <string>
#include <vector>
constexpr int kMaxN = 10;
struct UnionSet {
int a[kMaxN];
int cnt;
int n;
void Init(int n) {
this->n = n;
for (int i = 0; i < n; ++i) {
a[i] = i;
}
cnt = 0;
}
int Get(int x) {
if (a[x] != x) {
a[x] = Get(a[x]);
}
return a[x];
}
bool Update(int x, int y) {
x = Get(x);
y = Get(y);
if (x == y) {
return false;
}
if (x < y) {
a[y] = x;
} else {
a[x] = y;
}
++cnt;
return true;
}
bool OK() { return cnt == n - 1; }
};
int n, m;
std::vector<int> a, b;
bool Check(UnionSet s, int id) {
if (s.OK()) {
return 1;
}
if (id >= m) {
return 0;
}
for (int i = id; i < m && !s.OK(); ++i) {
s.Update(a[i], b[i]);
}
return s.OK();
}
bool Dfs(int id, UnionSet s1, UnionSet s2) {
if (s1.OK() && s2.OK()) {
return 1;
}
if (s1.OK()) {
return Check(s2, id);
}
if (s2.OK()) {
return Check(s1, id);
}
if (!Check(s1, id) || !Check(s2, id)) {
return false;
}
if (id >= m) {
return false;
}
while (id < m) {
if (s1.Get(a[id]) != s1.Get(b[id])) {
UnionSet new_s1 = s1;
new_s1.Update(a[id], b[id]);
if (Dfs(id + 1, new_s1, s2)) {
return 1;
}
}
s2.Update(a[id], b[id]);
++id;
}
return false;
}
class FoxAirline2 {
public:
std::string isPossible(int node_number, const std::vector<int> &ea,
const std::vector<int> &eb) {
n = node_number;
a = ea;
b = eb;
m = static_cast<int>(a.size());
UnionSet s1, s2;
s1.Init(n);
s2.Init(n);
if (Dfs(0, s1, s2)) {
return "Possible";
}
return "Impossible";
}
};
code for problem3
#include <cstdlib>
#include <ctime>
#include <unordered_map>
#include <vector>
class MSTCounter {
public:
static int Pow(long long a, int b, int mod) {
long long result = 1;
while (b > 0) {
if (b % 2 == 1) {
result = result * a % mod;
}
a = a * a % mod;
b /= 2;
}
return static_cast<int>(result);
}
static int Solver(const std::vector<std::vector<bool>> &g, int mod) {
int n = static_cast<int>(g.size());
std::vector<std::vector<int>> a(n, std::vector<int>(n));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i != j && g[i][j]) {
a[i][j] = mod - 1;
a[i][i] += 1;
}
}
}
bool tag = false;
for (int i = 1; i < n; ++i) {
int k = 0;
for (int j = i; j < n; ++j) {
if (a[j][i] != 0) {
k = j;
break;
}
}
if (i != k) {
tag = !tag;
std::swap(a[i], a[k]);
}
for (int j = i + 1; j < n; ++j) {
long long t = 1ll * a[j][i] * Pow(a[i][i], mod - 2, mod) % mod;
for (int k = i; k < n; ++k) {
a[j][k] = static_cast<int>(mod - t * a[i][k] % mod + a[j][k]) % mod;
}
}
}
long long result = 1;
for (int i = 1; i < n; ++i) {
result = result * a[i][i] % mod;
}
if (tag) {
result = mod - result;
}
return static_cast<int>(result);
}
};
static constexpr int kMod = 1000000007;
static constexpr int kNode = 12;
static constexpr int kSampleNumber = 1024;
struct Graph {
std::vector<std::vector<bool>> g;
int result;
void Construct() {
g.resize(kNode);
for (int i = 0; i < kNode; ++i) {
g[i].resize(kNode);
}
for (int i = 0; i < kNode; ++i) {
for (int j = i + 1; j < kNode; ++j) {
bool t = (std::rand() & 1) == 1;
g[i][j] = g[j][i] = t;
}
}
result = MSTCounter::Solver(g, kMod);
}
void GetResult(int n, int start, std::vector<int> *result) {
for (int i = 0; i < kNode; ++i) {
for (int j = i + 1; j < kNode; ++j) {
if (g[i][j]) {
int u = i + start;
int v = j + start;
result->push_back(u * n + v);
}
}
}
}
};
Graph graph[kSampleNumber];
class InverseMatrixTree {
public:
std::vector<int> constructGraph(int r) {
if (r == 0) {
return {2};
}
std::srand(std::time(nullptr));
for (int i = 0; i < kSampleNumber; ++i) {
graph[i].Construct();
}
std::unordered_map<int, std::pair<int, int>> mapper;
for (int i = 0; i < kSampleNumber; ++i) {
for (int j = i; j < kSampleNumber; ++j) {
int key =
static_cast<int>(1ll * graph[i].result * graph[j].result % kMod);
if (key != 0) {
mapper[key] = {i, j};
}
}
}
for (const auto &e : mapper) {
int key0 = e.first;
int key1 = static_cast<int>(1ll * r *
MSTCounter::Pow(key0, kMod - 2, kMod) % kMod);
if (mapper.count(key1)) {
int t[4] = {e.second.first, e.second.second, mapper[key1].first,
mapper[key1].second};
int n = kNode * 4;
std::vector<int> result = {n};
for (int i = 0; i < 4; ++i) {
graph[t[i]].GetResult(n, kNode * i, &result);
if (i > 0) {
int u = kNode * i;
int v = u - 1;
result.push_back(u * n + v);
}
}
return result;
}
}
return {};
}
};
参考
http://uoj.ac/problem/75
http://vfleaking.blog.uoj.ac/blog/180
