Shaw的博客 https://blog.shawgarcia.cn/ 这是我的博客网站 Mon, 05 Oct 2026 12:04:13 GMT http://hexo.io/ 堆积木 https://blog.shawgarcia.cn/posts/30609.html https://blog.shawgarcia.cn/posts/30609.html Thu, 02 Nov 2023 16:00:00 GMT 广义表的应用——积木堆叠移动模拟。 堆积木

蒜头君有 n 块积木，编号分别为 1 到 n。一开始，蒜头把第 i 块积木放在位置 i。蒜头君进行 m 次操作，每次操作，蒜头把位置 b 上的积木整体移动到位置 a 上面。比如 1 位置的积木是 1，2 位置的积木是 2，那么把位置 2 的积木移动到位置 1 后，位置 1 上的积木从下到上依次为 1,2。

输入格式

第一行输入 2 个整数 n,m (1≤n≤10000,0≤m≤10000)。

接下来 m 行，每行输入 2 个整数 a,b (1≤a,b≤n)，如果a，b 相等则本次不需要移动。

输出格式

输出 n 行，第 i 行输出位置 i 从下到上的积木编号，如果该行没有积木输出一行空行。

实现代码

这道题是我第一次用广义表，应该还是能优化不少的，bug改着改着就解决了，没什么实感（？）

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
#include<iostream>
#include<stdlib.h>
using namespace std;
typedef struct node
{
int data;
int top; 
struct node* link;
struct node* next;
}lsnode,*lslink;
lslink listscreat(int n)
{
lslink H,p,r,q;
H=(lslink)malloc(sizeof(lsnode));
H->next=NULL;
r=H;
for(int i=1;i<=n;++i)
{
p=(lslink)malloc(sizeof(lsnode));
q=(lslink)malloc(sizeof(lsnode));
q->data=i;
p->data=i;
r->next=p;
p->link=q;
q->next=NULL;
p->next=NULL;
p->top=1;
r=p;
}
return H;
}
lslink findit(lslink H,int n)
{
for(int i=1;i<=n;++i)
H=H->next;
//cout<<"成功进入findit函数，且这个返回值是"<<H->data<<endl;
return H;
}
lslink finaone(lslink H)
{
//cout<<"成功进入fi函数"<<endl;
lslink p=H;
for(int i=0;i<H->top;++i)
p=p->link;
//cout<<"这个函数的link链表最后一个是"<<p->data;
return p;
}
int main()
{
int n,m,a,b;
cin>>n>>m;
lslink H=listscreat(n);
lslink r,s,p=H->next;
for(int i=1;i<=m;++i)
{
cin>>a>>b;
if(a==b) continue;//a与b相同时不移动 
r=findit(H,a);
s=findit(H,b);
if(s->top==0) continue;
lslink r1;
r1=finaone(r);
r1->link=s->link;
r->top+=s->top;
s->top=0;
}
for(int i=1;i<=n;++i)
{
lslink qwq=p->link;
for(int j=1;j<=p->top;++j)
{
cout<<qwq->data<<" ";
qwq=qwq->link;
}
cout<<endl;
p=p->next; 
}
return 0;
}
]]> 编程题 广义表 https://blog.shawgarcia.cn/posts/30609.html#disqus_thread 幻方矩阵&话题焦点人物 https://blog.shawgarcia.cn/posts/42025.html https://blog.shawgarcia.cn/posts/42025.html Thu, 02 Nov 2023 16:00:00 GMT 数组与矩阵行列交换，以及微博话题焦点人物统计。 幻方矩阵

一天蒜头君买了一个幻方矩阵，这个矩阵每次可以交换任意两行或者任意两列。花椰妹看到说这么简单的东西，我自己就可以编程实现了。蒜头君要强地说这么简单我肯定也会，但是蒜头君并不会，只好求助你来编程实现。

输入格式

第一行输入两个整数 n,m，表示这个幻方矩阵大小为 n×m。

接下来是一个 n×m 的矩阵。

接下来一行有一个整数 op，表示有 op 次操作。

接下来 op 行，每行有三个整数 x，y，z。

当 x=0 的时候表示交换第 y 行和第 z 行。

当 x=1 的时候表示交换第 y 列和第 z 列。

输出格式

输出交换后的矩阵。

数据范围

对于 30% 的数据，1≤n,m,op≤100。

对于 60% 的数据，1≤n,m,n×m≤10的5次方，1≤op≤100。

