光之微 迎接光的洗礼 2024-09-26T16:30:28.482Z http://example.com/ OCCJ Hexo page http://example.com/undefined/undefined.html 2024-09-26T16:30:28.000Z 2024-09-26T16:30:28.482Z 第五届太原理工大学新生赛初赛题解 http://example.com/undefined/dfab75bc.html 2023-10-21T15:30:11.000Z 2023-10-21T15:47:22.903Z 第五届太原理工大学程序设计竞赛新生赛（初赛）题解

⭐A.饿饿饭饭

题目：

image-20231021204708027-1697902243556-1.png

🌟题解：

很简单，签个到输出谁饿了

代码：

1
2
3
4
5
6
7
#include<iostream>
using namespace std;
int main()
{
    string s; cin>>s;
    cout<<s<<":eeff";
}

⭐B.扣点点

题目：

image-20231021205039596-1697902243556-2.png

🌟题解：

hammer喜欢玩扣点点但太菜了理不清牌（doge），让你帮忙按一定顺序整理，典型的排序吧

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
1.这种字符串数组排序较为简单
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 15;
string s[N];
int main()
{
    int n; cin>>n;
    for(int i = 0;i<n;i++)   
    {
        char j[2];
        cin>>j[1]>>j[0];
        s[i] += j[0];
        s[i] += j[1];
    }
    sort(s,s+n);
    for(int i = 0;i<n;i++)  
    {
        cout<<s[i][1]<<s[i][0]<<' ';
    }
    return 0;
}
2.标记法
#include <iostream>
using namespace std;
const int N = 15;
int cnt[4][10]; 
int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        int num;
        char s;
        cin >> num >> s;
        int id;
        if (s == 'B') id = 0;
        else if (s == 'C') id = 1;
        else id = 2;
        cnt[id][num]++;
    }
    for (int i = 0; i < 3; ++i) { 
        for (int j = 1; j <= 9; ++j) {
            for (int k = 0; k < cnt[i][j]; ++k) { //可能这里不好理解，就是看k+到比cnt这大就是cnt-反过来也可以写成while(cnt[i][j]--&&cnt>0)
                cout << j << (i==0 ? 'B' : i==1 ? 'C' : 'D') << " "; 
            }
        }
    }
    cout << endl;
    return 0;
}
3.自己写个结构体排序
#include<bits/stdc++.h>
using namespace std;
int n;
struct node{
    char x,y;
}a[15];
bool cmp(node q,node p){
    if(q.y!=p.y)return q.y<p.y;
    else return q.x<p.x;
}
string s;
int main(){
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>s;
        a[i].x=s[0];
        a[i].y=s[1];
    }
    sort(a,a+n,cmp);
    for(int i=0;i<n;i++){
        cout<<a[i].x<<a[i].y<<" ";
    }
}
4.利用mulimap性质（某孙神的）
#include <bits/stdc++.h>
using namespace std;
int main(){
    multimap<char,char>mp;
    multimap<char,char>ans;
    int n;
    cin>>n;
    while(n--){
        char ch;
        char temp;
        cin>>temp>>ch;
        mp.insert({temp,ch});
    }
    for(auto it=mp.begin();it!=mp.end();it++){
        ans.insert(pair<char,char>(it->second,it->first));
    }
    for(auto it=ans.begin();it!=ans.end();it++){
        cout<<it->second<<it->first<<" ";
    }
    return 0;
}

⭐C.String problem

题目：

image-20231021211432622-1697902243557-3.png

🌟题解：

也很简单的一道，比较三个字符串字符就行，2个一样就改一次，都不一样就改两次，

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<iostream>
using namespace std;
int n;
string s1,s2,s3;
int ans;
int main()
{
    cin>>n;
    cin>>s1>>s2>>s3;
    for(int i=0;i<n;i++)
    {
        if(s1[i]==s2[i] && s1[i]==s3[i]) continue;
        else if(s1[i]==s2[i] || s1[i]==s3[i] || s2[i]==s3[i]) ans++;
        else ans+=2;
    }
    cout<<ans<<endl;  
    return 0;
}

