Hexo

C语言核心语法(1)：第一个C程序

2025-12-09T07:39:44.000Z

大家好！这里是杰杰酱，以下内容有需要补充的，或者大家有什么意见或者建议，欢迎在评论区留言！如果看到我会更新的，欢迎大家批评指正！

“The only way to learn a new programming language is by writing programs in it.”

— Brian W. Kernighan, 《The C Programming Language》

经典示例：Hello, World! 程序

#include 

int main() {
    printf("Hello, World!\n");
    return 0;
}

学习C语言的旅程，几乎都是从这个经典的“Hello, World!”程序起步的 —— 相信多数老师都会让大家先写下这段代码。

今天我们就借着它，拆解C语言的核心基础，迈出入门第一步。

📌 为什么要这样写？

1. `int main()`：程序的入口

电脑运行程序时，必须明确“从哪里开始执行”——这是程序的核心起点。 C语言有个硬性规定：所有可执行程序都必须有且仅有一个main()函数，这就是程序的入口。

这部分实际上有多种写法：
int main(void): 无参数，返回int类型（标准写法）
int main(int argc, char *argv[]): 带参数，返回int类型（应该是在工程中的常用写法）
signed main(): 与int main()相同，返回int类型. 一般在算法竞赛中，在使用了#define int long long后，才会使用。（具体原因，后面会作解释）
void main(): 无返回值（最常见的非标准写法） (不建议使用)
main(): 省略返回值类型（旧标准兼容写法） (不建议使用)

2. `{ ... }`：代码块

main()后面的一对大括号{ }，划定了这个入口函数的代码块范围，意思是：所有在{ }里的代码，都将被视为main()函数的一部分，会被顺序执行。

我们想让电脑做的所有操作（比如输出文字，或者数学运算），都必须写在这对大括号之间。

并不只是函数后面需要放代码块，其他的一些关键字后也要放，比如if、for、while等，后面会详细介绍。

3. `printf("Hello, World!\n");`：实现输出功能的核心指令

我们的目标是在屏幕上打印“Hello, World!”这句话

而printf()正是C语言用来格式化输出的工具（print=打印，f=format，即格式化）。
括号里的"Hello, World!\n"是要输出的内容（双引号包裹的是“字符串”）。
末尾的\n是换行符，能让输出后光标自动换行。
最后必须加;，这是C语言的“语句结束符”，告诉电脑“这条指令到这就完了”。

4. `#include` ：`printf()`的声明

电脑不会凭空认识printf()函数，因为它不是C语言的“内置默认功能”，而是在C语言“标准输入输出库”（简称stdio库）里的工具。

#include是C语言的预处理指令，作用相当于复制粘贴：在编译之前，#include 会在编译的时候把stdio头文件的所有内容（包含printf()的函数声明、使用规则）链接到当前程序中，告诉电脑：printf()是合法工具，该怎么调用它。

如果少了这一行，电脑会不认识printf()，程序就会报错。

5. `return 0;`：函数的“结束信号”

回到main()函数开头的int：return 0;就是履行这个约定。

当main()函数里的所有指令都执行完后，会向操作系统返回一个“0”，表示告诉系统：“这个程序正常执行完毕，没有出错”。

实际上，从C++11开始，return 0;可以不用写，因为编译器会隐式插入 return 0;，等价于显式书写。（但是这并不代表其他函数也不用return，这只是因为 main 函数比较特殊而已）

经过上面部分的学习，相信你一定清楚了一个基本的C程序需要包含什么东西了，希望这篇文章能帮助你入门C语言。

哈尔滨CCPC前有感

2025-12-05T06:06:44.000Z

现在我是在飞往哈尔滨的飞机上(当时写的)，有感而发，然后记录下来。

我上一次坐飞机，是在我初二的时候。那个年纪的我，和高中的我，和现在的我，对事物的心态，是截然不同的。

当时的我，年岁尚浅，未识世界万千，初中的知识储备，本来也没多少，掌握这些自然是不在话下，便以为自己学富五车，面对问题胸有“成竹”，带有一种虚假的自信。为什么说是虚假的呢，因为这种自信根基于我对我所学知识的掌控能力，当时的知识面不广，知识深度也不算很深，所以对他们的掌控力很强(但也仅限于此)，自然自信。

等到高中的时候，一开始我对自己还是很有自信的，为什么呢，原因很简单，因为我对知识的广度和深度的认知还停留在初中时期，我以为我在高中依然能很好地掌控他 —— 当然现实并非如此，我的成绩并没有很好的起色，同时当时我也做出了一些不成熟的行为，并没有意识到这一点。当这一层壁垒被打破的时候，没有意识到它被打破的这个现象是极其危险的，因为你对接下来面对的挑战没有半点准备(这一点不仅体现在任何学科的学习上，也包括人际关系)。好的，当然我也没有这么弱，后面还是意识到了这个变化，意识到曾经手拿把掐的东西脱离了我的掌控，好就好在，学习方面，只是广度和深度增加了，但是知识结构没有变化(至少没有像大学这样变化这么大，还是语数英物化生的一些基础知识)，尚可用以前的办法应付(但是因为学科增加了，略有吃力)，但是在人际上，很明显以往的方法和态度是不正确的，是错误的，但是我对这样一个虚无的事物并没有一个比较清晰的描摹，以致于一直在回避面对这个未知的事物。在这里要特别感谢我高中的舍友以及在这一点上一直在指引我的朋友，没有他们，现在的我必然还是浑浑噩噩的。

就这样过了三年，我来到了大学学习计算机。还记得当时高二的时候，我当时的同桌(曾经的oi✌🏻，现在是中大✌🏻)跟我简单普及了一点点算法的知识(当时以为这就是计算机)，算是给我埋下了一颗读计算机的种子吧，然后这颗种子在高考结束后发芽了。其实当时我对计算机的认识还是错误的，狭隘的，不够深刻的，但是当时我以为新的壁垒到这就结束了(现在看来，其实真的是无止境啊)。

人生本就是一场走走停停的旅途，没有一种永恒不变的模式可以帮助我们面对一切局面，你眼中的天边，或许不过是别人严重的一个小小的井口。但是也不能妄自菲薄，如果连自己都不能够相信，大概也就只能到这里了罢。

如果能给我一次与小时候的我对话的机会，我大概会这么说吧。

C/C++IDE介绍之DevC++

2025-12-03T18:04:20.000Z

DevC++ 是一个基于MinGW的C/C++集成开发环境（IDE），它提供了一个简单而强大的界面，用于编写、编译和调试C/C++程序。

下载与安装

下载源

以上下载源中，官方网站似乎上不去了，SourceForge似乎需要魔法，而且下载速度不快。实在不行的话腾讯源也可以，记得选直接下载就好了。

版本选择：实际上官方最新版5.11早在2017就停止更新（48.1MB）
安装步骤：
这里没有中文选项，直接点击OK即可选择I Agree 不用理会，直接Next 选择默认安装路径（这里不建议默认，建议安装在其他盘：比如D盘或者E盘，实在不行也尽量安装在C:\Users\用户名\ 下，不建议安装在C:\Program File 下）点击Install 等待安装完成点击Finish（圈内的可选可不选，选了就是直接打开Dev C++而已）完成安装

首次配置

这里可以选择简体中文点击Next 这里可以不做修改，也可以选择你喜欢的字体和配色点击Next 点击OK

然后就可以开始使用啦！

基本使用

创建新项目/文件：
1. 入口1 点击工具条左侧按钮
2. 入口2 点击「文件」→「新建」→「项目…」
由于我一般使用Dev C++只用于算法竞赛，因此我只介绍单文件的创建。（一般如果是C++项目的话，建议使用Visual Studio 或 Clion）一般我们就直接使用，直接在代码区里面编码即可。编写完代码之后可以点击编译、运行，查看输出结果；也可以直接点击编译运行。
常用快捷键

F9：编译
F10：运行
F11：编译并运行
F5：调试
Ctrl+N：新建文件
Ctrl+O：打开文件
Ctrl+S：保存文件

现在开始，还来得及

2025-10-28T16:00:00.000Z

2025年12月4日 02:42:22

明天晚上就是Python考试了，8号还有一场Springboot考试，13号还有一场六级

www时间怎么过得这么快啊

要抓紧时间复习了QWQ

2025-10-29 23:12:17

今天花了一天，用hexo模板搭了个简单的博客。

只是做了一件，想做很久，很久以前就应该做的事情。

其实这个博客还有很多地方没有完善

能力有限，夜深了，明天再做吧

in queue…

Fenwick 树状数组

2025-10-28T16:00:00.000Z

Fenwick 树状数组

原理

1. 简单题

洛谷 P3374 【模板】树状数组 1

洛谷 P3368 【模板】树状数组 2

洛谷 P5057 [CQOI2006] 简单题

洛谷 P2068 统计和

洛谷 P4939 Agent2

洛谷 P2880 [USACO07JAN] Balanced Lineup G

洛谷 P6225 [eJOI 2019] 异或橙子

洛谷 P1908 逆序对

洛谷 P1774 最接近神的人

洛谷 P4378 [USACO18OPEN] Out of Sorts S

2.中等题

洛谷 P2357 守墓人

原理

luogu P3374 【模板】树状数组 1

题面描述：

已知一个数列，你需要进行下面两种操作：

将某一个数加上 x；
求出某区间每一个数的和。

代码

#include 
using namespace std;
#define int long long
#define lowbit(x) ((x)&-(x))

const int N = 1e6 + 10;

int n,m;
int tree[N];

void update(int x,int d) {
while(x <= n) {
tree[x] += d;
x += lowbit(x);
}
}

void del(int x,int d) {
while(x > 0) {
tree[x] -= d;
x -= lowbit(x);
}
}

int fin(int x) {
int re = 0;
while(x) {
re += tree[x];
x -= lowbit(x);
}
return re;
}

signed main() {
cin >> n >> m;
for(int i = 1 ; i <= n ; i ++) {
int num;
cin >> num;
update(i,num);
}
for(int i = 0 ; i < m ; i ++) {
int op;
cin >> op;
if(op == 1) {
int x,d;
cin >> x >> d;
update(x,d);
} else {
int st,en;
cin >> st >> en;
cout << fin(en) - fin(st-1)<< "\n";
}
}
return 0;
}

luogu P3368 【模板】树状数组 2

题面描述：

已知一个数列，你需要进行下面两种操作：

将某区间每一个数加上 x；
求出某一个数的值。

解题思路：

其实这道题和前面那道模板题本质上是一样的，只需要对数列初始的时候进行前缀和，然后就能利用差分操作进行快速的区间加法操作和单点查询操作了

这也是很经典的利用树状数组优化前缀和差分的操作了。

代码：

#include 
using namespace std;
#define int long long
#define lowbit(x) ((x)&-(x)) 

const int N = 1e6 + 10;

int n,m,old = 0;
int tree[N];

void update(int x,int d) {
while(x <= n) {
tree[x] += d;
x += lowbit(x);
}
}

void del(int x,int d) {
while(x > 0) {
tree[x] -= d;
x -= lowbit(x);
}
}

int fin(int x) {
int re = 0;
while(x) {
re += tree[x];
x -= lowbit(x);
}
return re;
}

signed main() {
cin >> n >> m;
for(int i = 1 ; i <= n ; i ++) {
int num;
cin >> num;
update(i,num-old);
old = num;
}
for(int i = 0 ; i < m ; i ++) {
int op;
cin >> op;
if(op == 1) {
int x,y,d;
cin >> x >> y >> d;
update(x,d);
update(y+1,d*(-1));;
} else {
int x;
cin >> x;
cout << fin(x)<< "\n";
}
}
return 0;
}

luogu P5057 [CQOI2006] 简单题

题面描述：

有一个 n 个元素的数组，每个元素初始均为 0。有 m 条指令，每条指令为两种操作中的一种：

让其中一段连续序列数字反转；（即 0 变 1，1 变 0）
询问某个元素的值。

解题思路：

实际上仍然是前缀和的思路，我们可以注意到，翻转奇数次就是 1 ，翻转偶数次就是 0 ，所以我们只要用前缀和维护某个数反转了几次即可。