对于 100% 的数据，1≤n,m,n×m,op≤10的5次方，1≤ 矩阵中每个数字的大小 ≤10的6次方。

实现代码

比较简单的一道题，在使用动态数组之前是过不了测试点的。

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
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int n,m;
cin>>n>>m;
int **a=new int*[n];
for(int i=0;i<n;++i)
a[i]=new int[m];
for(int i=0;i<n;++i)
for(int j=0;j<m;++j)
cin>>a[i][j];
int op;
cin>>op;
int x,y,z;
for(int i=0;i<op;++i)
{
cin>>x>>y>>z;
if(!x)//x==0
for(int j=0;j<m;++j)
swap(a[y-1][j],a[z-1][j]);
else//x==1
for(int j=0;j<n;++j)
swap(a[j][y-1],a[j][z-1]);
}
for(int i=0;i<n;++i)
{
for(int j=0;j<m-1;++j)
cout<<a[i][j]<<" ";
cout<<a[i][m-1];
if(i!=n-1) cout<<endl;
}
for(int i=0;i<n;++i)
  delete []a[i];
delete []a;
return 0;
}

话题焦点人物

微博提供了一种便捷的交流平台。一条微博中，可以提及其它用户。例如你发出一条微博为：“期末考试顺利 @蒜头君 @花椰菜”，则你提及了蒜头君和花椰菜两位用户。

我们收集了 N(1<N<10000) 条微博，并已将其中的用户名提取出来，用小于等于100 的正整数表示。

通过分析这些数据，我们希望发现大家的话题焦点人物，即被提及最多的人（如果有多个，找到编号最小的），并找出那些提及它的人。

输入格式

输入共两部分：

第一部分是微博数量 N，1<N<10000。

第二部分是 N 条微博，每条微博占一行，表示为：

发送者序号 a，提及人数 k(0≤k≤20)，然后是 k 个被提及者序号 1,2…b1​,b2​…bk​；其中 a 和 1,2…b1​,b2​…bk​ 均为大于 0 小于等于 100 的整数。相邻两个整数之间用单个空格分隔。

输出格式

输出分两行：

第一行是被提及最多的人的序号；

第二行是提及它的人的序号，从小到大输出，相邻两个数之间用单个空格分隔。同一个序号只输出一次。

实现代码

在这之前，我需要说明的是，我自己的代码仅仅通过了一个测试点，代码里依旧有问题没有解决，不过我认识到自己的代码过于垃圾我的数据结构构建有大问题，然后在网上找到了一份参考答案，和我的思路一致，但在数据结构的规划上比我的好得多，各位可以看原文->

题目 - 话题焦点

然后呢，这是我在看了Grausam的博客后修改的代码（：

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
#include<iostream>
#include<algorithm> 
using namespace std;
int main()
{
    int N,a[101][101],m,mm;
    cin>>N;
    int qwq=0;
    for(int i=0;i<101;++i)
    for(int j=0;j<101;++j)
    a[i][j]=0;
    int awa=0;
    for(int i=0;i<N;++i)
    {
        cin>>mm>>m;
        int l;
        //cout<<"l输入成功"<<endl;
        for(int j=0;j<m;++j)
        {
            cin>>l;
            a[mm][l]++;
            //cout<<l<<"出现了"<<k[l]<<"次了,"<<l<<"的输入者是"<<mm<<endl; 
        }
    }
    int max = 1;
for (int i = 1; i <= 100; i++) 
{
for (int j = 1; j <= 100; j++) 
a[0][i] += a[j][i];
if (a[0][i] > a[0][max])
max = i;
}
cout<<max<<endl;
    for(int i=1;i<=100;++i)
    if(a[i][max]) cout<<i<<" ";
    return 0;
}

我原本的10分代码里有好几个数组，我对自己的垃圾代码的评价是：纯粹的模拟是行不通的。

]]> 编程题 数组 https://blog.shawgarcia.cn/posts/42025.html#disqus_thread 回文判断&逆波兰式 https://blog.shawgarcia.cn/posts/50961.html https://blog.shawgarcia.cn/posts/50961.html Wed, 01 Nov 2023 16:00:00 GMT 栈的应用——回文判断与逆波兰式求值。 回文判断

我们把正读和反读都相同的字符序列称为“回文”，例如abba和abcba是回文，abcde不是回文。尝试写一个算法判别读入的一个以@为结束符的字符是否是回文。

输入格式

