North American Southeast Regional 2019 (Div 1) 补题

最新推荐文章于 2022-01-17 16:18:17 发布
最新推荐文章于 2022-01-17 16:18:17 发布
阅读量655 收藏 5
点赞数
分类专栏： 赛后补题专栏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44059127/article/details/112513326
版权

题目链接

https://codeforces.com/gym/102423

参考题解

A - Carryless Square Root

简要题意：

本题定义加法为不进位加法，如 3 + 8 = 1 3 + 8 = 1 3+8=1，乘法按竖式乘法计算，不进位。给定 n ( 1 ≤ n ≤ 1 0 25 ) n(1 \leq n \leq 10^{25}) n(1≤n≤1025)，求满足 a ∗ a = n a*a=n a∗a=n 的最小的 a a a，无解输出 − 1 -1 −1。

解题思路：

若 n n n 为偶数，无解。否则 a a a 的位数为 n + 1 2 \frac{n + 1}{2} 2n+1​，从高位到低位枚举搜索即可。

参考代码：
#include<bits/stdc++.h>
using namespace std;
#define pb emplace_back
#define sz(a) ((int)a.size())
#define lson (rt << 1)
#define rson (rt << 1 | 1)
#define gmid (l + r >> 1)
typedef long long ll;
typedef pair<int, int> pii;
const int maxn = 2e5 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
 
vector<pii> vc[30];
int a[30], b[30], sum[30];
int n, m;
 
int check(int l, int r){
 
    for(int i = l; i <= r; ++i){
 
        int tmp = 0;
        for(auto &e : vc[i]){
 
            (tmp += b[e.first] * b[e.second]) %= 10;
        }
        if(tmp != a[i]) return 0;
    }
    return 1;
}
 
int dfs(int pn, int pm){
 
    if(pm < 0) return check(0, m - 2);
    int l = pm == m - 1 ? 1 : 0;
    for(int i = l; i < 10; ++i){
 
        b[pm] = i;
        if(check(pn, pn) && dfs(pn - 1, pm - 1)) return 1;
    }
    return 0;
}
 
int main(){
 
    ios::sync_with_stdio(0); cin.tie(0);
    string s; cin >> s;
    reverse(s.begin(), s.end());
    n = s.size();
    for(int i = 0; i < n; ++i) a[i] = s[i] - '0';
    if(n % 2 == 0){
        
        cout << "-1\n";
        return 0;
    }
    m = (n + 1) / 2;
    for(int i = 0; i < m; ++i){
 
        for(int j = 0; j < m; ++j) vc[i + j].pb(pii{i, j});
    }
    if(dfs(n - 1, m - 1)){
 
        for(int i = m - 1; i >= 0; --i) cout << b[i]; cout << endl;
    }
    else{
 
        cout << "-1\n";
    }
    return 0;
}

B - Computer Cache

简要题意：

给定一块 n n n 个字节的缓存，再有 m m m 个数据块，第 i i i 个有 k i k_i ki​ 字节。接下来 q q q 个操作：① 1 , i , p 1, i, p 1,i,p，表示将第 i i i 个数据块存入缓存的 [ p , p + k i − 1 ] [p, p + k_i - 1] [p,p+ki​−1] 位置；② 2 , p 2, p 2,p，询问当前缓存第 p p p 个字节的值；③ 3 , i , l , r 3, i, l, r 3,i,l,r，将第 i i i 个数据块 [ l , r ] [l, r] [l,r] 字节的值加一。

解题思路：

用线段树维护缓存每个字节的数据来源，每次 ① 操作即为区间赋值，记录来源的数据块编号、当前存入的起始位置、当前数据块版本。对于 ③ 操作，用主席树维护每个数据块每个版本的值。② 操作单点询问，先获取到原始值，再对应查询主席树中的增量，两者相加为答案。

参考代码：
#include<bits/stdc++.h>
using namespace std;
#define pb emplace_back
#define sz(a) ((int)a.size())
#define lson (rt << 1)
#define rson (rt << 1 | 1)
#define gmid (l + r >> 1)
typedef long long ll;
typedef pair<int, int> pii;
const int maxn = 5e5 + 5;
const int mod = 11092019;
const int inf = 0x3f3f3f3f;
 
int a[maxn], li[maxn], len[maxn], bel[maxn];
int n, m, q, tot;
 
