The 2021 Sichuan Provincial Collegiate Programming Contest

最新推荐文章于 2024-07-23 16:57:10 发布
最新推荐文章于 2024-07-23 16:57:10 发布
阅读量1.5k 收藏 6
点赞数 5
分类专栏： Codeforces 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42060154/article/details/117608179
版权

今年年初就和深爷策划去打星参加一场ICPC，正好今年5月底公司多送了2天年假，于是找来了还在电科读研的师弟林喵喵，组了一支退役旅游队。chenjb的这套题出得蛮好，总体来说题目难度不大，但很多题目却很有意思。本老年人成为全场最坑，感谢喵喵和深爷不嫌我菜，带我玩。最终我们只通过了7题，果然退役很久之后越来越菜。结果不是很满意吧，但是能再次去打onsite，真的很开心，彷佛又回到了20岁QAQ

A.Chuanpai
分析：水题

#include "bits/stdc++.h"
using namespace std;
int T;
int main() {
  // freopen("in.txt", "r", stdin);
  scanf("%d", &T);
  while (T--) {
    int k;
    scanf("%d", &k);
    int cnt = 0;
    for (int i = 1; i <= k; i++) {
      for (int j = i; j <= k; j++) {
        if (i + j == k) {
          if (i >= 1 && j >= 1 && i <= 6 && j <= 6) cnt++;
        }
      }
    }
    printf("%d\n", cnt);
  }
  return 0;
}

B.Hotpot
分析： 2 n 2n 2n次就会是一个循环，所以只需要模拟 2 n 2n 2n次以内的所有情况即可

#include "bits/stdc++.h"
using namespace std;
const int maxn = 1e5 + 10;
int T, n, k, m, vis[maxn];
pair<int, int> p[maxn];
int main() {
  // freopen("in.txt", "r", stdin);
  scanf("%d", &T);
  while (T--) {
    memset(vis, 0, sizeof(vis));
    scanf("%d%d%d", &n, &k, &m);
    for (int i = 0; i < n; i++) {
      int x;
      scanf("%d", &x);
      p[i] = make_pair(x, 0);
    }
    if (m >= 2 * n) {
      for (int i = 0; i < 2 * n; i++) {
        int a = i % n;
        if (vis[p[a].first] == 0)
          vis[p[a].first]++;
        else {
          vis[p[a].first]--;
          p[a].second++;
        }
      }
      int tmp = m / (2 * n);
      for (int i = 0; i < n; i++) p[i].second *= tmp;
    }
    int mod = m % (2 * n);
    for (int i = 0; i < mod; i++) {
      int a = i % n;
      if (vis[p[a].first] == 0)
        vis[p[a].first]++;
      else {
        vis[p[a].first]--;
        p[a].second++;
      }
    }
    for (int i = 0; i < n; i++) {
      if (i == n - 1)
        printf("%d\n", p[i].second);
      else
        printf("%d ", p[i].second);
    }
  }
  return 0;
}

D.Rock Paper Scissors
分析：先手的所有出牌情况都不对胜负产生影响，只有后手影响胜负，所以后手优先考虑会胜利的，再考虑平局的，最后考虑会扣分的

#include "bits/stdc++.h"
using namespace std;
int T;
typedef long long LL;
LL br, bp, bs, dr, dp, ds;
int main() {
  // freopen("in.txt", "r", stdin);
  scanf("%d", &T);
  while (T--) {
    scanf("%lld%lld%lld", &br, &bp, &bs);
    scanf("%lld%lld%lld", &dr, &dp, &ds);
    LL cnt = 0;
    if (br) {
      // cout << dp << endl;
      if (dp && br) {
        LL tmp = min(dp, br);
        cnt += tmp;
        dp -= tmp;
        br -= tmp;
      }
      // cout << "--->" << br << "  " << dp << endl;
      if (dr && br) {
        LL tmp = min(dr, br);
        dr -= tmp;
        br -= tmp;
      }
      if (ds && br) {
        LL tmp = min(ds, br);
        cnt -= tmp;
        br -= tmp;
        ds -= tmp;
      }
    }
    if (bp) {
      if (ds && bp) {
        LL tmp = min(ds, bp);
        cnt += tmp;
        ds -= tmp;
        bp -= tmp;
      }
      if (dp && bp) {
        LL tmp = min(dp, bp);
        dp -= tmp;
        bp -= tmp;
      }
      if (dr && bp) {
        LL tmp = min(dr, bp);
        cnt -= tmp;
        dr -= tmp;
        bp -= tmp;
      }
    }
    if (bs) {
      if (dr && bs) {
        LL tmp = min(dr, bs);
        cnt += tmp;
        dr -= tmp;
        bs -= tmp;
      }
      if (ds && bs) {
        LL tmp = min(ds, bs);
        ds -= tmp;
        bs -= tmp;
      }
      if (bs && dp) {
        LL tmp = min(bs, dp);
        cnt -= tmp;
        bs -= tmp;
        dp -= tmp;
      }
    }
    printf("%lld\n", cnt);
  }
  return 0;
}