输入为一行，为待判断的字符串，以@结尾。字符串长度不超过 30，除最后一个字符外，其余字符均由小写字母组成。

输出格式

输出一行，如果输入的字符串是回文，则输出true；如果输入的字符串不是回文，则输出false。

实现代码

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
#include<iostream>
#include<stdlib.h>
#include<string>
using namespace std;
typedef struct
{
char data[31];
int top;
}sqstack,*sqslink;
bool push(sqslink &s,char x)
{
if(s->top >=30) return 0;//栈满溢出
else
{
s->top++;
s->data[s->top]=x;
return 1;
} 
}
bool emptystack(sqslink s)
{
if(s->top <0) return 1;
else return 0;
}
char pop(sqslink &s)
{
if(emptystack(s)) return 0;
else
{
s->top--;
return(s->data[s->top]);
}
}
int main()
{
string ch;
sqslink s1,s2;
s1=(sqslink)malloc(sizeof(sqstack));
s2=(sqslink)malloc(sizeof(sqstack));
s1->top =0;
s2->top =0;
cin>>ch;
for(int i=0;i<ch.length()-1;++i)
push(s1,ch[i]);
//cout<<"S1真的正常吗"<<endl;
//for(int i=1;i<ch.length();++i)
//cout<<s1->data[i]<<" ";
//cout<<endl; 
s1->top+=1;
//cout<<"S2逐渐入栈"<<endl;
while(s1->top>1)
{
push(s2,pop(s1));
//cout<<s2->data[s2->top]<<" ";
}
//cout<<endl;
int n=s2->top;
s2->top=n+1;
s1->top=n+1;
//cout<<"字符串长度"<<n<<endl;
for(int i=1;i<=n;++i)
{
//cout<<pop(s1)<<"和"<<pop(s2)<<endl;
if(pop(s1)!=pop(s2))
{
cout<<"false";
return 0;
}
}
cout<<"true";
return 0;
}

啊，调试用的输出语句就不删了。

逆波兰式

假设表达式由数字和双目四则运算符+，-，*，/构成。试利用栈实现一个算法，将一个通常书写形式且书写正确的表达式转换为逆波兰式（后缀表达式），同时将转换后的逆波兰式求值，最后仅需输出求值结果。

输入格式

输入共有一行，为待求值的表达式，以换行结束。表达式保证是合法的，表达式中的整数在 [0,9] 以内，表达式长度不超过 20。表达式中仅包含+，-，*，/以及数字，不会出现其他字符。

输出格式

输出仅有一行，为输入表达式的正确计算结果。

实现代码

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
#include<iostream>
#include<string>
#include<stdlib.h>
using namespace std;
typedef struct
{
int data[21];
int top;
}sqstack,*sqslink;
int pop(sqslink &s)
{
s->top--;
return s->data[s->top+1];
}
void push(sqslink &s,int x)
{
s->top++;
s->data[s->top]=x;
}
int main()
{
string str;
cin>>str;
sqslink s;
s=(sqslink)malloc(sizeof(sqstack));
s->top=0;
int len=str.length();
bool l=0;
for(int i=0;i<len;++i)
{
if(l)
{
push(s,0-((int)str[i]-48));
l=0;
continue;
}
if(str[i]>=48&&str[i]<=57)
push(s,(int)str[i]-48);
else 
if(str[i]=='-')
{
l=1;
continue;
}
else
if(str[i]=='*')
{
push(s,(int)pop(s)*((int)str[i+1]-48));
i++;
}
else 
if(str[i]=='/')
{
push(s,(int)pop(s)/((int)str[i+1]-48));
i++;
}
}
while(1)
{
if(s->top<=1) break;
push(s,pop(s)+pop(s));
}
cout<<pop(s);
return 0;
}

大概思路就是把该乘除的都算好再存到栈里，最后取出来累加就好了，如果有减号就提前加个负号。

]]> 编程题 栈 https://blog.shawgarcia.cn/posts/50961.html#disqus_thread 蒜头君的魔法机 https://blog.shawgarcia.cn/posts/44813.html https://blog.shawgarcia.cn/posts/44813.html Tue, 24 Oct 2023 16:00:00 GMT 栈模拟——判断目标出栈序列是否合法。 蒜头君的魔法机

蒜头君有一台神奇的魔法机，它能将输入的序列进行一系列复杂的变换，输出原序列的另一种排列方式。蒜头君十分好奇魔法机的工作原理，终于有一天他尝试着把魔法机拆开研究了。