#include 
#define int long long
#define lowbit(x) (x&-x)

template <typename T>
struct Fenwick {
    int n;
    std::vector a;

    Fenwick(int n_ = 0) {
        init(n_);
    }

    void init(int n_) {
        n = n_;
        a.assign(n, T{});
    }

    void add(int x, const T &v) {
        for (int i = x; i <= n; i += i & -i) {
            a[i - 1] = a[i - 1] + v;
        }
    }

    T sum(int x) {
        T ans{};
        for (int i = x; i > 0; i -= i & -i) {
            ans = ans + a[i - 1];
        }
        return ans;
    }

    T rangeSum(int l, int r) {
        return sum(r) - sum(l);
    }

    int select(const T &k) {
        int x = 0;
        T cur{}; 
        for (int i = 1 << std::__lg(n); i; i /= 2) {
            if (x + i <= n && cur + a[x + i - 1] <= k) {
                x += i;
                cur = cur + a[x - 1];
            }
        }
        return x;
    }
};

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    int n,m;
    std::cin >> n >> m;
    Fenwick<int> f(n+2);
    while(m--) {
        int op;
        std::cin >> op;
        if(op == 1) {
            int l,r;
            std::cin >> l >> r;
            f.add(l,1);
            f.add(r+1,-1);
        } else {
            int i;
            std::cin >> i;
            std::cout << ((f.sum(i) & 1) == 0 ? 0 : 1) << "\n";
        }
    }
    return 0;
}

luogu P2068 统计和

题面描述：

给定一个长度为 n(0 ≤ n ≤ 10⁵)，初始值都为 0 的序列，x(0 ≤ x ≤ 10⁵) 次的修改某些位置上的数字，每次加上一个数，并在此期间提出 y(0 ≤ y ≤ 10⁵) 个问题，求每段区间的和。

解题思路：

这题实际上就是经典的 单点修改 + 区间查询 ，区间查询可以从前缀和演变过来，两个一前一后的前缀和相减之后，得到的就是区间和了

代码：

#include 
using namespace std;
#define int long long 
#define lowbit(x) ((x)&-(x))

const int N = 1e6 + 10;

int n,w;
int tree[N];

void update(int x,int d) {
while(x <= n) {
tree[x] += d;
x += lowbit(x);
}
}

int fin(int x) {
int re = 0;
while(x) {
re += tree[x];
x -= lowbit(x);
}
return re;
}

signed main() {
cin >> n >> w;
while(w--) {
char op;
cin >> op;
if(op == 'x') {
int x,d;
cin >> x >> d;
update(x,d);
} else {
int x,y;
cin >> x >> y;
cout << fin(y) - fin(x-1) << "\n";
}
}
return 0;
}

luogu P4939 Agent2

题面描述：

在一个时间长度为 N 天的行动中，指挥对你下达了 M 条命令操作，命令操作如下：

输入 0, a, b，这代表在第 a 天到第 b 天，有一名队员要行动。
输入 1 a，这代表指挥询问你根据目前的信息，在第 a 天有多少名队员要行动。

解题思路：

实际上就是对差分数组进行 单点修改 和 用前缀和操作进行查询 的经典操作

#include 
#define int long long
#define all(x) x.begin(),x.end()
#define all1(x) x.begin()+1,x.end()
#define lowbit(x) (x&-x)


template <typename T>
struct Fenwick {
    int n;
    std::vector a;

    Fenwick(int n_ = 0) {
        init(n_);
    }

    void init(int n_) {
        n = n_;
        a.assign(n, T{});
    }

    void add(int x, const T &v) {
        for (int i = x; i <= n; i += i & -i) {
            a[i - 1] = a[i - 1] + v;
        }
    }

    T sum(int x) {
        T ans{};
        for (int i = x; i > 0; i -= i & -i) {
            ans = ans + a[i - 1];
        }
        return ans;
    }

    T rangeSum(int l, int r) {
        return sum(r) - sum(l);
    }

    int select(const T &k) {
        int x = 0;
        T cur{}; 
        for (int i = 1 << std::__lg(n); i; i /= 2) {
            if (x + i <= n && cur + a[x + i - 1] <= k) {
                x += i;
                cur = cur + a[x - 1];
            }
        }
        return x;
    }
};

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    
    int n,m;
    std::cin >> n >> m;
    Fenwick<int> f(n+2);

    while(m--) {
        int op;
        std::cin >> op;
        if(op == 0) {
            int a,b;
            std::cin >> a >> b;
            f.add(a,1);
            f.add(b+1,-1);
        } else {
            int a;
            std::cin >> a;
            std::cout << f.sum(a) << "\n";
        }
    }
    
    return 0;
}

luogu P2880 [USACO07JAN] Balanced Lineup G

题面描述：

给你一个长度为 n 的序列，询问 q 次，每次询问给你 a、b ，要求你给出序列区间 a、b 中的极差

解题思路：

实际上我们需要使用树状数组来维护区间最大值和区间最小值。

更新操作原理：

首先将当前位置x的值设为d
然后更新当前节点的兄弟节点信息（在同一个父节点下的其他节点）
最后通过不断加上lowbit(x)更新所有包含该节点的父节点

查询操作原理：

从右往左遍历区间 [y, x]
对于无法被树状数组覆盖的部分，直接比较原始数组的值
对于能够被树状数组覆盖的区间，利用树状数组查询该区间的最大值

PS: 感觉区间最值维护的题目，不修改的不如上 ST表，带修改的不如上线段树，树状数组有点神秘了

#include 
#include 
#define lowbit(x) ((x)&-(x))
#define int long long

const int N = 1e6;
int n,q;
int treeX[N],treeN[N],num[N];

void UpdateMax(int x , int d) {
treeX[x] = d;
for(int i = 1 ; i < lowbit(x) ; i <<= 1) {
treeX[x] = std::max(treeX[x] , treeX[x-i]);
}
while(x <= n) {
treeX[x] = std::max(treeX[x] , d);
x += lowbit(x);
}
}

void UpdateMin(int x , int d)
{
treeN[x] = d;
for(int i = 1 ; i < lowbit(x) ; i <<= 1)
{
treeN[x] = std::min(treeN[x] , treeN[x-i]);
}
while(x <= n)
{
treeN[x] = std::min(treeN[x] , d);
x += lowbit(x);
}
}

int FindMax(int x,int y)
{
int re = 0;
while(x >= y)
{
re = std::max(re , num[x]);
x--;
while(x - y > lowbit(x))
{
re = std::max(re , treeX[x]);
x -= lowbit(x);
}
}
return re;
}

int FindMin(int x,int y)
{
if(x == y) return 0;
int re = 1e16;
while(x >= y)
{
re = std::min(re , num[x]);
x--;
while(x - y > lowbit(x))
{
re = std::min(re , treeN[x]);
x -= lowbit(x);
}
}
return re;
}

signed main()
{
std::cin >> n >> q;
for(int i = 1 ; i <= n;i ++)
{
std::cin >> num[i];
UpdateMax(i , num[i]);
UpdateMin(i , num[i]);
}

for(int i = 0 ; i < q ; i ++)
{
int a,b;
std::cin >> a >> b;
if(a!=b)
std::cout << FindMax(b,a) - FindMin(b,a) << "\n";
else
std::cout << 0 << "\n";
}
return 0;
}

luogu P6225 [eJOI 2019] 异或橙子

题面描述：

给你一个长度为 n 的序列，你会进行 q 次操作：

操作1：将序列第 i 个数修改为 x

操作2：求序列的区间 l、r 中所有区间的异或和的异或和，例如 l = 2, r = 4 的情况，记橙子序列 A 中第 i 个橙子的整数是 a_i，那么他要求的就是： a₂ ⊕ a₃ ⊕ a₄ ⊕ (a₂ ⊕ a₃) ⊕ (a₃ ⊕ a₄) ⊕ (a₂ ⊕ a₃ ⊕ a₄)

解题思路：

首先我们知道异或的性质，一个数 a 自己与自己异或奇数次，结果是自己本身；自己与自己异或偶数次，结果为 0.

修改操作很好维护，我们要处理的关键点应该是区间内所有区间的异或和的异或和

那么我们就应该要计算出这个区间内的某一个数和自己异或了多少次

这句话我们可以翻译为：这个区间内有多少个连续的区间包括了他本身

假设要求区间为 l、r ，这个数下标为 i ，那么这个数就异或了 (i − l + 1) * (r − i + 1) 次

事实上，我们不需要处理这个数异或和为 0 的情况，也就是，我们只需要处理 (i − l + 1) * (r − i + 1) 为奇数时的情况。

两个数相乘为奇数的时候，只有奇数乘奇数一种情况，所以只有在 i 和 l 奇偶性相同且 i 和 r 奇偶性相同的时候，才需要计算

也就是说：

如果 l 和 r 奇偶性不同，所有数都异或了偶数次，我们可以直接输出 0 ；
如果 l 和 r 奇偶性相同，我们只需要计算下标在 l 和 r 之间且下标奇偶性与他们相同的元素的异或和即可。

从中我们可以看出，我们可以分奇偶性去讨论这个结果，因此分奇偶性两个树状数组去维护区间异或和会比较方便。

代码：

#include 
#define int long long
#define lowbit(x) (x&-x)

using vi = std::vector<int>;

template <typename T>
struct Fenwick {
    int n;
    std::vector a;

    Fenwick(int n_ = 0) {
        init(n_);
    }

    void init(int n_) {
        n = n_;
        a.assign(n, T{});
    }

    void add(int x, const T &v) {
        for (int i = x; i <= n; i += i & -i) {
            a[i] ^= v;
        }
    }

    T sum(int x) {
        T ans{};
        for (int i = x; i > 0; i -= i & -i) {
            ans ^= a[i];
        }
        return ans;
    }
};

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    int n,m;
    std::cin >> n >> m;
    Fenwick<int> f_odd(n+10),f_even(n+10);
    vi a(n+10);

    for(int i = 1; i <= n; i ++) {
        int x;
        std::cin >> x;
        if(i & 1) {
            f_odd.add(i,x);
        } else {
            f_even.add(i,x);
        }
        a[i] = x;
    }

    while(m--) {
        int op;
        std::cin >> op;
        if(op == 1) {
            int i,j;
            std::cin >> i >> j;
            if(i & 1) {
                f_odd.add(i,j ^ a[i]);
            } else {
                f_even.add(i,j ^ a[i]);
            }
            a[i] = j;
        } else {
            int l,r;
            std::cin >> l >> r;
            if((r - l) & 1) {
                std::cout << 0 << "\n";
                continue;
            }
            if(l & 1) {
                std::cout << (f_odd.sum(r) ^ f_odd.sum(l-1)) << '\n';
            } else {
                std::cout << (f_even.sum(r) ^ f_even.sum(l-1)) << '\n';
            }
        }
    }
    return 0;
}

luogu P1908 逆序对

题面描述：

给你一个长度为 n 的序列 a ，要求你给出 i < j 且 a_i > a_j 的无序数对 {i, j} 的个数（序列中的数 a_i 不超过 10⁹ ，1 ≤ n ≤ 5 × 10⁵）

解题思路

首先，10⁹ 太大了，我们无法开这么大的数组，但是 n 的个数不是很大，我们存的下 n 个数，并且我们又只需要这 n 个数之间的大小关系，所以我们可以先对这 n 个数进行离散化。

然后我们就要计算逆序对了。

如何利用树状数组计算逆序对呢？

我们可以对利用树状数组对这个序列反过来计数，每次 add 一个数之后，我们统计比这个数小的数的个数，即可知道这个数作为 a_i 的逆序对的个数了

PS： 虽然归并排序同样可以计算逆序对个数，但是我个人认为还是树状数组比较好写

代码：

#include 
#include 
#define lowbit(x) ((x)&-(x))
#define int long long

const int N = 1e6 + 10;

int n,num,tree[N],rank[N];
struct point{
int num,val;
}a[N];

bool cmp(point a,point b) {
if(a.val == b.val) return a.num < b.num;
return a.val < b.val;
}

void update(int x,int d) {
while(x <= n) {
tree[x] += d;
x += lowbit(x);
}
}