⭐D.数豆豆

题目：

image-20231021213103623-1697902243557-4.png

🌟题解：

考察一下思维吧，其实也很简单，就是每次拿大的数字，排下序就好了

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
#include <string>
#include<algorithm>
using namespace std;
int main()
{
    string s;
    cin>>s;
    sort(s.begin(),s.end());
    reverse(s.begin(),s.end());
    string s1,s2;
    for(int i=0;i<s.size();++i)
    {
        if(i%2==0)
            s1=s1+s[i];
        else
            s2=s2+s[i];
    }
    if(s1[0]=='0')    s1="0";
    if(s2[0]=='0')    s2="0";
    cout<<s1<<endl;
    cout<<s2<<endl;
    return 0;
}

⭐E.Another string problem

题目：

image-20231021214553076.png

🌟题解：

也是挺简单的，呆梨同学们都可以报名新生赛体验今年12月。就判断下是否两个字符串只有一个字符不一样就行，注意中间缺字符或者多字符也是可以的，那么就有三种情况，字符一样长，不一样长是删除还是增加（差距为1），还有差距大于1了因为只能改一次肯定不行。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include<bits/stdc++.h>
using namespace std;
int main() {
    string s, t;
    cin >> s ; cin>>t;
    int n = s.size(), m = t.size();
    if (abs(n-m) > 1) cout << "NO" << endl;
    else if (n == m) {
        int cnt = 0;
        for (int i = 0; i < n; ++i)
            if (s[i] != t[i] && ++cnt > 1) {
                cout << "NO" << endl; return 0;
            }
        cout << "YES" << endl;
    } else { 
        int i, j,cnt=0;
        for (i = 0, j = 0; i < n && j < m; ++i, ++j) {
            if (s[i] != t[j]) {
                if (n > m) --j;
                else --i;
                if (++cnt > 1) {
                    cout << "NO" << endl; return 0;
                }
            }
        }
        if (i < n || j < m) ++cnt;
        cout << (cnt == 1 ? "YES" : "NO") << endl;
    }
    return 0;
}

⭐F.迷失的Syuggie

题目：

image-20231021231016042.png

🌟题解：

也是一道典型的bfs题

网格由字符的二维数组"f"表示，其中"#“表示障碍物，”."表示空白格子。算法从起始点（标记为’S’）开始，探索所有可能的路径，直到达到目标点（标记为’T’）或者在给定的步数限制"k"内探索完所有可能的路径。最短路径长度存储在变量"ans"中，每当找到一条更短的路径时，它就会被更新。最后，最短路径长度被打印出来。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include <iostream>
#include <queue>
using namespace std;
const int N=1010;
typedef pair<int,int> PII;
struct point {
    int x,y,step;
};
queue<point> q;
char f[N][N];
int x[]={-1,0,1,0},y[]={0,1,0,-1};
int n,m,k;
int sx,sy,tx,ty;
int ans=1e6;
int bfs()
{
    q.push({sx,sy,0});
    f[sx][sy]='#';
    while(q.size())
    {
        auto t=q.front();
        q.pop();
        if(t.step<=k) 
        {
            ans=min(ans,abs(t.x-tx)+abs(t.y-ty));

        }
        for(int i=0;i<4;i++)
        {
            int a=t.x+x[i],b=t.y+y[i];
            if(a>=1&&a<=n&&b>=1&&b<=m&&f[a][b]!='#')
            {
                q.push({a,b,t.step+1});
                f[a][b]='#';
            }
        }
    
    }
    return ans;
}
int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            char c;
            cin>>c;
            if(c=='T')
            {
                tx=i;
                ty=j;
            }
            else if(c=='S')
            {
                sx=i;
                sy=j;
            }
            f[i][j]=c;
        }
    cout<<bfs()<<endl;
    return 0;
}