E.Don’t Really Like How The Story Ends
分析：
( 1 ) (1) (1)如果 v v v与 v + 1 v + 1 v+1 直接相连，则访问搜索 v + 1 v + 1 v+1
( 2 ) (2) (2)如果 v v v点存在没有访问的相邻节点且 v v v点不与 v + 1 v + 1 v+1点相连，此时必须将 v + 1 v + 1 v+1 连接到 v v v上
( 3 ) (3) (3)如果 v v v点所有相邻节点都被访问了， v + 1 v + 1 v+1 可以与 v v v相连，也可以和从 1 = > v 1 =>v 1=>v中路径上的任意一点相连，路径上的点都在递归栈里面，此时可以让 v v v点退栈，一直回到某个满足条件 1 1 1或 2 2 2的节点
( 4 ) (4) (4)如果第 3 3 3点的点退栈一直到起点1号点都没有直接相连，说明存在不连通部分，此时必须加边，此时再去搜索不连通的部分，一直到全部搜索完

#include "bits/stdc++.h"
using namespace std;
const int maxn=1e5+100;
int n,m,T;
vector<int>g[maxn];
int vis[maxn],nxt,cnt;
void dfs(int u){
    nxt++;
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(vis[v]) continue;
        if(v==nxt){
            vis[nxt]=1;
            dfs(nxt);
        }else{
            cnt++;
            vis[nxt]=1;
            dfs(nxt);
            i--;
        }
    }
    if(u==1){
        while(nxt<=n){
            vis[nxt]=1;
            dfs(nxt);
            cnt++;
        }
    }
}
int main()
{
    //freopen("in.txt","r",stdin);
    scanf("%d",&T);
    while(T--){
        for(int i=0;i<=n;i++) {
            g[i].clear();
            vis[i]=0;
        }
        cnt=0,nxt=1;
        scanf("%d%d",&n,&m);
        for(int i=1;i<=m;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            if(x<y) g[x].push_back(y);
            if(y<x) g[y].push_back(x);
        }
        for(int i=1;i<=n;i++) sort(g[i].begin(),g[i].end());
        vis[1]=1;
        dfs(1);
        printf("%d\n",cnt);
    }
    return 0;
}

F.Direction Setting
分析：最小费用流
对于一条边 ( l , r ) ( l , r ) (l,r) 要么指向 l l l要么指向 r r r，对于 l l l来说，前 a i a_i ai​条指向自己的边对结果贡献为0，只有从第 a i + 1 a_i+1 ai​+1条开始，每增加 1 1 1条，权值增加 1 1 1，对于每个点来说，一定是先走免费的，再走收费的，其实就是跑一个最小费用流
具体连边为：
把第 i i i条边抽象为点 m i m_i mi​，往 l i l_i li​和 r i r_i ri​连边，容量为1，费用为0；源点 s s s往 m i m_i mi​连，容量为1，费用为0；对于每个点 u u u，往汇点连 1 1 1条容量为 a u a_u au​，费用为0的， 1 1 1条容量为 I N F INF INF，费用为 1 1 1的