int sum(int x) {
int re = 0;
while(x) {
re += tree[x];
x -= lowbit(x);
}
return re;
}

signed main() {
std::cin >> n;
for(int i = 1 ; i <= n ; i ++) {
std::cin >> a[i].val;
a[i].num = i;
}

std::sort(a+1,a+n+1,cmp);
for(int i = 1 ; i <= n ; i ++) rank[a[i].num] = i;
int ans = 0;

for(int i = 1 ; i <= n ; i ++) {
update(rank[i],1);
ans += i - sum(rank[i]);
}

std::cout << ans;
}

luogu P1774 最接近神的人

题面描述：

给你一个长度为 n 的序列，你可以选择任意两个位置不同数字进行交换，问你至少需要交换多少次才能使整个序列变成非下降序列。

1 ≤ n ≤ 5 × 10⁵， A_i ∈ [ − 2³¹, 2³¹)

解题思路：

经验丰富的同学一眼就能看得出来这道题本质上要求的就是逆序对数，因为每两个逆序对数他们的大小位置都需要逆转，所以可以看成他们都需要交换一次

#include 
#include 
#define lowbit(x) ((x)&-(x))
#define int long long

const int N = 1e6 + 10;

int n,num,tree[N],rank[N];
struct point{
int num,val;
}a[N];

bool cmp(point a,point b) {
if(a.val == b.val) return a.num < b.num;
return a.val < b.val;
}

void update(int x,int d) {
while(x <= n) {
tree[x] += d;
x += lowbit(x);
}
}

int sum(int x) {
int re = 0;
while(x) {
re += tree[x];
x -= lowbit(x);
}
return re;
}

signed main() {
std::cin >> n;
for(int i = 1 ; i <= n ; i ++) {
std::cin >> a[i].val;
a[i].num = i;
}

std::sort(a+1,a+n+1,cmp);
for(int i = 1 ; i <= n ; i ++) rank[a[i].num] = i;
int ans = 0;

for(int i = 1 ; i <= n ; i ++) {
update(rank[i],1);
ans += i - sum(rank[i]);
}

std::cout << ans;
}

luogu P4378 [USACO18OPEN] Out of Sorts S

题面描述：

给你一个长度为 n 的序列，以下是一段冒泡排序的伪代码：

sorted = false
while (not sorted):
   sorted = true
   moo
   for i = 0 to N-2:
      if A[i+1] < A[i]:
         swap A[i], A[i+1]
         sorted = false

其中 moo 代表输出一行moo

问：对于这个序列，执行完以上的冒泡排序后，一共输出了多少行moo

解题思路 by hs_black：

首先我们要看懂题面中的伪代码讲的是什么意思：其实就是每次输出一行的moo，然后跑一次冒泡排序，直到整个序列已经完全有序

所以，我们要输出的行数，就是他跑的冒泡排序的次数 + 1 。

那么他到底要跑多少趟冒泡排序呢？

对于一个序列, 我们称之为有序的, 当且仅当对于任意一个位置前面没有比它大的数(可以模拟一下)

对于冒泡排序有一个小性质: 每一次都会把序列未排好序的最大数“沉底”, 即推到序列尾部

比如:6 1 2 3 4 5 进行一次为 1 2 3 4 5 6

那么对于位置i, 冒泡排序进行到 i − 1 时, a_i − 1 为前 i − 1 个数中最大的一个, 如果它大于 a_i 那么它就会到 a_i 的后面

由此可推知, 每一次位置i前都会将一个比 a_i 大的数推至其后, 直至没有比它大的

那么我们对每位置求一下它前面有几个比它大就好啦(注意要将答案加一)

具体来说先进行离散化, 再树状数组求解即可

PS：也有不需要树状数组的做法，同学们可以自己探索一下

代码：

#include 
#include 
#define lowbit(x) ((x)&-(x))
#define int long long

const int N = 1e6 + 10;

int n,num,tree[N],rank[N];
struct point{
int num,val;
}a[N];

bool cmp(point a,point b) {
if(a.val == b.val) return a.num < b.num;
return a.val < b.val;
}

void update(int x,int d) {
while(x <= n) {
tree[x] += d;
x += lowbit(x);
}
}

int sum(int x) {
int re = 0;
while(x) {
re += tree[x];
x -= lowbit(x);
}
return re;
}

signed main() {
std::cin >> n;
for(int i = 1 ; i <= n ; i ++) {
std::cin >> a[i].val;
a[i].num = i;
}

std::sort(a+1,a+n+1,cmp);
for(int i = 1 ; i <= n ; i ++) rank[a[i].num] = i;
int ans = 0;

for(int i = 1 ; i <= n ; i ++) {
update(rank[i],1);
ans = std::max(ans, i - sum(rank[i]) + 1);
}

std::cout << ans;
}

luogu P2357 守墓人

题面描述：

守墓人有 n 个墓碑，你会得到所有墓碑的初始风水值，他会进行 f 次下列操作中的一种操作：

操作 1 ：将 [l, r] 区间的墓碑全部增加 k
操作 2 ：将 1 号墓碑风水值增加 k
操作 3 ：将 1 号墓碑风水值降低 k
操作 4 ：统计区间 [l, r] 之间所有墓碑的风水值之和
操作 5 ：求 1 号墓碑的风水值

1 ≤ n, f ≤ 2 × 10⁵，答案不超过 64 位整数。

解题思路

从题目的数据范围，我们可以发现，我们每次操作的时间复杂度大约只能在 O(logn) 之内，

从要求来看：区间增加操作，我们需要对对原数组进行差分操作；区间求和操作，我们需要对原数组进行前缀和操作

因此，很明显这并不是一个树状数组就可以解决的问题。

三个数组：差分数组，原数组，前缀和数组；我们可以通过差分数组与原数组之间的关系以及原数组与前缀和数组之间的关系，计算一下差分数组与前缀和数组之间的关系

具体推理如下（by 胡小兔）：

位置p的前缀和 =

$$\sum_{i=1}^{p} a[i] = \sum_{i=1}^{p}\sum_{j=1}^{i} d[j]$$

在等式最右侧的式子$\sum_{i=1}^{p}\sum_{j=1}^{i} d[j]$中，d[1] 被用了p次，d[2]被用了p − 1次……那么我们可以写出：位置p的前缀和 =

$$\sum_{i=1}^{p}\sum_{j=1}^{i} d[j] = \sum_{i=1}^{p} d[i]*(p-i+1) = (p+1)*\sum_{i=1}^{p} d[i] - \sum_{i=1}^{p} d[i]*i$$

那么我们可以维护两个数组的前缀和：一个数组是 sum1[i] = d[i]，另一个数组是 sum2[i] = d[i] * i。

代码：

#include 
#define int long long
#define lowbit(x) (x&-x)

template <typename T>
struct Fenwick {
    int n;
    std::vector a;

    Fenwick(int n_ = 0) {
        init(n_);
    }

    void init(int n_) {
        n = n_;
        a.assign(n, T{});
    }

    void add(int x, const T &v) {
        for (int i = x; i <= n; i += i & -i) {
            a[i] = a[i] + v;
        }
    }

    T sum(int x) {
        T ans{};
        for (int i = x; i > 0; i -= i & -i) {
            ans = ans + a[i];
        }
        return ans;
    }
};

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    int n,m;
    std::cin >> n >> m;

    int mem = 0;

    Fenwick<int> f1(n+2),f2(n+2);
    for(int i = 1 ; i <= n ; i ++) {
        int x;
        std::cin >> x;
        f1.add(i, x - mem);
        f2.add(i, (x - mem) * i);
        mem = x;
    }
    while(m--) {
        int op;
        std::cin >> op;
        if(op == 1) {
            int l,r,v;
            std::cin >> l >> r >> v;
            f1.add(l, v);
            f2.add(l, v * l);
            f1.add(r+1, - v);
            f2.add(r+1, - v * (r + 1));
        } else if(op == 2) {
            int v;
            std::cin >> v;
            f1.add(1, v);
            f1.add(2, -v);
            f2.add(1, v);
            f2.add(2, -v * 2);
        } else if(op == 3) {
            int v;
            std::cin >> v;
            f1.add(1, -v);
            f1.add(2, v);
            f2.add(1, -v);
            f2.add(2, v * 2);
        } else if(op == 4) {
            int l,r;
            std::cin >> l >> r;
            std::cout << (r + 1) * f1.sum(r) - f2.sum(r) - ((l) * f1.sum(l-1) - f2.sum(l-1)) << '\n';
        } else {
            std::cout << f1.sum(1) << '\n';
        }
    }
    return 0;
}

SCAU 高级程序设计语言教材习题

2024-11-10T16:00:00.000Z

SCAU 高级程序设计语言教材习题

第三章

18041 分期还款(加强版)

Description

从银行贷款金额为 d，准备每月还款额为 p，月利率为 r 。请编写程序输入这三个数值，计算并输出多少个月能够还清贷款，输出时保留 1 位小数。如果无法还清，请输出 “God” 计算公式如下：

$$m = \frac{\log{\frac{p}{p - d \times r}}}{\log{(1+r)}}$$

输入格式

三个数，分别为货款金额、每月还款和月利率，以空格分隔，均为非负数，其中 d，p，r > = 0

输出格式

需要还款的月份

输入样例

1	50 50 0.01

输出样例

1.0

题解

主要是使用 if-else筛去无法计算或者不符合实际的情况，其余的情况正常计算即可

1 + r > 0 时，无法计算，输出 God
p − d × r = 0 时，该分数无意义，无法计算，输出 God
p 与 p − d × r 符号不一致时，$\frac{p}{p - d \times r} \le 0$ 无法计算，输出 God （由于题目给出 p 是非负的，只需要判断 p 是否等于 0 和 p − d × r 是否小于 0 即可）
当 d = 0 时，无需还款，直接输出 0.0
其他情况，直接计算即可

代码

#include 
#include 

int main() {

    double d,p,r;
    scanf("%lf%lf%lf",&d,&p,&r);
    
    if(d == 0) {
    printf("0.0\n");
}
    else if(p - d*r <= 0 || p == 0) {
    printf("God\n");
}
    else{
        printf("%.1f", log10(p/(p-d*r))/log10(1+r));
    }
    
    return 0;
}

第四章

18042 计算分段函数值

Description 根据如下数学公式，编写程序输入 x ，计算并输出 y 的值，保留两位小数 $$y = \begin{cases}x &, x \lt 1 \\2x - 1 &, 1 \le x \lt 10 \\3x - 11 &, x \ge 10\end{cases}$$ 输入格式 输入一个实数 x 输出格式 输出函数值

输入样例

输出样例

0.00

题解

开个 if - else if - else 选择分支结构就好了，分类讨论一下

代码

#include 

int main() {
    double x;
    scanf("%lf",&x);
    double ans;
    
    if(x<1) {
    ans = x;
}
    else if(x >= 1 && x < 10) {
    ans = 2 * x - 1;
}
    else {
    ans = 3 * x - 11;
}

printf("%.2f",ans);
return 0;
}

18043 找出3个数中最大的数

Description

编写程序，由键盘输入 3 个整数，输出其中最大的数。

输入格式

三个整数，空格分隔

输出格式

最大的数

输入样例

3 6 4

输出样例

题解

用一个变量存储最大的那个数（即答案）

用两个 if-else ，找出最大的数

代码

#include 

int main()
{
    int a,b,c;
    scanf("%d %d %d",&a,&b,&c);
    
    int max = a;
    if(b > max) {
    max = b;
}
    if(c > max) {
    max = c;
    }
    
    printf("%d",max);
    return 0;
}

18044 成绩等级评分

Description

编写程序，由键盘输入一个百分制的整数成绩，要求输出对应的成绩等级。 90 分以上为 A ， 80 到 89 分为 B ， 70 到 79 分为 C ， 60 到 69 分为 D ，60 分以下为 E 。成绩不在 0 到 100 之间时输出 “error”

输入格式

一个整数成绩

输出格式

输出对应的等级或 error

输入样例

输出样例

题解

直接来几个 if - else if - else 选择分支结构就好了

搞什么switch 可以，但是没必要（个人看法）（我记得老师上课会讲这种写法的）

代码

#include 