通过一系列复杂的演算，蒜头君终于发现了魔法机的工作原理：其实魔法机就是一个栈，根据栈先进后出的性质，每次一个数字进栈或将栈顶元素弹出，由此可以产生不同的出栈序列，出栈序列就是原序列的另一种排列了。

在研究完原理后，蒜头君凭借记忆很快就把魔法机组装好了。现在蒜头君想测试下魔法机在组装完成后是否出现问题。

首先他将 1 到 N 这 N 个数字依次输入魔法机里，然后随机写下一组序列a，现在他想知道能否通过魔法机得到序列a，聪明的你能帮蒜头君算一算吗？

输入格式

输入有两行，第一行是一个正整数 N(1≤N≤100)，表示输入魔法机序列的长度，第二行是序列a，共有 N 个整数，表示要得到的目标序列。

序列为 1 到 N 的排列，即序列a长度为 N，保证序列中的整数都不相同，且整数在区间 [1, N] 内。

输出格式

输出一行，如果能通过魔法机得到序列a，则输出YES，否则输出NO。

实现代码

思路：模拟魔法机的实现，其中a数组是期望的出栈顺序；栈r是存的是n到1的数据，栈顶在1的位置，按从大到小排；栈s是魔法机本体；遍历a数组，如果s栈的栈顶元素和a[i]不一样（还不到出栈的时候），就把r栈的栈顶元素给s栈（试试下一个元素是否可以按照期望出栈），如果遇到s栈的栈顶元素大于a[i]的情况，表示这个期望的出栈顺序无法实现。

可能表述不到位，以下是实现代码。

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
#include<iostream>
#include<stdlib.h> 
using namespace std;
typedef struct
{
int data[101];
int top;
}sqstack,*sqslink;
int push(sqslink &s,int x)
{
if(s->top >=100) return 0;//栈满溢出
else
{
s->top++;
s->data[s->top]=x;
return 1;
} 
}
bool emptystack(sqslink s)
{
if(s->top <0) return 1;
else return 0;
}
int pop(sqslink &s)
{
if(emptystack(s)) return 0;
else
{
s->top--;
return(s->data[s->top]);
}
}
int main()
{
int n;
cin>>n;
int a[101];
for(int i=0;i<n;++i)
cin>>a[i];
sqslink s,r;
s=(sqslink)malloc(sizeof(sqstack));
s->top=0;
r=(sqslink)malloc(sizeof(sqstack));;
r->top=0;
for(int i=n;i>=1;--i)
push(r,i);
int i=0;
s->data[s->top]=0;
while(1)
{
if(i==n) break;
if(s->data[s->top]==a[i])
{
pop(s);
i++;
continue;
}
else if(s->data[s->top]>a[i])
{
cout<<"NO";
return 0;
}
push(s,r->data[r->top]);
r->top-=1;

}
cout<<"YES";
return 0;
}

收藏Shaw的博客谢谢喵~

]]> 编程题 栈 https://blog.shawgarcia.cn/posts/44813.html#disqus_thread 队列：通话记录 https://blog.shawgarcia.cn/posts/44812.html https://blog.shawgarcia.cn/posts/44812.html Mon, 23 Oct 2023 16:00:00 GMT 队列的应用——三类通话记录的归类与输出。 通话记录（队列）

已知不超过 50条通话记录，通话记录有三种类型：0代表未接来电，1 代表已接来电，2 代表已拨电话。要求分别将三种类型前 10 条通话记录以三列的形式输出。

输入格式

输入不超过 50条通话记录，每条通话记录都占一行。每一行的第一个数字代表通话记录的类型，第二个数字代表电话号码，电话号码均由 11个数字组成。他们之间用一个空格隔开。

输出格式

分三列输出未接来电、已接电话和已拨电话。

每列之间用一个空格分割，最后一列后没有空格。每种类型输出前十个电话，先出现的通话记录先输出，不足十个的用 0 占位。