#include "bits/stdc++.h"
using namespace std;
const int maxn = 3e5 + 100;
const int INF = 0x3f3f3f3f;
int dis[maxn], vis[maxn], flow[maxn], pre[maxn], id[maxn];
int a[maxn], l[maxn], r[maxn];
int n, m, s, t;
struct edge {
  int to, nxt, flow, w;
} d[maxn];
int head[maxn], cnt = 1;
void add(int u, int v, int flow, int w) {
  d[++cnt] = (edge){v, head[u], flow, w}, head[u] = cnt;
  d[++cnt] = (edge){u, head[v], 0, -w}, head[v] = cnt;
}
bool spfa(int s,int t,int mx){
    for(int i=0;i<=mx;i++) dis[i]=INF,vis[i]=0;
    queue<int>q; q.push(s);
    dis[s]=0,flow[s]=INF;
    while(q.size()){
        int u=q.front(); q.pop();
        vis[u]=0;
        for(int i=head[u];i;i=d[i].nxt){
            int v=d[i].to;
            if(d[i].flow&&dis[u]+d[i].w<dis[v]){
                dis[v] = dis[u]+d[i].w,pre[v]=i;
                flow[v]=min(d[i].flow,flow[u]);
                if(!vis[v]) q.push(v),vis[v]=1;
            }
        }
    }
    return dis[t]!=INF;
}
int Cost_Flow(int s,int t,int mx){
    int mincost=0;
    while(spfa(s,t,mx)){
        mincost+=dis[t]*flow[t];
        int x=t,i;
        while(x!=s){
            i=pre[x];
            d[i].flow-=flow[t],d[i^1].flow+=flow[t];
            x=d[i^1].to;
        }
    }
    return mincost;
}
int main()
{
    //freopen("in.txt","r",stdin);
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        for(int i=1;i<=m;i++) scanf("%d%d",&l[i],&r[i]);
        s=0,t=n+m+1;
        for(int i=1;i<=m;i++){
            add(s,i,1,0);
            id[i]=cnt+1;
            add(i,m+l[i],1,0);
            add(i,m+r[i],1,0);
        }
        for(int i=1;i<=n;i++){
            add(m+i,t,a[i],0);
            add(m+i,t,INF,1);
        }
        printf("%d\n",Cost_Flow(s,t,n+m+1));
        for(int i=1;i<=m;i++) printf("%d",d[id[i]].flow==0?1:0);
        printf("\n");
        cnt =1;
        for(int i=0;i<=t;i++) head[i]=0;
    }
    return 0;
}

H.Nihongo wa Muzukashii Desu
分析：无脑模拟

#include "bits/stdc++.h"
using namespace std;
int T;
map<string, string> mp;
void init() {
  mp["imasu"] = "tte";
  mp["mimasu"] = "nde";
  mp["kimasu"] = "ite";
  mp["gimasu"] = "ide";
  mp["shimasu"] = "shite";
  mp["chimasu"] = "tte";
  mp["rimasu"] = "tte";
  mp["bimasu"] = "nde";
  mp["nimasu"] = "nde";
}
bool check(string a, string b) {
  int i = 0, j = a.length() - 1;
  // cout << a << " " << endl;
  while (i < j) {
    swap(a[i], a[j]);
    i++, j--;
  }
  // cout << a << " " << endl;
  i = 0;
  // cout << b << " " << endl;
  int k = b.length() - 1;
  while (i < k) {
    swap(b[i], b[k]);
    i++, k--;
  }
  // cout << b << " " << endl;
  int lena = a.length(), lenb = b.length();
  i = 0;
  while (i < lena && i < lenb) {
    if (a[i] == b[i])
      i++;
    else
      return false;
  }
  return true;
}
int main() {
  // freopen("in.txt", "r", stdin);
  init();
  cin >> T;
  while (T--) {
    string s;
    cin >> s;
    string res = "";
    if (check(s, "chimasu")) {
      res += s.substr(0, s.length() - 7) + mp["chimasu"];
    } else if (check(s, "rimasu")) {
      res += s.substr(0, s.length() - 6) + mp["rimasu"];
    } else if (check(s, "bimasu")) {
      res += s.substr(0, s.length() - 6) + mp["bimasu"];
    } else if (check(s, "nimasu")) {
      res += s.substr(0, s.length() - 6) + mp["nimasu"];
    } else if (check(s, "kimasu")) {
      if (s == "ikimasu")
        res = "itte";
      else
        res += s.substr(0, s.length() - 6) + mp["kimasu"];
    } else if (check(s, "gimasu")) {
      res += s.substr(0, s.length() - 6) + mp["gimasu"];
    } else if (check(s, "shimasu")) {
      res += s.substr(0, s.length() - 7) + mp["shimasu"];
    } else if (check(s, "mimasu")) {
      res += s.substr(0, s.length() - 6) + mp["mimasu"];
    } else if (check(s, "imasu")) {
      res += s.substr(0, s.length() - 5) + mp["imasu"];
    } else
      res = s;
    cout << res << endl;
  }
  return 0;
}

