第30次CCF计算机软件能力认证
100+100+100+80+100=480
重复局面
题目大意
依次给定\(n\)个国际象棋局面，依次回答每个局面是第几次出现。
解题思路
拿map记录下每个局面，统计计数即可。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
int n;
cin >> n;
map<string, int> qwq;
while(n--){
string s;
for(int i = 0; i < 8; ++ i){
string a;
cin >> a;
s += a;
}
qwq[s] ++;
cout << qwq[s] << '\n';
}
return 0;
}
矩阵运算
题目大意
给定\(n \times d\)的矩阵 \(q, k, v\)，一个 \(n\)维向量 \(w\)，计算 \((w \cdot (q \times k^{T})) \times v\) 的结果。
\(n \leq 10^4, d \leq 20\)
解题思路
\(q \times k^{T}\)的结果是 \(n \times n\)的矩阵，因为计算结果可能会超出 \(int\)范围， \(10^8\)的 \(long long\)内存有 \(700MB+ \geq 512MB\)，因此不能按此计算。
注意矩阵乘法具有结合律，而且点乘 \(\cdot\)不会影响此处的结果，因此我们可以改为算 \(w \cdot q \times (k^{T} \times v)\) ，这样\(k^{T} \times v\)只有 \(d \times d\)的大小，完全可以储存和计算。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
int n, d;
cin >> n >> d;
vector<vector<LL>> q(n, vector<LL>(d, 0)), k(n, vector<LL>(d, 0)), v(n, vector<LL>(d, 0));
vector<LL> w(n, 0);
for(auto &i : q)
for(auto &j : i)
cin >> j;
for(auto &i : k)
for(auto &j : i)
cin >> j;
for(auto &i : v)
for(auto &j : i)
cin >> j;
for(auto &i : w)
cin >> i;
vector<vector<LL>> tmp(d, vector<LL>(d, 0)), tmp2(n, vector<LL>(d, 0));
for(int i = 0; i < n; ++ i)
for(int j = 0; j < d; ++ j)
for(int z = 0; z < d; ++ z){
tmp[j][z] += k[i][j] * v[i][z];
}
for(int i = 0; i < d; ++ i)
for(int j = 0; j < n; ++ j)
for(int z = 0; z < d; ++ z){
tmp2[j][z] += q[j][i] * tmp[i][z];
}
for(int i = 0; i < n; ++ i)
for(int j = 0; j < d; ++ j)
tmp2[i][j] *= w[i];
for(int i = 0; i < n; ++ i)
for(int j = 0; j < d; ++ j)
cout << tmp2[i][j] << " \n"[j == d - 1];
return 0;
}
解压缩
题目大意
给定了一个压缩后的数据，以及解压的规则，输出解压后的数据。
解题思路
就按照规则模拟即可，注意大端模式和小端模式的数据解析。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define LOWER 3
#define CONST_VAL 0
#define BACK_SHORT 1
#define BACK_LONG 2
LL get_num(char c){
if (isdigit(c))
return c - '0';
else
return c - 'a' + 10;
}
LL get_sz(const string& s, int& pos, int len){
LL sum = 0;
for(int i = pos; i < pos + len; ++ i){
sum = sum * 16 + get_num(s[i]);
}
pos += len;
return sum;
}
LL get_sz_small(const string& s, int& pos, int len){
LL sum = 0;
LL ji = 1;
for(int i = pos; i < pos + len;){
sum = sum + ji * get_sz(s, i, 2);
ji <<= 8;
}
pos += len;
return sum;
}
string get_string(const string& s, int& pos, int len){
string tmp = s.substr(pos, len);
pos += len;
return tmp;
}
bool up_zero(LL num){
return !((num >> 7) & 1);
}
LL remove_up(LL num){
if (up_zero(num))
return num;
else
return num ^ (1 << 7);
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
int n;
cin >> n;
n = (n + 7) / 8;
string s;
for(int i = 0; i < n; ++ i){
string a;
cin >> a;
s += a;
}
int id = 0;
LL sz = 0;
LL ji = 1;
while(true){
int sign = get_sz(s, id, 2);
sz += ji * remove_up(sign);
ji *= 128;
if (up_zero(sign)){
break;
}
}
string ans;
while(ans.size() < sz * 2){
int sign = get_sz(s, id, 2);
if ((sign & LOWER) == CONST_VAL){
int len = (sign >> 2);
if (len < 60){
++ len;
ans += get_string(s, id, len * 2);
}else{
len = get_sz_small(s, id, (len - 60 + 1) * 2);
++ len;
ans += get_string(s, id, len * 2);
}
}else if ((sign & LOWER) == BACK_SHORT){
int len = ((sign >> 2) & 7) + 4;
int o = ((sign >> 5) << 8) + get_sz(s, id, 2);
len *= 2;
o *= 2;
if (o >= len){
ans += ans.substr(ans.size() - o, len);
}else{
int pos = ans.size() - o;
string tmp;
while(len){
tmp += ans[pos];
pos ++;
if (pos == ans.size())
pos -= o;
-- len;
}
ans += tmp;
}
}else if ((sign & LOWER) == BACK_LONG){
int len = (sign >> 2) + 1;
int o = get_sz_small(s, id, 4);
len *= 2;
o *= 2;
if (o >= len){
ans += ans.substr(ans.size() - o, len);
}else{
int pos = ans.size() - o;
string tmp;
while(len){
tmp += ans[pos];
pos ++;
if (pos == ans.size())
pos -= o;
-- len;
}
ans += tmp;
}
}
}
for(int i = 0; i < ans.size(); ++ i){
if (i && i % 16 == 0)
cout << '\n';
cout << ans[i];
}
return 0;
}
电力网络
题目大意
给定一张\(n\)个点 \(m\)条边的无向连通图，要求给每个点规定一个颜色，共有\(k\)种颜色可选，使得总代价最小。
总代价包括点的代价和边的代价，点的代价即选定该点的颜色对应的代价。边的代价由每条边两点颜色决定，以矩阵形式给出。
五个子任务：
- 点数\(\leq 6\)，颜色数 \(\leq 10\)
- 点数 \(\leq 10^4\)，颜色数 \(\leq 10\)，一棵树
- 点数 \(\leq 10^4\)，颜色数 \(\leq 10\)，一棵基环树
- 点数 \(\leq 10^4\)，颜色数 \(\leq 10\)，一个图，但去掉其中的某个点\(D\)及其连边，变成一棵树，且与点\(D\)相连的点都是以某个点 \(S\)为根的叶子
- 点数 \(\leq 10^4\)，颜色数 \(\leq 10\)，一个图，但度数\(> 2\)的点数 \(\leq 6\)
解题思路
第一个子任务，直接暴力，枚举每个点的颜色然后求代价的最小值，复杂度为\(O(k^n + n + m)\)
第二个子任务，设\(dp[i][j]\)表示 点\(i\) 的颜色为\(j\)的最小代价，枚举儿子的颜色，树形\(dp\)转移。复杂度为\(O(nk^2)\)
第三个子任务，找到环上的任意一条边\((u, v)\)，枚举 \(u\)的颜色（消除后效性），然后以 \(v\)为根( \(u\)也行）做上述树形 \(dp\)即可。复杂度为\(O(nk^3)\)，如何找到环上一条边，跑一下并查集即可。
第四个子任务，找到点\(D\)，然后枚举点\(D\)的颜色（同样消除后效性），然后以不与点\(D\)有连边的点\(s\)做上述树形 \(dp\)即可。复杂度为\(O(nk^3)\)，如何找到点\(D\)，首先统计每个点的度数，点\(D\)的度数\(d\)满足 \(m - d = n - 2\)（数据可能水了，有这个条件就够了，感觉单满足这个条件还不够，可能会存在把 点\(D\)去掉后不联通），然后与点 \(D\)相连的点的度数都为 \(2\)（为叶子）
第五个子任务，如果全部度数\(<= 2\)，那么随便枚举一个点的颜色，然后上述树形 \(dp\)即可。否则找到度数\(> 2\)的点，剩下的都是度数为\(2,1\)的点，它们仅可能形成一条链（不可能是环），然后\(C_6^2\)枚举每条链，再花 \(O(k)\)枚举每条链的一端颜色，做一遍上述树形 \(dp\)，然后再枚举每个度数 \(> 2\)的颜色，求最小值。复杂度为 \(O(k^6 + nk^3)\)，但感觉不太好写，也没时间写了（
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const LL inf = 1e18;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
int n, k, m;
cin >> n >> m >> k;
vector<vector<int>> pcost(n, vector<int>(k));
for(auto &i : pcost)
for(auto &j : i)
cin >> j;
vector<vector<array<int, 2>>> edge(n);
vector<array<int, 2>> edges(m);
vector<vector<int>> ecost(m, vector<int>(k * k));
for(int i = 0; i < m; ++ i){
int u, v;
cin >> u >> v;
edges[i] = {u, v};
edge[u].push_back({v, i});
edge[v].push_back({u, i});
for(auto &j : ecost[i])
cin >> j;
}
if (n <= 6 && k <= 10){
vector<int> used(n);
LL ans = inf;
LL tmp = 0;
function<void(int)> dfs = [&](int x){
if (x == n){
LL back = tmp;
for(int i = 0; i < m; ++ i){
int u = edges[i][0], v = edges[i][1], id = i;
int r = used[u] * k + used[v];
tmp += ecost[id][r];
}
ans = min(ans, tmp);
tmp = back;
return;
}
for(int i = 0; i < k; ++ i){
tmp += pcost[x][i];
used[x] = i;
dfs(x + 1);
tmp -= pcost[x][i];
}
};
dfs(0);
cout << ans << '\n';
}else if (m == n - 1){
vector<vector<LL>> dp(n, vector<LL>(k, 0));
function<void(int, int)> dfs = [&](int u, int fa){
for(auto e : edge[u]){
int v = e[0], id = e[1];
if (v == fa)
continue;
dfs(v, u);
for(int i = 0; i < k; ++ i){
LL tmp = inf;
for(int j = 0; j < k; ++ j){
int L = i, R = j;
if (u != edges[id][0])
swap(L, R);
int r = L * k + R;
tmp = min(tmp, dp[v][j] + pcost[v][j] + ecost[id][r]);
}
dp[u][i] += tmp;
}
}
};
dfs(0, 0);
LL ans = inf;
for(int i = 0; i < k; ++ i)
ans = min(ans, dp[0][i] + pcost[0][i]);
cout << ans << '\n';
}else if (m == n){
vector<int> id(n);
iota(id.begin(), id.end(), 0);
int ignore = 0;
function<int(int)> findfa = [&](int x){
return x == id[x] ? x : id[x] = findfa(id[x]);
};
for(int i = 0; i < m; ++ i){
int u = edges[i][0], v = edges[i][1];
int fu = findfa(u), fv = findfa(v);
if (fu == fv){
ignore = i;
break;
}
id[fu] = fv;
}
vector<vector<LL>> dp(n, vector<LL>(k, 0));
LL ans = inf;
int fixed = edges[ignore][0], st = edges[ignore][1];
for(int col = 0; col < k; ++ col){
for(auto &i : dp)
fill(i.begin(), i.end(), 0);
function<void(int, int)> dfs = [&](int u, int fa){
for(auto e : edge[u]){
int v = e[0], id = e[1];
if (v == fa || id == ignore)
continue;
dfs(v, u);
for(int i = 0; i < k; ++ i){
if (u == fixed && i != col)
continue;
LL tmp = inf;
for(int j = 0; j < k; ++ j){
if (v == fixed && j != col)
continue;
int L = i, R = j;
if (u != edges[id][0])
swap(L, R);
int r = L * k + R;
tmp = min(tmp, dp[v][j] + pcost[v][j] + ecost[id][r]);
}
dp[u][i] += tmp;
}
}
};
dfs(st, st);
for(int i = 0; i < k; ++ i){
int L = i, R = col;
if (st != edges[ignore][0])
swap(L, R);
int r = L * k + R;
ans = min(ans, dp[st][i] + pcost[st][i] + ecost[ignore][r]);
}
}
cout << ans << '\n';
}else{
vector<int> du(n);
for(int i = 0; i < m; ++ i){
int u = edges[i][0], v = edges[i][1];
++ du[u];
++ du[v];
}
int target = 0;
for(int i = 0; i < n; ++ i){
if (m - du[i] == n - 2){
target = i;
break;
}
}
vector<int> forbid(n, 0);
for(auto &e : edge[target]){
int v = e[0];
forbid[v] = 1;
}
int st = 0;
while(st == target || forbid[st])
++ st;
vector<vector<LL>> dp(n, vector<LL>(k, 0));
LL ans = inf;
for(int col = 0; col < k; ++ col){
for(auto &i : dp)
fill(i.begin(), i.end(), 0);
function<void(int, int)> dfs = [&](int u, int fa){
for(auto e : edge[u]){
int v = e[0], id = e[1];
if (v == fa)
continue;
if (v != target)
dfs(v, u);
for(int i = 0; i < k; ++ i){
LL tmp = inf;
for(int j = 0; j < k; ++ j){
if (v == target && j != col)
continue;
int L = i, R = j;
if (u != edges[id][0])
swap(L, R);
int r = L * k + R;
if (v == target){
tmp = min(tmp, 1ll * ecost[id][r]);
}else{
tmp = min(tmp, dp[v][j] + pcost[v][j] + ecost[id][r]);
}
}
dp[u][i] += tmp;
}
}
};
dfs(st, st);
for(int i = 0; i < k; ++ i){
ans = min(ans, dp[st][i] + pcost[st][i] + pcost[target][col]);
}
}
cout << ans << '\n';
}
return 0;
}
闪耀循环
题目大意
给定\(n\)个字符串\(s_i\) 以及一个字符串\(t\)，对于每个字符串\(s_i\)，回答以下问题 ：
依次选择若干个串\(s_j, s_k, s_l, ...\)，组成串 \(s_i,s_j,s_k,s_l,...\)，要求前一串的末尾字母和后一串的开头字母相同，第一个串的开头字母和最后一个串的末尾字母相同，字符串 \(t\)的每个字母都在这些串组成的大串出现过。求最小代价。
代价为每个串的长度 \(-1\)的和。
\(|t| \leq 10\)
解题思路
对于每个串，能够提供的信息就是首末字母和包含的字符串\(t\)的字母情况。
建一张图，点是每个字母，对于一个串 \(s_i = a...b\)，连一条边 \(b \to a\)，边权有两个，一个是串长度 \(-1\)，另一个是包含的字符串 \(t\)的字母情况，因为 \(|t| \leq 10\)，可以二进制位压缩成一个数。
然后设 \(dis[i][j][k]\)表示最终回到点 \(i\)，当前在点 \(j\)，已经获得到的字符串 \(t\)的字母情况为 \(k\)，最终到点 \(i\)且字母情况为满（即包括了 \(t\)的所有字母）的最小代价。
然后从 \(dis[i][i][(1 << |t|) - 1] = 0\)开始 \(dijkstra\)搜。枚举另边，不断消去第三维的值。
对于每个串\(s_i\)的信息\(a, b, sign\)（包含串 \(t\)字母的情况），答案就是\(dis[a][b][c] + |s_i| - 1\)，但由于我们是从终点开始搜的，对于第三维是能消去就先消去，但最后求答案是从起点考虑，虽然说经过了这条边，包含串 \(t\)的字母情况变成 \(sign\)，但其中有的字母可以后面的串得到，从终点搜到这里会已经消去，因此这里的\(c\)应该遍历\(sign\)的所有子集，取最小值。
状态数是\(O(2^{10} \times 26 \times 26)\)，但每个状态的连边实际上是有 \(O(n)\)的数量集，转移代价可能比较大，但或许实际上没那么大（或者数据水了），就过了。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const LL inf = 1e18;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
int n;
string t;
cin >> n >> t;
vector<int> id(26, -1);
int cnt = 0;
for(auto &i : t){
id[i - 'a'] = cnt;
++ cnt;
}
vector<vector<array<int, 3>>> edge(26);
vector<array<int, 4>> query(n);
for(int i = 0; i < n; ++ i){
string s;
cin >> s;
int st = s.front() - 'a';
int ed = s.back() - 'a';
int sign = 0;
int len = s.size() - 1;
for(auto &i : s){
if (id[i - 'a'] != -1){
sign |= (1 << id[i - 'a']);
}
}
edge[ed].push_back({st, len, sign});
query[i] = {st, ed, sign, len};
}
int up = (1 << cnt);
vector<vector<vector<LL>>> dis(26, vector<vector<LL>>(26, vector<LL>(up, inf)));
for(int i = 0; i < 26; ++ i){
dis[i][i][up - 1] = 0;
priority_queue<array<LL, 3>> team;
team.push({0, i, up - 1});
while(!team.empty()){
array<LL, 3> top = team.top();
team.pop();
LL distance = -top[0];
int u = top[1], sign = top[2];
if (dis[i][u][sign] != distance)
continue;
for(auto &e : edge[u]){
int v = e[0], len = e[1], si = e[2];
int nxtsign = (sign ^ (sign & si));
if (dis[i][v][nxtsign] > distance + len){
dis[i][v][nxtsign] = distance + len;
team.push({-dis[i][v][nxtsign], v, nxtsign});
}
}
}
}
for(int i = 0; i < n; ++ i){
LL ans = inf;
int sign = query[i][2];
for(int s = sign; s; s = (s - 1) & sign)
ans = min(ans, dis[query[i][0]][query[i][1]][s]);
ans = min(ans, dis[query[i][0]][query[i][1]][0]);
if (ans == inf)
ans = -1;
else
ans += query[i][3];
cout << ans << '\n';
}
return 0;
}
