比赛链接
A 九峰与签到题
签到题
不多说，直接上代码
AC代码
#include<bits/stdc++.h>
using namespace std;
#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % 1000000007
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int N = 20 + 10;
bool vis[N];
int st[N];
int main()
{
#ifdef LOCAL
freopen("data.in", "r", stdin);
#endif
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
int n, m;
cin >> m >> n;
while (m--)
{
int t;
string op;
cin >> t >> op;
if (op == "AC") st[t]++;
else st[t]--;
if (st[t] < 0) vis[t] = true;
}
_rep(i, 1, n) if (!vis[i]) cout << i << " ";
cout << endl;
return 0;
}
B 武辰延的字符串
这个题目在比赛的时候做了我好久，就是那种感觉可以做出来，但是就是做不出来的那种感觉。
实际上还差很远，错因： 模拟的时候没有经过严格的证明，数据点没找出来，随意的给运行剪枝，导致答案不对。
对于数据点没找出来这个问题，需要在看题的时候将所有限制条件列出来，然后给自己出各种情况的数据点，这个能力有待提高！
这个题目考点就是字符串哈希 + 二分。
对于匹配字符串好用的就是字符串哈希或者KMP了，这个题目范围有点大，所以个人偏向于哈希，感觉快一些。
对于公式 ：
s
i
+
s
j
=
t
i
+
j
s_i + s_j = t_{i + j}
si+sj=ti+j 如果两边的前缀
s
i
s_i
si相同的话，那么可以同时减去
s
i
s_i
si，那么剩下来的就是我们需要的答案了，有多长就代表在以
s
i
s_i
si为前缀的情况下的所有结果。
接下来就是求最大匹配长度的问题了，看到最大，然可以根据字符串哈希值比较大小条件可以划分为两个不同的部分，这时候我们就要想到二分了。
如果两边的字符串哈希值是一样的，那么就说明还可以往右边取，如果不一样就说明要往左边移动。
主要是没有想到将公式变形一下找到相同的，就直接模拟了，模拟前也没有好好分析题目。 这个毛病要改！！！
AC代码
#include<bits/stdc++.h>
#include<unordered_map>
using namespace std;
#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % 1000000007
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef unsigned long long ull;
const int N = 100000 + 10, P = 131;
ull ha[N], hb[N], p[N];
char a[N], b[N];
int sza, szb;
unordered_map<ll, bool> vis;
ull get(int l, int r, ull h[])
{
return h[r] - h[l - 1] * p[r - l + 1];
}
int main()
{
#ifdef LOCAL
freopen("data.in", "r", stdin);
#endif
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> a + 1 >> b + 1;
sza = strlen(a + 1), szb = strlen(b + 1);
p[0] = 1;
int n = max(sza, szb), m = min(sza, szb);
_rep(i, 1, n)
{
if (sza <= n) ha[i] = ha[i - 1] * P + a[i];
if (szb <= n) hb[i] = hb[i - 1] * P + b[i];
p[i] = p[i - 1] * P;
}
ll ans = 0;
_rep(i, 1, m) if (get(1, i, ha) == get(1, i, hb))
{
int l = 0, r = min(sza, szb - i);
while (l < r)
{
int mid = l + r + 1 >> 1;
if (get(1, mid, ha) == get(i + 1, mid + i, hb)) l = mid;
else r = mid - 1;
}
ans += l;
}
cout << ans << endl;
return 0;
}
D 温澈滢的狗狗
这个题目看了我好久，，（主要是太菜了）
做题的时候想到了用二分，但是不知道怎么去定义它的性质。
两两不同颜色的狗之间会产生亲密度，对每一对有亲密度的狗按照关键词进行排序，求第k对狗的下标。
如果模拟的话肯定会超时，所以要往快速找到第k对狗的方向想，会想到使用二分思想。
想到用二分思想就要想能不能找到一个能够二分的条件。
第一关键词是按照亲密度去的，所以想想能不能以亲密度去划分。
我们假设第k对的亲密度为x，那么就说明
>
x
> x
>x 的部分是不需要的，所以就有明显的二分性。
知道了以亲密度作为判断条件，那么接下来的步骤就是完善细节，计算每个
≤
x
\leq x
≤x亲密度的个数。
只有颜色不同才会有亲密度，直接求有点麻烦，时间复杂度也会比较高，直接求不行，那么就试试间接的求法：
异
色
点
对
数
=
总
点
对
数
−
同
色
点
对
数
（
O
(
n
)
）
异色点对数=总点对数-同色点对数 （O(n)）
异色点对数=总点对数−同色点对数（O(n)）
设x为亲密度，我们将同色点都放到同一个下标的数组中。
总点对数 ：
(
n
−
x
)
∗
x
+
x
∗
(
x
−
1
)
/
2
(n - x) * x + x * (x - 1) / 2
(n−x)∗x+x∗(x−1)/2
我们知道亲密度了，（亲密度是下标距离）那么从下标1开始到(n - x) 分别做区间，每个区间都可以取x个数与区间第一个点形成对，有（n - x ）个区间，所以就为
(
n
−
x
)
∗
x
(n - x) * x
(n−x)∗x, 后部分区间不能延长了，到达总下标的末端了，所以可取值分别为
x
−
1
、
x
−
2
、
x
−
3
…
…
x
−
(
x
−
1
)
x - 1、x - 2、x - 3……x - (x - 1)
x−1、x−2、x−3……x−(x−1),等差数列求和就得出了
x
∗
(
x
−
1
)
/
2
x * (x - 1) / 2
x∗(x−1)/2 。
同色点数利用双指针求解即可（这个不知道怎么用语言讲，待会看代码吧。）
二分具体条件出来了，那么就可以求出来最大亲密度为
l
l
l 总对数小于
k
k
k 的
l
l
l值。
所以第k对狗的亲密度为
l
+
1
l + 1
l+1。
亲密度知道了，直接for循环找即可。
AC 代码
#include<bits/stdc++.h>
using namespace std;
#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % MOD
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int N = 100000 + 10;
int c[N], n;
ll k;
vi same[N];
ll cal(ll x)
{
ll tot = (n - x) * x + x * (x - 1) / 2;
_rep(i, 1, n)
{
int r = 0, sz = same[i].size();
_for (j, 0, sz)
{
while (r < sz && same[i][r] - same[i][j] <= x) ++r;
tot -= r - j - 1;
}
}
return tot;
}
int main()
{
#ifdef LOCAL
freopen("data.in", "r", stdin);
#endif
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> k;
_rep(i, 1, n)
{
cin >> c[i];
same[c[i]].push_back(i);
}
if (cal(n) < k) return puts("-1"), 0;
int l = 0, r = n;
while (l < r)
{
int mid = l + r + 1 >> 1;
if (cal(mid) < k) l = mid;
else r = mid - 1;
}
int dist = l + 1;
ll cnt = cal(l);
_rep(i, 1, n - dist) if (c[i] != c[i + dist])
{
cnt++;
if (cnt == k)
{
cout << i << " " << i + dist << endl;
break;
}
}
return 0;
}
E 九峰与子序列
很明显的动态规划题目，但是我就是想不到，我想到以子序列为dp的目标，但是没有想到以字符串k为dp目标。
多尝试不同的条件，说不定就能碰出火花，不能懒！
记住，动态规划不是一步就达到答案的，是一步一步转化之后才到达答案的。
f
[
i
]
[
j
]
f[i][j]
f[i][j]表示前i个定序列匹配到字符串k第j位的所有合法方案， 所以分为取和不取两种选择，这就类似于01背包了，但是比01背包多了一个点就是取之前需要判断它是否能拼接成字符串k。
所以状态转移方程为 ：
f
[
i
]
[
j
]
=
f
[
i
−
1
]
[
j
−
l
e
n
[
i
]
]
∗
c
h
e
c
k
(
h
a
[
j
]
,
j
−
l
e
n
[
i
]
+
1
,
j
)
+
f
[
i
−
1
]
[
j
]
f[i][j] = f[i - 1][j - len[i]] * check(ha[j], j - len[i] +1, j) + f[i - 1][j]
f[i][j]=f[i−1][j−len[i]]∗check(ha[j],j−len[i]+1,j)+f[i−1][j]
利用滚动数组，将状态转移方程进一步转化为 ：
f
[
j
]
=
f
[
j
−
l
e
n
[
i
]
]
∗
c
h
e
c
k
(
h
a
[
i
]
,
j
−
l
e
n
[
i
]
+
1
,
j
)
+
f
[
j
]
f[j] = f[j - len[i]] * check(ha[i], j - len[i] +1, j) + f[j]
f[j]=f[j−len[i]]∗check(ha[i],j−len[i]+1,j)+f[j]
使用之前的值，所以别忘记了是逆序遍历。
AC代码
#include<bits/stdc++.h>
using namespace std;
#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % 1000000007
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int N = 5000000 + 10, P = 131, M = 50;
ull p[N], h[N], ha[M];
ll f[N];
int n, len[M];
char k[N], a[M][N];
bool check(ull hash, int l, int r)
{
return hash == h[r] - h[l - 1] * p[r - l + 1];
}
int main()
{
#ifdef LOCAL
freopen("data.in", "r", stdin);
#endif
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> k + 1;
int sz = strlen(k + 1);
p[0] = 1;
_rep(i, 1, 5e6) {
p[i] = p[i - 1] * P;
if (i <= sz) h[i] = h[i - 1] * P + k[i];
}
_rep(i, 1, n)
{
cin >> a[i] + 1;
len[i] = strlen(a[i] + 1);
_rep(j, 1, len[i]) ha[i] = ha[i] * P + a[i][j];
}
f[0] = 1;
_rep(i, 1, n) For(j, sz, len[i]) f[j] += f[j - len[i]] * check(ha[i], j - len[i] + 1, j);
cout << f[sz] << endl;
return 0;
}
F 魏迟燕的自走棋
这个题目就差一点点就做出来了，太遗憾了，我只是将权值排序了，但是没有将他的下标所连接的点做出改变。
对匈牙利算法还不够熟练！
审题很重要，重视！
AC 代码
#include<bits/stdc++.h>
using namespace std;
#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % 1000000007
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int N = 100000 + 10;
int match[N];
int n, m;
int st[N];
struct Node
{
int k, a[3], w;
bool operator < (const Node& t) const
{
return w > t.w;
}
}alls[N];
bool find(int x)
{
_for (i, 0, alls[x].k)
{
int j = alls[x].a[i];
if (!st[j])
{
st[j] = true;
if (match[j] == 0 || find(match[j]))
{
match[j] = x;
st[j] = false;
return true;
}
}
}
return false;
}
int main()
{
#ifdef LOCAL
freopen("data.in", "r", stdin);
#endif
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> m;
_rep(i, 1, m)
{
cin >> alls[i].k;
_for(j, 0, alls[i].k) cin >> alls[i].a[j];
cin >> alls[i].w;
}
sort(alls + 1, alls + m + 1);
_rep(i, 1, m) find(i);
ll ans = 0;
_rep(i, 1, n) if (match[i]) ans += alls[match[i]].w;
cout << ans << endl;
return 0;
}
G 九峰与蛇形填数
这个题目直接暴力就可以了，不需要用啥线段树。
每个点每次取值肯定是最后一个覆盖到它区域的值，所以直接取那个数即可。
然后还有一个细节就是剪枝，预处理区域的大小，如果这个点不在这个区域直接break。不用赋值了。
AC代码 （有bug）
#include<bits/stdc++.h>
using namespace std;
#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % MOD
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int N = 3000 + 10, M = 2010, INF = 0x3f3f3f3f;
int n, m;
int x[N], y[N], k[N],g[M][M];
bool inside(int t, int a, int b)
{
return a <= t && t <= b;
}
int main()
{
#ifdef LOCAL
freopen("data.in", "r", stdin);
#endif
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> m;
int x1 = INF, y1 = INF, x2 = 0, y2 = 0;
_rep(i, 1, m)
{
cin >> x[i] >> y[i] >> k[i];
x1 = min(x1, x[i]);
y1 = min(y1, y[i]);
x2 = max(x2, x[i] + k[i] - 1);
y2 = max(y2, y[i] + k[i] - 1);
}
_rep(i, 1, n) _rep(j, 1, n) For(l, m, 1)
{
if (!inside(i, x1, x2) || !inside(j, y1, y2)) break;
if (inside(i, x[l], x[l] + k[l] - 1) && inside(j, y[l], y[l] + k[l] - 1))
{
g[i][j] = k[l] * (i - x[l]);
if (i - x[l] & 1) g[i][j] += y[l] + k[l] - j;
else g[i][j] += j - y[l] + 1;
break;
}
}
_rep(i, 1, n) _rep(j, 1, n) printf("%d%s", g[i][j], j == n ? "\n" : " ");
return 0;
}
----------------------------------------------------------2020、2、20---------------------------------------------------------------------
惨遭hack！还是老老实实用正规做法做吧！后面补上正规做法。感谢榜一大佬及时提醒！
看完线段树的题解之后感觉并没有想象中的那么难，都是围绕着取某个点最后一次覆盖做优化。
这里建议使用线段树求解，虽然雨巨说这个写法有点毛病，但是标算就是用线段树，出题人的意思就是让我们巩固一下线段树知识，写的每一个题总得有反思和提高，如果投机取巧，使用的还是以前会的东西，那这个题目对于你来说意义不大。
核心：找到每个点最后一次被覆盖的矩阵下标。
对于需要快速的对区间或者点的修改查询的题，我们就要想到线段树之类的知识点。
因为是矩阵，所以要用二维去维护。
维护的是每个点最后一次被覆盖的矩阵下标，每次都修改肯定是超时的，所以需要使用懒标记。
线段树的变形感觉有好多，现在又看到一种，，
AC代码 （标算）
#include<bits/stdc++.h>
using namespace std;
#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % MOD
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int N = 2000 + 10, M = 3010;
int n, m;
struct Node
{
struct point
{
int l, r, lz;
}tr[N << 2];
void push_down(int u){
auto& t = tr[u];
if (t.lz)
{
tr[u << 1].lz = t.lz;
tr[u << 1 | 1].lz = t.lz;
t.lz = 0;
}
}
void build(int u, int l, int r)
{
tr[u] = { l, r, 0 };
if (l != r)
{
int mid = l + r >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
}
}
void modify(int u, int l, int r, int k)
{
auto& t = tr[u];
if (l <= t.l && t.r <= r) t.lz = k;
else
{
int mid = t.l + t.r >> 1;
push_down(u);
if (r <= mid) modify(u << 1, l, r, k);
else if (l > mid) modify(u << 1 | 1, l, r, k);
else modify(u << 1, l, mid, k), modify(u << 1 | 1, mid + 1, r, k);
}
}
int query(int u, int l)
{
auto& t = tr[u];
if (t.l == t.r) return t.lz;
int mid = t.l + t.r >> 1;
push_down(u);
if (l <= mid) return query(u << 1, l);
return query(u << 1 | 1, l);
}
}g[N];
struct Mat
{
int x, y, k;
}mat[M];
int cal(int x, int y, int k, int i, int j)
{
if (i - x & 1) return k * (i - x) + y + k - j;
return k * (i - x) + j - y + 1;
}
int main()
{
#ifdef LOCAL
freopen("data.in", "r", stdin);
#endif
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> m;
_rep(i, 1, n) g[i].build(1, 1, n);
_rep(i, 1, m) {
cin >> mat[i].x >> mat[i].y >> mat[i].k;
_rep(j, mat[i].x, mat[i].x + mat[i].k - 1)
g[j].modify(1, mat[i].y, mat[i].y + mat[i].k - 1, i);
}
_rep(i, 1, n) _rep(j, 1, n)
{
int v = g[i].query(1, j);
if (!v) cout << 0;
else
{
auto& t = mat[v];
cout << cal(t.x, t.y, t.k, i, j);
}
cout << (j == n ? "\n" : " ");
}
return 0;
}
H 吴楚月的表达式
这个题目只要把dfs的参数搞清楚了，就差不多了。
我们对运算进行分析可以发现，只要对前一个数进行优先级运算就可以了：
- + : ( a + b ) + w [ j ] +: ( a + b) + w[j] +:(a+b)+w[j]
- − : ( a + b ) − w [ j ] -: ( a + b) - w[j] −:(a+b)−w[j]
- ∗ : a + b ∗ w [ j ] * : a + b * w[j] ∗:a+b∗w[j]
- / : a + b ∗ w [ j ] − 1 /: a + b * w[j]^{-1} /:a+b∗w[j]−1
因为是从根节点出发，所以只需要三个变量 a 、 b 、 v a、b、v a、b、v就可以了， v v v记录当前位置。
AC代码
#include<bits/stdc++.h>
using namespace std;
#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % MOD
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int N = 100000 + 10, MOD = 1e9 + 7;
int n, w[N], fa[N], h[N], ne[N], e[N], idx;
ll ans[N];
char op[N];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
ll qmi(int a, int b)
{
ll res = 1, t = a;
while (b)
{
if (b & 1) res = mod(res * t);
t = mod(t * t);
b >>= 1;
}
return res;
}
void dfs(ll a, ll b, int v)
{
ans[v] = mod(a + b);
for (int i = h[v]; ~i; i = ne[i])
{
int j = e[i];
switch (op[j])
{
case '+':
dfs(a + b, w[j], j);
break;
case '-':
dfs(a + b, MOD - w[j], j);
break;
case '*':
dfs(a, mod(b * w[j]), j);
break;
default:
dfs(a, mod(b * qmi(w[j], MOD - 2)), j);
}
}
}
int main()
{
#ifdef LOCAL
freopen("data.in", "r", stdin);
#endif
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
memset(h, -1, sizeof h);
cin >> n;
_rep(i, 1, n) cin >> w[i];
add(0, 1);
_rep(i, 2, n) cin >> fa[i], add(fa[i], i);
cin >> op + 2;
op[1] = '+';
dfs(0, 0, 0);
_rep(i, 1, n) cout << ans[i] << " ";
cout << endl;
return 0;
}
I 九峰与分割序列
这个题目也太难了吧😭😭😭
感谢溢流眼泪大佬写的博客，看了好久终于看懂了。
真没想到DP还可以这么玩，学到了学到了，，，
求一种分割方法使得所有子区间的贡献之和最大，我们设
d
p
[
i
]
dp[i]
dp[i]为到
i
i
i为止所有子区间的最大贡献和，
f
[
i
]
f[i]
f[i]为到
i
i
i为止最后最后一段区间长度大于k的所有贡献之和。
那么就会有动态转移方程：
d
p
(
i
)
=
m
a
x
{
d
p
(
i
−
1
)
+
a
i
2
∗
S
(
j
,
i
)
+
f
(
j
−
1
)
(
i
−
j
+
1
≤
k
)
dp(i) = max \begin{cases} dp(i - 1) + a_i \\ 2 * S(j, i) + f(j - 1) & (i - j +1 \leq k) \end{cases}
dp(i)=max{dp(i−1)+ai2∗S(j,i)+f(j−1)(i−j+1≤k)
上部分为不分割，因为只是加一倍的原来的那段区间和，那么它的值也就是相当于当前的值加上前面那一段，下部分为符合分割条件可以分割，就是取可以分割的区间乘以2加上前面那一段。
f
[
i
]
f[i]
f[i]的状态转移好理解，就是让后面k + 1个数取一倍，剩下的数取最大即可。
f
(
i
)
=
d
p
(
i
−
k
−
1
)
+
S
(
i
−
k
,
i
)
f(i) = dp(i - k - 1) + S(i - k, i)
f(i)=dp(i−k−1)+S(i−k,i)
继续优化，看能不能将dp的转移方程的第二个条件的
j
j
j给优化一下。
因为它的长度永远都是只能小于等于
k
k
k的，所以可以想到滑动窗口，也就是单调队列。
让单调队列维护
2
∗
S
(
j
,
i
)
+
f
(
j
−
1
)
2 * S(j, i) + f(j - 1)
2∗S(j,i)+f(j−1)的最大值，每次取队首就是最大值。
单调队列基础知识就不讲了，代码中有一个弹出队列的细节在这里讲一下。
while (hh <= tt && 2 * S(q[tt] + 1, i) + f[q[tt]] < f[i]) --tt; 为什么是小于
f
[
i
]
f[i]
f[i]？
因为如果把i放入队列
2
∗
S
(
j
,
i
)
+
f
(
j
−
1
)
2 * S(j, i) + f(j - 1)
2∗S(j,i)+f(j−1)的值就会变成2 * S(i+ 1, i) + f[i] 也就是
f
[
i
]
f[i]
f[i]。
代码中维护的是 k + 1 k + 1 k+1个下标。
AC代码
#include<bits/stdc++.h>
using namespace std;
#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % MOD
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int N = 100000 + 10;
int n, k;
ll dp[N], f[N], c[N];
int a[N], q[N];
ll S(int l, int r)
{
return c[r] - c[l - 1];
}
int main()
{
#ifdef LOCAL
freopen("data.in", "r", stdin);
#endif
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> k;
_rep(i, 1, n)
{
cin >> a[i];
dp[i] = f[i] = c[i] = c[i - 1] + a[i];
}
int hh = 0, tt = -1;
q[++tt] = k + 1;
_rep(i, k + 2, n)
{
while (hh <= tt && i - q[hh] > k) ++hh;
dp[i] = max(2 * S(q[hh] + 1, i) + f[q[hh]], dp[i - 1] + a[i]);
f[i] = dp[i - k - 1] + S(i - k, i);
while (hh <= tt && 2 * S(q[tt] + 1, i) + f[q[tt]] < f[i]) --tt;
q[++tt] = i;
}
cout << dp[n] << endl;
return 0;
}
J 邬澄瑶的公约数
这个题目气死我了，WA了几发，看错题了，把他按照最大公倍数去算了。晕死。
这个题目只要找到所有数字中都出现的质数的最小幂相乘就得出结果了。
看题要仔细，做题前的 “ 静 ” 要做到！
AC代码
#include<bits/stdc++.h>
#include<unordered_map>
using namespace std;
#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % 1000000007
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int N = 10000 + 10;
ll a[N], t[N];
unordered_map<ll, ll> ansMap;
int cnt[N];
void dive(ll x, ll p)
{
for (int i = 2; 1ll * i * i <= x; ++i)
if (x % i == 0)
{
ll s = 0;
while (x % i == 0) x /= i, s++;
if (!cnt[i]) ansMap[i] = s * p, cnt[i]++;
else {
ll o = min(ansMap[i], s * p);
ansMap[i] = o;
cnt[i]++;
}
}
if (x > 1) {
if (!cnt[x]) ansMap[x] = p, cnt[x]++;
else {
ll o = min(ansMap[x], p);
ansMap[x] = o;
cnt[x]++;
}
}
}
ll qmi(ll a, ll b)
{
ll res = 1;
while (b)
{
if (b & 1) res = mod(res * a);
a = mod(a * a);
b >>= 1;
}
return res;
}
int main()
{
#ifdef LOCAL
freopen("data.in", "r", stdin);
#endif
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
int n;
cin >> n;
_for(i, 0, n) cin >> a[i];
_for(i, 0, n) cin >> t[i];
_for(i, 0, n) dive(a[i], t[i]);
if (n == 1) {
cout << qmi(a[0], t[0]) << endl;
return 0;
}
ll ans = 1;
for (const auto& p : ansMap)
if (cnt[p.first] == n) ans = mod(ans * qmi(p.first, p.second));
cout << ans << endl;
return 0;
}
总结
学会转换公式，减少没有必要运行的东西。
仔细分析题目，给定的条件要运用到位。
没有思路的时候就造各种奇葩的数据点，根据数据点去找思路。
猜测题目考点。
遇到认为是二分的题目，就疯狂寻找有没有能够使得题目二分的性质。
认为是动态规划的题目，就要以迭代的思想去考虑，动态规划不是一步就找到答案的，可以想象为优化版的dfs。
312
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
