2022“杭电杯”中国大学生算法设计超级联赛（9）题解报告

最新推荐文章于 2023-09-04 12:03:03 发布
最新推荐文章于 2023-09-04 12:03:03 发布
阅读量318 收藏
点赞数
文章标签： 算法 c++ 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66388127/article/details/126619220
版权

Problem J. Sum Plus Product

题解：

可以判断出\prod_{i=1}^{n}(a_{i}+1)是不变量，所以答案就是\prod_{i=1}^{n}(a_{i}+1) - 1。

代码：

#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<string>
#include<cstring>
#include<cmath>
#define int long long
#define double long double
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;

const int N = 2e5 + 10;
const int mod = 998244353;

int n, a[N];

void solve() {
    cin >> n ;
    for(int i = 1; i <= n ; i ++) cin >> a[i];
    for(int i = 1; i < n; i ++){
        a[i + 1] = (a[i] * a[i + 1] % mod + a[i] + a[i + 1]) % mod;
    }
    cout << a[n] << '\n';
}

signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int t;
    cin >> t;
    while(t--){
        solve();
    }
}

 Problem H. Shortest Path in GCD Graph

题解：

做法. 首先最短路长度不超过2，因为对任意(𝑥, 𝑦)，沿路径𝑥 → 1 → 𝑦即可得到一条长度为2的路径。最短路长度为1当且仅当𝑔𝑐𝑑 (𝑥, 𝑦) = 1，否则等价于询问[1, 𝑛]中满足𝑔𝑐𝑑 (𝑥, 𝑧) =1且𝑔𝑐𝑑 (𝑦, 𝑧) = 1的𝑧的数量，分解𝑥, 𝑦后用容斥可以解决。注意𝑔𝑐𝑑 (𝑥, 𝑦) = 2时，直接𝑥 → 𝑦也是一条长度为2的路径。

代码：

#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<string>
#include<cstring>
#include<cmath>
#define int long long
#define double long double
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;

const int N = 2e5 + 10;
const int mod = 998244353;

int n, nn, q, ans;
vector<int> d;

int gcd(int x, int y){
    return x % y ? gcd(y, x % y) : y;
}

void init(int n){
    for(int i = 2; i * i <= n; i ++){
        if(n % i) continue;
        d.push_back(i);
        while(n % i == 0) n /= i;
    }
    if(n > 1) d.push_back(n);
}

void dfs(int ii, int cnt, int res){
    if(ii == nn){
        if(cnt == 0) return;
        if(cnt % 2) ans += n / res;
        else ans -= n / res;
        return;
    }
    dfs(ii + 1, cnt, res);
    dfs(ii + 1, cnt + 1, res * d[ii]);
}

void solve() {
    cin >> n >> q;
    int u, v;
    while(q--){
        cin >> u >> v;
        if(gcd(u, v) == 1) cout << "1 1\n";
        else{
            ans = 0;
            cout << "2 ";
            d.clear();
            init(u), init(v);
            sort(d.begin(), d.end());
            d.erase(unique(d.begin(), d.end()), d.end());
            nn = d.size();
            dfs(0, 0, 1);
            cout << n - ans + (gcd(u, v) == 2) << '\n';
        }
    }
}

signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int t = 1;
    //cin >> t;
    while(t--){
        solve();
    }
}

Problem G. Matryoshka Doll

题解：

做法. 𝑑𝑝 (𝑥, 𝑦)表示将前𝑥个套娃分成𝑦组的方案数，转移为
𝑑𝑝 (𝑥, 𝑦) = 𝑑𝑝 (𝑥 − 1, 𝑦 − 1) + 𝑑𝑝 (𝑥 − 1, 𝑦) · max{0, 𝑦 − 𝑓 (𝑥)}.
其中𝑓 (𝑥)表示满足1 ≤ 𝑧 < 𝑥且𝑎𝑥 − 𝑟 < 𝑎𝑧 ≤ 𝑎𝑥 的𝑧的个数。

代码：

#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<string>
#include<cstring>
#include<cmath>
#include<set>
#include<stack>
#define int long long
#define double long double
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;

