蓝桥杯算法赛第4场小白入门赛&强者挑战赛

已于 2024-02-04 09:19:36 修改
阅读量1.1k 收藏 18
点赞数 20
分类专栏： 比赛题解 ACM/ICPC 文章标签： 蓝桥杯 算法 ACM 动态规划
于 2024-01-31 16:39:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012061345/article/details/135939811
版权

蓝桥杯算法赛第4场小白入门赛&强者挑战赛

链接：
第 4 场 小白入门赛
第 4 场 强者挑战赛

小白1

直接用C++内置函数即可。

#include <bits/stdc++.h>
using namespace std;

#include <bits/extc++.h>
using namespace __gnu_pbds;

using llt = long long;
using Real = double;
using vi = vector<int>;

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(0);
    cout << __builtin_popcount(2024) << endl;
    return 0;
}

小白2

做个字典即可。

import os
import sys
p = {'yuanxing':1, 'zhengfangxing':2, 'changfangxing':3, 'sanjiaoxing':4, 'tuoyuanxing':5, 'liubianxing':6}

n = int(input())
a = input().split()
ans = 0
for i in a:
    ans += p[i]
print(ans)

小白3

经典的NIM问题。当异或和为零时，先手必败。所以当石子数量为偶数时，分成两堆即可。当数量为奇数时，无论怎么分，最低位的1不可能异或为零，也就是说异或和必不为零，先手必胜。

#include <iostream>
using namespace std;
int main()
{
  int n; cin >> n;
  cout << (n % 2 == 0 ? "B" : "A") << "\n"; 
  return 0;
}

强者1

很明显的贪心，无论轮到谁取，均取当前最大的数即可。

#include <bits/stdc++.h>
using namespace std;

#include <bits/extc++.h>
using namespace __gnu_pbds;


using llt = long long;
using Real = double;
using vi = vector<int>;
using pii = pair<int, int>;


int N;
vi A;

void proc(){    
    sort(A.begin(), A.end(), greater<int>());
    llt a[2] = {0};
    int o = 0;
    for(int i=1;i<N;i+=2){
        a[o] += A[i - 1];
        a[o ^ 1] += A[i];
        o ^= 1;
    }
    cout << a[0] << " " << a[1] << endl;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(0);
    cin >> N;
    A.assign(N, {});
    for(auto & i : A) cin >> i;
    proc();
    return 0;
}

小白4强者2

抽屉原理。因为总取值范围为36500，所以当取数数量超过100时，必然有两个数之差在365及其以内。当数量不超过100时，排序以后逐个检验一下即可。

#include <bits/stdc++.h>
using namespace std;

#include <bits/extc++.h>
using namespace __gnu_pbds;

using llt = long long;
using Real = double;
using vi = vector<int>;

int N;
int Q;
vi A;

const array<string, 2> ANS = {"NO", "YES"};

int proc(int s, int e){
    if(e >= s + 100) return 1;
    vi vec(A.begin() + s, A.begin() + e + 1);
    sort(vec.begin(), vec.end());
    for(int i=1,n=vec.size();i<n;++i){
        if(vec[i] - vec[i - 1] <= 365) return 1;
    }
    return 0;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(0);
    cin >> N >> Q;
    A.assign(N, {});
    for(auto & i : A) cin >> i;
    for(int s,e,q=1;q<=Q;++q){
        cin >> s >> e;
        cout << ANS[proc(s - 1, e - 1)] << "\n"; 
    }
    return 0;
}

小白5强者3

逆序对树状数组相关。首先把二元组的数组计算出来，每个元素是 ( i , P A i ) (i, P_{A_i}) (i,PAi​​)。这个很容易计算。将二元组数组看做是 ( x , y ) (x,y) (x,y)的数组，所以该题的条件其实就是一个二维偏序的条件，即两个维度都要小。然后该题本质上就是对每一个点 ( x i , y i ) (x_i,y_i) (xi​,yi​)求：
c i × x + i − ∑ j 是 i 左下的点 x j c_i\times{x+i} - \sum_{j是i左下的点}{x_j} ci​×x+i−j是i左下的点∑​xj​