int main() {
    int score;
    scanf("%d", &score);
    
    if(score>100 || score<0) {
    printf("error");
}
    else if(score>=90) {
    printf("A");
}
    else if(score>=80) {
    printf("B");
}
    else if(score>=70) {
    printf("C");
}
    else if(score>=60) {
    printf("D");
}
    else {
    printf("E");
}
        
    return 0;
}

18045 前一个和后一个字符

Description

编写程序，输入一个数字字符，输出其前一个和后一个的数字字符，如果输入的是0前一个输出“first”，9后一个则输出“last”，输入的不是数学字符，输出“error”

输入格式

一个字符

输出格式

输出结果

输入样例

输出样例

first 1

题解

依然是直接来几个 if - else 就好了

先判断是不是数字

再判断是不是 0 或者 9

代码

#include 

int main() {

    int ch = getchar();
    
    if('0'<=ch && ch<='9') {
    
    int num = ch - '0';
    
        if(num == 0) {
        printf("first");
} else {
printf("%d",num - 1);
}

printf(" ");

if(num == 9) {
        printf("last");
} else {
printf("%d",num + 1);
}
    }
else {
printf("error");
}

return 0;
}

18037 20秒后的时间

Description

编写程序，输入三个整数变量 hour（小时）、minute（分钟）、second（秒）代表一个时间，输出该时间 20 秒以后的时间。

输入格式

一行三个整数，分别代表小时、分钟、秒，中间使用冒号分隔

输出格式

输出一个时间，数字间用冒号分隔

小时、分钟、秒均占两个数字位，不足位用0补足

输入样例

15:30:41

输出样例

15:31:01

题解

先给秒数加上 20 ，后面再加几个 if - else 判断是否要进位就可以了

代码

#include 

int main()
{
    int h,m,s;
    scanf("%d:%d:%d", &h,&m,&s);
    
    s += 20;
    if(s >= 60) {
        s %= 60;
        m++;
    }
    if(m >= 60) {
        m %= 60;
        h++;
    }
    if(h >= 24) {
    h %= 24;
}

    printf("%02d:%02d:%02d\n", h, m, s);
    return 0;
}

第五章

18046 字母分类统计

Description

输入一行以换行符结束的字符，统计并输出其中英文字母、数字、空格和其它字符的个数。

输入格式

一行字符，以换行符结束

输出格式

一行4个数字分别为：英文字母、数字、空格和其它字符的个数，两数据之间以一个空格分隔

输入样例

ABC 456!

输出样例

3 3 1 1

题解

判断字符属于那种类型

使用 if - else 分类进行计数即可

代码

#include 

int main() {
    char ch;
    int nL=0, nN=0, nS=0, nO=0;
    
    while((ch = getchar()) != '\n')
    {
        if(ch >= 'a' && ch <= 'z'|| ch >= 'A' && ch <= 'Z') {
        nL++;
}
        else if (ch >= '0' && ch <= '9') {
        nN++;
}
        else if (ch == ' ') {
        nS++;
}
        else {
        nO++;
}
    }
    
    printf("%d %d %d %d\n", nL, nN, nS, nO);
    return 0;
}

18047 水仙花数

Description

输出所有的水仙花数。所谓水仙花数是一个 3 位的正整数，其各位数字的立方和等于这个数本身。

例如，153 是水仙花数，因为 1³ + 5³ + 3³ = 153。

输入格式

无

输出格式

一行一个，由小到大输出所有水仙花数

输入样例

无

输出样例

略

题解

从 100 遍历到 999

对每个数拆开位进行计算，判断是否相等

代码

#include 

int main() {

    for(int i = 100 ; i <= 999 ; i ++) {
    
    int f1 = i/100;
    int f2 = (i - f1 * 100) / 10;
    int f3 = i % 10;
    
    if(f1*f1*f1 + f2*f2*f2 + f3*f3*f3 == i) {
    printf("%d\n",i);
}
}
    
    return 0;
}

1037 计算数列和

Description

有数列：

$$\frac{2}{1} \quad \frac{3}{2} \quad \frac{5}{3} \quad \frac{8}{5} \quad \frac{13}{8} \quad \frac{21}{13}$$

编程实现，由键盘输入 n，计算输出数列前 n 项和。（结果保留四位小数，提示：要使用 double ，否则精度不够）

输出格式

请按格式输出

输入样例

输出样例

32.6603

题解

经过观察我们可以发现

下一个分数的分母等于上一个数的分子

下一个数的的分子等于上一个数的分子和分母的和

就这样往下递推计算前 n 项和即可

代码

#include

int main() {   
    double up = 2;
double down = 1;
double ans = 0;

int n;
    scanf("%d",&n);
    
    for(int i = 1 ; i <= n ; i ++) {
s += up/down;
a = a + b;
b = a - b;
    }
    
    printf("%.4f\n",ans);
}

18048 自由落体

Description

一个球从 100 米的高度自由落下，每次落地后弹起的原来高度的一半。计算并输出第 n 次落地时，共经过了多少米，第 n 次弹起的高度是多少？结果显示 3 位小数。

输入格式

从键盘输入一个数 n(n > 0)

输出格式

输出两个数，分别为共经过的米数和第 n 次弹起的高度，以一个空格分隔

输入样例

输出样例

1	100.000 50.000

题解

这题看似计数很麻烦，实际上只要分开算就好了

观察可得，第 n 次落地，他经过了 n 次落地和 n − 1 次弹起，

我们只需要计算这些期间内经过的路程即可

代码

#include 

int main() {
    double sum = 0;
    double down = 100;
    double up = 50;
    
    int n;
    scanf("%d", &n);
    for(int i = 1 ; i <= n ; i++) {
        sum += down;
        down /= 2;
    }
    for(int i = 1 ; i < n ; i++) {
        sum += up;
        up /= 2;
    }
    
    printf("%.3f %.3f", sum, up);
    return 0;
}

18049 迭代法求平方根

Description

使用迭代法求 a 的平方根。求平方根的迭代公式如下，要求计算到相邻两次求出的 x 的差的绝对值小于 10^− 5 时停止，结果显示 4 位小数

$$x_{n+1} = \frac{1}{2}(x_n + \frac{a}{x_n})$$

输入格式

输入一个非负实数 a

输出格式

计算并输出平方根

输入样例

输出样例

4.0000

题解

使用while 循环，不断逼近即可求得答案

注意 0 ÷ 0 无意义，需要特判

代码

#include 
#include 

int main()
{
    double num;
    scanf("%lf", &num);
    
    if(num == 0) {
    printf("%.4f",0);
    return 0;
}
    
    double x0 = num;
    double x1 = (x0 + num/x0) / 2;
    
    while(fabs(x0 - x1) >= 1e-5) {
    x0 = (x1 + num/x1) / 2;
    
    double temp = x0;
    x0 = x1;
    x1 = temp;
}

    printf("%.4f\n", x1);
    return 0;
}

18050 打印三角形

Description

编写程序，输入整数 n，输出 n 行的字符图案。例如 n = 5 时输出：

    *
   **
  ***
 ****
*****
 ****
  ***
   **
    *

输入格式

输入一个整数

输出格式

输出 2 × n − 1 行的三角形

输入样例

输出样例

1
2
3

 *
**
 *

题解

只需要每个循环计算出打印多少个空格，打印多少个星号即可

后面直接按这个数量和顺序输出就可以了

代码（分两个循环输出版本）

#include 

int main() {
int n;
scanf("%d",&n);

for(int i = 1 ; i < n ; i ++) {
        
int space = n - i;
int xing = i;
        
for(int j = 0 ; j < space ; j ++) {
printf(" ");
}
for(int j = 0 ; j < xing ; j ++) {
printf("*");
}
printf("\n");
}

for(int i = 1 ; i <= n ; i ++) {
printf("*");
}
printf("\n");

for(int i = n-1 ; i > 0 ; i --) {
        
int space = n - i;
int xing = i;
        
for(int j = 0 ; j < space ; j ++) {
printf(" ");
}
for(int j = 0 ; j < xing ; j ++) {
printf("*");
}
printf("\n");
}

return 0;
}

代码（一个大循环搞定版本）

#include 
#include 

int main() {
int n;
scanf("%d",&n);

for(int i = -n+1 ; i < n ; i ++) {
int l = n - abs(i);

int space = n - l;
int xing = l;
        
for(int j = 0 ; j < space ; j ++) {
printf(" ");
}
for(int j = 0 ; j < xing ; j ++) {
printf("*");
}
printf("\n");
}

return 0;
}

18051 勾股数

Description

若三个正整数 a、b、c ，其中 a ≤ b ≤ c ，满足 a² + b² = c² ，称这三个数为“勾股数”，例如：3、4、5 是勾股数。编程输出不大于 n 的所有勾股数。

输入格式

输入一个数 (n < = 100)

输出格式

输出所有勾股数，按第 1 个数字由小到大排列（若第 1 个数字相同，按第 2 个数字排）

输入样例

输出样例

题解

数据太弱，直接三层大循环就解决了

可以用 sqrt 优化到两层大循环，但是还要判断，反正数据弱到三层能过那就三层算了

代码（三层循环）

#include 

int main() {
int n;
scanf("%d",&n);

for(int i = 1 ; i <= n ; i ++) {
for(int j = i ; j <= n ; j ++) {
for(int k = j ; k <= n ; k ++) {
if(i*i + j*j == k*k) {
printf("%d %d %d\n",i,j,k);
}
}
}
}

return 0;
}

代码（两层大循环）

#include 
#include 

int main() {
int n;
scanf("%d",&n);

for(int i = 1 ; i <= n ; i ++) {
for(int j = i ; j <= n ; j ++) {
double ans = sqrt(i*i + j*j);
if((int)ans == ans && ans <= n) {
printf("%d %d %d\n",i,j,(int)ans);
}
}
}

return 0;
}

第六章

18052 插入数据

Description

已经有一个按升序排列的数组，编写程序输入一个整数 x，把 x 插入到数组中，使数组仍然保持升序。

数组如下：

2 3 5 7 11 13 17 23 29 31 34 71 79 97 103

#include 
int a[16]={2, 3, 5, 7, 11, 13, 17, 23, 29, 31, 34, 71, 79, 97, 103};
void display()
{
    int i;
    for(i=0; i<16; i++) printf("%d ", a[i]);
}
int main()
{
_______________________
    display();
    return 0;
}

输入格式

输入一个整数 x

输出格式

输出更新后的数组元素

输入样例

题解

先把这个整数放到数组末尾，然后从后往前遍历：

凡是前一个元素比这个元素大的，就交换

代码

#include 
int a[16]={2, 3, 5, 7, 11, 13, 17, 23, 29, 31, 34, 71, 79, 97, 103};
void display()
{
    int i;
    for(i=0; i<16; i++) printf("%d ", a[i]);
}
int main()
{

scanf("%d",&a[15]);
for(int i = 15 ; i > 0 ; i --) {
if(a[i] < a[i-1]) {
int temp = a[i];
a[i] = a[i-1];
a[i-1] = temp;
}
}

1
2
3

    display();
    return 0;
}

18053 大于平均分

Description

输入 10 个整数，计算它们的平均值，并统计有多少个数比平均值大。

输入格式

10 个整数

输出格式

比平均值大的数的个数

输入样例

1	0 1 2 3 4 5 6 7 8 9

输出样例

题解

用数组存储输入

先遍历一遍数组，得出平均数

再进行比较和计数

代码

#include 

int main() {
int a[10];
for(int i = 0 ; i < 10 ; i ++) {
scanf("%d",&a[i]);
}

double ave = 0;
for(int i = 0 ; i < 10 ; i ++) {
ave += a[i];
}
ave /= 10;

int ans = 0;
for(int i = 0 ; i < 10 ; i ++) {
if(a[i] > ave) {
ans ++;
}
}

printf("%d",ans);
return 0;
}

18054 输出不同的数

Description

输入 10 个整数，输出其中不同的数，即如果一个数出现了多次，只输出一次。

输入格式

输入 10 个整数

输出格式

依次输出不同的数字（一行一个，从上到下依次输出先出现的数）

输入样例

1	1 2 1 3 3 2 4 5 5 9

输出样例

题解