const int N = 5e3 + 10;
const int mod = 998244353;

int n, k, r, a[N], dp[N][N];

void solve()
{
    cin >> n >> k >> r;
    for(int i = 0; i <= n; i++){
        for(int j = 0; j <= k; j ++){
            dp[i][j] = 0;
        }
    }
    for(int i = 1; i <= n; i++){
        cin >> a[i];
    }
    int p = 0; 
    dp[0][0] = 1;
    for(int i = 1; i <= n; i++){
        while(p + 1 < i && a[p + 1] + r <= a[i]) p ++;
        int s = i - p - 1;
        for(int j = s + 1; j <= i; j++){
            dp[i] [j] = ((j - s) * dp[i - 1][j] + dp[i - 1][j - 1]) % mod;
        }
    }
    cout << dp[n][k] << '\n';
}

signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int t = 1;
    cin >> t;
    while(t--){
        solve();
    }
}

Problem C. Fast Bubble Sort

题解：

假设𝑃 = 𝑛1𝜆1𝑛2𝜆2 · · · 𝑛𝑘 𝜆𝑘 ,则𝐵(𝑃) = 𝜆1𝑛1𝜆2𝑛2 · · · 𝜆𝑘𝑛𝑘 ,其中𝑛1, · · · , 𝑛𝑘 为从左到右的局
部最大值且有
𝑛1 < 𝑛2 < · · · < 𝑛𝑘,
则不难证明答案为非空𝜆𝑖 的个数。
将询问离线,每次从𝑛到1倒序扫描左端点𝑙并回答所有左端点为𝑙的询问。对于每个固定的左端
点𝑙，[𝑙, 𝑛]中从左到右的局部最大值可以通过单调栈维护，局部最大值插入/删除对于答案的影
响可以用树状数组/线段树快速更新/求解。

代码：

// #pragma comment(linker, "/STACK:102400000,102400000")
#pragma GCC optimize("O3")
#pragma GCC optimize("O2")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
// #pragma GCC optimize("trapv")
#include<bits/stdc++.h>
// #include <bits/extc++.h>
#define int long long
#define double long double
// #define i128 long long
// #define double long double
using namespace std;
 
#define rep(i,n) for (int i=0;i<(int)(n);++i)
#define rep1(i,n) for (int i=1;i<=(int)(n);++i)
#define range(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define pb push_back
#define F first
#define S second
 
typedef long long ll;
typedef unsigned long long ull;
// typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vi;


namespace internal {

// @param n `0 <= n`
// @return minimum non-negative `x` s.t. `n <= 2**x`
int ceil_pow2(int n) {
    int x = 0;
    while ((1U << x) < (unsigned int)(n)) x++;
    return x;
}

// @param n `1 <= n`
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
// constexpr int bsf_constexpr(unsigned int n) {
//     int x = 0;
//     while (!(n & (1 << x))) x++;
//     return x;
// }

// @param n `1 <= n`
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
int bsf(unsigned int n) {
#ifdef _MSC_VER
    unsigned long index;
    _BitScanForward(&index, n);
    return index;
#else
    return __builtin_ctz(n);
#endif
}

}  // namespace internal