J - Ants
分析：解题的关键结论在于两只蚂蚁发生碰撞，可以认为直接穿过。在挡板消失之前，每个蚂蚁在每一轮中会移动 2 L 2L 2L的距离，挡板被撞击 n n n次。因此只用模拟最后一轮的情况即可。两块挡板都维护一个队列，维护撞到这块挡板的蚂蚁的时间序列，每次在两个队头中选择一个最小值，模拟之后塞进另一个队列即可。

#include "bits/stdc++.h"
using namespace std;
typedef long long LL;
const int maxn = 2e6 + 100;
const LL L = 1e9 + 1;
int n, d[maxn], t1, t2, h1, h2;
LL a, b, p[maxn], q1[maxn], q2[maxn], ans;
void solve1() {
  LL u = q1[++h1];
  ans = max(ans, u);
  if (a) {
    --a;
    q2[++t2] = u + L;
  }
}
void solve2() {
  LL u = q2[++h2];
  ans = max(ans, u);
  if (b) {
    --b;
    q1[++t1] = u + L;
  }
}
int main() {
  // freopen("in.txt", "r", stdin);
  scanf("%d%lld%lld", &n, &a, &b);
  for (int i = 1; i <= n; i++) scanf("%lld", &p[i]);
  for (int i = 1; i <= n; i++) scanf("%d", &d[i]);
  LL tmp = min(a, b) / (LL)n;
  a -= tmp * n, b -= tmp * n;
  LL s = tmp * 2 * L;
  for (int i = 1; i <= n; i++)
    if (d[i] == 0) q1[++t1] = p[i];
  for (int i = n; i >= 1; i--)
    if (d[i] == 1) q2[++t2] = L - p[i];
  while (h1 < t1 || h2 < t2) {
    if (h2 >= t2 || (h1 < t1 && q1[h1] < q2[h2]))
      solve1();
    else
      solve2();
  }
  printf("%lld\n", s + ans);
  return 0;
}

K. K-skip Permutation
分析：按剩余类分组

#include "bits/stdc++.h"
using namespace std;
const int maxn = 1e6 + 100;
int vis[maxn], n, k;
vector<int> vec[maxn];
int main() {
  // freopen("in.txt", "r", stdin);
  scanf("%d%d", &n, &k);
  for (int i = 1; i <= n; i++) {
    int mod = i % k;
    vec[mod].push_back(i);
  }
  int cnt = 0;
  for (int i = 0; i < k; i++) {
    for (int j = 0; j < vec[i].size(); j++) {
      cnt++;
      if (cnt == n)
        printf("%d\n", vec[i][j]);
      else
        printf("%d ", vec[i][j]);
    }
  }
  return 0;
}

L. Spicy Restaurant
分析：令 d p ( i , j ) dp(i,j) dp(i,j)表示距离 i i i位置切好等于 j j j的最小值，则最多跑 100 100 100遍 B F S BFS BFS，可以得到最终答案

#include "bits/stdc++.h"
using namespace std;
const int maxn = 2e5 + 100;
const int INF = 0x3f3f3f3f;
int n, m, q, w[maxn], dp[maxn][100 + 10];
vector<int> g[maxn];
void bfs(int num) {
  queue<int> que;
  for (int i = 1; i <= n; i++)
    if (w[i] == num) {
      que.push(i);
      dp[i][num] = 0;
    }
  while (!que.empty()) {
    int u = que.front();
    que.pop();
    for (auto v : g[u]) {
      if (dp[v][num] != INF) continue;
      que.push(v);
      dp[v][num] = dp[u][num] + 1;
    }
  }
}
int main() {
  // freopen("in.txt", "r", stdin);
  scanf("%d%d%d", &n, &m, &q);
  for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
  for (int i = 1; i <= n; i++) {
    for (int j = 0; j <= 100; j++) dp[i][j] = INF;
  }
  for (int i = 1; i <= m; i++) {
    int x, y;
    scanf("%d%d", &x, &y);
    g[x].push_back(y);
    g[y].push_back(x);
  }
  for (int i = 1; i <= 100; i++) bfs(i);
  for (int i = 1; i <= n; i++)
    for (int j = 1; j <= 100; j++) dp[i][j] = min(dp[i][j], dp[i][j - 1]);
  while (q--) {
    int p, a;
    scanf("%d%d", &p, &a);
    printf("%d\n", dp[p][a] == INF ? -1 : dp[p][a]);
  }
  return 0;
}

M.True Story
分析：只需要看最多有多少个满足的即可