开一个足够大的计数数组（比如包含 1000000 个元素）

每次输入就使对应的数组元素 + 1

还有在对应数组元素为 0 时才打印该数字

代码

#include 

const int N = 1e7;
int a[N];

int main() {
int num;

for(int i = 0 ; i < 10 ; i ++) {
scanf("%d",&num);

if(a[num] == 0) {
printf("%d\n",num);
}

a[num] ++;
}
return 0;
}

18055 主对角线上的元素之和

Description

输入一个 3 行 4 列的整数矩阵，计算并输出主对角线上的元素之和

输入格式

3 行 4 列整数矩阵

输出格式

主对角线上的元素之和

输入样例

1
2
3

1 2 3 4
5 6 7 8
9 10 11 12

输出样例

题解

实际上只要把 a[0][0] 、a[1][1] 和 a[2][2] 加起来就可以了

代码

#include 

int main() {
int a[3][4];
for(int i = 0 ; i < 3 ; i ++) {
for(int j = 0 ; j < 4 ; j ++) {
scanf("%d",&a[i][j]);
}
}

int ans = 0;
for(int i = 0 ; i < 3 ; i ++) {
ans += a[i][i];
}

printf("%d",ans);
return 0;
}

1051 找矩阵中的鞍点

Description 由键盘输入一个 3 × 4（ 3 行 4 列）的数字矩阵，其中任意两个数字均不相同。要求输出该数字矩阵中的鞍点（即在矩阵行中最大，列中最小的数）。若没有鞍点，输出“NO”字样。

输入样例

1
2
3

87  90  110  98
70  97  210  65
99  45  120  30

输出样例

题解

从左上角到右下角依次遍历

看看有没有是鞍点的元素

如果有就直接输出并 return 0;

如果没有就直接输出 NO

代码

#include 

int main() {
int a[3][4];
for(int i = 0 ; i < 3 ; i ++) {
for(int j = 0 ; j < 4 ; j ++) {
scanf("%d",&a[i][j]);
}
}

for(int i = 0 ; i < 3 ; i ++) {
int max = 0;
for(int j = 0 ; j < 4 ; j ++) {
if(a[i][max] < a[i][j]) {
max = j;
}
}

int min = i;
for(int j = 0 ; j < 3 ; j ++) {
if(a[min][max] > a[j][max]) {
min = j;
}
}

if(min == i) {
printf("%d",a[min][max]);
return 0;
}
}
printf("NO");
return 0;
}

18056 字母统计

Description

输入三行字符串（每行以换行回车为结束符），每行不超过 80 个字符。统计并输出其有多少个大写字母。

输入格式

三行字符串

输出格式

大写字母个数

输入样例

1
2
3

A-1 123
ABC abc
G

输出样例

题解

首先，我们需要一个对应字符的 ASCII 码的计数数组

其次，其实不用按字符串输入，只需要当换行符对应的计数数组到达 3 ，就可以停止读入字符了

最后，我们只要检查从 A 到 Z 中间的字符出现过多少次就可以了

代码

#include 

int a[200];

int main() {
char ch;

while(ch = getchar()) {

a[ch] ++;

if(a['\n'] >= 3) {
break;
}
}

int ans = 0;
for(int i = 'A' ; i <= 'Z' ; i ++) {
ans += a[i];
}

printf("%d",ans);
return 0;
}

1145 回文串

Description

读入一行字符串（不多于 80 个字符，以回车结束），判断该字符串是否为回文串（即从左向右拼写与从右向左拼写是一样的），是则输出 Y ，不是则输出 N 。

输入格式

一行字符串

输出格式

是则输出 Y ，不是则输出 N

输入样例

abba

输出样例

题解

先确定字符串长度

然后左右两边不断比较，往中间缩进

这种也叫双指针算法

代码

#include 
#include 
int main() {
char a[100];
scanf("%s",&a);

int l = strlen(a);
int left = 0 , right = l-1;

while(left < right) {
if(a[left] != a[right]) {
printf("N");
return 0;
}

left ++;
right --;
}
printf("Y");

return 0;
}

18057 ASCII码值之和的差

Description

输入两个字符串 s1 和 s2 (每个串占一行，以换行回车符结束)，计算两个字符串的所有字符的 ASCII 码值之和的差。

输入格式

两行字符，每行字符不超过 80 个字符

输出格式

ASCII 码值之和的差

输入样例

1
2

234
123

输出样例

题解

其实这题我真的很想喷他

因为他的题目真的没有交代清楚

注意！ 这里的差值不是差的绝对值

就是第一个减去第二个！

那就其实直接遍历求和再相减就可以了

（但是下面的gets不能换成scanf，我也不知道为什么）

代码

#include 
#include 

int main() {
char a[100],b[100];
gets(a);
gets(b);

int l1 = strlen(a);
int l2 = strlen(b);

int ans1 = 0;
int ans2 = 0;

for(int i = 0 ; i < l1 ; i ++) {
ans1 += a[i];
}
for(int i = 0 ; i < l2 ; i ++) {
ans2 += b[i];
}

printf("%d",ans1 - ans2);

return 0;
}

第七章

18065 所有数字之和

Description

编写一个函数，计算一个整数的所有数字之和

#include "stdio.h"

int sum(int n)
{
    _______________________
}

main()
{
    int n;
    scanf("%d", &n);
    printf("%d", sum(n));
}

输入格式

由键盘输入一个整数

输出格式

输出该数各位数字之和

输入样例

输出样例

题解

每次操作把最后那一位数提取出来（对10取模）

然后把那一位数删去（除以10）

直到当前数字为0

代码

#include "stdio.h"

int sum(int n)
{

int ans = 0;
   while(n) {
   ans += n % 10;
   n /= 10;
}
return ans;

}

main()
{
    int n;
    scanf("%d", &n);
    printf("%d", sum(n));
}

18066 元音字母

Description

编写一个函数，挑选一个字符串中的所有元音字母构成并返回一个新的字符串

#include "stdio.h"

void yuan(char *s,char *s2)
{
_______________________
}

main()
{
    char str[81], str2[81];
    gets(str);
    yuan(str,str2);
    printf("%s", str2);
}

输入格式

由键盘输入一行字符，以’’结束

输出格式

输出新构成的字符串

输入样例

I am good

输出样例

Iaoo

题解

直接把 aeiouAEIOU 单独拉出来

当出现以上数字的字符就把他单独放进一个新的字符串里面

记得最后放上空字符\0

代码

#include "stdio.h"

void yuan(char *s,char *s2)
{

int l = 0;
int idx = 0;
while(s[l] != '\0') {
if(s[l] == 'a' || 
s[l] == 'e' || 
s[l] == 'i' || 
s[l] == 'o' || 
s[l] == 'u' || 
s[l] == 'A' || 
s[l] == 'E' || 
s[l] == 'I' || 
s[l] == 'O' || 
s[l] == 'U') {
s2[idx] = s[l];
idx ++;
}

l ++;
}
s2[idx] = '\0';

}

main()
{
    char str[81], str2[81];
    gets(str);
    yuan(str,str2);
    printf("%s", str2);
}

18067 字符统计

Description

编写一个函数，统计一个字符串中字母、数字和空格的个数。使用全局变量存放字母和数字个数，函数返回值是空格个数

#include 
#include 
#include 

int nL=0, nN=0;

int statistics(char *s)
{
    _______________________
}

int main()
{
    char s[81];
    int nS;
    gets(s);
    nS = statistics(s);

    printf("%d %d %d\n", nL, nN, nS);
    return 0;
}

输入格式

输入一行字符，以’’符结束

输出格式

统计结果

输入样例

Ab 45

输出样例

2 2 1

题解

还是一样，遍历一下计数就好了

代码

#include 
#include 
#include 

int nL=0, nN=0;

int statistics(char *s)
{

int l = strlen(s);
   int res = 0;
   
   for(int i = 0 ; i < n ; i ++) {
   if(s[i] >= '0' && s[i] <= '9') {
   nN ++;
}
else if(s[i] >= 'a' && s[i] <= 'z') {
nL ++;
}
else if(s[i] >= 'A' && s[i] <= 'Z') {
nL ++;
}
else if(s[i] == ' ') {
res ++;
}
}

return res;int l = strlen(s);
   int res = 0;
   
   for(int i = 0 ; i < l ; i ++) {
   if(s[i] >= '0' && s[i] <= '9') {
   nN ++;
}
else if(s[i] >= 'a' && s[i] <= 'z') {
nL ++;
}
else if(s[i] >= 'A' && s[i] <= 'Z') {
nL ++;
}
else if(s[i] == ' ') {
res ++;
}
}

return res;

}

int main()
{
    char s[81];
    int nS;
    gets(s);
    nS = statistics(s);

    printf("%d %d %d\n", nL, nN, nS);
    return 0;
}

18068 选择排序

Description

输入10个整数，编写一个实现对数组进行选择排序的函数

#include 

int sort(int a[], int n)
{
    int i,j,k,tmp;
    for(i=0;i-1; i++)
    {
        k=i;
        for(_______________________)
            if(_______________________) k=j;
        tmp=a[k];a[k]=a[i];a[i]=tmp;
    }
}

int main()
{
    int a[10];
    int i;
    for(i=0; i<10; i++) scanf("%d", &a[i]);
    sort(a,10);
    for(i=0; i<10; i++) printf("%d\n", a[i]);
    return 0;
}

输入格式

10 个整数，以空格分隔

输出格式

排序后的 10 个整数，一行一个数字

输入样例

1	3 2 1 6 5 4 9 8 7 0

输出样例

题解

选择排序的思路就是:

在未被排序的数字里找到最大/最小的数字

然后放在这一堆数字的最前面/最后面

以此往复，直到只剩下一个数字（就已经自动排好序了）

代码

#include 

int sort(int a[], int n)
{
    int i,j,k,tmp;
    for(i=0;i-1; i++)
    {
        k=i;
        for(j = i ; j < n ; j ++/*方框1*/)
            if(a[k] > a[j]/*方框2*/) k=j;
        tmp=a[k];a[k]=a[i];a[i]=tmp;
    }
}

int main()
{
    int a[10];
    int i;
    for(i=0; i<10; i++) scanf("%d", &a[i]);
    sort(a,10);
    for(i=0; i<10; i++) printf("%d\n", a[i]);
    return 0;
}

18069 x的n次方

Description

输入正整数x和n，编写递归函数求x的n次方。

#include 

int F(int x, int n)
{
    if(_____________) 
    return _____________;
    else 
    return _____________;
}

int main()
{
    int x, n;
    scanf("%d%d", &x, &n);
    printf("%d", F(x, n));
    return 0;
}

输入格式

两个正整数，x 和 n

输出格式

x 的 n 次方，假定结果不会超过 10 的次方。

输入样例

5 2

输出样例

题解

一开始还以为是快速幂，后来发现一个 if-else 构造不出来

其实只要指数一直递减去递归，然后在指数为1的时候返回原数字，在回溯的时候把上一个数字乘上来就好了

代码

#include 

int F(int x, int n)
{
    if(n == 1/*方框1*/) 
    return x/*方框2*/;
    else 
    return F(x,n-1) * x /*方框3*/;
}

int main()
{
    int x, n;
    scanf("%d%d", &x, &n);
    printf("%d", F(x, n));
    return 0;
}

18070 矩阵行交换或列交换

Description

输入一个 4 × 4 矩阵，编写两个函数分别实现对二维数组元素的行与行进行交换，以及列与列进行交换

#include 

void swap(int *a, int *b)
{
    int temp;
    temp=*a;*a=*b;*b=temp;
}

void col(int a[][4], int i, int j)
{
    _______________________
}

void row(int a[][4], int i, int j)
{
    _______________________
}

int main()
{
    int a[4][4];
    int i,j;
    for(i=0; i<4; i++)
        for(j=0; j<4; j++)
            scanf("%d", &a[i][j]);
    col(a,0,2);
    row(a,0,2);
    col(a,1,3);
    row(a,1,3);
    col(a,0,3);
    row(a,0,3);
    for(i=0; i<4; i++)
    {
        for(j=0; j<4; j++)
            printf("%d ", a[i][j]);
        printf("\n");
    }
    return 0;
}