struct SegTree{
 
    int cov[maxn << 2];
    void pushDown(int rt){
 
        if(cov[rt]){
 
            cov[lson] = cov[rson] = cov[rt];
            cov[rt] = 0;
        }
    }
    void update(int l, int r, int rt, int L, int R, int val){
 
        if(l >= L && r <= R) { cov[rt] = val; return; }
        int mid = gmid; pushDown(rt);
        if(L <= mid) update(l, mid, lson, L, R, val);
        if(R > mid) update(mid + 1, r, rson, L, R, val);
    }
    int query(int l, int r, int rt, int pos){
 
        if(l == r) return cov[rt];
        int mid = gmid; pushDown(rt);
        if(pos <= mid) return query(l, mid, lson, pos);
        else return query(mid + 1, r, rson, pos);
    }
} tr_p, tr_l, tr_tim;
 
struct ZXTree{
 
    ll sum[maxn * 20], add[maxn * 20];
    int ls[maxn * 20], rs[maxn * 20], rt[maxn], tot;
    void update(int l, int r, int &rt, int pre, int L, int R, int val){
 
        rt = ++tot, ls[rt] = ls[pre], rs[rt] = rs[pre], sum[rt] = sum[pre], add[rt] = add[pre];
        if(l >= L && r <= R){
 
            add[rt] += val;
            sum[rt] += val * 1ll * (r - l + 1);
            return;
        }
        int mid = gmid;
        if(L <= mid) update(l, mid, ls[rt], ls[pre], L, R, val);
        if(R > mid) update(mid + 1, r, rs[rt], rs[pre], L, R, val);
        sum[rt] = sum[ls[rt]] + sum[rs[rt]] + add[rt] * 1ll * (r - l + 1);
    }
    ll query(int l, int r, int rt, int pre, int L, int R){
 
        if(!rt) return 0;
        if(l >= L && r <= R) return sum[rt];
        int mid = gmid; ll ret = (min(r, R) - max(l, L) + 1) * add[rt];
        if(L <= mid) ret += query(l, mid, ls[rt], ls[pre], L, R);
        if(R > mid) ret += query(mid + 1, r, rs[rt], rs[pre], L, R);
        return ret;
    }
} tr_dt;
 
int main(){
 
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n >> m >> q;
    for(int i = 1; i <= m; ++i){
 
        cin >> len[i];
        li[i] = tot + 1;
        for(int j = 1; j <= len[i]; ++j){
 
            ++tot; cin >> a[tot];
            bel[tot] = i;
        }
    }
    for(int d = 1; d <= q; ++d){
 
        tr_dt.rt[d] = tr_dt.rt[d - 1];
        int opt, x, y, z; cin >> opt >> x;
        if(opt == 1){
 
            cin >> y;
            tr_p.update(1, n, 1, y, y + len[x] - 1, y);
            tr_l.update(1, n, 1, y, y + len[x] - 1, li[x]);
            tr_tim.update(1, n, 1, y, y + len[x] - 1, d);
        }
        else if(opt == 2){
 
            int p = tr_p.query(1, n, 1, x);
            int l = tr_l.query(1, n, 1, x);
            int tim = tr_tim.query(1, n, 1, x);
            if(!p) { cout << "0\n"; continue; }
            int id = l + (x - p);
            ll ret = a[id], dt = tr_dt.query(1, tot, tr_dt.rt[tim], tr_dt.rt[0], id, id);
            (ret += dt) %= 256;
            cout << ret << "\n";
        }
        else{
 
            cin >> y >> z;
            tr_dt.update(1, tot, tr_dt.rt[d], tr_dt.rt[d - 1], li[x] + y - 1, li[x] + z - 1, 1);
        }
    }
    return 0;
}

C - Elven Efficiency

简要题意：

给定 n n n 个数 a i a_i ai​，再有 m m m 次操作，每次给定一个数 b i b_i bi​，若 a i a_i ai​ 被 b i b_i bi​ 整除则需要自增，问最后自增的总次数。

解题思路：

我摊牌了，复杂度不会证明。

参考代码：
#include<bits/stdc++.h>
using namespace std;
#define pb emplace_back
#define sz(a) ((int)a.size())
#define lson (rt << 1)
#define rson (rt << 1 | 1)
#define gmid (l + r >> 1)
typedef long long ll;
const int maxn = 6e5 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
 