其中 c i c_i ci​是位于 i i i点左下的所有点的数量。

弄两个树状数组，记作b1和b2，则对每一个点 ( x , y ) (x,y) (x,y):

  • 在b1中查询[1, y)的和，该和表示一共有多少个点位于左下，记作c
  • 在b2中查询[1, y)的和，该和表示左下点x坐标之和, 记作s
  • 然后将 c * x - s 累加进去即可
  • 然后将 b1[y] 加 1， b2[y] 加 x 即可
#include <bits/stdc++.h>
using namespace std;

#include <bits/extc++.h>
using namespace __gnu_pbds;


using llt = long long;
using Real = double;
using vi = vector<int>;

struct FenwickTree{ // 树状数组

using value_type = long long int;
using vec_type = vector<value_type>;

int n;
vec_type c;

FenwickTree() = default;

static int lowbit(int x){return x & -x;}

void init(int nn){this->c.assign((this->n=nn) + 1, 0);}

void modify(int pos, value_type delta){
    for(int i=pos;i<=this->n;i+=lowbit(i)) this->c[i] += delta;
}

value_type query(int pos)const{
    value_type ans = 0;
    for(int i=pos;i;i-=lowbit(i)) ans += this->c[i];
    return ans;
}

value_type query(int s, int e)const{return this->query(e) - this->query(s - 1);}

}Bt1, Bt2;

using pii = pair<int, int>;

int N;
vi A, B;

void input(vi & v, int n){
    v.assign(n, {});
    for(auto & i : v) cin >> i;
}

llt proc(){
    vi pos(N + 1, {});
    for(int i=0;i<N;++i) pos[B[i]] = i;

    vector<pair<int, int>> vec(N);
    for(int i=0;i<N;++i){
        vec[i] = {i + 1, pos[A[i]] + 1};
    }
    // sort(vec.begin(), vec.end(), [](pii a, pii b){return a.second < b.second;});

    llt ans = 0;
    Bt1.init(N); Bt2.init(N);
    for(int i=0;i<N;++i){
        auto k = vec[i].first;
        auto v = vec[i].second;

        auto c = Bt1.query(v);
        Bt1.modify(v, 1);

        auto s = Bt2.query(v);
        Bt2.modify(v, k);

        ans += c * k - s;
    }

    return ans;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(0);
    cin >> N;
    input(A, N); input(B, N);
    cout << proc() << endl;
    return 0;
}

小白6强者4

概率推公式。有 N N N个格子，第 i i i格有 P i P_i Pi​的概率到下一格（第 N N N格的下一格是第1格），有 1 − P i 1-P_i 1−Pi​的概率就此停止。问每一格最终停下的概率，以及对这些概率排序。

对于第1格而言，有 1 − P 1 1-P_1 1−P1​的概率直接停下，或者转一圈回来以后再以 1 − P 1 1-P_1 1−P1​的概率，或者转二圈再以 1 − P 1 1-P_1 1−P1​的概率，……；
对于第2格而言，首先要到达第2格，这个概率是 P 1 P_1 P1​，然后剩下的推导类似；
所以，首先令
Π = ∏ i = 1 N P i \Pi=\prod_{i=1}^{N}{P_i} Π=i=1∏N​Pi​
即转一圈的概率。

对第 i i i格，停止在此的概率是：
Q i = P 1 × P 2 × ⋯ × P i − 1 × ( 1 − P i ) × ( 1 + Π + Π 2 + Π 3 + ⋯ ) = P 1 × P 2 × ⋯ × P i − 1 × ( 1 − P i ) × 1 1 − Π Q_i=P_1\times{P_2}\times\cdots\times{P_{i-1}}\times{(1-P_i)}\times\big(1+\Pi+\Pi^2+\Pi^3+\cdots\big)=P_1\times{P_2}\times\cdots\times{P_{i-1}}\times{(1-P_i)}\times\frac{1}{1-\Pi} Qi​=P1​×P2​×⋯×Pi−1​×(1−Pi​)×(1+Π+Π2+Π3+⋯)=P1​×P2​×⋯×Pi−1​×(1−Pi​)×1−Π1​