输入格式

输入一个 4 × 4矩阵

输出格式

输出经过变换的矩阵

输入样例

1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16

输出样例

6 8 5 7
14 16 13 15
2 4 1 3
10 12 9 11

题解

暴力去写就好了，把每一行/每一列的每个值都交换

代码

#include 

void swap(int *a, int *b)
{
    int temp;
    temp=*a;*a=*b;*b=temp;
}

void col(int a[][4], int i, int j)
{

   for(int k = 0 ; k < 4 ; k ++) {
   int temp = a[i][k];
   a[i][k] = a[j][k];
   a[j][k] = temp;
}

}

void row(int a[][4], int i, int j)
{

   for(int k = 0 ; k < 4 ; k ++) {
   int temp = a[k][i];
   a[k][i] = a[k][j];
   a[k][j] = temp;
}

}

int main()
{
    int a[4][4];
    int i,j;
    for(i=0; i<4; i++)
        for(j=0; j<4; j++)
            scanf("%d", &a[i][j]);
    col(a,0,2);
    row(a,0,2);
    col(a,1,3);
    row(a,1,3);
    col(a,0,3);
    row(a,0,3);
    for(i=0; i<4; i++)
    {
        for(j=0; j<4; j++)
            printf("%d ", a[i][j]);
        printf("\n");
    }
    return 0;
}

18071 学生信息统计

Description

输入 10 个学生 5 门课的考试成绩，分别用函数实现以下功能：

计算一个学生的平均分。
计算每门课程的平均分。
找出每门课程的最高分。

显示结果，显示两位小数。

#include 

void average(double a[][5], int n)
{
_______________________
}

void average2(double a[][5], int n)
{
_______________________
}

void top(double a[][5], int n)
{
_______________________
}

int main()
{
    double a[10][5];
    int i, j;
    for(i=0; i<10; i++)
        for(j=0; j<5; j++)
            scanf("%lf", &a[i][j]);
    average(a,10);
    average2(a,10);
    top(a,10);
    return 0;
}

输入格式

输入 10 个学生 5 门课成绩

输出格式

输出每个学生的平均分，以空格分隔

输出每门课的平均分，以空格分隔

输出每门课的最高分，以空格分隔

输入样例

79 61 57 70 77
67 73 83 72 70
82 59 85 84 80
80 53 67 72 79
80 59 72 92 84
88 72 79 79 80
76 99 82 73 97
67 96 81 69 63
58 80 98 93 84
66 61 64 57 64

输出样例

1
2
3

68.80 73.00 78.00 70.20 77.40 79.60 85.40 75.20 82.60 62.40 
74.30 71.30 76.80 76.10 77.80 
88.00 99.00 98.00 93.00 97.00

题解

只要在对应的行或者列遍历一遍，计算结果后，直接输出即可（不要忘记换行）

代码

#include 

void average(double a[][5], int n)
{

for(int i = 0 ; i < 10 ; i ++) {
double ans = 0;
for(int j = 0 ; j < 5 ; j ++) {
ans += a[i][j];
}
ans /= 5;
printf("%.2f ",ans);
}
printf("\n");

}

void average2(double a[][5], int n)
{

for(int i = 0 ; i < 5 ; i ++) {
double ans = 0;
for(int j = 0 ; j < 10 ; j ++) {
ans += a[j][i];
}
ans /= 10;
printf("%.2f ",ans);
}
printf("\n");

}

void top(double a[][5], int n)
{

for(int i = 0 ; i < 5 ; i ++) {
double max = 0;
for(int j = 0 ; j < 10 ; j ++) {
if(max < a[j][i]) {
max = a[j][i];
}
}
printf("%.2f ",max);
}
printf("\n");

}

int main()
{
    double a[10][5];
    int i, j;
    for(i=0; i<10; i++)
        for(j=0; j<5; j++)
            scanf("%lf", &a[i][j]);
    average(a,10);
    average2(a,10);
    top(a,10);
    return 0;
}

第八章

18058 一年的第几天

Description

定义一个结构体类型表示日期类型（包括年、月、日）。程序中定义一个日期类型的变量，输入该日期的年、月、日，计算并输出该日期是一年的第几天。

#include 

struct DATE
{
_______________________
};

int days(struct DATE date)
{
_______________________
}

int main()
{
    struct DATE d;
    scanf("%d-%d-%d", &d.year, &d.month, &d.day);
    printf("%d", days(d));
}

输入格式

年月日，格式如样例

输出格式

该年的第几天

输入样例

2015-1-1

输出样例

题解

因为以你那最多也就 366 天，我们可以从第一天开始遍历计数，直到现在这天就停止遍历计数就可以了

比较麻烦的是计算闰年的地方，大家可以看一下我的处理方式

代码

#include 

struct DATE
{

1	int year,month,day;

};

int days(struct DATE date)
{

int ans = 0;
int m = 1;
int year = date.year;

for(int i = 1 ; i <= 31 ; i ++) {
ans ++;
if(m == date.month && i == date.day) {
return ans;
}

if(i == 28 && m == 2) {
if(year % 4 == 0) {
if(year % 100 == 0 && year % 400 != 0) {
i = 0;
m ++;
}
} else {
i = 0;
m ++;
}
}

if(i == 29 && m == 2) {
if(year % 4 == 0) {
if(year % 100 == 0 && year % 400 != 0) {

} else {
i = 0;
m ++;
}
}
}

if(i == 30) {
if(m == 4 || m == 6 || m == 9 || m == 11) {
i = 0;
m ++;
}
}

if(i == 31) {
if(m == 1 || m == 3 || m == 5 || m == 7 ||  m == 8 || m == 10 || m == 12) {
i = 0;
m ++;
}
}
}

}

int main()
{
    struct DATE d;
    scanf("%d-%d-%d", &d.year, &d.month, &d.day);
    printf("%d", days(d));
}

18059 学生成绩表

Description

输入 10 个学生，每个学生的数据包括学号、姓名、3 门课的成绩。定义结构体类型表示学生类型，输入 10 个学生的数据，

计算每个学生的平均成绩。按平均成绩由高到低输出所有学生信息，成绩相同时按学号从小到大输出。

#include 

struct data
{
_______________________
};

int main()
{
    int i,j;
    struct data stu[10],tmp;
    for(i=0; i<10; i++)
    {
_______________________
    }
    for(i=0; i<9; i++)
        for(j=0; j<9-i; j++)
        {
_______________________
        }
    for(i=0; i<10; i++)
    {
        printf("%d %s %.0lf %.0lf %.0lf\n", stu[i].num, stu[i].name, stu[i].score[0], stu[i].score[1], stu[i].score[2]);
    }
    return 0;
}

输入格式

10 个学生信息，每行一个学生

输出格式

如题

输入样例

1 aaa 50 60 70
2 bbb 50 50 50
3 ccc 60 70 80
4 ddd 40 40 40 
5 eee 70 80 90
6 fff 30 30 30 
7 ggg 80 90 100
8 hhh 20 20 20
9 iii 100 100 100
10 jjj 10 10 10

输出样例

9 iii 100 100 100
7 ggg 80 90 100
5 eee 70 80 90
3 ccc 60 70 80
1 aaa 50 60 70
2 bbb 50 50 50
4 ddd 40 40 40 
6 fff 30 30 30 
8 hhh 20 20 20
10 jjj 10 10 10

题解

注意！

因为这是填空题，所以后面出现的关于结构体的变量，你在声明的时候一定要保持 变量名一致！

其次，关于排序的算法，这里其实你也改变不了他给你的算法，只能用冒泡排序，结构体可以直接交换就行

代码

#include 

struct data
{

int num;
char name[50];
double score[3];
double ave;

};

int main()
{
    int i,j;
    struct data stu[10],tmp;
    for(i=0; i<10; i++)
    {

1
2
3

scanf("%d%s%lf%lf%lf", &stu[i].num, &stu[i].name, &stu[i].score[0], &stu[i].score[1], &stu[i].score[2]);
      stu[i].ave = stu[i].score[0] + stu[i].score[1] + stu[i].score[2];
      stu[i].ave /= 3;

}
for(i=0; i<9; i++)
    for(j=0; j<9-i; j++)
    {

if(stu[j].ave < stu[j + 1].ave) {
             tmp = stu[j];
stu[j] = stu[j + 1];
stu[j + 1] = tmp;
         }

        }
    for(i=0; i<10; i++)
    {
        printf("%d %s %.0lf %.0lf %.0lf\n", stu[i].num, stu[i].name, stu[i].score[0], stu[i].score[1], stu[i].score[2]);
    }
    return 0;
}

18060 删除空格

Description

用指针方法解决，输入一个字符串，删除字符串中所有空格后，输出字符串

#include 

void removeSpace(char *s)
{
_______________________
}

int main()
{
    char s[81];
    gets(s);
    removeSpace(s);
    printf("%s", s);
    return 0;
}

输入格式

一行字符，以换行回车结束，最多不超过80个字符

输出格式

删除所有空格后输出

输入样例

abc    456

输出样例

abc456

题解

可以去了解一下双指针算法

做一个快指针，一个慢指针，两边同向出发，遇到空格快指针就跳过，其余情况把快指针传给慢指针，直到遇到空字符为止

代码

#include 

void removeSpace(char *s)
{

int l = 0, r = 0;
while(1) {
if(s[r] == ' ') {
r ++;
continue;
}

s[l] = s[r];

if(s[r] == '\0') {
return;
}

l ++;
r ++;
}

}

int main()
{
    char s[81];
    gets(s);
    removeSpace(s);
    printf("%s", s);
    return 0;
}

18061 数的交换

Description

输入 10 个整数，把其中最小的数与第一个数交换，最大的数与最后一个数交换。使用 3 个函数解决问题：

输入 10 个整数的函数
进行交换处理的函数
输出 10 个数的函数

#include 

void input(int a[])
{
    _______________________
}

void swap(int a[])
{
    _______________________
}

void display(int a[])
{
    int i;
    for(i=0; i<10; i++)
        printf("%d\n", a[i]);
}

int main()
{
    int a[10];
    input(a);
    printf("input done\n");
    swap(a);
    printf("swap done\n");
    display(a);
    printf("display done\n");
    return 0;
}

输入格式

输入 10 个整数

输出格式

输出结果，一行一个数字

输入样例

1	2 1 3 4 5 6 7 8 9 0

输出样例

input done
swap done
0
1
3
4
5
6
7
8
2
9
display done

题解

这题的表述很简单，但是他有一个点没有讲清楚，那就是：

两个数之间只交换一次！

所以我们只需要判断第二次交换的两个数是不是第一次交换得两个数就可以了

如果是，就直接返回；

如果不是，就交换

特殊一点讲

只要确定第一次交换的数字就是最大值和最小值，那我们就可以只交换一次了

代码

#include 

void input(int a[])
{

1
2
3

   for(int i = 0 ; i < 10 ; i ++) {
   scanf("%d",&a[i]);
}

}

void swap(int a[])
{

   int max = 0,min = 0;
   
   for(int i = 0 ; i < 10 ; i ++) {
   if(a[i] < a[min]) min = i;
}

int temp = a[0];
a[0] = a[min];
a[min] = temp;

for(int i = 0 ; i < 10 ; i ++) {
   if(a[i] > a[max]) max = i;
}

if(min == 9 && max == 9) return;

temp = a[9];
a[9] = a[max];
a[max] = temp;

}

void display(int a[])
{
    int i;
    for(i=0; i<10; i++)
        printf("%d\n", a[i]);
}

int main()
{
    int a[10];
    input(a);
    printf("input done\n");
    swap(a);
    printf("swap done\n");
    display(a);
    printf("display done\n");
    return 0;
}

18062 二维数组每行中的最大值

Description

输入一个 4 × 4 的二维整型数组，使用指针变量查找并输出二维整型数组中每一行的最大值。

#include 

void find(int a[][4])
{
    int (*p)[4], *q, *max;
    for(_______________________)
    {
        max=*p;
        for(_______________________)
        {
_______________________
        }
        printf("%d\n", *max);
    }
}

int main()
{
    int a[4][4],i,j;
    for(i=0; i<4; i++)
        for(j=0; j<4; j++)
            scanf("%d", &a[i][j]);
    find(a);
    return 0;
}