vector<int> fac[maxn];
set<int> mul[maxn];
int a[maxn], b[maxn], cnt[maxn];
int n, m;
 
int main(){
 
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n >> m;
    for(int i = 1; i <= n; ++i) cin >> a[i];
    for(int i = 1; i <= m; ++i) cin >> b[i];
    for(int i = 2; i < maxn; ++i){
 
        for(int j = i; j < maxn; j += i) fac[j].pb(i);
    }
    for(int i = 1; i <= n; ++i){
 
        if(!cnt[a[i]]){
 
            for(auto &v : fac[a[i]]) mul[v].emplace(a[i]);
        }
        ++cnt[a[i]];
    }
    ll ret = 0;
    for(int i = 1; i <= m; ++i){
 
        vector<int> vc(sz(mul[b[i]]));
        copy(mul[b[i]].begin(), mul[b[i]].end(), vc.begin());
        for(auto &v : vc){
 
            ret += cnt[v];
            cnt[v + 1] += cnt[v];
            cnt[v] = 0;
            for(auto &e : fac[v]){
 
                mul[e].erase(v);
            }
            for(auto &e : fac[v + 1]){
 
                mul[e].emplace(v + 1);
            }
        }
    }
    cout << ret << endl;
    return 0;
}

D - Swap Free

简要题意：

给定 n n n 个不同的字符串，若两个字符串间仅有两位不同且能其中一个通过交换能得到另一个，则两者连边，求最大独立集。

解题思路：

一次交换操作会改变逆序数奇偶性，将所有字符串按逆序数奇偶分为两类，连边仅在这两类间，故图是二分图，匈牙利跑最大匹配，答案为 n n n 减去最大匹配数。

参考代码：
#include<bits/stdc++.h>
using namespace std;
#define pb emplace_back
#define sz(a) ((int)a.size())
#define lson (rt << 1)
#define rson (rt << 1 | 1)
#define gmid (l + r >> 1)
typedef long long ll;
const int maxn = 5e2 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
 
vector<int> G[maxn];
string ss[maxn];
int mt[maxn], vis[maxn];
int n;
 
int dfs(int u){
 
    for(auto &v : G[u]){
 
        if(vis[v]) continue;
        vis[v] = 1;
        if(!mt[v] || dfs(mt[v])){
 
            mt[v] = u;
            return 1;
        }
    }
    return 0;
}
 
int solve(){
 
    int ret = 0;
    for(int i = 1; i <= n; ++i){
 
        memset(vis, 0, sizeof vis);
        ret += dfs(i);
    }
    return ret / 2;
}
 
int check(const string &s1, const string &s2){
 
    vector<int> vc;
    for(int i = 0; i < s1.size(); ++i){
 
        if(s1[i] != s2[i]) vc.pb(i);
    }
    if(sz(vc) == 2){
 
        int p1 = vc[0], p2 = vc[1];
        if(s1[p1] == s2[p2] && s1[p2] == s2[p1]) return 1;
    }
    return 0;
}
 
void build(){
 
    for(int i = 1; i <= n; ++i){
 
        for(int j = i + 1; j <= n; ++j){
 
            if(check(ss[i], ss[j])) G[i].pb(j), G[j].pb(i);
        }
    }
}
 
int main(){
 
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n;
    for(int i = 1; i <= n; ++i) cin >> ss[i];
    build();
    int ret = n - solve();
    cout << ret << endl;
    return 0;
}

G - Jumping Path

简要题意：

给定一个 n n n 个结点的树，每个结点带权，求根到叶方向的 L I S LIS LIS 及个数。

解题思路：

序列问题放到树上，若是序列问题，可以先将序列按权值排序，用树状数组维护每个下标结尾的 L I S LIS LIS 和个数，转移则是查询全局最大值和最大值对应的 L I S LIS LIS 个数之和。放到树上，将全局查询变为子树（区间）查询。

参考代码：
#include<bits/stdc++.h>
using namespace std;
#define pb emplace_back
#define sz(a) ((int)a.size())
#define lson (rt << 1)
#define rson (rt << 1 | 1)
#define gmid (l + r >> 1)
typedef long long ll;
typedef pair<int, int> pii;
const int maxn = 1e6 + 5;
const int mod = 11092019;
const int inf = 0x3f3f3f3f;
 