如果不考虑求逆的时间，在 O ( N ) O(N) O(N)内即可求出上述每一个 Q i Q_i Qi​。

然后考虑排序，这个比较麻烦，因为要比较概率本身，而不能比较取模以后的数。

考虑 Q i Q_i Qi​和 Q j Q_j Qj​比较大小，不失一般性，假设 i < j i\lt{j} i<j。则
Q i = P 1 × P 2 × ⋯ × P i − 1 × ( 1 − P i ) × 1 1 − Π Q_i=P_1\times{P_2}\times\cdots\times{P_{i-1}}\times{(1-P_i)}\times\frac{1}{1-\Pi} Qi​=P1​×P2​×⋯×Pi−1​×(1−Pi​)×1−Π1​
Q j = P 1 × P 2 × ⋯ × P i − 1 × P i × ⋯ × ( 1 − P j ) × 1 1 − Π Q_j=P_1\times{P_2}\times\cdots\times{P_{i-1}}\times{P_i}\times\cdots\times{(1-P_j)}\times\frac{1}{1-\Pi} Qj​=P1​×P2​×⋯×Pi−1​×Pi​×⋯×(1−Pj​)×1−Π1​

首先讨论特殊情况：

  1. 当 P i , P j P_i,P_j Pi​,Pj​全为1时，即不可能停在此2格，停下的概率为零，根据题意， i i i应该排在前面；
  2. 当 P i , P j P_i,P_j Pi​,Pj​任意为1时，可知一个停下的概率为零，另一个不为零，则大小关系可以确定。

然后讨论一般情况，即二者全不为1时。可以证明 Q i ≥ Q j Q_i\ge{Q_j} Qi​≥Qj​。

Q i ≥ Q j ⇔ P 1 × P 2 × ⋯ × P i − 1 × ( 1 − P i ) × 1 1 − Π ≥ P 1 × P 2 × ⋯ × P i − 1 × P i × ⋯ × ( 1 − P j ) × 1 1 − Π ⇔ 1 − P i ≥ P i × ⋯ × ( 1 − P j ) \begin{aligned} Q_i\ge{Q_j} &\Leftrightarrow{P_1\times{P_2}\times\cdots\times{P_{i-1}}\times{(1-P_i)}\times\frac{1}{1-\Pi}}\ge{P_1\times{P_2}\times\cdots\times{P_{i-1}}\times{P_i}\times\cdots\times{(1-P_j)}\times\frac{1}{1-\Pi}}\\ &\Leftrightarrow{1-P_i}\ge{{P_i}\times\cdots\times{(1-P_j)}} \end{aligned} Qi​≥Qj​​⇔P1​×P2​×⋯×Pi−1​×(1−Pi​)×1−Π1​≥P1​×P2​×⋯×Pi−1​×Pi​×⋯×(1−Pj​)×1−Π1​⇔1−Pi​≥Pi​×⋯×(1−Pj​)​
对最后一个不等式的右边做缩放，只需证明
1 − P i ≥ P i × ( 1 − P j ) (*) {1-P_i}\ge{{P_i}\times{(1-P_j)}}\tag{*} 1−Pi​≥Pi​×(1−Pj​)(*)
即可

而 ( ∗ ) (*) (∗)等价于
1 − 2 P i + P i P j ≥ 0 1-2P_i+P_{i}P_j\ge{0} 1−2Pi​+Pi​Pj​≥0

注意到题目给出的概率的形式，当 P i P_i Pi​不为1时，必有 P i ≤ 1 2 P_i\le{\frac{1}{2}} Pi​≤21​成立。因此最后一个不等式是成立的，从而可知 i i i要排在 j j j前面。

于是得到了一个不必计算概率的具体值就能排序的准则， s o r t sort sort一下即可。

#include <bits/stdc++.h>
using namespace std;

#include <bits/extc++.h>
using namespace __gnu_pbds;