⭐G.寻找签到题之路

题目：

image-20231021221209375.png

🌟题解：

一眼典型背包dp，直接写就好。。。。就是时间有限要得分最大，每个题目时间也知道。总时间就是背包，每个题目分数就是价值，时间就是重量。不过也有大佬别的做法

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
1.
#include<bits/stdc++.h>
using namespace std;
const int N = 10010;
int t[N],s[N];    
int f[N][N];  
int main() 
{
    int n, m;   
    cin >> n >> m;
    for(int i = 1; i <= n; i++) 
        cin >> s[i] >> t[i];
    for(int i = 1; i <= n; i++) 
        for(int j = 1; j <= m; j++)
        {
            if(j < t[i]) 
                f[i][j] = f[i - 1][j];
            else    
                f[i][j] = max(f[i - 1][j], f[i - 1][j - t[i]] + s[i]);
        }           
    cout << f[n][m] << endl;
    return 0;
}//正的
#include<iostream>
using namespace std;
const int N = 1000005;
int n,m;
int f[N];
int v,w;
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>w>>v;
        for(int j=m;j>=v;j--)
        {
            f[j]=max(f[j],f[j-v]+w);
        }
    }
    cout<<f[m]<<endl;
    return 0;
}//逆的
2.dfs来自dy
#include<bits/stdc++.h>
using namespace std;
int t, n;
int s[21], ti[21];
int maxn;
void dfs(int time, int score, int tit) {
    if (time <0)return;
    if (tit == n){
        maxn = max(maxn, score);
        return;}
    dfs(time,score,tit+1);
    dfs(time-ti[tit],score+s[tit],tit+1);
    return;
}
int main() {
    cin >> n >> t;
    for (int i = 0; i < n; i++) {
        cin >> s[i] >> ti[i];
    }
    dfs(t, 0, 0);
    cout << maxn;
}

⭐H.子矩阵和

题目：

image-20231021222537488.png

🌟题解：

就是典型的二维前缀和处理一下查询

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include<iostream>
using namespace std;
typedef long long ll;
const int N=10010;
ll a[N],b[N],c[N][N],s[N][N];
int main()
{
    ll n,m,q;
    cin>>n>>m;
    for(ll i=1;i<=n;i++)
        cin>>a[i];
    for(ll i=1;i<=m;i++)
        cin>>b[i];
    for(ll i=1;i<=n;i++)
        for(ll j=1;j<=m;j++)
            c[i][j]=a[i]*b[j];
    for(ll i=1;i<=n;i++)
        for(ll j=1;j<=m;j++)
             s[i][j] = s[i][j - 1] + s[i - 1][j] - s[i - 1][j - 1] + c[i][j];
    cin>>q;
    while(q--)
    {
        ll x1,y1,x2,y2;
        cin>>x1>>y1>>x2>>y2;
        cout<<s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]<<endl;
    }
    return 0;
}

⭐I.最短区间

题目：

image-20231021222929110.png

🌟题解：

双指针i，j指一指循环区间根据条件找到最小区间

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
1.
#include<iostream>
using namespace std;
const int N = 100005;
typedef long long ll;
ll n,x;
ll a[N];
ll mul=1,ma;
int ans=N;
int main()
{
    cin>>n>>x;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1,j=1;i<=n;i++)
    {
        while(mul<x && j<=n)
        {
            mul*=a[j];j++;
        }
        if(mul>=x) ans=min(ans,j-i);
        mul/=a[i];
    }
    if(ans>n) ans=-1;
    cout<<ans<<endl;
    return 0;
}
2.
#include <iostream>
using namespace std;
const int N = 1e5 + 5;
int a[N];
int main() {
    int n, x;
    cin >> n >> x;
    for (int i = 1; i <= n; ++i)
        cin >> a[i];
    int left = 1, right = 1, len = 0;
    long long prod = a[1];
    while (right <= n) {
        if (prod >= x) { 
            if (len == 0 || right - left + 1 < len) 
                len = right - left + 1;
            prod /= a[left]; 
            left++;
            if (left > right) { 
                right++;
                if (right <= n)
                    prod *= a[right];
            }
        } else {
            right++;
            if (right <= n)
                prod *= a[right];
        }
    }
    if (len == 0)
        cout << "-1" << endl;
    else
        cout << len << endl;
    return 0;
}