vector<int> G[maxn];
int a[maxn], dfn[maxn], siz[maxn], tp[maxn];
int n, tim;
 
struct SegTree{
 
    pii mx[maxn << 2];
    pii merge(pii x, pii y){
 
        if(x.first == y.first) return {x.first, (x.second + y.second) % mod};
        else return max(x, y);
    }
    void pushUp(int rt){
 
        mx[rt] = merge(mx[lson], mx[rson]);
    }
    void update(int l, int r, int rt, int pos, pii val){
 
        if(l == r) { mx[rt] = val; return; }
        int mid = gmid;
        if(pos <= mid) update(l, mid, lson, pos, val);
        else update(mid + 1, r, rson, pos, val);
        pushUp(rt);
    }
    pii query(int l, int r, int rt, int L, int R){
 
        if(l >= L && r <= R) return mx[rt];
        int mid = gmid; pii ret = {0, 0};
        if(L <= mid) ret = merge(ret, query(l, mid, lson, L, R));
        if(R > mid) ret = merge(ret, query(mid + 1, r, rson, L, R));
        return ret;
    }
} tr;
 
void dfs(int u){
 
    dfn[u] = ++tim, siz[u] = 1;
    for(auto &v : G[u]){
 
        dfs(v);
        siz[u] += siz[v];
    }
}
 
int main(){
 
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n;
    for(int i = 1; i <= n; ++i) cin >> a[i];
    for(int i = 2; i <= n; ++i){
 
        int u; cin >> u;
        G[u].pb(i);
    }
    dfs(1);
    for(int i = 1; i <= n; ++i) tp[i] = i;
    sort(tp + 1, tp + 1 + n, [](int x, int y){
        return a[x] != a[y] ? a[x] > a[y] : dfn[x] != dfn[y] ? dfn[x] > dfn[y] : x > y;
    });
    for(int i = 1; i <= n; ++i){
 
        int u = tp[i];
        if(siz[u] == 1){
 
            tr.update(1, n, 1, dfn[u], pii{1, 1});
            continue;
        }
        int l = dfn[u] + 1, r = dfn[u] + siz[u] - 1;
        pii tmp = tr.query(1, n, 1, l, r);
        if(tmp.first == 0) tmp = {1, 1};
        else ++tmp.first;
        tr.update(1, n, 1, dfn[u], tmp);
    }
    pii ret = tr.query(1, n, 1, 1, n);
    cout << ret.first << " " << ret.second << endl;
    return 0;
}

H - Levenshtein Distance

简要题意：

给定字符集和一个字符串，问能通过一次插入、删除或修改得到的所有字符串。

解题思路：

暴力做，再去重。

参考代码：
#include<bits/stdc++.h>
using namespace std;
#define pb emplace_back
#define sz(a) ((int)a.size())
#define lson (rt << 1)
#define rson (rt << 1 | 1)
#define gmid (l + r >> 1)
typedef long long ll;
const int maxn = 4e3 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
 
int main(){
 
    ios::sync_with_stdio(0); cin.tie(0);
    string a, s; cin >> a >> s;
    set<string> st;
    for(int i = 0; i <= s.size(); ++i){
 
        for(auto &v : a){
 
            string t = s.substr(0, i) + v + s.substr(i);
            st.insert(t);
        }
    }
    for(int i = 0; i < s.size(); ++i){
 
        string t = "";
        for(int j = 0; j < s.size(); ++j){
 
            if(j != i) t += s[j];
        }
        st.insert(t);
        for(auto &v : a){
 
            string t = s; t[i] = v;
            st.insert(t);
        }
    }
    if(st.count(s)) st.erase(s);
    for(auto &v : st) cout << v << endl;
    return 0;
}

I - Maze Connect

简要题意：

给定一个网格图，仅包含 \ / . 三种字符，问最少需要删除多少个斜杠字符才能使得没有 . 被包围。

解题思路：

将斜杠看作边建图，利用平面图的欧拉定理，用并查集维护连通性即可。

参考代码：
#include<bits/stdc++.h>
using namespace std;
#define pb emplace_back
#define sz(a) ((int)a.size())
#define lson (rt << 1)
#define rson (rt << 1 | 1)
#define gmid (l + r >> 1)
typedef long long ll;
const int maxn = 1e3 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
 