using llt = long long;
using Real = double;
using vi = vector<int>;

llt const MOD = 998244353;

llt qpow(llt a, llt n){
    llt r = 1;
    while(n){
        if(n & 1) r = r * a % MOD;
        a = a * a % MOD;
        n >>= 1;
    }
    return r;
}

llt inv(llt a){return qpow(a, MOD-2LL);}

int N;
vector<llt> P;

llt myhash(const vector<llt> & vec){
    llt ans = 0;
    llt k = 0;
    for(auto i : vec){
        ans = (ans + (++k) * i % MOD) % MOD;
    }
    return ans;
}

void proc(){
    auto tmp = accumulate(P.begin(), P.end(), 0LL);
    auto pi = inv(qpow(2LL, tmp));

    auto fenmu = inv((MOD + 1 - pi) % MOD);
    vector<llt> ans(N);
    llt fenzi = 1;
    for(int i=0;i<N;++i){
        auto p = inv(qpow(2, P[i]));
        auto q = (MOD + 1 - p) % MOD;
        ans[i] = fenzi * q % MOD * fenmu % MOD;
        fenzi = fenzi * p % MOD;
    }

    vector<llt> rank(N);
    for(int i=0;i<N;++i) rank[i] = i + 1;
    sort(rank.begin(), rank.end(), [&](int i, int j){
        i -= 1, j -= 1;
        if(0 == P[i]){ // 100%会走，即停到此处的概率为0
            if(0 == P[j]) return i < j; 
            return false; // 停在j的概率肯定比i大
        }
        if(0 == P[j]) return true;
        return i < j;
    });

    cout << myhash(ans) << endl;
    cout << myhash(rank) << endl;
    return;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(0);
    cin >> N;
    P.assign(N, {});
    for(auto & i : P) cin >> i;
    proc();
    return 0;
}

强者5

预处理加 D P DP DP。

注意到题目强调了每个用户是独立的，因此首先做一个预处理，计算出二维数组 U s e r 2 G a i n User2Gain User2Gain。 U s e r 2 G a i n [ i ] [ j ] User2Gain[i][j] User2Gain[i][j]表示如果给第 i i i个用户分配 j j j个空间，其收益是多少。收益等于M - 缺页中断数。（为什么要减一下计算收益，因为笔者最开始弄错了，以为是一个分组背包，所以减一下刚好可以计算最大收益）

U s e r 2 G a i n User2Gain User2Gain辅助以数据结构应该比较容易算出来。假设用户的请求数量平均分配为 M / K M/K M/K个，则预处理时间应该是 O ( K × M k log ⁡ M K ) O(K\times\frac{M}{k}\log{\frac{M}{K}}) O(K×kM​logKM​)，最差情况可能是 O ( M log ⁡ M ) O(M\log{M}) O(MlogM)。不太确定这个复杂度对不对。

接下来 D P DP DP，令 D i , j D_{i,j} Di,j​表示前 i i i个用户分配 j j j个空间所能获得的最大收益，则
D i , j = max ⁡ ( D i − 1 , k + U s e r 2 G a i n [ i ] [ j − k ] , k ∈ [ 0 , j ] ) D_{i,j}=\max(D_{i-1,k}+User2Gain[i][j-k],k\in{[0,j]}) Di,j​=max(Di−1,k​+User2Gain[i][j−k],k∈[0,j])

算出最大收益，再减回来就得到了最小的缺页数。

上述计算要三重循环，看起来是立方的，但实际上不是。考虑到每个用户平均分配到 M K \frac{M}{K} KM​个空间，因此，第1个用户只需计算到 M K \frac{M}{K} KM​，第2个用户只需计算到 2 M K \frac{2M}{K} K2M​，第3个用户到 3 M K \frac{3M}{K} K3M​，……

实际计算次数是
( M K + 2 M K + 3 M K + ⋯ + K M K ) × M K ≡ O ( M 2 ) \big(\frac{M}{K}+\frac{2M}{K}+\frac{3M}{K}+\cdots+\frac{KM}{K}\big)\times{\frac{M}{K}}\equiv{O(M^2)} (KM​+K2M​+K3M​+⋯+KKM​)×KM​≡O(M2)

