CodeForces1151
Maxim and Biology
解析：
题目大意
每次可以使原串中的一个字符\(+1/-1\)，\(Z + 1\to A, A -1\to Z\)，求至少修改多少次可以使 ACTG 是原串的子串
\(4\le |S|\le 50\)
思路：
直接暴力尝试每个子串。
code
#include <bits/stdc++.h>
const int N = 50 + 10;
const int INF = 0x3f3f3f3f;
using namespace std;
int n, ans;
char s[N];
signed main()
{
scanf ("%d%s", &n, s + 1); ans = INF;
for (int i = 1; i <= n - 3; i++)
{
ans = min (ans, min (abs(s[i] - 'A'), 26 - abs((s[i] - 'A'))) +
min (abs(s[i + 1] - 'C'), 26 - abs((s[i + 1] - 'C'))) +
min (abs(s[i + 2] - 'T'), 26 - abs((s[i + 2] - 'T'))) +
min (abs(s[i + 3] - 'G'), 26 - abs((s[i + 3] - 'G'))));
}
printf ("%d\n", ans);
return 0;
}
Dima and a Bad XOR
解析：
题目大意：
给你一个大小为 \(n \times m\) 的矩阵，其中只包含非负整数。你需要从矩阵的每一行中选出一个整数，使得所选整数的按位异或严格大于零。
输出 \(n\) 行，每行一个正整数表示选择选当前第几个数。
思路：
考虑异或和大于零的充要条件是某一位不为零，那么可以拆位考虑。现在问题变成了给你一个0/1矩阵，让你在每行选一个数使最终异或和为1。
根据异或的性质可以发现选 0 不会影响异或结果，所以我们只需要找出来奇数个1即可。
我们先判断所有行中有 1 的行的个数，如果为奇数那每行都选 1 即可。如果个数为偶数那就找一个既有 0 也有 1 的行强行选 0 即可。
code：
#include <bits/stdc++.h>
using namespace std;
const int N = 500 + 10;
inline int read ()
{
int x = 0, f = 1;
char ch = getchar ();
while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar (); }
while (ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar (); }
return x * f;
}
int n, m;
int a[N][N];
void solve (int x, int d)
{
printf ("TAK\n");
for (int i = 1; i <= n; i++)
{
bool flag2 = false;
if (x != i)
{
for (int j = 1; j <= m; j++)
if ((a[i][j] >> d) & 1) { printf ("%d ", j); flag2 = true; break; }
}
else
{
for (int j = 1; j <= m; j++)
if (!((a[i][j] >> d) & 1)) { printf ("%d ", j); flag2 = true; break; }
}
if (!flag2) printf ("1 ");
}
}
signed main()
{
n = read (), m = read ();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[i][j] = read ();
for (int d = 10; d >= 0; d--)
{
int cnt = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if ((a[i][j] >> d) & 1) { cnt++; break; }
if (cnt & 1) { solve (0, d); return 0; }
else
{
for (int i = 1; i <= n; i++)
{
int cnt2 = 0;
for (int j = 1; j <= m; j++)
if ((a[i][j] >> d) & 1) cnt2++;
if (cnt2 && cnt2 < m) { solve (i, d); return 0; }
}
}
}
printf ("NIE\n");
return 0;
}
Problem for Nazar
解析：
题目大意
当\(i\)为奇数时，从集合\(\mathrm{A}\)中依次取数（取过了），当\(i\)为偶数时，从集合\(\mathrm{B}\)中向后取数。求黑板上第\(l\)个数到第\(r\)个数的和，答案对 \(10^9+7\)取余。
\(1 \le l,r \le 10^{18}\)
思路：
考虑把询问的区间按照奇数和偶数分成若干段，最多有 \(\log 10^{18}\) 个段，于是直接暴力即可。
code
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e5 + 10;
const int INV = 500000004;
const int mods = 1e9 + 7;
typedef pair <int, int> pii;
inline int read ()
{
int x = 0, f = 1;
char ch = getchar ();
while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar (); }
while (ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar (); }
return x * f;
}
int l, r;
int sum1, sum2;
int ans;
signed main()
{
l = read (), r = read ();
int sum = 0;
for (int i = 1; i <= 100; i++)
{
int lst = sum + 1;
sum += (1ll << (i - 1));
int b, e, cnt;
if (sum >= l)
{
if (i & 1)
{
b = 2 * (sum1 + 1 + ((l > lst) ? l - lst : 0)) - 1;
cnt = min (r, sum) - max (lst, l) + 1; cnt %= mods;
e = b + 2 * (cnt - 1);
ans += (b + e) % mods * cnt % mods * INV % mods;
}
else
{
b = 2 * (sum2 + 1 + ((l > lst) ? l - lst : 0));
cnt = min (r, sum) - max (lst, l) + 1; cnt %= mods;
e = b + 2 * (cnt - 1);
ans += (b + e) % mods * cnt % mods * INV % mods;
}
ans %= mods;
}
if (sum >= r || sum > 1e18) break;
if (i & 1) sum1 += (1ll << (i - 1));
else sum2 += (1ll << (i - 1));
}
printf ("%lld\n", ans);
return 0;
}
Stas and the Queue at the Buffet
解析：
题目大意：
共有 \(n\) 个人，第 \(i\) 个人有属性值 \(a_i,b_i\)，现在要给这 \(n\) 个人重排顺序，设第 \(i\) 个人站在位置 \(j\)，则他的不满意度是 \(a_i \times (j-1) + b_i \times (n-j)\)
最小化所有人的不满意度之和，求这个最小值
思路：
我们变一下式子：
\[\sum_{i=1}^{n}a_i\times (i-1)+b_i\times (n-i)\\
\sum_{i=1}^{n}a_i\times i-a_i-b_i\times i\\
n\times \sum_{i=1}^n b_i+\sum_{i=1}^na_i+\sum_{i=1}^{n}(a_i-b_i)\times i\\
\]
问题变为 \(\sum_{i=1}^n(a_i-b_i)\times i\) 的最小值，我们按照 \(a_i-b_i\) 从大到小排序即可。
code：
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e5 + 10;
typedef pair <int, int> pii;
inline int read ()
{
int x = 0, f = 1;
char ch = getchar ();
while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar (); }
while (ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar (); }
return x * f;
}
int n;
struct node {
int x, y, z;
bool operator < (const node &A) const {
return z > A.z;
}
} a[N];
signed main()
{
n = read ();
for (int i = 1; i <= n; i++)
a[i].x = read (), a[i].y = read (), a[i].z = a[i].x - a[i].y;
sort (a + 1, a + n + 1);
int ans = 0;
for (int i = 1; i <= n; i++) ans += a[i].x * (i - 1) + a[i].y * (n - i);
printf ("%lld\n", ans);
return 0;
}
Number of Components
解析：
题目大意：
有一条 \(n(1 \leq n \leq 10^5)\) 个节点的链，编号相邻节点有边，每个点一个权值 \(a_i(1 \leq a_i \leq n)\)，\(f(l,r)\)定义为权值在\([l,r]\) 的点中的连通块数量求 \(\sum_{l=1}^{n}\sum_{r=l}^{n} f(l,r)\) 。
思路：
考虑套路：连通块个数=所有权值在 \([l,r]\) 内的点的个数 \(-\) 连接他们的边的个数，这个是可以分开计算的。
我们考虑每个点对答案的贡献，不难发现对于 \(l\leq a_i \and a_i \leq r\) 的所有区间这个点都贡献了一次，答案为 \(a_i\times (n-a_i+1)\) ，这部分可以线性解决。
边权同理，我们把 \(a_i\rightarrow a_{i+1}\) 的边当作是一个点，类似二维数点，考虑 \(\forall l, r|l\in[1,\min(a_i,a_{i+1})],r\in[\max(a_i,a_{i+1}), n]\) 的 \((l,r)\) 都会对答案造成 \(-1\) 的贡献，一共贡献了 \(\min(a_i,a_{i+1})\times(n-\max(a_i,a_{i+1}+1))\) 次。
总联通块个数做差即可，时间复杂度线性。
code：
#include <bits/stdc++.h>
#define int long long
using namespace std;
typedef pair <int, int> pii;
inline int read ( )
{
int x = 0, f = 1;
char ch = getchar ( );
while (ch < '0' || ch > '9') {if (ch == '-') f = - 1; ch = getchar ( );}
while (ch >= '0' && ch <='9') {x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar ( );}
return x * f;
}
int n, ans;
signed main()
{
n = read (); int lst, now;
for (int i = 1; i <= n; i++)
{
now = read ();
ans += (now * (n - now + 1));
if (i > 1) ans -= (min (lst, now) * (n - max (lst, now) + 1));
lst = now;
}
printf ("%lld\n", ans);
return 0;
}
Sonya and Informatics
解析：
题目大意：
给一个长度为 \(n\) \((n\leq 100)\) 的 \(0/1\) 串，进行 \(k\) \((k \leq 10^9)\) 次操作，每次操作随机选择两个位置 \(i,j\) \((1 \leq i < j \leq n)\)，交换 \(i,j\) 上的数，求 \(k\) 次操作后，该 \(0/1\) 串变成非降序列的概率，答案对 \(10^9+7\) 取模。
思路：
考虑非降要求最终序列一定是前面是 0 后面是 1，假设 0 有 \(cnt\) 个，那么设 \(dp_{i,j}\) 表示交换了 \(i\) 次后前 \(cnt\) 个位置有 \(j\) 个 \(0\)，那么有转移：
\[dp_{i+1,j+1}=dp_{i+1,j+1}+dp_{i,j}\times \frac{(cnt-j)^2}{\frac{n\times (n-1)}{2}}
\]
其中 \(\frac{n\times (n-1)}{2}\) 可以预处理逆元，\((cnt-j)^2\) 表示恰好选到前 \(cnt\) 个位置中的 1 的和后 \(n-cnt\) 中 0 的概率。
同时有转移：
\[dp_{i+1,j-1}=dp_{i+1,j-1}+dp_{i,j}\times \frac{j\times (n-cnt-(cnt-j))}{\frac{n\times (n-1)}{2}}
\]
\(j\times (n-cnt-(cnt-j))\) 表示恰好选到前 \(cnt\) 个位置中的 0 的和后 \(n-cnt\) 中 1 的概率。
剩下的转移到 \(dp_{i+1,j}\) 即可。
我们发现 \(n\leq 100\) 而 \(k\leq 10^9\) ，这显然可以矩快优化dp，我们设计如下矩阵：
\[A=\begin{bmatrix}
P(3,0)&P(1,0)&0&0&0&\cdots &0\\
P(2,1)&P(3,1)&P(1,1)&0&0&\cdots &0\\
0&P(2,2)&P(3,2)&P(1,2)&0&\cdots &0\\
0&0&P(2,3)&P(3,3)&P(1,3)&\cdots &0\\
\vdots & \vdots & \vdots &\vdots&\vdots & \ddots & \vdots \\
0&0&0&0&0&\cdots &P(3,cnt)\\
\end{bmatrix}
\]
其中 \(P(i,j)\) 表示第 \(i\) 类转移，转移前的前 \(cnt\) 个中有 \(j\) 个 0，那么有：
\[\begin{bmatrix}
dp_{i,0}&dp_{i,1}&dp_{i,2}&\cdots &dp_{i,cnt}
\end{bmatrix}
\times
A
=
\begin{bmatrix}
dp_{i+1,0}&dp_{i+1,1}&dp_{i+1,2}&\cdots &dp_{i+1,cnt}
\end{bmatrix}
\]
考虑设初始状态 \(dp_{0,x}=1\)，其中 \(x\) 表示前 \(cnt\) 个中的 0 的数量，那么答案为：
\[\begin{bmatrix}
dp_{0,0}&dp_{0,1}&dp_{0,2}&\cdots &dp_{0,cnt}
\end{bmatrix}
\times
A^k
=
\begin{bmatrix}
dp_{m,0}&dp_{m,1}&dp_{m,2}&\cdots &dp_{m,cnt}
\end{bmatrix}
\]
则答案为 \(dp_{m,cnt}\)。
时间复杂度 \(\mathcal O(n^3\log k)\)。
code：
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 100 + 10;
const int mods = 1e9 + 7;
typedef pair <int, int> pii;
inline int read ()
{
int x = 0, f = 1;
char ch = getchar ();
while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar (); }
while (ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar (); }
return x * f;
}
int n, m;
int a[N], cnt;
struct Matrix {
int h, r;
int m[N][N];
void init () { for (int i = 1; i <= h; i++) m[i][i] = 1; }
}ans;
Matrix operator * (const Matrix x, const Matrix y)
{
Matrix res;
res.h = x.h; res.r = y.r;
memset (res.m, 0, sizeof (res.m));
for (int i = 1; i <= x.h; i++)
for (int j = 1; j <= y.r; j++)
for (int k = 1; k <= x.r; k++)
(res.m[i][j] += ((x.m[i][k] * y.m[k][j]) % mods)) %= mods;
return res;
}
Matrix qpow (Matrix a, int p)
{
Matrix res;
res.h = res.r = a.h;
res.init ();
while (p) { if (p & 1) res = res * a; a = a * a; p >>= 1; }
return res;
}
int qpow2 (int a, int p)
{
int res = 1;
while (p) { if (p & 1) res = (res * a) % mods; a = (a * a) % mods; p >>= 1; }
return res;
}
signed main()
{
n = read (), m = read ();
for (int i = 1; i <= n; i++) a[i] = read (), cnt += !(a[i]);
ans.h = 1, ans.r = cnt + 1;
int cnt2 = 0;
for (int i = 1; i <= cnt; i++) cnt2 += !(a[i]);
ans.m[1][cnt2 + 1] = 1;
Matrix e;
e.h = e.r = cnt + 1;
int inv = qpow2 (n * (n - 1) / 2, mods - 2);
for (int i = 0; i <= cnt; i++)
{
int x, y, z;
x = ((cnt - i) * (cnt - i)) % mods;
y = (i * (n - cnt - cnt + i)) % mods;
z = (n * (n - 1) / 2 - x - y) % mods;
(x *= inv) %= mods; (y *= inv) %= mods; (z *= inv) %= mods;
e.m[i + 1][i + 1] = z; e.m[i + 1][i + 2] = x; e.m[i + 1][i] = y;
}
Matrix q = qpow (e, m);
ans = ans * q;
printf ("%lld\n", ans.m[1][cnt + 1]);
return 0;
}