⭐J.点球大战

题目：

image-20231021231553939.png

🌟题解：

代码：

⭐K.冠军预言

题目：

image-20231021231610977.png

🌟题解：

代码：

⭐L.an interesting problem

题目：

image-20231021231632155.png

image-20231021231655031.png

image-20231021231705949.png

🌟题解：

很复杂的一道题但是思维很简单，代码量很多

代码：

⭐M.选数异或

题目：

image-20231021230033580.png

🌟题解：

我们可以用一个桶来记录每个数出现的次数，然后从前往后遍历数列，对于每个数 x，我们可以计算出在它之前出现的比它大的数的个数，就是(i-1-cnt[x])，其中 i 是当前遍历到的位置，cnt[x] 是 x* 出现的次数。这个式子的意思是，在 x 之前，一共有 i−1 个数，其中有 cnt[x] 个数等于 x，所以比 x大的数的个数就是 i−1−cnt[x]。

最后的答案就是所有的逆序对个数之和。时间复杂度 O*(*n)。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<iostream>
using namespace std;
const int N = 1000010;
typedef long long ll;
ll n,cnt[N],x,ans;
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) 
    {
        cin>>x;
        ans+=(i-1-cnt[x]);
        cnt[x]++;
    }
    cout<<ans<<endl;
    return 0;
}

题目难度：A<B<CG<HD<E<I<M<F<JKL

]]> <h1>第五届太原理工大学程序设计竞赛新生赛（初赛）题解</h1> <h2 id="⭐A-饿饿饭饭">⭐A.饿饿饭饭</h2> <h3 id="题目：">题目：</h3> <p><img src="https://github.com/cjmarklll/cjmarklll.gi 杂题结论 http://example.com/undefined/f1b6fc8a.html 2023-09-16T06:49:45.000Z 2023-09-16T07:44:24.735Z 1.[a,b]的奇数之和

[1,2k-1]的奇数之和：k^2

111.png

((b+1)/2)((b+1)/2)-(a/2)(a/2)

2.[a,b]的偶数之和：

[1,2k]的偶数和

k+k^2

：(b/2-(a-1)/2)+(b/2)(b/2)-((a-1)/2)((a-1)/2)

3.八进制十进制小数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include<iostream>
#include<cstring>
using namespace std;
const int N = 10010;
char d[N] ;  //八进制数
int ans[N] ;  //十进制数
int main(){
    while(cin>>d){
        memset(ans,0,sizeof(ans));  //每组数据都必须先初始化ans[] 
        int d2;
        int len = strlen(d);       //记录小数的位数 
        int t = 0 ;
        for(int i = len - 1 ; i > 1 ; i--){
            d2 = d[i] - '0' ;     //d2来接收小数的每一位的数 
            int k = 0 , j = 0 ;
            while(j<t || d2){    //此循环内语句为数组模拟除法计算 
                d2 = d2*10 + ans[j++]; 
                ans[k++] = d2/8 ;
                d2 %= 8 ;
            }
            t = k;     //记录最后的得到的位数 
        }
        cout<<d<<" [8] = 0." ;
        for(int i = 0 ; i < t ; i++)
            cout<<ans[i];
        cout<<" [10]"<<endl;
    }
    return 0;
}

十进制转R进制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
#include <stdlib.h>

char digits[] = "0123456789ABCDEF";
#define N 32
char ans[N + 2];