这似乎也是最差情况。同样不保证这个复杂度分析一定对，感觉没错。

#include <bits/stdc++.h>
using namespace std;

#include <bits/extc++.h>
using namespace __gnu_pbds;


using llt = long long;
using Real = double;
using vi = vector<int>;
using pii = pair<int, int>;

__gnu_pbds::priority_queue<pii, function<bool(const pii &, const pii &)>> Q([](const pii & a, const pii & b){
    assert(a.second != b.second);
    return a.second < b.second;
});

int N, K, M;
vector<pii> Req;
vi Lisan;
vector<vi> User2Gain;
vector<vi> D;

int proc(const vi & req, int alloc){
    map<int, pair<vi, int>> req2pos;
    for(int i=0;i<req.size();++i) req2pos[req[i]].first.emplace_back(i);

    Q.clear();
    int k = 1;
    for(auto & p : req2pos){
        p.second.second = 0;
        p.second.first.emplace_back(M + M + k++);
    }

    vi flag(M + 1, 0);
    int ans = 0;
    int used = 0;
    for(int i=0;i<req.size();++i){
        auto r = req[i];
        if(0 == flag[r]){
            ans += 1;

            if(used < alloc){
                used += 1;
            }else{
                while(1){
                    auto h = Q.top();
                    Q.pop();
                    if(h.second > i){
                        flag[h.first] = 0;
                        break;
                    }
                }
            }
        }
        flag[r] = 1;
        auto & mm = req2pos[r];
        Q.push({r, mm.first[++mm.second]});
    }
    return ans;
}

void proc(const vi & req, vi & gain){
    vi flag(M + 1, 0);
    int n = 0;
    for(auto i : req){
        if(flag[i] == 0){
            flag[i] = 1;
            n += 1;
        }
    }
    if(n > N) n = N;
    gain.assign(n + 1, 0);
    gain[0] = M - req.size();
    for(int i=1;i<=n;++i){
        gain[i] = M - proc(req, i);
    }

    return;
}

int proc(){
    Lisan.clear(); Lisan.reserve(M + 1);
    Lisan.emplace_back(0);
    for(const auto & p : Req) Lisan.emplace_back(p.second);
    sort(Lisan.begin(), Lisan.end());
    Lisan.erase(unique(Lisan.begin(), Lisan.end()), Lisan.end());

    vector<vi> user2req(K + 1, vi());
    for(auto & p : Req){
        p.second = lower_bound(Lisan.begin(), Lisan.end(), p.second) - Lisan.begin();
        user2req[p.first].emplace_back(p.second);
    }

    User2Gain.assign(K + 1, vi());
    for(int i=1;i<=K;++i){
        proc(user2req[i], User2Gain[i]);
 
        // cout << i << ":";
        // for(auto j : User2Gain[i]){
        //     cout << " " << M - j;
        // }
        // cout << endl;
    }

    D.assign(K + 1, vi(N + 1, 0));
    int total = 0;
    for(int user=1;user<=K;++user){
        const auto & gain = User2Gain[user];
        total += gain.size() - 1;
        if(total >= N) total = N;
        
        for(int space=0;space<=total;++space){
            int ava = min((int)gain.size() - 1, space);
            auto & tmp = D[user][space];
            
            for(int i=0;i<=ava;++i){
                tmp = max(tmp, D[user-1][space-i] + gain[i]);
            }
        }
        
    }

    int ans = M * K;
    const auto & vec = D[K];
    for(int i=0;i<=N;++i){
        ans = min(ans, M * K - vec[i]);
    }
    return ans;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(0);
    int nofkase = 1;
    cin >> nofkase;
    while(nofkase--){
        cin >> N >> K >> M;
        Req.assign(M, {});
        for(auto & p : Req) cin >> p.first >> p.second;
        cout << proc() << "\n";
    }
    return 0;
}

强者6