实现代码

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
#include<iostream>
#include<string>
#include<stdlib.h>
using namespace std;
typedef struct//队列
{
string data[51];
int front,rear;
}squeue,*squlink;
void enqueue(squlink &Q,string s)//入队
{
Q->rear+=1;
Q->data[Q->rear]=s;
}
bool Emptyqueue(squlink Q)//判断队列是否为空
{
if(Q->front==Q->rear ) return 1;
else return 0;
}
string dequeue(squlink Q)//出队
{
if(Emptyqueue(Q)) return "0";
else
{
Q->front =Q->front+1;
return Q->data[Q->front];
}
}
int main()
{
squlink Q1,Q2,Q3;//三个队列，分别存三种电话
Q1=(squlink)malloc(sizeof(squeue));
Q1->front=0;
Q1->rear =0;
Q2=(squlink)malloc(sizeof(squeue));
Q2->front=0;
Q2->rear =0;
Q3=(squlink)malloc(sizeof(squeue));
Q3->front=0;
Q3->rear =0;
string str;
while(getline(cin,str))//循环直到不输入为止
{
if(str[0]=='0')
{
enqueue(Q1,str.substr(2,11) );//将输入的数据的电话号码部分入队
}
if(str[0]=='1')
{
enqueue(Q2,str.substr(2,11));
}
if(str[0]=='2')
{
enqueue(Q3,str.substr(2,11));
}
}
for(int i=0;i<10;++i)
cout<<dequeue(Q1)<<" "<<dequeue(Q2)<<" "<<dequeue(Q3)<<endl;//出队，直接输出
return 0;
}

挺简单一道题，大概熟悉一下队列的操作

收藏Shaw的博客谢谢喵~

]]> 编程题 队列 https://blog.shawgarcia.cn/posts/44812.html#disqus_thread 链表初学整理 https://blog.shawgarcia.cn/posts/30047.html https://blog.shawgarcia.cn/posts/30047.html Sat, 21 Oct 2023 16:00:00 GMT 链表入门与基础操作整理（有序集合交集、节点增删、单向转双向等）。 链表

首先是对链表的介绍（由chatgpt3.5生成）

链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表中的节点可以在内存中的任何位置，它们通过指针连接在一起，形成一个链式结构。

链表可以分为单向链表和双向链表两种类型。在单向链表中，每个节点只有一个指针，指向下一个节点；而在双向链表中，每个节点有两个指针，分别指向前一个节点和后一个节点。

链表相对于数组的优势在于插入和删除操作的效率较高。由于链表中的节点可以在内存中的任何位置，因此在插入和删除节点时，只需要修改相邻节点的指针，而不需要移动其他节点。这使得链表在需要频繁插入和删除操作的场景中更加高效。

然而，链表的缺点是访问节点的效率较低。由于链表中的节点不是连续存储的，因此无法通过下标直接访问节点，而是需要从头节点开始遍历链表，直到找到目标节点。这使得链表在需要频繁访问节点的场景中效率较低。

总结起来，链表是一种常见的数据结构，适用于需要频繁插入和删除操作的场景。它的优势在于插入和删除操作的效率较高，但访问节点的效率较低。

啊，gpt老师说得好（鼓掌）

那么就从实际体验中来体会链表吧！

首先是作业里的第一道题

有序集合的交运算

假设以两个元素依次递增有序排序排列的线性表 A 和 B 分别表示两个集合（即同一表中的元素值各不相同），现要求另辟空间构成一个线性表 C，其元素为 A 和 B 中的元素的交集，且表 C 中的元素也依值递增有序排列。试对顺序表编写求 C 的算法。

输入格式

输入一共有 4 行，每两行描述一个线性表。

第一行为线性表长度 n（0≤ni​<50）。

第二行为线性表的 n 个元素 ai​（0≤ai​<200）。

输出格式

输出一共有两行，第一行为线性表 C 的元素个数。

第二行为线性表 C 的元素顺序输出的结果，按从小到大的顺序输出，每两个整数之间一个空格，最后一个整数后面没有空格。