int main()
{
    int n, r;
    while (~scanf ("%d%d", &n, &r)) {
        if(r==0)break;
        if (n < 0) {printf("-"); n = -n;}
        int i = 0;
        while (n) ans[i++] = digits[n % r], n /= r;
        if (i == 0) ans[i++] = '0';

        /* 输出结果 */
        while (--i >= 0) putchar(ans[i]);
        putchar('\n');
    }

    return 0;
}

A转B

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <iostream>
#include <string>
#include <ctype.h>
using namespace std;
string convert(int a, string& s, int b)
{
    long val, dcount, digit;
    char result[72], c;
    string ans;
 
    val = 0;
    for(int i=0; i<(int)s.size(); i++) {
        if(isdigit(s[i]))
            val = val * a + s[i] - '0';
        else
            val = val * a + toupper(s[i]) - 'A' + 10;
    }
    dcount = 0;
    while(val) {
        digit = val % b;
        val /= b;
        result[dcount++] = ((digit >= 10) ? 'A' - 10 : '0') + digit;
    }
    if(dcount == 0) {
        result[dcount++] = '0';
        result[dcount] = '\0';
    } else
        result[dcount] = '\0';
    for(int i=0, j=dcount-1; i<j; i++, j--) {
        c = result[i];
        result[i] = result[j];
        result[j] = c;
    }
    ans = result;
    return ans;
}
 
int main()
{
    int a, b;
    string s;
    cin >> a >> s >> b;
    cout << convert(a, s, b) << endl;
    return 0;
}

2转16位数爆longlong

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/* Bailian2798 2进制转化为16进制 */
 
#include <stdio.h>
#include <string.h>
 
#define N 10000
#define N2 4
char s[N + N2 + 1];
 
char convert[] = "0123456789ABCDEF";
 
int main(void)
{
    int n, len, digits, i, k;
 
    scanf("%d", &n);
    getchar();
    while(n--) {
        gets(s + N2);
 
        s[0] = s[1] = s[2] = s[3] = '0';
        len = strlen(s + N2);               /* 2进制位数 */
        digits = (len + N2 - 1) / N2;   /* 16进制位数 */
        len += N2 - 1;
        for(i=1, k=len; i<=digits; i++) {
            s[k--] = convert[(s[len - 3] - '0') * 8 + (s[len - 2] - '0') * 4 + (s[len - 1] - '0') * 2 + (s[len] - '0')];
            len -= N2;
        }
 
        printf("%s\n", &s[k + 1]);
    }
 
    return 0;
}

4.大小写转换

1
2
3
4
5
6
7
8
大写变小写、小写变大写 : 字符 ^= 32;

大写变小写、小写变小写 : 字符 |= 32;

小写变大写、大写变大写 : 字符 &= -33;
a-z：97-122
A-Z：65-90
0-9：48-57
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    int t = x;
    int value = 0;
    while (x / 10){
        value = 10 * value + x % 10;
        x /=  10;
    }
    if(value*10 + x == t) return 1;
    else return 0;
}判断回文数字
  /*幻方*/ #include<iostream>
using namespace std;
 int n,a[40][40],x,y;
int main(){
    cin>>n;
    x=1,y=(n+1)/2;
    for(int i=1;i<=n*n;i++){
        a[x][y]=i;
        if(!a[(x-2+n)%n+1][y%n+1]) x=(x-2+n)%n+1,y=y%n+1;
        else x=x%n+1;
    }
for(int i=1;i<=n;i++){
    for(int j=1;j<=n;j++){cout<<a[i][j]<<' ';}
        cout<<endl;}
}
]]> <h1>1.[a,b]的奇数之和</h1> <h2 id="1-2k-1-的奇数之和：k-2">[1,2k-1]的奇数之和：k^2</h2> <p><img src="https://github.com/cjmarklll/cjmarklll.github.io/blob/ma 序列式容器 http://example.com/undefined/1ae3852a.html 2023-09-12T05:50:18.000Z 2023-09-16T08:41:03.283Z 一、简介