char ss[maxn][maxn];
int id[maxn][maxn], pre[maxn * maxn];
int n, m;
 
int fin(int x){
 
    return x == pre[x] ? x : pre[x] = fin(pre[x]);
}
 
int unite(int x, int y){
 
    int fx = fin(x), fy = fin(y);
    if(fx == fy) return 0;
    pre[fx] = fy;
    return 1;
}
 
int main(){
 
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n >> m;
    for(int i = 1; i <= n; ++i) cin >> ss[i] + 1;
    ++n, ++m;
    int tot = 0;
    for(int i = 0; i <= n; ++i){
 
        for(int j = 0; j <= m; ++j) id[i][j] = ++tot;
    }
    for(int i = 1; i <= tot; ++i) pre[i] = i;
    int ret = 0;
    for(int i = 1; i < n; ++i){
 
        for(int j = 1; j < m; ++j){
 
            if(ss[i][j] == '.') continue;
            if(ss[i][j] == '/'){
 
                ret += !unite(id[i][j - 1], id[i - 1][j]);
            }
            else{
 
                ret += !unite(id[i - 1][j - 1], id[i][j]);
            }
        }
    }
    cout << ret << endl;
    return 0;
}

J - One of Each

简要题意：

给定 n n n 个数，值域为 [ 1 , m ] [1, m] [1,m]，保证每个数至少出现一次。求一个字典序最小的 1-m 的排列。

解题思路：

维护一个可选区间 [ l , r ] [l, r] [l,r]， r r r 为保证后续解存在的右端点， l l l 为剩余区间的左端点。初始 r r r 就是所有数最后一次出现位置的最小下标。每次在 [ l , r ] [l, r] [l,r] 贪心选择一个最靠前的最小数，然后更新 l l l 和 r r r。实际实现可以用栈做到 O ( n ) O(n) O(n)。

参考代码：
#include<bits/stdc++.h>
using namespace std;
#define pb emplace_back
#define sz(a) ((int)a.size())
#define lson (rt << 1)
#define rson (rt << 1 | 1)
#define gmid (l + r >> 1)
typedef long long ll;
typedef pair<int, int> pii;
const int maxn = 2e5 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
 
int a[maxn], rm[maxn], vis[maxn];
int n, m;
 