以下是实现所用的代码

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
#include<iostream>
#include<stdlib.h>
using namespace std;
typedef struct node//链表的节点
{
int data;
struct node* next;
}Node,*link;//方便后续直接使用link来定义用于指向节点的指针
link Crealist(int n)//创建链表的函数，链表节点数为n
{
int num[201];//利用数组暂存输入的数据，后来发现并不需要这么麻烦，直接在后面添加节点的循环里的每一个循环里输入一个数就可以了；
for(int i=0;i<n;++i)
cin>>num[i];
link H,P,r;
H=(link)malloc(sizeof(Node));//开辟地址，使头指针指向一个地址。
H->next=NULL;
r=H;//总是指向P节点（新节点）前一个节点的一个指针。
for(int i=0;i<n;++i)//每一次循环加一个节点
{
P=(link)malloc(sizeof(Node));//新的节点
P->data=num[i];//新节点里存的数据
r->next=P;//新节点的前一个节点的next指向新节点，使节点之间被连起来。
r=P;//更新r指针
}
return H;//返回头节点
}
link Creaemptylist()//创建一个空链表
{
link H;
H=(link)malloc(sizeof(Node));
H->next=NULL;
return H;
}
bool findit(int a,link h,int m)//检测能够在链表的前m个节点中找到data为a的节点，如果有，返回true。
{
link p=h->next;
for(int i=0;i<m;++i)
{
if(p->data==a) return 1;
p=p->next;
}
return 0;
}
int main()
{
int n,m,nc=0;
cin>>n; //线性表长度
link ha=Crealist(n);
cin>>m;//第二个线性表的长度
link hb=Crealist(m);
link hc=Creaemptylist();//合并后的线性表
link pa,pb,pc,r;//可移动的指针，确保头节点始终能够访问
pa=ha->next;
pb=hb->next;
r=hc;
for(int i=0;i<n;++i)
{
if(findit(pa->data,hb,m))//如果在第二个链表中能够找到和第一个链表第i+1个数相等的数
{
nc++;//链表长度+1
pc=(link)malloc(sizeof(Node));//增加节点
pc->data=pa->data;
r->next=pc;
r=pc;
}
if(i!=n-1) pa=pa->next;//如果没有遍历到最后一个元素
}
cout<<nc<<endl;
link pk=hc->next;
for(int i=0;i<nc;++i)//输出新链表
{
cout<<pk->data;
pk=pk->next;
if(i<nc-1) cout<<" ";
}
return 0;
}

最直接的算法，做完这道题后算是理解了链表是怎么运行的了。
接下来是后面三道题

哪位同学最优秀

蒜头君想把计算机专业相关的课程都写一遍，放到计蒜客上面帮助同学们学习。但是蒜头君意识到要写的课程有很多很多，蒜头君实在忙不过来，于是他想招几位实习生帮助一块写课程。招聘广告一发，吸引了好多大牛前来应聘，于是蒜头君每天都要安排面试。

有一天，结束了一天面试后，boss 跑来问蒜头君：“小蒜，你觉得今天面试的同学里面，谁最优秀呀，谁最适合写课程呀？”蒜头君递给 boss 一沓简历，回答到：“这里有 N 份简历，boss 你猜猜哪位同学最优秀。”

每份简历都有一个对应的 id，编号从 11 开始，依次从第一份简历到最后一份简历。boss 会从简历里抽掉 M 份简历，每次他随机念一个数字 numi​，然后从第一份简历开始数，数到第 numi​ 份时，就会把对应的简历抽掉，接着念下一个数字。抽掉 M 份简历后，boss 从剩余的简历中，取出最中间的一份简历，然后点点头念道：“我相信这位同学一定最优秀，哈哈”。

现在蒜头君想知道这份简历的 id 是多少，聪明的你能帮他算出来吗？

输入格式

第一行输入两个正整数 N 和 M（1≤M<N≤1000）。

第二行输入 M 个整数 numi​（1≤numi​≤1000），表示 boss 依次念出来的数字。

保证 N−M 是奇数，输入的 numi​ 小于等于当前剩余简历数量。

输出格式

输出为一行，输出 boss 认为最优秀的同学的 id 是多少。

以下是实现代码，和上面操作差不多的就不进行注释了

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
#include<iostream>
#include<stdlib.h>
using namespace std;
typedef struct Node
{
    int id;
    Node* next;
}node,*link;
link crealist(int n)
{
    link H,p,r;
    H=(link)malloc(sizeof(node));
    H->next =NULL;
    r=H;
    for(int i=1;i<=n;++i)
    {
    p=(link)malloc(sizeof(node));
    p->id =i;
    r->next =p;
    r=p;
}
return H; 
}
link getelem(link H,int i)//找第i个元素
{
int j=0;
link p=H;
if(i<0) return NULL;
while(p->next&&j<i)
{
p=p->next ;
j++;
}
if(i==j) return p;
else return NULL;
}
void delnum(link H,int i)//删掉第i个元素
{
link p,q;
if(i==1) p=H;
else p=getelem(H,i-1);//取第i-1个元素，方便后续操作
if(p&&p->next)
{
q=p->next ;
p->next =q->next ;//第i-1个节点的next直接指向第i+1个节点，“孤立”第i个元素
}
free(q); //释放已经被孤立的节点，完成删除
}
int main()
{
int N,M,num;
cin>>N>>M;
link h=crealist(N);
link p;
p=h;
int n[1001];
for(int i=0;i<M;++i)
{
cin>>n[i];
delnum(p,n[i]);//删掉被叫到的那个人
}
int great=(N-M+1)/2;//优秀的那个人是第great个人
cout<<getelem(p,great)->id <<endl;
return 0;
}