差分加树状数组。
假设第 i i i个请求和第 j j j个请求是同一个页面，则 j j j有可能命中缓存。取决于 i , j i,j i,j之间不同页面种类的数量与缓存空间的大小关系。为方便论述，称不同页面种类的数量为间隔数。例如：
1 , 2 , 3 , 4 , 2 , 3 , 4 , 1 1,2,3,4,2,3,4,1 1,2,3,4,2,3,4,1

上述两个页面1之间的间隔数为3，所以当缓存空间大于3时，第二个页面1必然是命中的；否则必然有缺页中断。基于简单的贪心可知，如果缓存空间为 K K K时，某个 j j j请求会有缺页中断，则缓存空间更小时，必然也会有缺页中断。因此只需要对相邻的相等页面，求出间隔数即可。这是一个典型的树状数组应用。

令 A A A数组是页面请求数组， B B B是一个树状数组。pre[v]是数值v在数组 A A A中前一个最近的位置。则：

for i,v in A:
    求B[pre[v], v]之间的和，记作s, s就是一个间隔数, 令cnt[s] += 1
    将B[pre[v]] -= 1
    将B[i] += 1
    pre[v] = i

由此就得到了每一个间隔数出现的数量，根据此就能算出缺页数（注意到此时，页面是几其实已经不重要）。

计算间隔数应该是 O ( M log ⁡ M ) O(M\log{M}) O(MlogM)，根据间隔数计算 A n s Ans Ans应该是 O ( M ) O(M) O(M)。

#include <bits/stdc++.h>
using namespace std;

#include <bits/extc++.h>
using namespace __gnu_pbds;


using llt = long long;
using Real = double;
using vi = vector<int>;
using pii = pair<int, int>;

struct FenwickTree{ // 树状数组

using value_type = long long int;
using vec_type = vector<value_type>;

int n;
vec_type c;

FenwickTree() = default;

static int lowbit(int x){return x & -x;}

void init(int nn){this->c.assign((this->n=nn) + 1, 0);}

void modify(int pos, value_type delta){
    for(int i=pos;i<=this->n;i+=lowbit(i)) this->c[i] += delta;
}

value_type query(int pos)const{
    value_type ans = 0;
    for(int i=pos;i;i-=lowbit(i)) ans += this->c[i];
    return ans;
}

value_type query(int s, int e)const{return this->query(e) - this->query(s - 1);}

}Bt;


int M;
vi A;
vi Ans;