#include "bits/stdc++.h"
using namespace std;
const int maxn = 1e5 + 10;
int n, k, x, p0;
int s[maxn], t[maxn], p[maxn];
int main() {
  // freopen("in.txt", "r", stdin);
  scanf("%d%d%d%d", &n, &k, &x, &p0);
  int ans = p0;
  for (int i = 1; i <= n; i++) scanf("%d", &s[i]);
  for (int i = 1; i <= k; i++) scanf("%d", &t[i]);
  for (int i = 1; i <= k; i++) scanf("%d", &p[i]);
  for (int i = 1; i <= k; i++) ans = max(ans, p[i] - t[i]);
  int cnt = 0;
  for (int i = 1; i <= n; i++) {
    int tmp = (x + s[i] - 1) / s[i];
    if (tmp <= ans) cnt++;
  }
  printf("%d\n", cnt);
  return 0;
}
gzgywh
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
bc English provincial exam review
01-10
active voice allegory alliteration allusion analogy antagonist anti-climax antithesis apostrophe argumentative essay anecdotal evidence archaic language aside assonance atmosphere audience ...
LLM for Hubei Provincial Government Affairs..zip
12-24
AIGC（Artificial Intelligence Generated Content，人工智能生成内容）的重要性体现在以下几个方面： 内容创作效率提升： AIGC能够快速生成大量高质量的内容，包括文本、图像、音频、视频等，极大地提高了创作效率...
「团队训练赛」The 2021 Sichuan Provincial Collegiate Programming Contest 题解
Suryxin's blogs
04-25 1430
The 2021 Sichuan Provincial Collegiate Programming Contest A - Chuanpai 题目描述： 你有一个骰子，扔两次，得到的数字和等于k的方案是多少，其中(3, 4) 和 (4,3)属于一种方案 思路： 显然小于2和大于12的方案都是0 其他的模拟一下就行 //Work by: Chelsea #include <bits/stdc++.h> using namespace std; #define endl '\n' #de
The 2021 Sichuan Provincial Collegiate Programming Contest J - Ants（思维，模拟）
qq_45863710的博客
10-13 260
Ants https://codeforces.com/gym/103117/problem/J 相遇反向即可当作穿过了，这是白书上的经典题了。那么不同于那个经典题的地方就在于其两端有障碍限制。我们设总长为 xxx ，那么我们发现我们可以把 2x2x2x 作为一个周期，我们发现这个周期内左右内壁均会被碰 nnn 次，且所有蚂蚁都会回到原地。那么显然我们中途完整的周期我们都可以直接快速计算，最后左壁耐久度将由 AAA 变为 A%nA\%nA%n ，右壁耐久度由 BBB 将变为 B%nB\%nB%n 。这个.
[cf] The 2021 Sichuan Provincial Collegiate Programming Contest 赛前训练
qq_34364611的博客
10-23 369
目录前言 :A - Chuanpai思路CODEK - K-skip Permutation思路CODED - Rock Paper Scissors思路CODEH - Nihongo wa Muzukashii Desu思路CODEB - Hotpot思路CODE 前言 : 传送门 : 全程一直再写,但是基本都是模拟体验还好 因为规定半小时的训练赛,当开到EEE题,刚刚开始算法的时候就没时间了,只有半小时了 A - Chuanpai 思路 范围很小,看了一下可以直接暴力 + 特判即可 CODE #incl
The 2021 Sichuan Provincial Collegiate Programming Contest F. Direction Setting
aldolreaction的博客
09-21 181
题面 题意 给定 nnn 个点 mmm 条边，可以任意选择边的方向，其中： D=∑i=1nmax⁡(0,di−ai) D={\sum_{i=1}^n\max (0, d_i-a_i)} D=i=1∑n​max(0,di​−ai​) 求 min⁡D\min DminD， did_idi​ 为 iii 的入度。并输出边方向，0 为正向，1 为负向。 2≤n≤300,1≤m≤300,0≤ai≤104,∑n,∑m≤3×1032\le n\le 300,1\le m\le 300,0\le a_i\l
The 2024 Sichuan Provincial Collegiate Programming Contest（E，H，L）
sgyjhhik的博客
07-07 583
思路：博弈论，因为每次只能拿一个或者两个，当一个人面临剩下三个石头这个情况，他拿一个是输，拿两个也是输，所以谁先碰到3这种情况谁就输，扩展开来，谁先碰到3的倍数这种情况谁就输了，因为面对三的倍数，拿两个别人可以拿一个，拿一个别人可以拿两个，自己仍面临三的倍数，最后会面临三这种情况，因此谁先面临三的倍数这种情况谁就必输，GG会先拿，所以若是总数n,n%3。题意：两个人在拿石头，每次最多拿一个或两个，GG先拿，那个人都想获胜并且尽可能多的得到棋子，问获胜方的石子的个数。思路：模拟题，模拟过程就行。
The 2021 Sichuan Provincial Collegiate Programming Contest 2021-07-19
qq_51803703的博客
07-21 493
Problem B : Hot Pot 题意： n 个人围坐在火锅旁，共有m次行动点，每人轮流的一次操作会消耗一点点数，若火锅中没有某人爱吃的菜，则TA会想向火锅中加入这个菜，幸福度将不会改变，若存在的话，则其会将菜吃掉，并增加一点幸福度，输出行动点归零时每人的幸福度。 知识点： 模拟 题解： 将每个人都进行完一次操作时定义为一轮周期，显然地，如果一 轮周期中喜欢同一种菜品的人数是偶数的话，处于奇数位的人将只能添加这个菜，而偶数位的人则会吃掉这个菜。但如果一轮周期中喜欢同一个菜品的人数是奇数的话，位于最后一
The 2024 Sichuan Provincial Collegiate Programming Contest补题
2301_76594389的博客
06-20 530
【代码】The 2024 Sichuan Provincial Collegiate Programming Contest补题。
The 2021 Sichuan Provincial Collegiate Programming Contest J.Ants(思维题/模拟)
Code92007的博客
07-12 356
题目 n(1<=n<=1e6)只蚂蚁，在一根杆上，杆左端点0，右端点1e9+1， n只蚂蚁第i只的初始位置在ai，输入保证 di=0代表当前向左爬，di=1代表当前向右爬 左端点有一个柱子，被撞a(1<=a<=1e9)次后消失，被撞<=a次的时候都会把蚂蚁往反方向弹 右端点有一个柱子，被撞b(1<=b<=1e9)次后消失，被撞<=b次的时候都会把蚂蚁往反方向弹 思路来源 乱搞AC 题解 L为左右端点距离，考虑时间每过2*L是一个循环， 这时
The 2024 Sichuan Provincial Collegiate Programming Contest F. Isoball: 2D Version
m0_74056929的博客
07-11 211
我的思路比较笨，把圆当作一个矩形，因为圆完全在矩形中，其实和以圆心为原点，半径为边长的矩形在矩形中是等价的。有一个固定的矩形，一个大小固定的圆沿一个方向运动，问有没有一个时刻圆完全在矩形里。就是一个球根据一个向量移动，有没有一个时刻能够满足完全在矩形里（这个题意容易懂，没什么好简化的）再根据以上所有情况去考虑是否符合完全包含就可以了。[1]将圆的左边移动到和矩形左边共线。[2]将圆的右边移动到和矩形右边共线。[1]将圆的上边移动到和矩形上边共线。[2]将圆的下边移动到和矩形下边共线。代码写的较丑，请见谅。
2020CCPC河南省赛正式赛.pdf
08-24
【ACM竞赛】是国际大学生程序设计竞赛（International Collegiate Programming Contest）的简称，是一项旨在展示大学生创新能力、团队合作精神和解决实际问题能力的国际性比赛。2020年河南省CCPC大赛属于ACM竞赛的...
An Agent-oriented Data Sharing and Decision Support Service for Hubei Provincial Care Platform
02-10
An Agent-oriented Data Sharing and Decision Support Service for Hubei Provincial Care Platform
2021届高考英语二轮复习之全国卷陌生词汇十202102021150
08-07
3. (2019·全国卷Ⅰ) The provincial government and its _partners_ (合作伙伴们) offer many programs to help students find summer jobs. 4. (2019·北京高考) They conclude that when task interdependence ...
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
执梗的博客
07-23 1842
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
C语言100道基础拔高题（1）
最新发布
2303_78660417的博客
07-23 3019
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
2024秋招算法
weixin_43364551的博客
07-22 2250
根据代码随想录和力扣进行算法训练的笔记
2019 Sichuan Province Programming Contest
04-01
As an AI language model, I don't have the latest information on the 2019 Sichuan Province Programming Contest. However, I suggest checking official websites of the contest organizers, such as the ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

gzgywh

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值