以上代码有“寻找第i个元素”和“删掉第i个元素”的函数

接下来是第三道题

单向链表变双向

已知有一个单向循环链表，其每个结点中含三个域：prior，data 和 next，其中 data 域为数据域，next 为指向后继结点的指针域，prior 也为指针域，但它的值为空 (NULL) ，试编写算法将此单向循环链表改为双向循环链表，即使prior 成为指向前驱结点的指针域。

输入格式

输入共有三行，第一行为该单向循环链表的长度 n（1≤n≤60）。

第二行为该单向循环链表的各个元素 ai​（1≤ai​≤2000），它们各不相同且都为数字。

第三行为一个数字 m，表示链表中的一个元素值，要求输出时以该元素为起点反向输出整个双向链表。

输出格式

输出为一行，即完成双向链表后以反向顺序输出该链表，每两个整数之间一个空格，最后一个整数后面没有空格。

以下是实现代码，和上面操作差不多的就不进行注释了

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
#include<iostream>
#include<stdlib.h>
using namespace std;
typedef struct dualnode//节点多了一个指向上一个元素的指针 
{
int data;
dualnode* prior;
dualnode* next;
}node,*link; 
link crealist(int n)
{
link H,p,r;
H=(link)malloc(sizeof(node));
H->next =NULL;
r=H;
int num[2001];
for(int i=0;i<n;++i)
cin>>num[i];
for(int i=0;i<n;++i)
{
p=(link)malloc(sizeof(node));
p->data =num[i];
p->prior=NULL;
r->next =p;
r=p;
}
return H;
}
void turndual(link H,int n)//对prior指针进行填充 
{
link p=H->next ;
link r=H;
for(int i=0;i<n-1&&p!=NULL;++i)
{
p->prior=r;
r=r->next;
p=p->next;
}
p->prior=r;
}
link otherside(link H,int n)//搜寻链表最后一个节点并返回 
{
link p;
p=H;
for(int i=0;i<n;++i)
p=p->next;
return p;
}
link gachat(link H,int a)//元素a在哪个位置 
{
link p=H;
while(p->next&&p->next->data !=a)
p=p->next;
if(p->next->data==a) return p->next;
else return NULL;
}
int main()
{
int n,m;
cin>>n;
link H=crealist(n);
turndual(H,n);  //变双向！ 
link E=otherside(H,n);    //E是链表最后一个元素 
cin>>m;    //以哪个元素为起点 
link changnum=gachat(H,m);  //元素m在第几个位置         
link p=changnum;
while(p!=H)//按照要求进行输出 
{
cout<<p->data <<" ";
p=p->prior ;
}
while(E!=changnum)
{
cout<<E->data<<" ";
E=E->prior;
}
return 0;
}

接下来是最后一道题

蜗牛旅行

蜗牛在制定今天的旅游计划，有 n 个景点可选，它已经把这些景点按照顺路游览的顺序排成一排了，每个地方有相应的景观，这里用一个整数表示。

蜗牛希望选取连续的一段景点，还要选出来的每一个景点的景观都不同，问它最多能选出多少个景点进行旅游。

输入格式

第一行，一个正整数 n(1≤n≤10的5次方)。

第二行，包含 n 个正整数 ai​(1≤ai​≤10的6次方) ，第 i 个整数表示第 i 个景点的景观。

输出格式

输出一行，包含一个整数，表示蜗牛最多能选出的景点数。

数据范围

对于 60% 的数据，1≤n≤10的3次方

对于 100% 的数据，1≤n≤10的5次方,1≤ai​≤10的6次方