template <class S, S (*op)(S, S), S (*e)()> struct segtree {
  public:
    segtree() : segtree(0) {}
    segtree(int n) : segtree(std::vector<S>(n, e())) {}
    segtree(const std::vector<S>& v) : _n((int)(v.size())) {
        log = internal::ceil_pow2(_n);
        size = 1 << log;
        d = std::vector<S>(2 * size, e());
        for (int i = 0; i < _n; i++) d[size + i] = v[i];
        for (int i = size - 1; i >= 1; i--) {
            update(i);
        }
    }

    void set(int p, S x) {
        assert(0 <= p && p < _n);
        p += size;
        d[p] = x;
        for (int i = 1; i <= log; i++) update(p >> i);
    }

    S get(int p) {
        assert(0 <= p && p < _n);
        return d[p + size];
    }

    S prod(int l, int r) {
        assert(0 <= l && l <= r && r <= _n);
        S sml = e(), smr = e();
        l += size;
        r += size;

        while (l < r) {
            if (l & 1) sml = op(sml, d[l++]);
            if (r & 1) smr = op(d[--r], smr);
            l >>= 1;
            r >>= 1;
        }
        return op(sml, smr);
    }

    S all_prod() { return d[1]; }

    template <bool (*f)(S)> int max_right(int l) {
        return max_right(l, [](S x) { return f(x); });
    }
    template <class F> int max_right(int l, F f) {
        assert(0 <= l && l <= _n);
        assert(f(e()));
        if (l == _n) return _n;
        l += size;
        S sm = e();
        do {
            while (l % 2 == 0) l >>= 1;
            if (!f(op(sm, d[l]))) {
                while (l < size) {
                    l = (2 * l);
                    if (f(op(sm, d[l]))) {
                        sm = op(sm, d[l]);
                        l++;
                    }
                }
                return l - size;
            }
            sm = op(sm, d[l]);
            l++;
        } while ((l & -l) != l);
        return _n;
    }

    template <bool (*f)(S)> int min_left(int r) {
        return min_left(r, [](S x) { return f(x); });
    }
    template <class F> int min_left(int r, F f) {
        assert(0 <= r && r <= _n);
        assert(f(e()));
        if (r == 0) return 0;
        r += size;
        S sm = e();
        do {
            r--;
            while (r > 1 && (r % 2)) r >>= 1;
            if (!f(op(d[r], sm))) {
                while (r < size) {
                    r = (2 * r + 1);
                    if (f(op(d[r], sm))) {
                        sm = op(d[r], sm);
                        r--;
                    }
                }
                return r + 1 - size;
            }
            sm = op(d[r], sm);
        } while ((r & -r) != r);
        return 0;
    }

  private:
    int _n, size, log;
    std::vector<S> d;

    void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};

using S=int;
S op(S l,S r){return l+r;}
S e(){return 0;}


int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};
const int mod=998244353;
const int base[]={12321,32123};
const double EPS=1e-9;
const double pi=acos(-1);
const int INF=1e18;
const int N=100017;
mt19937 rng(1235);

int n,q;
int p[N];
int ans[N],C[N],now[N];
vector<pii> info[N];
int st[N];

int lowbit(int u){return u&(-u);}
void update(int u,int w){for (int i=u;i<=n+7;i+=lowbit(i)) C[i]+=w;}
int query(int u){int ans=0; for (int i=u;i;i-=lowbit(i)) ans+=C[i]; return ans;}
signed main(){
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  int _;
  cin>>_;
  //_=1;
  while (_--){
    cin>>n>>q;
    rep(i,n) cin>>p[i];
    for (int i=1;i<=n+5;++i) C[i]=0,now[i]=0;
    rep(i,N) info[i].clear();
    p[n]=n+1;
    rep(i,q){
      int u,v;
      cin>>u>>v;
      u--, v--;
      info[u].pb({i,v});
    }
    int cnt=0;
    st[cnt++]=n; 
    auto upd=[&](int u){
      update(u+1,(now[u+1]?-1:1)), now[u+1]^=1;
      update(u+2,(now[u+2]?-1:1)), now[u+2]^=1;
    };
    for (int i=n-1;i>-1;--i){
      while (cnt&&p[i]>p[st[cnt-1]]) {
        cnt--; upd(st[cnt]);
      }
      st[cnt++]=i, upd(i);
      for (auto c:info[i]){
        int id=c.F, r=c.S;
        if (i==r) ans[id]=0;
        else ans[id]=(query(r+1)-query(i))/2;
      }
    }
    rep(i,q) cout<<ans[i]<<"\n";
  }
  return 0;
}

Problem A. Arithmetic Subsequence、

题解：

首先如果某个数出现次数大于等于3则不存在解。然后如果所有数字均为偶数，我们
可将所有数除以二;如果所有数字均为奇数，我们可将所有数减去一;否则,我们将所有奇数放在
左边，所有偶数放在右边，对奇数/偶数分治解决。

代码：

#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<string>
#include<cstring>
#include<cmath>
#include<set>
#include<map>
#include<stack>
#define int long long
#define double long double
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;