int main(){
 
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n >> m;
    for(int i = 1; i <= n; ++i){
 
        cin >> a[i];
        rm[a[i]] = i;
    }
    set<int> st_r;
    for(int i = 1; i <= m; ++i){
 
        st_r.emplace(rm[i]);
    }
    st_r.emplace(n + 1);
    vector<int> ans;
    set<pii> st_l;
    int l = 1, r = *st_r.begin();
    for(int i = 1; i <= r; ++i){
 
        st_l.emplace(pii{a[i], i});
    }
    for(int i = 1; i <= m; ++i){
 
        // cout << i << " " << l << " " << r << endl;
        pii e = *st_l.begin();
        while(vis[e.first]){
 
            st_l.erase(st_l.begin());
            e = *st_l.begin();
        }
        ans.emplace_back(e.first);
        vis[e.first] = 1;
        while(l <= e.second){
 
            if(st_l.count(pii{a[l], l})) st_l.erase(pii{a[l], l});
            ++l;
        }
        st_r.erase(rm[e.first]);
        int nr = *st_r.begin();
        while(r < nr){
 
            ++r;
            st_l.emplace(pii{a[r], r});
        }
    }
    for(auto &v : ans) cout << v << " "; cout << endl;
    return 0;
}
freeze up
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ICPC North Western European Regional Contest 2019
01-20
整理的算法模板：ACM算法模板总结（分类详细版） Table of Contents F. Firetrucks Are Red E....I Inverted Deck F.... 如何用并查集建立联系呢？...并且dfs跑图输出n-1遍； #include using namespac
North American Southeast Regional 2019 (Div 1) 题解
nidhs的博客
07-26 134
7.26训练
NorthAmericanSoutheastRegional2019部分题解
rwbyblake的博客
01-22 365
A - Carryless Square Root 题目大意 给定一个数n，让你找出最小的a使得 a*a 在无进位乘法下等于n 代码 //dfs 但是有一些细节问题需要注意 #include <bits/stdc++.h> using namespace std; const int N = 2e2 + 10; const int INF = 0x3f3f3f3f; const long long LINF = 0x3f3f3f3f3f3f3f3f; const unsigned long l
North American Southeast Regional 2019 (Div 1) J. One of Each
qq_43653111的博客
01-18 379
J. One of Each 题目链接 题意：求a的子序列中字典序最小的1到k的排列 思路： 1.贪心错误做法：每遍历一个数字，就去查询上一个该数字出现的位置的下个数字是否比它小，如果小，那么本次出现的该数字就可以代替上一个数字. 反例：7 4 7 4 2 4 3 1 3 2 4 如果按照上一种做法最后序列应该是2 4 1 3 但是很明显最后的 2，4可以代替之前的，所以这种贪心策略并不可取。 2...
North American Southeast Regional 2019 (Div 1) D - Swap Free
qq_43653111的博客
01-19 3042
D - Swap Free 题目链接： 题意：找一个集合的最大子集，这个集合中不允许互斥，两个字符串能相互转化（串字符交换一次变成另一个串）就算互斥。 思路：最大独立集 定义：选出一些顶点使得这些顶点两两不相邻，则这些点构成的集合称为独立集。找出一个包含顶点数最多的独立集称为最大独立集。 定理：最大独立集 = 所有顶点数 - 最小顶点覆盖 = 所有顶点数 - 最大匹配 就是最大独立集模板题,建...
SDUT 2022 Winter Team Contest - 1
weixin_54699118的博客
01-17 400
题目链接：link A - Carryless Square Root 思路： 两个数字进行题目说的运算，的出来的长度一定是奇数，因为a⋅a=na·a=na⋅a=n aaa的长度为lenlenlen话，最终结果的长度为2∗len−12*len-12∗len−1，把运算展开就可以的到这个结论，然后从高位到低位，从小数开始试，dfsdfsdfs #include <bits/stdc++.h> using namespace std; const int N = 666; string s; i
SIM900 Reference Design Guide_V1.02_north1iz_SIM900_
09-29
该指南由north1iz发布，旨在帮助工程师理解和实施基于SIM900的系统设计。 在指南中，首先会介绍SIM900模块的基本特性，包括其通信能力、功耗特性以及工作频段。SIM900支持900/1800MHz双频GSM网络，能够在全球范围内...
north-american-octo-lana
07-12
由于标签部分为空，我们无法直接获得特定的技术关键词，但我们可以根据文件名“north-american-octo-lana-master”进行推理。 "north-american-octo-lana-master"这个文件名可能代表这是整个项目或代码库的主分支。...
North-American-Charging-Standard-Technical-Specification
最新发布
08-30
作为一名 IT 行业大师，我将深入解读 North-American-Charging-Standard-Technical-Specification，以帮助您更好地理解该技术规范。 首先，让我们来了解该技术规范的标题和描述。“North-American-Charging-...
north-american-adventure:EIP 的 Spring-boot
06-13
【标题】"north-american-adventure:EIP 的 Spring-boot" 提到的是一个项目，它将企业集成模式（Enterprise Integration Patterns, EIP）与 Spring Boot 结合应用。Spring Boot 是一个流行且强大的 Java 框架，用于...
自己写平方根squareroot函数
weixin_33965305的博客
08-08 632
今日做一面试题目，写一平方根squareroot函数，函数接口为： unsigned int squareroot(unsigned int input);　　　　//不考虑float情况   经过思考，用位移的方法，一个整数32bits，那么平方根最多16bits，那么对于这16个bits，从最大权重的bit开始，看是置1还是置0，一步一步往后走，到最后一个bit被置完之后，平方根也就求出...
C++ 学习笔记10
热门推荐
无知的我
07-14 35万+
Design and implement a simple spell checker.   许多常用字处理软件都内置了拼写检查程序。请设计和实现自己的拼写检查程序。可以在程序中建立字典文件。   dictionary.txt abandon abandonment
Gym - 102423J
qq_47783181的博客
01-22 110
J - One of Each（贪心，栈） 大佬的代码，tql。 打比赛的时候没想出来，过后看了看这个代码。 用桶排序的思想，记录每个数字出现的个数，然后用栈实现最小的字典序输出。桶的作用就是判断这个数是不是最后一个数字，如果是最后一个数字就不得不去选了，然后栈的作用就是尽可能将前面的数字变小，如果栈顶的数后面还有，且要插入的数字比这个数小的话，就将栈顶出栈，然后将更小的数入栈。具体代码如下： #include <bits/stdc++.h> #define LL long long using
2017-2018 ACM-ICPC Southeast Regional Contest (Div. 1)
weixin_34387468的博客
11-18 236
A. Ducks in a Row 当$n\times k&gt;|S|$时，显然无解。 否则最优解中翻转的区间一定两两不相交，设$f[i][j][x][y]$表示考虑前$i$个位置，第$i$个位置翻转情况为$j$，当前连续段长度为$x$，已有$y$个长度至少为$n$的$D$连续段的最少翻转次数，然后转移即可。 时间复杂度$O(|S|^2)$。 #include&lt;cstdio&g...
North American Southeast Regional 2019
Gold_Medal的博客
01-22 213
题目链接 H–Levenshtein Distance 题意：给出一个字母表，和一个字符串，你可以对字符串进行三种操作：添加一个字母，删除一个字母，替换一个字母（添加和替换的字母都必须是在第一行给出的字母表内），只能进行一次操作，求可以得到的新字符串，按照字典序从小到大输出。 分析：题目给出的字符串范围是2<=|s|<=100，所以我们直接暴力就可。在字符串每两个字符之间添加字母表中一个字母（当然包括字符串第一个字符前，和最后一个字符后的位置），依次删除一个字符，同样用字母表内的字母替换字
UVA 10001 Garden of Eden
Remilia's
08-04 1322
Garden of Eden  Cellular automata are mathematical idealizations of physical systems in which both space and time are discrete, and the physical quantities take on a finite set of discret
2019 ICPC North American Qualifier Contest E题 NVWLS
u013738000的博客
10-08 1039
题意 给你NNN个大写字母组成的单词和一串大写非元音字母所组成的字符串（L≤3×105L\leq 3\times 10^5L≤3×105）。已知字符串LLL是由给出单词的非元音字母组成的，求将这个字符串还原回正常单词以后，元音字母数量最多的一个原串。数据保证∑i=0nlen(si)≤105\sum_{i=0}^{n} len(s_i) \leq 10^5∑i=0n​len(si​)≤105。 解题...
North American Invitational Programming Contest (NAIPC) 2019
weixin_30457881的博客
08-12 390
NAIPC 2019 A - Piece of Cake 题意：从\(n\)个点中选择\(k\)个点构成多边形，问期望面积。 题解：如果能够确定两个点，那么可以从这两个点之间选择\(k-2\)个点来构成一个\(k\)边形。所以可以枚举两个点，计算这两个点被选入构成凸包的概率和对凸包贡献的面积。 #include <bits/stdc++.h> #define fopi fre...
2021 中石油 ICPC组队训练赛第12场
米莱虾
04-05 316
// A #include <bits/stdc++.h> #define ll long long using namespace std; const int N = 10010; int n,a[40],as[40],d[40],l[99]; char s[40]; bool vis[1010]; void dfs(int nd) { if(nd==n) { memset(d,0,sizeof(d)); for(int j=0; j<n..
add(p1,BorderLayout.NORTH)
06-07
add(p1, BorderLayout.NORTH) 是 Java Swing 中的一个方法，用于将一个组件添加到一个容器中，并使用 BorderLayout 布局管理器将该组件放置在容器的北部。 BorderLayout 是一种常用的布局管理器，它将容器分为五个区域：北、南、东、西和中间。当将组件添加到一个使用 BorderLayout 布局管理器的容器中时，可以使用 BorderLayout 的五个常量之一（BorderLayout.NORTH、BorderLayout.SOUTH、BorderLayout.EAST、BorderLayout.WEST 和 BorderLayout.CENTER）来指定该组件应该放置在哪个区域中。 例如，以下代码将一个名为 p1 的 JPanel 添加到一个名为 container 的 JPanel 中，并使用 BorderLayout 将 p1 放置在 container 的北部： ``` JPanel container = new JPanel(); JPanel p1 = new JPanel(); container.setLayout(new BorderLayout()); container.add(p1, BorderLayout.NORTH); ``` 这将使 p1 组件位于 container 容器的北部，并占据水平方向上的所有空间，但只占用垂直方向上所需的空间。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值