序列容器以线性序列的方式存储元素。它没有对元素进行排序，元素的顺序和存储它们的顺序相同。一般来说，有 5 种标准的序列容器，每种容器都具有不同的特性：

  • array<T,N> (数组 ：是一个长度固定的序列，有N个T类型的对象，不能增加或删除元素。

  • vector (向量容器) ：

  • 是一个长度可变的序列，用来存放T类型的对象。必要时，可以自动增加容量，但只能在序列的末尾高效地增加或删除元素。

  • deque (双向队列容器) ：

  • 是一个长度可变的、可以自动增长的序列，在序列的两端都不能高效地增加或删除元素。

  • list (链表容器) ：

  • 是一个长度可变的、由 T 类型对象组成的序列，它以双向链表的形式组织元素，在这个序列的任何地方都可以高效地增加或删除元素。访问容器中任意元素的速度要比前三种容器慢，这是因为 list 必须从第一个元素或最后一个元素开始访问，需要沿着链表移动，直到到达想要的元素。

  • forward list (正向链表容器) ：

  • 是一个长度可变的、由 T 类型对象组成的序列，它以单链表的形式组织元素，是一类比链表容器快、更节省内存的容器，但是它内部的元素只能从第一个元素开始访问。

下面是一些具体性质：

  • array<T,N>（数组容器）：

  • 表示可以存储 N 个 T 类型的元素，是 C++ 本身提供的一种容器。此类容器一旦建立，其长度就是固定不变的，这意味着不能增加或删除元素，只能改变某个元素的值；

  • vector（向量容器）：

  • 用来存放 T 类型的元素，是一个长度可变的序列容器，即在存储空间不足时，会自动申请更多的内存。使用此容器，在尾部增加或删除元素的效率最高（时间复杂度为 O(1) 常数阶），在其它位置插入或删除元素效率较差（时间复杂度为 O(n) 线性阶，其中 n 为容器中元素的个数）；

  • deque（双端队列容器）：

  • 和 vector 非常相似，区别在于使用该容器不仅尾部插入和删除元素高效，在头部插入或删除元素也同样高效，时间复杂度都是 O(1) 常数阶，但是在容器中某一位置处插入或删除元素，时间复杂度为 O(n) 线性阶；

  • list（链表容器）：

  • 是一个长度可变的、由 T 类型元素组成的序列，它以双向链表的形式组织元素，在这个序列的任何地方都可以高效地增加或删除元素（时间复杂度都为常数阶 O(1)），但访问容器中任意元素的速度要比前三种容器慢，这是因为 list 必须从第一个元素或最后一个元素开始访问，需要沿着链表移动，直到到达想要的元素。

  • forward_list（正向链表容器）：

  • 和 list 容器非常类似，只不过它以单链表的形式组织元素，它内部的元素只能从第一个元素开始访问，是一类比链表容器快、更节省内存的容器。

    222.png

二、函数成员

这些容器都有一些常见的函数成员帮助去实现各种操作。

函数成员函数功能vector<T,N>array<T,N>deque
begin()返回指向容器中第一个元素的迭代器。是是是
end()返回指向容器最后一个元素所在位置后一个位置的迭代器，通常和 begin() 结合使用。是是是
rbegin()返回指向最后一个元素的迭代器。是是是
rend()返回指向第一个元素所在位置前一个位置的迭代器。是是是
cbegin()和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。是是是
cend()和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。是是是
crbegin()和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。是是是
crend()和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。是是是
assign()用新元素替换原有内容。-是是
operator=()复制同类型容器的元素，或者用初始化列表替换现有内容。是是是
size()返回实际元素个数。是是是
max_size()返回元素个数的最大值。这通常是一个很大的值，一般是 232-1，所以我们很少会用到这个函数。是是是
capacity()返回当前容量。-是-
empty()判断容器中是否有元素，若无元素，则返回 true；反之，返回 false。是是是
resize()改变实际元素的个数。-是是
shrink _to_fit()将内存减少到等于当前元素实际所使用的大小。-是是
front()返回第一个元素的引用。是是是
back()返回最后一个元素的引用。是是是
operator使用索引访问元素。是是是
at()使用经过边界检査的索引访问元素。是是是
push_back()在序列的尾部添加一个元素。-是是
insert()在指定的位置插入一个或多个元素。-是是
emplace()在指定的位置直接生成一个元素。-是是
emplace_back()在序列尾部生成一个元素。-是是
pop_back()移出序列尾部的元素。-是是
erase()移出一个元素或一段元素。-是是
clear()移出所有的元素，容器大小变为 0。-是是
swap()交换两个容器的所有元素。是是是
data()返回指向容器中第一个元素的指针。是是-

list and forward_list

函数成员函数功能listforward_list
begin()返回指向容器中第一个元素的迭代器。是是
end()返回指向容器最后一个元素所在位置后一个位置的迭代器。是是
rbegin()返回指向最后一个元素的迭代器。是-
rend()返回指向第一个元素所在位置前一个位置的迭代器。是-
cbegin()和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。是是
before_begin()返回指向第一个元素前一个位置的迭代器。-是
cbefore_begin()和 before_begin() 功能相同，只不过在其基础上，增加了 const 属性，即不能用该指针修改元素的值。-是
cend()和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素是是
crbegin()和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。是-
crend()和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。是-
assign()用新元素替换原有内容。是是
operator=()复制同类型容器的元素，或者用初始化列表替换现有内容。是是
size()返回实际元素个数。是-
max_size()返回元素个数的最大值，这通常是一个很大的值，一般是 232-1，所以我们很少会用到这个函数。是是
resize()改变实际元素的个数。是是
empty()判断容器中是否有元素，若无元素，则返回 true；反之，返回 false。是是
front()返回容器中第一个元素的引用。是是
back()返回容器中最后一个元素的引用。是-
push_back()在序列的尾部添加一个元素。是-
push_front()在序列的起始位置添加一个元素。是是
emplace()在指定位置直接生成一个元素。是-
emplace_after()在指定位置的后面直接生成一个元素。-是
emplace_back()在序列尾部生成一个元素。是-
cmplacc_front()在序列的起始位生成一个元索。是是
insert()在指定的位置插入一个或多个元素。是-
insert_after()在指定位置的后面插入一个或多个元素。-是
pop_back()移除序列尾部的元素。是-
pop_front()移除序列头部的元素。是是
reverse()反转容器中某一段的元素。是是
erase()移除指定位置的一个元素或一段元素。是-
erase_after()移除指定位置后面的一个元素或一段元素。-是
remove()移除所有和参数匹配的元素。是是
remove_if()移除满足一元函数条件的所有元素。是是
unique()移除所有连续重复的元素。是是
clear()移除所有的元素，容器大小变为 0。是是
swap()交换两个容器的所有元素。是是
sort()对元素进行排序。是是
merge()合并两个有序容器。是是
splice()移动指定位置前面的所有元素到另一个同类型的 list 中。是-
splice_after()移动指定位置后面的所有元素到另一个同类型的 list 中。-是

非常多不过也没必要都记下来，只要掌握几种如begin(),end(),push_back(),sort(),swap()就好

]]> <h1>一、简介</h1> <p>序列容器以线性序列的方式存储元素。它没有对元素进行排序，元素的顺序和存储它们的顺序相同。一般来说，有 5 种标准的序列容器，每种容器都具有不同的特性：</p> <ul class="lvl-0"> <li class="lvl-2"> <p>ar STL简介 http://example.com/undefined/6d927e9f.html 2023-09-11T12:07:01.000Z 2023-09-11T13:11:44.445Z STL简介