输入格式

4 × 4 的整数矩阵

输出格式

每行最大值，一行一个

输入样例

输出样例

题解

其实这题和普通的找最大值没有区别

只不过是把下标变成指针而已，还有二级指针

注意一下指针之间的比较和交换即可

代码

#include 

void find(int a[][4])
{
    int (*p)[4], *q, *max;
    for(p = a; p < a + 4 ; p ++/*方框1*/)
    {
        max=*p;
        for(q = *p + 1 ; q < *p + 4; q ++/*方框2*/)
        {
if(*max < *q) {*max = *q;} /*方框3*/
        }
        printf("%d\n", *max);
    }
}

int main()
{
    int a[4][4],i,j;
    for(i=0; i<4; i++)
        for(j=0; j<4; j++)
            scanf("%d", &a[i][j]);
    find(a);
    return 0;
}

18063 圈中的游戏

Description

有 n 个人围成一圈，从第 1 个人开始报数 1、2、3 ，每报到 3 的人退出圈子。编程使用链表找出最后留下的人。

输入格式

输入一个数 n ， 1000000 ≥ n > 0

输出格式

输出最后留下的人的编号

输入样例

输出样例

题解

其实这是一道经典的数论题：约瑟夫问题，大家可以去了解一下

我当时是用的循环链表解决的

当然也有另一种更简便的写法，大家在后面也可以欣赏一下（至于这个算法的理论本身我就不给出了，大家自己去了解一下就好啦）

代码（循环链表）

#include 
struct round
{
int num;
struct round *next;
} ;

int main(void)
{
int n;
scanf("%d",&n);
struct round lin[n];
struct round *head=&lin[0],*pt=head,*ptt;
for(int i=0;i
{
lin[i].num=i+1;
if(i==n-1)
lin[i].next=&lin[0];
else
lin[i].next=&lin[i+1];
}

while(head->next!=head)
{
pt=pt->next;
ptt=pt->next;
if(ptt==head)
head=ptt->next;
pt->next=ptt->next;
pt=pt->next;
}
printf("%d",head->num);
}

代码（O(n)版）

#include 

int main()
{
int n;
scanf("%d",&n);
int f = 0;

for(int i = 1 ; i <= n ; i ++) {
f = (f + 3) % i;
}

printf("%d",f+1);
return 0;
}

18064 链表的有序合并

Description

已知有两个链表 a 和 b ，结点类型相同，均包括一个 int 类型的数据。编程把两个链表合并成一个，结点按升序排列。

#include "stdio.h"
#include "malloc.h"
#define LEN sizeof(struct DATA)

struct DATA
{
     long num;
     struct DATA *next;
};

struct DATA *create(int n)
{
     struct DATA *head=NULL,*p1=NULL,*p2=NULL;
     int i;
     for(i=1;i<=n;i++)
     {  p1=(struct DATA *)malloc(LEN);
        scanf("%ld",&p1->num);
        p1->next=NULL;
        if(i==1) head=p1;
        else p2->next=p1;
        p2=p1;
      }
      return(head);
}

struct DATA *merge(struct DATA *head, struct DATA *head2)
{
    _______________________
    return head;
}

struct DATA *insert(struct DATA *head, struct DATA *d)
{
    _______________________
    return head;
}

struct DATA *sort(struct DATA *head) 
{ 
    _______________________
    return head;
} 

void print(struct DATA *head)
{
    struct DATA *p;
    p=head;
    while(p!=NULL)
    {
        printf("%ld",p->num);
        p=p->next;
        printf("\n");
    }
}

main()
{
    struct DATA *head, *head2;
    int n;
    long del_num;
    scanf("%d",&n);
    head=create(n);
    scanf("%d",&n);
    head2=create(n);
    head = merge(head, head2);
    head = sort(head);
    print(head);
}

输入格式

第一行一个数 n ，表示第一个列表的数据个数

每二行为 n 个数

第三行为一个数 m

第四行为 m 个数

输出格式

输出合并后的有序的数据，一行一个数

输入样例

输出样例

题解

这道题目的本意是，让我们写一个插入的函数

然后在sort的时候遍历找到应该插入的位置

然后调用这个插入函数，结构体插进去

实现“插入”排序

其实我们也可以直接把整个链表挂在前一个链表的后面

然后对整个链表进行一个排序

但是这种虽然写起来简单，省下一个函数

但是时间复杂度差，就不展示了

代码

#include "stdio.h"
#include "malloc.h"
#define LEN sizeof(struct DATA)

struct DATA
{
     long num;
     struct DATA *next;
};

struct DATA *create(int n)
{
     struct DATA *head=NULL,*p1=NULL,*p2=NULL;
     int i;
     for(i=1;i<=n;i++)
     {  p1=(struct DATA *)malloc(LEN);
        scanf("%ld",&p1->num);
        p1->next=NULL;
        if(i==1) head=p1;
        else p2->next=p1;
        p2=p1;
      }
      return(head);
}

struct DATA *merge(struct DATA *head, struct DATA *head2)
{

struct DATA *p;
p=head;
while(p->next!=NULL) 
p=p->next;
p->next = head2;
return head;

return head;
}

struct DATA *insert(struct DATA *head, struct DATA *d)
{

struct DATA *p0,*p1,*p2;
p1=head;
p0=d;
if(head==NULL) {
head=p0;
p0->next=NULL;
}
else {
while((p0->num>p1->num)&&(p1->next!=NULL)) {
p2=p1;
  p1=p1->next;
  }
  if(p0->num<=p1->num) { 
  if(head==p1) head=p0;
    else p2->next=p0;
    p0->next=p1;
  }
  else {
  p1->next=p0;
  p0->next=NULL;
  }
}

return head;
}

struct DATA *sort(struct DATA *head) 
{

struct DATA *p1,*p2;
p2=head;p1=head;
p2=p2->next;
p1->next=NULL;
p1=p2;
while(p2->next!=NULL) {
    p2=p2->next;
    p1->next=NULL;
    head=insert(head,p1);
    p1=p2;
}
head=insert(head,p1);

return head;
} 

void print(struct DATA *head)
{
    struct DATA *p;
    p=head;
    while(p!=NULL)
    {
        printf("%ld",p->num);
        p=p->next;
        printf("\n");
    }
}

main()
{
    struct DATA *head, *head2;
    int n;
    long del_num;
    scanf("%d",&n);
    head=create(n);
    scanf("%d",&n);
    head2=create(n);
    head = merge(head, head2);
    head = sort(head);
    print(head);
}

题解：牛客周赛 Round 56（A-E）

2024-08-18T16:00:00.000Z

题解：牛客周赛 Round 56（A-E）

A 面包店故事

题面

小镇上有一家面包店，面包以 x 元的价格出售，加 y 元可以多加几块培根。小歪带着 n 元来到了面包店，他想知道自己能不能买到加培根的面包？

输入

在一行上输入三个整数 x, y, n(1≤x,y,n≤100) 代表面包的价格、培根的价格和小歪带的钱。

输出

如果小歪能加到培根，在一行上输出 YES ；否则，直接输出 NO 。

样例1

输入

3 1 5

输出

YES

说明面包加培根一共 4 元，小歪带了 5 元，他可以吃到培根！

样例2

输入

10 1 10

输出

NO

说明面包加培根一共 11 元，小歪带了 10 元，他吃不到培根 (⋟﹏⋞) 。

题解

直接比较是否 a + b > c 就好了 * 是则吃不到 * 否则吃得到

代码

#include 

int main(){
int a,b,c;
std::cin >> a >> b >> c;
std::cout << (a+b > c ? "NO\n" : "YES\n");
return 0;
}

B 放课后故事

题面

小S 想要举办一个纸飞机大赛，他最新研制出的纸飞机需要 k 张纸才能折成。为了制作纸飞机，他向班里的 n 个人要了一些纸，第 i 个人提供了 a_i 张纸给小S 研究纸飞机。放学了，小S 终于折好了全部的纸飞机，现在有 m 个人留下来和小S 一起飞纸飞机。最多有多少个人能分到纸飞机。

输入

第一行输入三个整数 n, m, k(1≤n≤10⁵; 0≤m≤10⁵; 1≤k≤10⁹) 代表班级同学数量、留下来的同学数量和叠一只纸飞机需要的纸的数量。第二行输入 n 个整数，代表每一个同学提供的纸的数量。

输出

在一行上输出一个整数，代表最多有多少个人能分到纸飞机。

样例1

输入

1 2	3 2 5 1 2 4

输出

说明

小S 一共收集到 7 张纸，只可以叠一架纸飞机。

样例2

输入

1 2	6 3 4 1 1 4 5 1 4

输出

说明小S 一共收集到 16 张纸，可以叠 4 架纸飞机，每个人都能分到纸飞机。

题解

（简短版）在场的人包括留下来的 m 人和小S 自己，所以实际上有 m + 1 个人 （详细版） 小S 手中的所有纸，实际上就是 n 人给出的所有纸（也就是第二行的和）小S 手中的飞机总数，也的确是纸的总数除以 k 但是，在场的人除了留下来的 m 人之外还有小S 自己所以实际上有 m + 1 个人

代码

#include 

using i64 = long long;

const int N = 1e7 + 10;
int a[N];

int main(){
i64 n,m,k;
i64 ans = 0;
std::cin >> n >> m >> k;
for(int i = 0 ; i < n ; i ++) {
std::cin >> a[i];
ans += a[i];
}
std::cout << std::min(ans/k,m+1);
return 0;
}

C 异或故事

题面

给定 t 组询问，76 每次询问都会给出一个正整数 a ，你需要在区间 [1, 10⁹] 中找到两个正整数 b 和 c ，使得 b ⊕ c = a。 ⊕ 代表按位异或。

输入

每个测试文件均包含多组测试数据。第一行输入一个整数 T (1 ≤ T ≤ 10⁵) 代表数据组数，每组测试数据描述如下：在一行上输入一个整数 a ( 1 ≤ a ≤ 10⁹ ) 代表 76 给出的初始数字。

输出

对于每一组测试数据，在一行上输出两个正整数，代表你找到的两个值。如果存在多个解决方案，您可以输出任意一个。

样例1

输入

输出

1
2
3

2 3
3 6
74 78

说明对于第一组测试数据，(10)₂xor (11)₂ = (01)₂ 对于第二组测试数据，(011)₂xor (110)₂ = (101)₂

题解

这题我们主要是利用异或的性质简单来说就是： $$\begin{aligned}a \oplus b = c \\a \oplus c = b \\b \oplus c = a\end{aligned}$$

要证明也很容易 $$

$$ 这样应该直观一点啦

然后，我们可以取一个数作为异或的主要对象，比如本题的上限 1e9 但是要注意：异或之后得到的结果可能是 0 或者大于 1e9 所以要做一个特判：假如存在上述情况，就让异或的数字变成 1e9 ≫ 1 （其实这一步特判是我guess的，没想到居然过了）（自己测了一下从1到1e9的所有数，确实全都过了）

代码

#include 

int t = 1;

void solve() {
int n;
std::cin >> n;
int q = n^((int)1e9 >> 1);
if(q > 1e9) {
q = n^(int)(1e9);
std::cout << q << " " << (int)(1e9) << "\n";
}
else std::cout << q << " " << ((int)1e9 >> 1) << "\n";
}


int main(){
std::cin >> t;
while(t--){
solve();
}
return 0;
}

D 构造故事

题面

小S 今天在数学课上学习了三角形，他回家立马拿出了自己的 n 根火柴，想知道从这 n 根火柴中任选 3 根，能否组成一个周长最大的三角形。由于小S 只会暴力枚举，所以他把这个问题交给了你，你能帮他解决这个问题吗？

输入

每个测试文件均包含多组测试数据。第一行输入一个整数 T(1≤T≤20) 代表数据组数，每组测试数据描述如下：第一行输入一个整数 n(3≤n≤10⁴) 代表小S 的火柴数量。第二行输入 n 个整数 a₁, a₂, …, a_n(1≤a_i≤10⁹) 代表每根火柴的长度

输出

对于每一组测试数据，在一行上输出一个整数，代表能组成周长最大三角形的周长；如果无论如何都无法组成三角形，直接输出 −1 。

样例1

输入

3
6
2 2 10 4 10 6
5
6 1 5 3 3
5
2 2 4 10 6

输出

3
6
2 2 10 4 10 6
5
6 1 5 3 3
5
2 2 4 10 6

说明对于第一组测试数据，有两个合法的三角形 (4, 10, 10) 和 (6, 10, 10) 。

题解

这题…..怎么说呢，实际上就是一个小学数学题根据三角形的性质： > 两边之和大于第三边两边之差小于第三边

我们采取一个贪心的思路

把他们排序一下（从小到大）相邻的两根火柴，假设是第 i 根和第 i + 1 根吧，长度分别为 a、b(a ≥ b) 假如他们不能和第 i − 1 根火柴（长度为 c）组成三角形那么他们一定不能和更前面的火柴组成三角形

因为假如他们不能组成三角形那么一定是 a − b > c 火柴长度比c小的同样不能和前两根火柴组成三角形

就算把 a 换成比 a 更大（也就是更后面的火柴）那 a − b > c 同样成立依然不能组成三角形

因此，要组成三角形，最优解应当是相邻三根火柴组成的三角形我们只要从后到前依次遍历即可

注意：要记得开long long

代码

#include 

using i64 = long long;

const int N = 1e7 + 10;
int t = 1;
i64 a[N];

void solve() {
int n;
std::cin >> n;
for(int i = 0 ; i < n ; i ++) {
std::cin >> a[i];
}
std::sort(a,a+n);
for(int i = n-2 ; i > 0 ; i --) {
if(a[i+1] - a[i] < a[i-1]) {
std::cout << a[i] + a[i-1] + a[i+1] << "\n";
return;
}
}
std::cout << -1 << "\n";
}


signed main(){
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);

std::cin >> t;
while(t--){
solve();
}
return 0;
}