const int N = 5e3 + 10;
const int mod = 998244353;

int n;
vector<int> ans;

void solve()
{
    cin >> n;
    vector<int> a(n, 0);
    ans.clear();
    map<int, int> cnt;
    for(int i = 0; i < n; i ++) cin >> a[i];
    for(int i = 0; i < n; i++){
        cnt[a[i]] ++;
        if(cnt[a[i]] >= 3) {
            cout << "NO\n";
            return;
        }
    }
    cout << "YES\n";
    vector<pair<int, int>> v;
    for(int i = 0; i < n; i++){
        v.push_back({0, a[i]});
        for(int j = 0; j < 30; j ++){
            if(a[i] >> j & 1) v[i].first |= (1ll << (29 - j));
        }
    }
    sort(begin(v), end(v));
    for(int i = 0; i < n; i ++) ans.push_back(v[i].second);
    for(auto re : ans) cout << re << ' ';
    cout << '\n';
}

signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int t = 1;
    cin >> t;
    while(t--){
        solve();
    }
}

0reooo
关注
杭电acm试题解析和答案
06-11
这是关于杭电的一些acm的解题答案和解析思路
2022“杭电杯”中国大学生算法设计超级联赛（9）
srh20的博客
08-26 175
啦啦啦
杭电ACM2021题
qq_43104182的博客
09-28 1048
#include&amp;lt;stdio.h&amp;gt; int main() { int n,i,temp,sum; while(scanf(&quot;%d&quot;,&amp;amp;n)!=EOF) { if(n==0) { break; } sum=0; for(i=0;i&amp;lt;n;i++) { scanf(&quot;%d&quot;,&amp
杭电ACM题目部分答案
11-30
包含杭电1000-1005,1009,1013,1018,1021,1040,1048,1049,1062,1071,1215,1219,1251,1863,2005,2007,2010-2012,2018,2021,2027,2029,2047,2054,2066,2203,2846
2022”杭电杯“中国大学生算法设计超级联赛（9）1 3 7题解
Shanhj的博客
08-17 442
1001题解 分治法
2021“MINIEYE杯”中国大学生算法设计超级联赛（6）-题解集1
08-03
在2021年"MINIEYE杯"中国大学生算法设计超级联赛中，涉及到多种算法问题，其中一个是"Prime Minister"。这个问题的核心在于找出区间[l, r]，使得区间和是一个质数。对于任何区间，可以通过转换找到一个对应的[r, r]...
2023“钉耙编程”中国大学生算法设计超级联赛（6）.zip
08-04
首先，我们来看"2023“钉耙编程”中国大学生算法设计超级联赛（6）- 题解.pdf"。这份文件很可能是对比赛题目的一种官方解答或解析，涵盖了各个问题的解决方案和思路。它可能包括了算法的设计、时间复杂度和空间...
2021“MINIEYE杯”中国大学生算法设计超级联赛（9）-题解1
08-03
在本题解中，主要涉及的是算法设计与优化的问题，特别是如何高效地构造一个整数。首先，我们从基础的二进制翻倍思想出发，然后通过应用四俄罗斯方法（Four Russians Method）来提高效率，最后通过进一步优化，找到了...
2021“MINIEYE杯”中国大学生算法设计超级联赛（4）-题解1
08-03
在本次"2021“MINIEYE杯”中国大学生算法设计超级联赛（4）-题解1"中，涉及的算法知识广泛，包括图论、字符串处理、动态规划和数据结构等。下面将对题目中的几个关键点进行详细解析： 1. **Calculus 题解**：这道题...
2023“钉耙编程”中国大学生算法设计超级联赛(9)-资料包.zip
08-15
《2023“钉耙编程”中国大学生算法设计超级联赛(9)——深度解析与扩展学习》 “钉耙编程”中国大学生算法设计超级联赛是面向广大编程爱好者及在校大学生的一项重要赛事，旨在提升参赛者的算法设计能力和编程实践...
ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)； 的作用和注意事项
最新发布
m0_62531913的博客
09-04 1万+
默认情况下，C++的输入输出流与C标准库的输入输出函数是同步的，这会造成一定的性能损失。：使用cin.tie(0)和cout.tie(0)可以取消cin与cout之间的绑定，这意味着在进行输入操作时，不需要强行刷新输出缓冲区。：如果你的程序在输入输出中同时使用了C++的输入输出流和C标准库的输入输出函数（如scanf和printf），则不应该使用这段代码。：在使用了这段代码后，应避免使用C标准库的输入输出函数（如printf和scanf），因为这些函数与输入输出流的同步已被关闭。这段代码的主要用途是。
ios::sync_with_stdio(false)；cin.tie(0)；cout.tie(0)；
Shùn Zhāng的博客
07-21 1080
sync_with_stdio()这个函数是一个是否兼容stdio的开关，默认情况写为true，C++为了兼容C，保证程序在使用了printf和cout的时候不发生混乱，将输出流绑到了一起。
22.4.12
aidaqiudeaichao的博客
04-12 570
1，没有上司的舞会（树形dp）2,二叉树模板;3，FBI树；4，手写哈希表； 1，没有上司的舞会 题意： 按照闫式dp分析法： 第一步状态表示： f[ u , 0 ] 表示在以u为根节点的子树中选，且不选u这个点的方案的集合； f[ u , 1] 表示在以u为根节点的子树中选，且选u这个点的方案的集合； 所以最终答案应该是max(f[root][0], f[root][1])； 属性：max； 第二步，状态计算： 先划分集合： 先看f[u , 0 ]， 因为当前u这个结点不选，所..
关于ios::sync_with_stdio(false);和cin.tie(0);cout.tie(0)
moyangxian
01-23 3792
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); 在ACM里，经常出现数据集超大造成 cin TLE的情况。这时候大部分人认为这是cin的效率不及scanf的错，甚至还上升到C语言和C++语言的执行效率层面的无聊争论。其实像上文所说，这只是C++为了兼容而采取的保守措施。我们可以在IO之前将stdio解除绑定，这样做了之后要注意不要同时混...
sync_with_stdio和cin.tie(0)； cout.tie(0)；
热门推荐
流楚丶格念的博客
02-25 1万+
文章目录sync_with_stdiotieACM应用 sync_with_stdio 这个函数是一个“是否兼容stdio”的开关，C++为了兼容C，保证程序在使用了std::printf和std::cout的时候不发生混乱，将输出流绑到了一起。 tie tie是将两个stream绑定的函数，空参数的话返回当前的输出流指针。 在默认的情况下cin绑定的是cout，每次执行 << 操作符的时候都要调用flush，这样会增加IO负担。可以通过tie(0)（0表示NULL）来解除cin与cout的绑定
2022年第十三届蓝桥杯省赛C++B组【真题解析】
qq_17807067的博客
10-06 1万+
2022年第十三届蓝桥杯省赛C++B组【真题解析】
第十三届蓝桥杯第二场模拟赛题解
一个算法学习者的博客
12-13 2416
第一题 第二题 #include <bits/stdc++.h> #define CLOSE ios::sync_with_stdio(false);cin.tie(0);cout.tie(0) //const int N=1e6; typedef long long ll; using namespace std; int main() { int sum=0; for(int i=1;i<=2021;i++) { if(..
VC中实现GCC的2个比较常用的位运算函数
weixin_30819163的博客
12-07 167
在GCC中内嵌了两个位运算的函数，但在VC中并没有这两个函数（有相似函数）。 //返回前导的0的个数。 int __builtin_clz (unsigned int x) //返回后面的0个个数，和__builtin_clz相对。 int __builtin_ctz (unsigned int x) 这两个函数在radix tree中直接计算索引，对性能有一定要求。 自己写有些效率问题...
cin.tie(NULL)--加速
Tczxw的专栏
07-08 5734
我是怎么在不知道这一对函数的情况下活到今天的，以前碰到cin TLE的时候总是傻乎乎地改成scanf，甚至还相信过C++在IO方面效率低下的鬼话，殊不知这只是C++为了兼容C而采取的保守措施。 tie tie是将两个stream绑定的函数，空参数的话返回当前的输出流指针。 1 2 3 4 5 6 7 8
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值