⭐STL的组成：

  • 容器（container）

  • 迭代器（iterator）这个概念很重要

  • 算法（algorithm）

  • 仿函数（function object）

  • 适配器（adaptor)

  • 空间配置器（allocator)

    本博客主要讲讲容器和算法还有一些迭代器的知识。另外三个我也不是很理解，共同进步。

    🌟容器：顾名思义是放东西的

    主要是：序列式容器（Sequence container）、关联式容器（associated container）、容器适配器（container adaptor）

    • 序列式容器：每个元素都有固定位置，取决于插入时间和地点，和值没有关系。（如vector、deque，list）
    • 关联式容器：元素位置取决于特定的排序原则，和插入顺序无关。（如map、set、multiset，multimap）
    • 容器适配器：包括stack、queue。

      ⭐算法：一些封装函数直接使用

      比如sort，mergesort，heapsort进行排序；max_element,min_element是元素值大最大最小；去掉重复数字的unique；元素反转的reverse等很多很多。

      🌟迭代器：STL使用迭代器来表示数据位置，可以简单认为是容器的指针，后面又更具体的介绍。

]]> <h2 id="STL简介">STL简介</h2> <h3 id="⭐STL的组成：">⭐STL的组成：</h3> <ul class="lvl-0"> <li class="lvl-2"> <h4 id="容器（container）">容器（container）</h4> </ 分解质因数 http://example.com/undefined/ece2ea76.html 2023-09-07T08:47:30.000Z 2023-09-11T13:12:24.739Z 分解质因数

