T1
解题思路
这题应该不是很难，主要是题意理解问题。
注意给出的两个数组里映射关系已经对应好了，只要判断是否为双射即可
参考程序
#include <bits/stdc++.h>
using namespace std;
class RelationClassifier {
public:
string isBijection( vector <int> domain, vector <int> range );
};
int reflect[110], used[110];
string RelationClassifier::isBijection(vector <int> domain, vector <int> range) {
int n = domain.size();
memset(reflect, 255, sizeof(reflect));
memset(used, 255, sizeof(used));
for(int i = 0; i < n; i++){
if(reflect[domain[i]] != -1 && reflect[domain[i]] != range[i]) return "Not";
if(used[range[i]] != -1 && reflect[domain[i]] != range[i]) return "Not";
reflect[domain[i]] = range[i];
used[range[i]] = 1;
}
return "Bijection";
}
T2
解题思路
首先理解题目中的两个操作的意思。
将点都向同一个方向移动相等距离，就是人可以在坐标系里随意走；可以将所有点旋转一个角度，就是人可以任意转动。那么我们只要找出一组互相垂直的直线，使它们穿过尽量多的点。
由于n的范围只有50，我们考虑最为暴力的做法。
首先枚举两个相异点 A 和 B，确定一条直线，再取异于A和B的点C，确定另一条垂线，最后扫一遍所有点就好了。
注意这里的特殊情况：A和B横或纵坐标相等时特判（斜率的做法，同时还要注意精度）；n小于等于3的时候答案就是n。
据说有大佬会此题不用浮点运算的做法，欢迎评论指出。
参考程序
#include <bits/stdc++.h>
using namespace std;
class PlaneGame {
public:
int bestShot( vector <int> x, vector <int> y );
};
long double k1, b1, k2, b2;
int t, ans;
int PlaneGame::bestShot(vector <int> x, vector <int> y) {
int n = x.size();
if(n <= 2) return n;//特判
ans = 0;
for(int i = 0; i < n - 1; i++)
for(int j = i + 1; j < n; j++)
for(int k = 0; k < n; k++){
if(i == k || j == k) continue;
if(x[i] != x[j] && y[i] != y[j]){
k1 = (long double)(y[j] - y[i]) / (long double)(x[j] - x[i]);
b1 = (long double)y[i] - k1 * (long double)x[i];
k2 = -1.0/k1;
b2 = (long double)y[k] - k2 * (long double)x[k];//两条直线的信息
t = 0;
for(int l = 0; l < n; l++)
if(abs((long double)y[l] - (k1 * x[l] + b1)) <= 0.0001 || abs((long double)y[l] - (k2 * x[l] + b2)) <= 0.0001) t++;//注意精度误差
ans = max(ans, t);
continue;
}
if(y[i] == y[j]){//特判
t = 0;
for(int l = 0; l < n; l++)
if(y[l] == y[i] || x[l] == x[k]) t++;
ans = max(ans, t);
continue;
}
if(x[i] == x[j]){
t = 0;
for(int l = 0; l < n; l++)
if(x[l] == x[i] || y[l] == y[k]) t++;
ans = max(ans, t);
continue;
}
}
return ans;
}
T3
解题思路
首先我们简化问题。如果祖先关系形成一棵树，那么问题就变成了十分简单的树形DP，相信大家都会做。
那么我们看看这道题的麻烦之处。这里有至多15个点有两个父亲。所以再按照原先的做法，有两个父亲的节点的子树就会被计算两次。
如何解决这个问题？最朴素的想法，可能就是切掉和其中一个父亲的关系，使它变为一棵树。但是问题又来了，这样无法维护和那个父亲间的关系（如果那个父亲不选，那么这个点就必须选啊qwq）。所以，这时候15这个数就派上用场了。由于它比较小，所以我们直接暴力枚举有两个父亲的节点，规定它们必须选，或者必须不选。如果我们认定这个节点必须不选，那么它的两个父亲就必须选了。
解决了？不，还有一个问题。仔细思考一下，发现删边也不能乱删。我们必须删指向深度较小的父亲的那条边。
至此，问题解决。最坏时间复杂度 (O(2^{15}*100)) 然而由于十分暴力，最慢的点跑了1.2秒（然而时限是两秒qwq）。如果有大佬有更好的做法，可以在品论区提出。
参考程序
程序中通过按最大深度排序及打标记实现删边。
#include <bits/stdc++.h>
using namespace std;
class VampireTreeDiv2 {
public:
int countMinSamples( vector <int> A, vector <int> B );
};
const long long mod = 1000000007;
long long n, cnt;
long long lp, f[1010], lin[2010], nxt[2010], deep[1010];
inline void add(long long x, long long y) { lin[++lp] = y; nxt[lp] = f[x]; f[x] = lp; return; }
void get_deep(long long pos, long long father){
deep[pos] = deep[father] + 1;
for(long long t = f[pos]; t; t = nxt[t])
if(deep[lin[t]] < deep[pos] + 1 && lin[t] != father) get_deep(lin[t], pos);
return;
}
struct Node{
long long deep, pos;
Node(long long deep_ = 0, long long pos_ = 0) { deep = deep_; pos = pos_; return; }
};
Node aa[1010];
bool cmp(Node x, Node y){
return x.deep > y.deep;
}
long long rec[1010], recc[1010];
long long caculated[1010];//标记
long long dp[1010][2], c[1010][2];//dp[i][0]表示i不选，dp[i][1]表示i选，c数组维护方案数
long long t;
long long ans, minnum;
int VampireTreeDiv2::countMinSamples(vector <int> A, vector <int> B) {
n = A.size();
cnt = 0;
memset(f, 0, sizeof(f));
lp = 0;
for(long long i = 0; i < n; i++){
add(A[i], i + 1);
if(B[i] != -1){
add(B[i], i + 1);
rec[++cnt] = i + 1;
}
}
ans = 0; minnum = 100010;
memset(deep, 0, sizeof(deep));
get_deep(0, 0);
for(long long i = 0; i <= n; i++) aa[i] = Node(deep[i], i);
sort(aa, aa + n + 1, cmp);//按最大深度排序
for(long long i = 0; i < (1 << cnt); i++){
memset(recc, 0, sizeof(recc));
memset(caculated, 0, sizeof(caculated));
for(long long j = 1; j <= cnt; j++)
if((i >> (j - 1)) & 1)
recc[rec[j]] = 1; else recc[rec[j]] = 2;
for(long long j = 0; j <= n; j++){
t = aa[j].pos;
dp[t][0] = 0; dp[t][1] = 1;
c[t][0] = 1; c[t][1] = 1;
for(long long k = f[t]; k; k = nxt[k]){
if(caculated[lin[k]]){
if(dp[lin[k]][1] > 100000){
dp[t][0] = 100010;
c[t][0] = 0;
}
continue;
}
if(recc[lin[k]] != 0) caculated[lin[k]] = 1;
dp[t][0] += dp[lin[k]][1];
c[t][0] = (c[t][0] * c[lin[k]][1]) % mod;
if(dp[lin[k]][0] < dp[lin[k]][1]){
dp[t][1] += dp[lin[k]][0];
c[t][1] = (c[t][1] * c[lin[k]][0]) % mod;
}
if(dp[lin[k]][0] > dp[lin[k]][1]){
dp[t][1] += dp[lin[k]][1];
c[t][1] = (c[t][1] * c[lin[k]][1]) % mod;
}
if(dp[lin[k]][0] == dp[lin[k]][1]){
dp[t][1] += dp[lin[k]][1];
c[t][1] = (c[t][1] * ((c[lin[k]][0] + c[lin[k]][1]) % mod)) % mod;
}
}
if(recc[t] == 1) dp[t][0] = 100010, c[t][0] = 0;
if(recc[t] == 2) dp[t][1] = 100010, c[t][1] = 0;
}
if(dp[0][0] < minnum){
minnum = dp[0][0];
ans = c[0][0];
} else
if(dp[0][0] == minnum) ans = (ans + c[0][0]) % mod;
if(dp[0][1] < minnum){
minnum = dp[0][1];
ans = c[0][1];
} else
if(dp[0][1] == minnum) ans = (ans + c[0][1]) % mod;
}
return ans;
}