以下是实现代码

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
#include<iostream>
#include<stdlib.h>
using namespace std;
typedef struct Node
{
int data;
Node* next;
}node,*link;
link crealist(int n)
{
link p,H,r;
H=(link)malloc(sizeof(node));
H->next =NULL;
r=H;
int *num=new int[n];
for(int i=0;i<n;++i)
{
cin>>num[i];
p=(link)malloc(sizeof(node));
p->data=num[i];
r->next =p;
r=p;
}
r->next =NULL;
delete []num;
return H;
}
link getit(link s,link e)//查找从s到e两个指针之间有没有和e指向的数据相同的数据 
{
while(s!=e)
{
if(s->data ==e->data ) return s;
else s=s->next ;
}
return NULL;
} 
int hm(link s,link it)//s指针和it指针之间有几个节点 
{
int l=0;
while(s!=it)
{
l++;
s=s->next;
}
return l;
}
int main()
{
int n,m[1001]={1},i=0;
cin>>n;
link H=crealist(n);
link s=H->next ;
link e=H->next ;
while(true)
{
if(e->next ==NULL) break;//e遍历到最后时及时退出循环 
e=e->next;
link it;
it=getit(s,e);
if(it!=NULL) //如果说有重复的景点…… 
{
i++;//连续不重复的选择个数+1 
m[i]=m[i-1]-hm(s,it);//开始数下一个可能的选择有多少景点 
s=it->next;//重置起点 
}
else m[i]++;
}
int f=0;
for(int j=0;j<=i;++j)
if(m[j]>=f) f=m[j];
cout<<f;
return 0;
}

啊，这篇博客到此就结束了，只是记录一下自己的学习。

收藏Shaw的博客谢谢喵~

]]> 编程题 链表 https://blog.shawgarcia.cn/posts/30047.html#disqus_thread Markdown语法总览 https://blog.shawgarcia.cn/posts/60386.html https://blog.shawgarcia.cn/posts/60386.html Thu, 17 Aug 2023 16:00:00 GMT Markdown 常用语法速查与示例。 其实本来就有语法总览的网站：Markdown语法总览

虽然已经有官网了，但我想着反正自己要试用，干脆写成一个博客罢（

基本语法

  • 标题(Heading)：在标题之前加“#”，#越多标题越小。(一共六级)

  • 粗体(Bold)：在要加粗的字两边分别加两个星号，比如这个，两个星号–>**。

  • 斜体(Italic)：在斜体的字两边分别加一个星号，比如这个。

  • 引用块(Blockquote)：在要引用的部分之前加“>”，如下：

    明日的夜空哨戒班

  • 有序列表(Ordered List)：阿拉伯数字+小数点就行了，如下：

    1. 塞尔达传说：时之笛
    2. 塞尔达传说：王国之泪
    3. 塞尔达传说：旷野之息

  • 无序列表(Unordered List)：前面每一个语法前的点其实是“-”，用的就是无序列表

  • 代码(Code)：用键盘左上角的反引号括起来``，比如cout<<"一键三连"<<endl;

  • 分隔线(Horizontal Rule)：在单独一行使用“—”、“***”、“___”，如下

  • 链接(Link)：[title]，在这之后加(具体链接)，如下
  • 图片(Image)：不知道能不能显示出来，总之先试试：使用!,后跟[alt text]，再之后是(“图片路径”)，如下：
    • 梅祖拉假面

拓展语法

序号名称职业
1塞尔达公主
2林克勇者
  • 代码块(Fenced Code Block)：在代码块之前和之后的行上使用三个反引号（(```）或三个波浪号（~~~），可以在第一次反引号之后加语言的名字实现语法高亮，如下
    1
    2
    3
    4
    int main()
    {
    cout<<"emm";
    }
  • 脚注(Footnote)：用[]里加^和阿拉伯数字来实现，[^2]这样的，这里需要一个注释。^1，啊，好像点进去后能在网址栏看到注释，我还不是很清楚这个怎么用。
  • 标题编号(Heading ID)：要添加自定义标题ID，请在与标题相同的行上用大括号括起该自定义ID。(具体参考)
  • 定义列表(Definition list)：用于定义一些术语，第一行写术语的名字，第二行先输冒号，然后解释。
Shaw
写这个博客的人
  • 删除线，前后分别用两个~括起来就好了，像这样
  • 任务列表(Task List)用[ ]在列表前进行标记：
    • 吃饭
    • 睡觉
    • 打豆豆
]]> 笔记 Markdown https://blog.shawgarcia.cn/posts/60386.html#disqus_thread 我的第一个博客 https://blog.shawgarcia.cn/posts/57728.html https://blog.shawgarcia.cn/posts/57728.html Tue, 15 Aug 2023 16:00:00 GMT 博客开通公告。 早中晚上好Hello（？）
我的博客网站正式开通啦！（好像暂时算是搞定了）

网站用途

大概用来写一些自己的学习心得、笔记之类的地方吧。

]]> 随笔 https://blog.shawgarcia.cn/posts/57728.html#disqus_thread