：

算术基本定理：

算术基本定理可表述为：任何一个大于1的自然数 N,如果N不为质数，那么N可以唯一分解成有限个质数的乘积。

结论一

首先根据 算术基本定理 可以知道，一个合数可以由多个比他小的质数相乘而得，而这些质数就是他的质因数。

并且，例如一个数 x是 n 的因数，并且是合数，那么问一个问题。是否存在一个质数是 x 的质因数，而不是 n 的质因数？答案是不可能的哈

证明：

很明显 因为 n/x = k，那么 x 的质因数组成 x 的时候只要再乘以 k 就可以得到 n，因此可以得出一个结论：n 的因数的质因数，肯定也是 n 的质因数。

结论二

那么能不能得到一个结论就是，n 的任何一个因数 x假如他是合数，那么他绝对可以由 n 的小于x的质因数所相乘而得

答案是可以的哈

证明：

根据上面的结论推导一下就可以了。n 的因数如果是合数，那么他绝对可以由比他小的质因数组合而成，同时这些质因数是 n 的质因数，那么不就可以得到上面问题的结论。

结论三

因此最后我们又可以得到一条结论：一个数的因数，如果排序的话，最开始的因数肯定是质因数，后面才有合数。

可不可以这么推论呢？可以的。

证明：

还是根据第一条理论。假如n 的因数除了 1 之外第一个因数是合数，那么他绝对可以由一些质因数组合而成，那么这些数是比他小的，且是 n 的质因数，因此，这些数也是 n 的因数，并且是质数。

结论四

**数 x 是数 n 的因数，且是合数，那么 n 的质因数不一定是 x 的质因数，而 x 的 质因数一定是 n 的质因数。**因此当将 n 的所有比x 小的质因数都除尽的时候，因此当 i 为 x 的时候自然是无法进行整除的。

因此现在可以证明，从小到大遍历数 n 的因数，并且每次都除尽的话，那么只会遍历到数 n 的质因数，而不会是合数

最后可以得出，每次if(n%i==0) 成立的时候 i 一定是 n 的质因数。

]]> <h1>分解质因数</h1> <p>：</p> <p>算术基本定理：</p> <p>算术基本定理可表述为：任何一个大于1的自然数 N,如果N不为质数，那么N可以唯一分解成有限个质数的乘积。</p> <h3 id="结论一">结论一</h3> <p>首先根据 <strong>算术基