E 约会故事

题面

情人节才刚刚过去没多久啊 (¯﹃¯∗) ，但是我们的 xqq 已经开始备战明年的情人节了。心灰意冷的他找到小S 生成了一个虚拟对象小C ，在一次次的模拟约会中达成“一起进入电影院”的人生成就。 xqq 决定向小C 发送邀请。在设定中，下述情况的小C 会残忍的拒绝 xqq 的邀请： * xqq 不在 00:00 后、01:59 前（含）这段小C 的睡前手机时间里发送邀请； * xqq 如果在小C 不开心时发送邀请；

接受了邀请还远远没有成功！在设定中，下述情况的小C 会在进入电影院前离去： * xqq 到电影院的时间比小C 晚； * xqq 给小C 准备的奶茶不是她喜欢的。如果小C 同意了邀请，且没有中途离去，我们视为 xqq 达成成就！让我们一起来判定——这一次， xqq 会成功吗。

输入

第一行输入两个整数 n, m(1≤n,m≤10⁵) 代表小C 感到开心的时间段数量和小C 喜欢的奶茶数量。此后 n 行，第 i 行输入两个长度为 5 ，且形如 hh : mm 的字符串代表小C 第 i 段感到开心的起止时间，保证每一段开心时间不超过 24 小时。除了这 n 个时间段外，剩余时间她都是不开心的。第 n + 1 行输入 m 个长度不超过 10 且由大小写字母混合构成的字符串 s₁, s₂, …, s_m 代表小C 喜欢喝的奶茶名字。第 n + 2 行输入一个整数 q(1≤q≤10⁵) 代表 xqq 尝试次数，每次尝试描述如下： * 第一行输入一个长度为 5 ，且形如 hh : mm 的字符串代表 xqq 发送邀请的时间点； * 第二行输入两个长度为 5 ，且形如 hh : mm 的字符串代表 xqq 到达电影院的时间和小C 到达电影院的时间，我们约定，他们会在同一天内到达； * 第三行输入一个长度不超过 10 且由大小写字母混合构成的字符串 t 代表 xqq 购买的奶茶名字。

本题中出现的时间格式均按照 ISO8601 的二十四小时格式标准，即形如 hh : mm，其中 hh(00 ≤ hh < 24) 代表小时数，mm(00 ≤ mm < 60) 代表分钟数。

输出

对于每一次尝试，如果 xqq 成功达成成就，在一行上输出 Winner xqq ；如果 xqq 成功邀请但是小C 中途离开，在一行上输出 Joker xqq ；否则，直接输出 Loser xqq 。

样例1

输入

3 2
00:03 00:47
00:30 01:23
12:00 17:00
Lemonade Cappuccino
5
00:35
12:00 12:00
Cappuccino
01:23
13:00 12:59
Cappuccino
01:15
11:00 12:43
WaTer
01:24
09:24 11:00
Lemonade
23:59
08:00 07:43
LeMonade

输出

Winner xqq
Joker xqq
Joker xqq
Loser xqq
Loser xqq

说明 * 对于第一次尝试： * xqq 在 00 : 35 发送邀请，此时在规定时间内，且小C 是开心的，所以他的邀请会被接受； * xqq 在 12 : 00 到达电影院，此时不晚于小C ，且携带了小C 爱喝的 Cappuccino ，所以她不会中途离开。 * 对于第二次尝试，由于迟到了，小C 中途离开； * 对于第三次尝试，由于带错了奶茶，小C 中途离开； * 对于第四次尝试，由于发送邀请时小C 不开心，所以邀请失败； * 对于第五次尝试，由于发送邀请时不在规定时间内，所以邀请失败。

样例2

输入

3 1
00:00 00:00
22:47 23:59
23:58 00:17
AbCdEfGhIj
1
00:00
00:00 00:00
AbCdEfGhIj

输出

1	Winner xqq

说明注意，当开心的起始时间和结束时间相等时，我们认为小C 一整天都感到开心。

题解

这题主要是记录时间的时候容易 TLE ，判断尝试是否成功的时候是可以达到 O(1) 的时间复杂度的由于对于一天的所有分钟总和数量不大，我们可以声明一个二维数组（如int time[12][60]，最好放大一点），讨论里面的某一分钟是否可以邀请小C。然后在第一波输入小C 开心的时段要注意 * 如果开始的时间比结束的时间小，说明这段时间在同一天之内 * 如果开始的时间比结束的时间大，说明这一段时间从这一天跨越到了第二天 * 如果开始时间和结束时间相同，说明整一天小C 都是快乐的 * 记录的时候在超过 01 : 59 的或者在 00 : 00 之前的就不要去记录了

最后比较的时候找到对应的数组元素去判断就好了。

代码

#include 
#define INF 0x3f3f3f3f
#define all(x) x.begin(),x.end()

using i64 = long long;
const int N = 1e7 + 10;
int t = 1;
int tag[50][70];

void solve() {
    int n,m;
    i64 sum = 0;
    std::mapint> mp;
    std::cin >> n >> m;
    std::string s[n*2];
    for(int i = 0 ; i < n*2 ; i ++) std::cin >> s[i];
    for(int i = 0 ; i < n*2 && sum <= 120; i +=2) {
        int a = (s[i][0] - '0')*10 + s[i][1] - '0';
        int b = (s[i][3] - '0')*10 + s[i][4] - '0';

        int a1 = (s[i+1][0] - '0')*10 + s[i+1][1] - '0';
        int b1 = (s[i+1][3] - '0')*10 + s[i+1][4] - '0';

        int en1 = (a < a1 || (a == a1 && b < b1) ? a : 0);
        int en2 = (a < a1 || (a == a1 && b < b1) ? a : 0);

        if(a == a1 && b == b1) {
            a = 0,b = 0;
            while(a <= 1) {
                if(tag[a][b] == 0) sum ++;
                tag[a][b]++;
                b ++;
                if(b == 60) {
                    b = 0;
                    a++;
                }
            }

            break;
        }

        bool jud = true;
        if(a1 > a) jud = true;
        else if(a1 == a) {
            if(b1 > b) jud = true;
            else jud = false;
        }
        else jud = false;

        if(jud) {
            while(a <= 1 && a >= 0) {
                if(tag[a][b] == 0) sum ++;
                tag[a][b]++;
                b ++;
                if(b == 60) {
                    b = 0;
                    a++;
                }
                if(a >= a1 && b > b1) break;
            }
        } else {
            while(a <= 1) {
                if(tag[a][b] == 0) sum ++;
                tag[a][b]++;
                b ++;
                if(b == 60) {
                    b = 0;
                    a++;
                }
            }

            a = 0,b = 0;

            while(a <= 1) {
                if(tag[a][b] == 0) sum ++;
                tag[a][b]++;
                b ++;
                if(b == 60) {
                    b = 0;
                    a++;
                }
                if(a >= a1 && b > b1) break;
            }
        }
    }
    for(int i = 0 ; i < m ; i ++) {
        std::string s;
        std::cin >> s;
        mp[s]++;
    }

    i64 p;
    std::cin >> p;
    while(p--) {
        std::string s1,s2,q1,q2;
        std::cin >> s1 >> q1 >> q2 >> s2;
        int a = (s1[0] - '0')*10 + s1[1] - '0';
        int b = (s1[3] - '0')*10 + s1[4] - '0';

        int a1 = (q1[0] - '0')*10 + q1[1] - '0';
        int b1 = (q1[3] - '0')*10 + q1[4] - '0';

        int a2 = (q2[0] - '0')*10 + q2[1] - '0';
        int b2 = (q2[3] - '0')*10 + q2[4] - '0';

        bool jud;
        if(a1 > a2) jud = false;
        else if(a1 == a2) {
            if(b1 <= b2) jud = true;
            else jud = false;
        }
        else jud = true;

        if(tag[a][b] > 0 && mp.count(s2) && jud) {
            std::cout << "Winner xqq\n";
        }
        else{
            std::cout << (tag[a][b] > 0 ? "Joker xqq\n" : "Loser xqq\n");
        }
    }
}


signed main(){
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    //std::cin >> t;
    while(t--){
        solve();
    }
    return 0;
}

题目来源有什么建议或者意见的欢迎在评论区留言！

Hexo

C语言核心语法(1)：第一个C程序

经典示例：Hello, World! 程序

📌 为什么要这样写？

1. int main()：程序的入口

2. { ... }：代码块

3. printf("Hello, World!\n");：实现输出功能的核心指令

4. #include ：printf()的声明

5. return 0;：函数的“结束信号”

哈尔滨CCPC前有感

C/C++IDE介绍之DevC++

下载与安装

首次配置

基本使用

现在开始，还来得及

Fenwick 树状数组

Fenwick 树状数组

原理

题面描述：

代码

SCAU 高级程序设计语言 教材习题

SCAU 高级程序设计语言 教材习题

第三章

18041 分期还款(加强版)

第四章

18042 计算分段函数值

18043 找出3个数中最大的数

18044 成绩等级评分

18045 前一个和后一个字符

18037 20秒后的时间

第五章

18046 字母分类统计

18047 水仙花数

1037 计算数列和

18048 自由落体

18049 迭代法求平方根

18050 打印三角形

18051 勾股数

第六章

18052 插入数据

18053 大于平均分

18054 输出不同的数

18055 主对角线上的元素之和

1051 找矩阵中的鞍点

18056 字母统计

1145 回文串

18057 ASCII码值之和的差

第七章

18065 所有数字之和

18066 元音字母

18067 字符统计

18068 选择排序

18069 x的n次方

18070 矩阵行交换或列交换

18071 学生信息统计

第八章

18058 一年的第几天

18059 学生成绩表

18060 删除空格

18061 数的交换

18062 二维数组每行中的最大值

18063 圈中的游戏

18064 链表的有序合并

题解：牛客周赛 Round 56（A-E）

题解：牛客周赛 Round 56（A-E）

A 面包店故事

题面

输入

输出

样例1

样例2

题解

代码

B 放课后故事

题面

输入

输出

样例1

样例2

题解

1. `int main()`：程序的入口

2. `{ ... }`：代码块

3. `printf("Hello, World!\n");`：实现输出功能的核心指令

4. `#include` ：`printf()`的声明

5. `return 0;`：函数的“结束信号”

SCAU 高级程序设计语言教材习题

SCAU 高级程序设计语言教材习题