void proc(){    
    Bt.init(M);
    map<int, int> cnt;
    vi pre(1000000 + 1, 0);
    for(int p,v,i=0;i<M;++i){
        p = i + 1;
        v = A[i];
        if(pre[v]){
            Bt.modify(pre[v], -1);
            cnt[Bt.query(pre[v], p)] += 1;
        }else{
            cnt[M] += 1;
        }        
        Bt.modify(pre[v] = p, 1);
    }

    Ans.assign(M + 1, 0);
    int sum = 0;

    int another = M;
    for(auto it=cnt.rbegin(),jt=++cnt.rbegin(),et=cnt.rend();jt!=et;++it,++jt){
        int last = it->first;
        int start = jt->first;
        sum += it->second;
        fill(Ans.begin() + start + 1, Ans.begin() + last + 1, sum);
    }

    cout << (Ans[0] = M);
    for(int i=1;i<=M;++i) cout << " " << Ans[i];
    cout << endl;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(0);
    cin >> M;
    A.assign(M, {});
    for(auto & i : A) cin >> i;
    proc();
    return 0;
}
罗博士
关注
  • 20
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
蓝桥杯第十三届蓝桥杯省赛第一轮
06-12
第十三届 蓝桥杯（电子类）EDA设计与开发项目 第一部分 客观试题（15 分） 1) 电容器在电路中的功能包括（ ）。 A. 滤波 B. 耦合 C. 谐振 D. 旁路 2) 下列表达式中与电路图相符的是（ ）。 A. Y = A + B + C B. Y = ...
第十三届省赛第二场蓝桥杯eda
06-12
第十三届 蓝桥杯（电子类）EDA设计与开发项目 第一部分 客观试题（15 分） 1) 一般情况下，下列哪种封装可设计的引脚数量最多（ ）. A. SOT23 B. SOP C. SOT89 D. BGA 2) 下列哪些情况可能导致从原理图向 PCB ...
Alexnet 和 VGGnet学习整理笔记
zero_gau的博客
10-30 2015
Alex Net AlexNet是2012年ImageNet竞赛冠军获得者Hinton和他的学生Alex Krizhevsky设计的。也是在那年之后，更多的更深的神经网路被提出，比如优秀的vgg,GoogleLeNet。其官方提供的数据模型，准确率达到57.1%,top 1-5 达到80.2%. 这项对于传统的机器学习分类算法而言，已经相当的出色。 上图所示是caffe中alexnet的网...
[ CTF ]【天格】战队WriteUp-第六届“强网杯”全国安全挑战赛（初赛）
ZXW_NUDT的博客
08-01 3440
第六届“强网杯”全国网络安全挑战赛
[论文阅读]KiTS(肾脏肿瘤分割挑战赛)2019第一名解决方案----An attempt at beating the 3D U-Net
gefeng1209的博客
10-26 3229
预处理方法 1.重采样 KiTS数据集的图像spacing是不相同的，卷积神经网络没有办法解释体素间距，因此需要通过重采样将所有图像的体素spacing统一到一个公共的值，文章的target spacing=3.22*1.62*1.62，对应的图像shape=128*248*248 2.强度裁剪 当从不同的扫描仪或医院扫描同一器官时，期望同一器官的强度值是相同的。这个属性经常被用来设置一个...
2018 华为软件精英挑战赛 （上合赛区决赛：227/300分）
Demon-初来驾到
04-30 3569
2018 华为软件精英挑战赛 （上合赛区决赛：227/300分） 开源 https://github.com/demonSong/HUAWEI-2018 前言 些许遗憾，没能进入上合赛区前四强，不过从中学习到的一些trick，以及比赛套路值得回味，当然还认识了许多赛区大佬，和他们交流的过程中，总能发掘一些新思路来弥补现有模型的不足。对于我们而言，这次比赛，我们被模型给限制住了思路，...
零基础小白怎么准备蓝桥杯-蓝桥杯竞赛经验分享
最新发布
孙不坚1208
12-06 1722
博主在蓝桥杯中获得过十四届Java B 组的省一国二，本文为大家介绍一下蓝桥杯并分享一下自己的参赛经验。​蓝桥杯全称《蓝桥杯全国软件和信息技术专业人才大赛》，是由国信蓝桥和工信部举办的全国性IT学科赛事。全国1200余所高校参赛，累计参赛人数超过40万人。蓝桥杯大赛连续两年被列入中国高等教育学会发布的“全国普通高校学科竞赛排行榜”，是高校教育教学改革和创新人才培养的重要竞赛项目。对大学生综合评测，奖学金评定，保研加分都有一定助益。
2021第十二届蓝桥杯省赛第一场成绩.zip
04-28
2021第十二届蓝桥杯省赛第一场成绩
蓝桥杯算法比赛历届试题
02-28
蓝桥杯算法比赛试题，包含训练题和答案
蓝桥杯算法竞赛复习资料(简单入门级一开始复习)
01-22
蓝桥杯算法竞赛复习资料(简单入门级一开始复习)。为促进软件和信息领域专业技术人才培养，提升高校毕业生的就业竞争力，工业和信息化部人才交流中心自 2010 年起，连续十三年举办 "蓝桥杯"全国软件和信息技术专业...
旋转体的体积和表面积
热门推荐
RBS的专栏
09-18 3万+
积分公式 令曲线y=f(x)y=f(x)绕xx轴旋转，形成的旋转体，则其体积和表面积可以计算积分而得（假设体积和表面积一定存在，积分一定存在，这里不讨论数学问题）。 体积公式为： V=∫πy2dxV={\int}{\pi}{y^2}dx 表面积公式为 S=∫2πy1+y′2−−−−−−√dxS=\int{2\pi}{y}\sqrt{1+{y^{\prime}}^2}dx 剩下的就是推导
快速傅里叶变换的相关定义、原理及其递归算法
RBS的专栏
06-18 1万+
快速傅里叶变换FFT是离散傅里叶变换DFT的一种快速算法，实际上诸如Matlab等科学计算软件都已经实现了FFT，只需调用相应的接口即可。在ACM里，FFT的典型应用就是大数的乘法或者多项式的乘法。顺便，如果题目规模不是很大，有关大数的运算推荐使用Java语言，使用java.math.BigInteger包完成；包括高精度运算，可以使用BigDecimal包完成。任何情况下，会一门外语总是很重要的
字符串的特征向量与KMP算法
RBS的专栏
03-30 8629
字符串的特征向量就是由字符串各位置上的特征数构成的一个向量。设字符串为P，令Pi为从字符串首字母到第i个位置的前缀，则字符串P的i位置上的特征数就是Pi的首尾非空真子串匹配的最大长度。例如：字符串abcdaabcab的特征向量是(0,0,0,0,1,1,2,3,1,2)。其中第5个位置的特征数是1，因为P5是abcdaa，首尾非空真子串能够匹配的就是a；而第7个位置的特征数是3，因为P7是abcda
快速傅里叶变换FFT的迭代实现
RBS的专栏
06-18 6201
《快速傅里叶变换的相关定义、原理及其递归算法》描述了y
根据递推公式构造系数矩阵用于快速幂
RBS的专栏
08-16 5813
简单的例子FibonacciFibonacci数列考虑FibonacciFibonacci数列， F(n)=F(n−1)+F(n−2)F(n)=F(n-1)+F(n-2) 将右边两项看做是一个列向量的形式，令 Xn−1={Fn−1Fn−2}X_{n-1}=\left\{\begin{matrix}F_{n-1}\\F_{n-2}\end{matrix}\right\} 很容易得到XnX_n的
树上莫队算法
RBS的专栏
01-05 5536
江湖传闻，莫队算法能够解决一切区间查询问题。这样说来，莫队算法也能够解决一切树上路径查询问题，将树上操作转化为DFS序列上的区间操作即可。当然考虑到，树上路径在DFS序列中的性质，还要会求LCALCA。考虑上图中的树，其DFS序为其任意点对aa、bb之间的路径，具有如下性质，令lcalca为aa、bb的最近公共祖先： 若lcalca是aa、bb之一，则aa、bb之间的InIn时刻的区间或者OutOu
自动机初步之DFA
RBS的专栏
08-02 5193
自动机是一种非常有力的工具，其完备的理论可以参考编译原理或者形式语言与自动机等相关教材。从某种定义角度而言，图灵机也是自动机的一种。这里提到的自动机特指有限状态自动机，简称为FA，根据状态转移的性质又分为确定的自动机（DFA）和非确定的自动机（NFA）。FA的表达能力等价于正规表达式或者正规文法。FA可以看做是一个有向带权图，图的顶点集合称为自动机的状态集合，图的权值集合为自动机的字母集合，图的边代
GJK算法求凸多边形之间的距离
RBS的专栏
04-18 4854
GJK算法最初用来求三维空间中凸多面体的距离（即最近距离），也因此经常用来做碰撞检测（距离是否为0）。后被推广到n维空间中求凸包之间的距离，此处用来求二维平面上2个凸多边形的距离。 GJK算法首先要解决计算Minkowski和的问题。所谓Minkowski和，指A、B两个集合，令A+B={x+y，其中x属于A，y属于B}即二者的Minkowski和。类似的可以定义负集与Minkow...
2022 第十四届蓝桥杯模拟赛第三期
03-29
本届蓝桥杯模拟赛第三期将于2022年5月14日举行。 本次模拟赛将分为初赛和复赛两个阶段。初赛采用在线评测的方式进行，参赛者需在规定时间内完成题目的提交和评测。初赛将根据成绩排名，选拔出前50%的选手进入复赛。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值